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

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=5d1c4358f6dd269e4a5313c7a717acafaebf90ab58acc30002affa060c8389b4 

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 

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() (empty)

135 __nvvmLazyAddModuleToProgram = _cyb_dlsym(handle, 'nvvmLazyAddModuleToProgram') 

136  

137 global __nvvmCompileProgram 

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

139 if __nvvmCompileProgram == NULL: (empty)

140 if handle == NULL: (empty)

141 handle = load_library() 

142 __nvvmCompileProgram = _cyb_dlsym(handle, 'nvvmCompileProgram') 

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') (empty)

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

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

192  

193 return _init_nvvm() (empty)

194  

195  

196cpdef dict _inspect_function_pointers(): (empty)

197 global _cyb_func_ptrs 

198 if _cyb_func_ptrs is not None: (empty)

199 return _cyb_func_ptrs 6 ctx1aLMNOP

200  

201 _check_or_init_nvvm() (empty)

202 cdef dict data = {} (empty)

203 global __nvvmGetErrorString 

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

205  

206 global __nvvmVersion 

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

208  

209 global __nvvmIRVersion 

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

211  

212 global __nvvmCreateProgram 

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

214  

215 global __nvvmDestroyProgram 

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

217  

218 global __nvvmAddModuleToProgram 

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

220  

221 global __nvvmLazyAddModuleToProgram 

222 data["__nvvmLazyAddModuleToProgram"] = <intptr_t>__nvvmLazyAddModuleToProgram (empty)

223  

224 global __nvvmCompileProgram 

225 data["__nvvmCompileProgram"] = <intptr_t>__nvvmCompileProgram 10 ctx1a'6789!#$%

226  

227 global __nvvmVerifyProgram 

228 data["__nvvmVerifyProgram"] = <intptr_t>__nvvmVerifyProgram 10 ctx1a'6789!#$%

229  

230 global __nvvmGetCompiledResultSize 

231 data["__nvvmGetCompiledResultSize"] = <intptr_t>__nvvmGetCompiledResultSize (empty)

232  

233 global __nvvmGetCompiledResult 

234 data["__nvvmGetCompiledResult"] = <intptr_t>__nvvmGetCompiledResult 38 ctx2a ( ) * + , - . / : ; = ? @ ] ^ _ ` { | ~ abfbk l 6 7 8 9 ! # $ % L M N O P

235  

236 global __nvvmGetProgramLogSize 

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

238  

239 global __nvvmGetProgramLog 

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

241  

242 global __nvvmLLVMVersion 

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

244 _cyb_func_ptrs = data 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

245 return data 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

246  

247  

248cpdef _inspect_function_pointer(str name): 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

249 global _cyb_func_ptrs 

250 if _cyb_func_ptrs is None: 6 ctx1aLMNOP

251 _cyb_func_ptrs = _inspect_function_pointers() (empty)

252 return _cyb_func_ptrs[name] 6 ctx1aLMNOP

253  

254  

255  

256  

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

258 cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint 58 ctx2a 2 3 D E F G H I Y 1 b c d e f g h i 4 R Q S T U V W X } m n ebZ J 0 j o p q r s t u v w x y z A B C k l L M N O P

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() 52 ctx2a D E F G H I b c d e f g h i bbS T U V W X 5 m n Z J 0 j K o p q r s t u v w x y z A B C k l L M N O P

269 if __nvvmGetErrorString == NULL: 1 ctx2bb

270 with gil: 

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

272 return (<const char* (*)(nvvmResult) noexcept nogil>__nvvmGetErrorString)( 2 ctx2a bb

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() 11 ctx1a'j6789!#$%

279 if __nvvmVersion == NULL: 10 ctx1a'6789!#$%

280 with gil: 

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

282 return (<nvvmResult (*)(int*, int*) noexcept nogil>__nvvmVersion)( 10 ctx1a'6789!#$%

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() 69 ctx2a D ( ) F * + H Y b , c - d . e / f : g ; h = i ? @ ] ^ _ ` { | m ~ n abj K o p q r s t u v w dbx y z A B C k l 6 7 8 9 ! # $ % L M N O P

289 if __nvvmIRVersion == NULL: 38 ctx2a ( ) * + , - . / : ; = ? @ ] ^ _ ` { | ~ abdbk l 6 7 8 9 ! # $ % L M N O P

290 with gil: 

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

292 return (<nvvmResult (*)(int*, int*, int*, int*) noexcept nogil>__nvvmIRVersion)( 38 ctx2a ( ) * + , - . / : ; = ? @ ] ^ _ ` { | ~ abdbk l 6 7 8 9 ! # $ % L M N O P

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() 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

299 if __nvvmCreateProgram == NULL: 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

300 with gil: 

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

302 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmCreateProgram)( 58 ctx1a23DEFGHIY1bcdefghi4RQSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

303 prog) 

304  

305  

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

307 global __nvvmDestroyProgram 

308 _check_or_init_nvvm() 59 ctx2a 2 3 D E F G H I Y 1 b c d e f g h i 4 R Q S T U V W X } m n cbZ J 0 j K o p q r s t u v w x y z A B C k l L M N O P

309 if __nvvmDestroyProgram == NULL: 58 ctx2a 2 3 D E F G H I Y 1 b c d e f g h i 4 R Q S T U V W X } m n cbZ J 0 j o p q r s t u v w x y z A B C k l L M N O P

310 with gil: 

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

312 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmDestroyProgram)( 58 ctx2a 2 3 D E F G H I Y 1 b c d e f g h i 4 R Q S T U V W X } m n cbZ J 0 j o p q r s t u v w x y z A B C k l L M N O P

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() 52 ctx1aDEFGHIbcdefghiRSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

319 if __nvvmAddModuleToProgram == NULL: 51 ctx1aDEFGHIbcdefghiSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

320 with gil: 

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

322 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmAddModuleToProgram)( 51 ctx1aDEFGHIbcdefghiSTUVWX5mnZJ0jKopqrstuvwxyzABCklLMNOP

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() 17 ctx1DEFGHIbcdefghiQJj

329 if __nvvmLazyAddModuleToProgram == NULL: 1 ctx1j

330 with gil: 

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

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

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() 44 ctx1aDEFGHIYbcdefghiQmnJjKopqrstuvwxyzABCklLMNOP

339 if __nvvmCompileProgram == NULL: 39 ctx1aDFHYbcdefghimnjKopqrstuvwxyzABCklLMNOP

340 with gil: 

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

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

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() 33 ctx1EGI1[STUVWXmnJjKopqrstuvwxyzABCkl

349 if __nvvmVerifyProgram == NULL: 32 ctx1EGI1STUVWXmnJjKopqrstuvwxyzABCkl

350 with gil: 

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

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

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() 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

359 if __nvvmGetCompiledResultSize == NULL: 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

360 with gil: 

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

362 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetCompiledResultSize)( 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

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() 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

369 if __nvvmGetCompiledResult == NULL: 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

370 with gil: 

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

372 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetCompiledResult)( 30 ctx1bcdefghiRmnjKopqrstuvwxyzABCkl

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 ctx1DEFGHIbcdefghiQJ

379 if __nvvmGetProgramLogSize == NULL: 16 ctx1DEFGHIbcdefghiQJ

380 with gil: 

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

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

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 ctx1DEFGHIbcdefghiQJ

389 if __nvvmGetProgramLog == NULL: 16 ctx1DEFGHIbcdefghiQJ

390 with gil: 

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

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

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 ctx1[

399 if __nvvmLLVMVersion == NULL: 1 ctx1[

400 with gil: 

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

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

403 arch, major)