Coverage for cuda/bindings/_internal/nvvm.pyx: 78.40%

1# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. (empty)

2# 

3# SPDX-License-Identifier: Apache-2.0 

4# 

5# This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. 

6# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e0b66c45b6f66a7ab7bae49939a26007efef95651084f1ef09fd32848260f2c8 

7  

8  

9# <<<< PREAMBLE CONTENT >>>> 

10  

11cdef extern from * nogil: 

12 """ 

13 #if defined(_MSC_VER) && !defined(__clang__) 

14 #include <intrin.h> 

15 static __forceinline int atomic_int_load(int *p) { 

16 int v = *(int volatile *)p; _ReadBarrier(); return v; 

17 } 

18 static __forceinline void atomic_int_store(int *p, int v) { 

19 _WriteBarrier(); *(int volatile *)p = v; 

20 } 

21 #elif defined(__cplusplus) 

22 /* GCC/Clang __atomic builtins work in any C++ standard without headers */ 

23 static inline int atomic_int_load(int *p) { 

24 return __atomic_load_n(p, __ATOMIC_ACQUIRE); 

25 } 

26 static inline void atomic_int_store(int *p, int v) { 

27 __atomic_store_n(p, v, __ATOMIC_RELEASE); 

28 } 

29 #else 

30 #include <stdatomic.h> 

31 static inline int atomic_int_load(int *p) { 

32 return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); 

33 } 

34 static inline void atomic_int_store(int *p, int v) { 

35 atomic_store_explicit((atomic_int *)p, v, memory_order_release); 

36 } 

37 #endif 

38  

39 """ 

40 cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil 

41 cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil 

42  

43cdef extern from "<dlfcn.h>": 

44 void* _cyb_dlsym "dlsym"(void*, const char*) nogil 

45 const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" 

46  

47from libc.stdint cimport intptr_t as _cyb_intptr_t 

48  

49import threading as _cyb_threading (empty)

50  

51cdef int _cyb___py_nvvm_init = 0 (empty)

52cdef dict _cyb_func_ptrs = None (empty)

53cdef object _cyb_symbol_lock = _cyb_threading.Lock() (empty)

54  

55# <<<< END OF PREAMBLE CONTENT >>>> 

56  

57from libc.stdint cimport uintptr_t 

58  

59from .utils import FunctionNotFoundError, NotSupportedError (empty)

60from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

61  

62  

63############################################################################### 

64# Wrapper init 

65############################################################################### 

66  

67cdef void* __nvvmGetErrorString = NULL (empty)

68cdef void* __nvvmVersion = NULL (empty)

69cdef void* __nvvmIRVersion = NULL (empty)

70cdef void* __nvvmCreateProgram = NULL (empty)

71cdef void* __nvvmDestroyProgram = NULL (empty)

72cdef void* __nvvmAddModuleToProgram = NULL (empty)

73cdef void* __nvvmLazyAddModuleToProgram = NULL (empty)

74cdef void* __nvvmCompileProgram = NULL (empty)

75cdef void* __nvvmVerifyProgram = NULL (empty)

76cdef void* __nvvmGetCompiledResultSize = NULL (empty)

77cdef void* __nvvmGetCompiledResult = NULL (empty)

78cdef void* __nvvmGetProgramLogSize = NULL (empty)

79cdef void* __nvvmGetProgramLog = NULL (empty)

80cdef void* __nvvmLLVMVersion = NULL (empty)

81  

82cdef int _init_nvvm() except -1 nogil: (empty)

83 global _cyb___py_nvvm_init 

84 cdef void* handle = NULL (empty)

85 with gil, _cyb_symbol_lock: (empty)

86 if _cyb___py_nvvm_init: return 0 (empty)

87  

88 global __nvvmGetErrorString 

89 __nvvmGetErrorString = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetErrorString') (empty)

90 if __nvvmGetErrorString == NULL: (empty)

91 if handle == NULL: (empty)

92 handle = load_library() (empty)

93 __nvvmGetErrorString = _cyb_dlsym(handle, 'nvvmGetErrorString') (empty)

94  

95 global __nvvmVersion 

96 __nvvmVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmVersion') (empty)

97 if __nvvmVersion == NULL: (empty)

98 if handle == NULL: (empty)

99 handle = load_library() 

100 __nvvmVersion = _cyb_dlsym(handle, 'nvvmVersion') 

101  

102 global __nvvmIRVersion 

103 __nvvmIRVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmIRVersion') (empty)

104 if __nvvmIRVersion == NULL: (empty)

105 if handle == NULL: 

106 handle = load_library() 

107 __nvvmIRVersion = _cyb_dlsym(handle, 'nvvmIRVersion') (empty)

108  

109 global __nvvmCreateProgram 

110 __nvvmCreateProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmCreateProgram') (empty)

111 if __nvvmCreateProgram == NULL: (empty)

112 if handle == NULL: 

113 handle = load_library() (empty)

114 __nvvmCreateProgram = _cyb_dlsym(handle, 'nvvmCreateProgram') 

115  

116 global __nvvmDestroyProgram 

117 __nvvmDestroyProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmDestroyProgram') (empty)

118 if __nvvmDestroyProgram == NULL: (empty)

119 if handle == NULL: (empty)

120 handle = load_library() 

121 __nvvmDestroyProgram = _cyb_dlsym(handle, 'nvvmDestroyProgram') 

122  

123 global __nvvmAddModuleToProgram 

124 __nvvmAddModuleToProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmAddModuleToProgram') (empty)

125 if __nvvmAddModuleToProgram == NULL: (empty)

126 if handle == NULL: 

127 handle = load_library() 

128 __nvvmAddModuleToProgram = _cyb_dlsym(handle, 'nvvmAddModuleToProgram') (empty)

129  

130 global __nvvmLazyAddModuleToProgram 

131 __nvvmLazyAddModuleToProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmLazyAddModuleToProgram') (empty)

132 if __nvvmLazyAddModuleToProgram == NULL: (empty)

133 if handle == NULL: (empty)

134 handle = load_library() 55 ctx1aYZj5k6l7m8noWXb9c!d#e$f%g'h(i)0Nw{*34O+P,Q-R.S/T:pqrst

135 __nvvmLazyAddModuleToProgram = _cyb_dlsym(handle, 'nvvmLazyAddModuleToProgram') 54 ctx1YZj5k6l7m8noWXb9c!d#e$f%g'h(i)0Nw{*34O+P,Q-R.S/T:pqrst

136  

137 global __nvvmCompileProgram 

138 __nvvmCompileProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmCompileProgram') (empty)

139 if __nvvmCompileProgram == NULL: (empty)

140 if handle == NULL: (empty)

141 handle = load_library() 

142 __nvvmCompileProgram = _cyb_dlsym(handle, 'nvvmCompileProgram') (empty)

143  

144 global __nvvmVerifyProgram 

145 __nvvmVerifyProgram = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmVerifyProgram') (empty)

146 if __nvvmVerifyProgram == NULL: (empty)

147 if handle == NULL: 

148 handle = load_library() (empty)

149 __nvvmVerifyProgram = _cyb_dlsym(handle, 'nvvmVerifyProgram') 

150  

151 global __nvvmGetCompiledResultSize 

152 __nvvmGetCompiledResultSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetCompiledResultSize') (empty)

153 if __nvvmGetCompiledResultSize == NULL: (empty)

154 if handle == NULL: (empty)

155 handle = load_library() 

156 __nvvmGetCompiledResultSize = _cyb_dlsym(handle, 'nvvmGetCompiledResultSize') 

157  

158 global __nvvmGetCompiledResult 

159 __nvvmGetCompiledResult = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetCompiledResult') (empty)

160 if __nvvmGetCompiledResult == NULL: (empty)

161 if handle == NULL: 

162 handle = load_library() 

163 __nvvmGetCompiledResult = _cyb_dlsym(handle, 'nvvmGetCompiledResult') (empty)

164  

165 global __nvvmGetProgramLogSize 

166 __nvvmGetProgramLogSize = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetProgramLogSize') (empty)

167 if __nvvmGetProgramLogSize == NULL: (empty)

168 if handle == NULL: 

169 handle = load_library() (empty)

170 __nvvmGetProgramLogSize = _cyb_dlsym(handle, 'nvvmGetProgramLogSize') 

171  

172 global __nvvmGetProgramLog 

173 __nvvmGetProgramLog = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmGetProgramLog') (empty)

174 if __nvvmGetProgramLog == NULL: (empty)

175 if handle == NULL: (empty)

176 handle = load_library() 

177 __nvvmGetProgramLog = _cyb_dlsym(handle, 'nvvmGetProgramLog') 

178  

179 global __nvvmLLVMVersion 

180 __nvvmLLVMVersion = _cyb_dlsym(_cyb_RTLD_DEFAULT, 'nvvmLLVMVersion') (empty)

181 if __nvvmLLVMVersion == NULL: (empty)

182 if handle == NULL: 

183 handle = load_library() 

184 __nvvmLLVMVersion = _cyb_dlsym(handle, 'nvvmLLVMVersion') (empty)

185  

186 _cyb_atomic_int_store(<int *>&_cyb___py_nvvm_init, 1) (empty)

187 return 0 (empty)

188  

189cdef inline int _check_or_init_nvvm() except -1 nogil: (empty)

190 if _cyb_atomic_int_load(<int *>&_cyb___py_nvvm_init): 91 ctx2a | Y Z j 5 k 6 l 7 m 8 n o W X b 9 c ! d # e $ f % g ' h ( i ) 0 N w { * 3 4 O + P , Q - R . S / T : ; } x ~ y ab1 U 2 V z A B C D E F G H I J K L M bbu v = ? @ [ ] ^ _ ` p q r s t

191 return 0 91 ctx2a | Y Z j 5 k 6 l 7 m 8 n o W X b 9 c ! d # e $ f % g ' h ( i ) 0 N w { * 3 4 O + P , Q - R . S / T : ; } x ~ y ab1 U 2 V z A B C D E F G H I J K L M bbu v = ? @ [ ] ^ _ ` p q r s t

192  

193 return _init_nvvm() (empty)

194  

195  

196cpdef dict _inspect_function_pointers(): 6 ctx1apqrst

197 global _cyb_func_ptrs 

198 if _cyb_func_ptrs is not None: (empty)

199 return _cyb_func_ptrs 

200  

201 _check_or_init_nvvm() (empty)

202 cdef dict data = {} (empty)

203 global __nvvmGetErrorString 

204 data["__nvvmGetErrorString"] = <_cyb_intptr_t>__nvvmGetErrorString (empty)

205  

206 global __nvvmVersion 

207 data["__nvvmVersion"] = <_cyb_intptr_t>__nvvmVersion (empty)

208  

209 global __nvvmIRVersion 

210 data["__nvvmIRVersion"] = <_cyb_intptr_t>__nvvmIRVersion (empty)

211  

212 global __nvvmCreateProgram 

213 data["__nvvmCreateProgram"] = <_cyb_intptr_t>__nvvmCreateProgram (empty)

214  

215 global __nvvmDestroyProgram 

216 data["__nvvmDestroyProgram"] = <_cyb_intptr_t>__nvvmDestroyProgram (empty)

217  

218 global __nvvmAddModuleToProgram 

219 data["__nvvmAddModuleToProgram"] = <_cyb_intptr_t>__nvvmAddModuleToProgram (empty)

220  

221 global __nvvmLazyAddModuleToProgram 

222 data["__nvvmLazyAddModuleToProgram"] = <_cyb_intptr_t>__nvvmLazyAddModuleToProgram 2 ctx1a4

223  

224 global __nvvmCompileProgram 

225 data["__nvvmCompileProgram"] = <_cyb_intptr_t>__nvvmCompileProgram 2 ctx1a4

226  

227 global __nvvmVerifyProgram 

228 data["__nvvmVerifyProgram"] = <_cyb_intptr_t>__nvvmVerifyProgram (empty)

229  

230 global __nvvmGetCompiledResultSize 

231 data["__nvvmGetCompiledResultSize"] = <_cyb_intptr_t>__nvvmGetCompiledResultSize 25 ctx1a56789!#$%'()*+,-./:pqrst

232  

233 global __nvvmGetCompiledResult 

234 data["__nvvmGetCompiledResult"] = <_cyb_intptr_t>__nvvmGetCompiledResult (empty)

235  

236 global __nvvmGetProgramLogSize 

237 data["__nvvmGetProgramLogSize"] = <_cyb_intptr_t>__nvvmGetProgramLogSize (empty)

238  

239 global __nvvmGetProgramLog 

240 data["__nvvmGetProgramLog"] = <_cyb_intptr_t>__nvvmGetProgramLog (empty)

241  

242 global __nvvmLLVMVersion 

243 data["__nvvmLLVMVersion"] = <_cyb_intptr_t>__nvvmLLVMVersion (empty)

244 _cyb_func_ptrs = data (empty)

245 return data 33 ctx1aYZjklmnoWXbcdefghi0NwOPQRSTpqrst

246  

247  

248cpdef _inspect_function_pointer(str name): (empty)

249 global _cyb_func_ptrs 

250 if _cyb_func_ptrs is None: 6 ctx1apqrst

251 _cyb_func_ptrs = _inspect_function_pointers() 33 ctx1aYZjklmnoWXbcdefghi0NwOPQRSTpqrst

252 return _cyb_func_ptrs[name] 33 ctx1aYZjklmnoWXbcdefghi0NwOPQRSTpqrst

253  

254  

255  

256  

257cdef void* load_library() except* with gil: (empty)

258 cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint (empty)

259 return <void*>handle (empty)

260  

261  

262############################################################################### 

263# Wrapper functions 

264############################################################################### 

265  

266cdef const char* _nvvmGetErrorString(nvvmResult result) except?NULL nogil: (empty)

267 global __nvvmGetErrorString 

268 _check_or_init_nvvm() 1 ctx1{

269 if __nvvmGetErrorString == NULL: 2 ctx1a{

270 with gil: 

271 raise FunctionNotFoundError("function nvvmGetErrorString is not found") 

272 return (<const char* (*)(nvvmResult) noexcept nogil>__nvvmGetErrorString)( 1 ctx1{

273 result) 

274  

275  

276cdef nvvmResult _nvvmVersion(int* major, int* minor) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

277 global __nvvmVersion 

278 _check_or_init_nvvm() 10 ctx1a4=?@[]^_`

279 if __nvvmVersion == NULL: 10 ctx1a4=?@[]^_`

280 with gil: 

281 raise FunctionNotFoundError("function nvvmVersion is not found") 17 ctx1jlnWbcdefghipqrst

282 return (<nvvmResult (*)(int*, int*) noexcept nogil>__nvvmVersion)( 27 ctx1ajlnWbcdefghi4=?@[]^_`pqrst

283 major, minor) 

284  

285  

286cdef nvvmResult _nvvmIRVersion(int* majorIR, int* minorIR, int* majorDbg, int* minorDbg) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

287 global __nvvmIRVersion 

288 _check_or_init_nvvm() 38 ctx2a 5 6 7 8 9 ! # $ % ' ( ) * + , - . / : ~ abbbu v = ? @ [ ] ^ _ ` p q r s t

289 if __nvvmIRVersion == NULL: 38 ctx2a 5 6 7 8 9 ! # $ % ' ( ) * + , - . / : ~ abbbu v = ? @ [ ] ^ _ ` p q r s t

290 with gil: 

291 raise FunctionNotFoundError("function nvvmIRVersion is not found") 10 ctx1kmoXOPQRST

292 return (<nvvmResult (*)(int*, int*, int*, int*) noexcept nogil>__nvvmIRVersion)( 48 ctx2a 5 k 6 7 m 8 o X 9 ! # $ % ' ( ) * O + P , Q - R . S / T : ~ abbbu v = ? @ [ ] ^ _ ` p q r s t

293 majorIR, minorIR, majorDbg, minorDbg) 

294  

295  

296cdef nvvmResult _nvvmCreateProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

297 global __nvvmCreateProgram 

298 _check_or_init_nvvm() 56 ctx1aYZjklmnoWXbcdefghi0NwOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

299 if __nvvmCreateProgram == NULL: 56 ctx1aYZjklmnoWXbcdefghi0NwOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

300 with gil: 

301 raise FunctionNotFoundError("function nvvmCreateProgram is not found") 9 ctx1bcdefghiN

302 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmCreateProgram)( 56 ctx1aYZjklmnoWXbcdefghi0NwOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

303 prog) 

304  

305  

306cdef nvvmResult _nvvmDestroyProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

307 global __nvvmDestroyProgram 

308 _check_or_init_nvvm() 56 ctx1a|YZjklmnoWXbcdefghi0NwOPQRST}xy1U2zABCDEFGHIJKLMuvpqrst

309 if __nvvmDestroyProgram == NULL: 56 ctx1a|YZjklmnoWXbcdefghi0NwOPQRST}xy1U2zABCDEFGHIJKLMuvpqrst

310 with gil: 

311 raise FunctionNotFoundError("function nvvmDestroyProgram is not found") 9 ctx1bcdefghiN

312 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmDestroyProgram)( 56 ctx1a|YZjklmnoWXbcdefghi0NwOPQRST}xy1U2zABCDEFGHIJKLMuvpqrst

313 prog) 

314  

315  

316cdef nvvmResult _nvvmAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

317 global __nvvmAddModuleToProgram 

318 _check_or_init_nvvm() 49 ctx1ajklmnobcdefghiOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

319 if __nvvmAddModuleToProgram == NULL: 49 ctx1ajklmnobcdefghiOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

320 with gil: 

321 raise FunctionNotFoundError("function nvvmAddModuleToProgram is not found") 15 ctx1jklmnobcdefghiw

322 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmAddModuleToProgram)( 50 ctx1ajklmnobcdefghiwOPQRST;xy1U2VzABCDEFGHIJKLMuvpqrst

323 prog, buffer, size, name) 

324  

325  

326cdef nvvmResult _nvvmLazyAddModuleToProgram(nvvmProgram prog, const char* buffer, size_t size, const char* name) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

327 global __nvvmLazyAddModuleToProgram 

328 _check_or_init_nvvm() 

329 if __nvvmLazyAddModuleToProgram == NULL: (empty)

330 with gil: 

331 raise FunctionNotFoundError("function nvvmLazyAddModuleToProgram is not found") 15 ctx1jklmnobcdefghiw

332 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmLazyAddModuleToProgram)( 15 ctx1jklmnobcdefghiw

333 prog, buffer, size, name) 

334  

335  

336cdef nvvmResult _nvvmCompileProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

337 global __nvvmCompileProgram 

338 _check_or_init_nvvm() 37 ctx1ajlnWbcdefghixyVzABCDEFGHIJKLMuvpqrst

339 if __nvvmCompileProgram == NULL: 37 ctx1ajlnWbcdefghixyVzABCDEFGHIJKLMuvpqrst

340 with gil: 

341 raise FunctionNotFoundError("function nvvmCompileProgram is not found") 1 ctx13

342 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmCompileProgram)( 38 ctx1ajlnWbcdefghi3xyVzABCDEFGHIJKLMuvpqrst

343 prog, numOptions, options) 

344  

345  

346cdef nvvmResult _nvvmVerifyProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

347 global __nvvmVerifyProgram 

348 _check_or_init_nvvm() 30 ctx1kmoXOPQRSTxyUVzABCDEFGHIJKLMuv

349 if __nvvmVerifyProgram == NULL: 30 ctx1kmoXOPQRSTxyUVzABCDEFGHIJKLMuv

350 with gil: 

351 raise FunctionNotFoundError("function nvvmVerifyProgram is not found") 

352 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmVerifyProgram)( 30 ctx1kmoXOPQRSTxyUVzABCDEFGHIJKLMuv

353 prog, numOptions, options) 

354  

355  

356cdef nvvmResult _nvvmGetCompiledResultSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

357 global __nvvmGetCompiledResultSize 

358 _check_or_init_nvvm() 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

359 if __nvvmGetCompiledResultSize == NULL: 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

360 with gil: 

361 raise FunctionNotFoundError("function nvvmGetCompiledResultSize is not found") 

362 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetCompiledResultSize)( 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

363 prog, bufferSizeRet) 

364  

365  

366cdef nvvmResult _nvvmGetCompiledResult(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

367 global __nvvmGetCompiledResult 

368 _check_or_init_nvvm() 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

369 if __nvvmGetCompiledResult == NULL: 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

370 with gil: 

371 raise FunctionNotFoundError("function nvvmGetCompiledResult is not found") 

372 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetCompiledResult)( 28 ctx1bcdefghiNxyVzABCDEFGHIJKLMuv

373 prog, buffer) 

374  

375  

376cdef nvvmResult _nvvmGetProgramLogSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

377 global __nvvmGetProgramLogSize 

378 _check_or_init_nvvm() 16 ctx1jklmnobcdefghiwU

379 if __nvvmGetProgramLogSize == NULL: 16 ctx1jklmnobcdefghiwU

380 with gil: 

381 raise FunctionNotFoundError("function nvvmGetProgramLogSize is not found") 

382 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetProgramLogSize)( 16 ctx1jklmnobcdefghiwU

383 prog, bufferSizeRet) 

384  

385  

386cdef nvvmResult _nvvmGetProgramLog(nvvmProgram prog, char* buffer) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

387 global __nvvmGetProgramLog 

388 _check_or_init_nvvm() 16 ctx1jklmnobcdefghiwU

389 if __nvvmGetProgramLog == NULL: 16 ctx1jklmnobcdefghiwU

390 with gil: 

391 raise FunctionNotFoundError("function nvvmGetProgramLog is not found") 

392 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetProgramLog)( 16 ctx1jklmnobcdefghiwU

393 prog, buffer) 

394  

395  

396cdef nvvmResult _nvvmLLVMVersion(const char* arch, int* major) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: (empty)

397 global __nvvmLLVMVersion 

398 _check_or_init_nvvm() 1 ctx13

399 if __nvvmLLVMVersion == NULL: 1 ctx13

400 with gil: 

401 raise FunctionNotFoundError("function nvvmLLVMVersion is not found") 

402 return (<nvvmResult (*)(const char*, int*) noexcept nogil>__nvvmLLVMVersion)( 1 ctx13

403 arch, major)