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

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

2# 

3# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE 

4# 

5# This code was automatically generated across versions from 12.0.1 to 13.2.0, generator version 0.3.1.dev1406+gd8426ea19.d20260316. Do not modify it directly. 

6  

7from libc.stdint cimport intptr_t, uintptr_t 

8  

9import threading (empty)

10from .utils import FunctionNotFoundError, NotSupportedError (empty)

11  

12from cuda.pathfinder import load_nvidia_dynamic_lib (empty)

13  

14  

15############################################################################### 

16# Extern 

17############################################################################### 

18  

19# You must 'from .utils import NotSupportedError' before using this template 

20  

21cdef extern from "<dlfcn.h>" nogil: 

22 void* dlopen(const char*, int) 

23 char* dlerror() 

24 void* dlsym(void*, const char*) 

25 int dlclose(void*) 

26  

27 enum: 

28 RTLD_LAZY 

29 RTLD_NOW 

30 RTLD_GLOBAL 

31 RTLD_LOCAL 

32  

33 const void* RTLD_DEFAULT 'RTLD_DEFAULT' 

34  

35cdef int get_cuda_version(): (empty)

36 cdef void* handle = NULL 

37 cdef int err, driver_ver = 0 

38  

39 # Load driver to check version 

40 handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL) (empty)

41 if handle == NULL: 

42 err_msg = dlerror() 

43 raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})') 

44 cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion") 

45 if cuDriverGetVersion == NULL: 

46 raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1') 

47 err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver) 

48 if err != 0: 

49 raise RuntimeError(f'cuDriverGetVersion returned error code {err}') 

50  

51 return driver_ver 

52  

53  

54  

55############################################################################### 

56# Wrapper init 

57############################################################################### 

58  

59cdef object __symbol_lock = threading.Lock() (empty)

60cdef bint __py_nvvm_init = False (empty)

61  

62cdef void* __nvvmGetErrorString = NULL (empty)

63cdef void* __nvvmVersion = NULL (empty)

64cdef void* __nvvmIRVersion = NULL (empty)

65cdef void* __nvvmCreateProgram = NULL (empty)

66cdef void* __nvvmDestroyProgram = NULL (empty)

67cdef void* __nvvmAddModuleToProgram = NULL (empty)

68cdef void* __nvvmLazyAddModuleToProgram = NULL (empty)

69cdef void* __nvvmCompileProgram = NULL (empty)

70cdef void* __nvvmVerifyProgram = NULL (empty)

71cdef void* __nvvmGetCompiledResultSize = NULL (empty)

72cdef void* __nvvmGetCompiledResult = NULL (empty)

73cdef void* __nvvmGetProgramLogSize = NULL (empty)

74cdef void* __nvvmGetProgramLog = NULL (empty)

75cdef void* __nvvmLLVMVersion = NULL (empty)

76  

77  

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

79 cdef uintptr_t handle = load_nvidia_dynamic_lib("nvvm")._handle_uint 2 ctx1ab

80 return <void*>handle 2 ctx1ab

81  

82  

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

84 global __py_nvvm_init 

85  

86 cdef void* handle = NULL 2 ctx1ab

87  

88 with gil, __symbol_lock: 2 ctx1ab

89 # Recheck the flag after obtaining the locks 

90 if __py_nvvm_init: 2 ctx1ab

91 return 0 (empty)

92  

93 # Load function 

94 global __nvvmGetErrorString 

95 __nvvmGetErrorString = dlsym(RTLD_DEFAULT, 'nvvmGetErrorString') 2 ctx1ab

96 if __nvvmGetErrorString == NULL: 2 ctx1ab

97 if handle == NULL: 2 ctx1ab

98 handle = load_library() 2 ctx1ab

99 __nvvmGetErrorString = dlsym(handle, 'nvvmGetErrorString') 3 ctx1abc

100  

101 global __nvvmVersion 

102 __nvvmVersion = dlsym(RTLD_DEFAULT, 'nvvmVersion') 2 ctx1ab

103 if __nvvmVersion == NULL: 2 ctx1ab

104 if handle == NULL: 

105 handle = load_library() 1 ctx1c

106 __nvvmVersion = dlsym(handle, 'nvvmVersion') 

107  

108 global __nvvmIRVersion 

109 __nvvmIRVersion = dlsym(RTLD_DEFAULT, 'nvvmIRVersion') 3 ctx1abc

110 if __nvvmIRVersion == NULL: 2 ctx1ab

111 if handle == NULL: 

112 handle = load_library() 1 ctx1c

113 __nvvmIRVersion = dlsym(handle, 'nvvmIRVersion') 

114  

115 global __nvvmCreateProgram 

116 __nvvmCreateProgram = dlsym(RTLD_DEFAULT, 'nvvmCreateProgram') 2 ctx1ab

117 if __nvvmCreateProgram == NULL: 2 ctx1ab

118 if handle == NULL: 1 ctx1c

119 handle = load_library() 

120 __nvvmCreateProgram = dlsym(handle, 'nvvmCreateProgram') 

121  

122 global __nvvmDestroyProgram 

123 __nvvmDestroyProgram = dlsym(RTLD_DEFAULT, 'nvvmDestroyProgram') 2 ctx1ab

124 if __nvvmDestroyProgram == NULL: 3 ctx1abc

125 if handle == NULL: 

126 handle = load_library() 

127 __nvvmDestroyProgram = dlsym(handle, 'nvvmDestroyProgram') 1 ctx1c

128  

129 global __nvvmAddModuleToProgram 

130 __nvvmAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmAddModuleToProgram') 3 ctx1abc

131 if __nvvmAddModuleToProgram == NULL: 2 ctx1ab

132 if handle == NULL: 

133 handle = load_library() 2 ctx1ac

134 __nvvmAddModuleToProgram = dlsym(handle, 'nvvmAddModuleToProgram') 

135  

136 global __nvvmLazyAddModuleToProgram 

137 __nvvmLazyAddModuleToProgram = dlsym(RTLD_DEFAULT, 'nvvmLazyAddModuleToProgram') 2 ctx1ab

138 if __nvvmLazyAddModuleToProgram == NULL: 2 ctx1ab

139 if handle == NULL: 1 ctx1c

140 handle = load_library() 

141 __nvvmLazyAddModuleToProgram = dlsym(handle, 'nvvmLazyAddModuleToProgram') 

142  

143 global __nvvmCompileProgram 

144 __nvvmCompileProgram = dlsym(RTLD_DEFAULT, 'nvvmCompileProgram') 2 ctx1ab

145 if __nvvmCompileProgram == NULL: 3 ctx1abc

146 if handle == NULL: 

147 handle = load_library() 

148 __nvvmCompileProgram = dlsym(handle, 'nvvmCompileProgram') 1 ctx1c

149  

150 global __nvvmVerifyProgram 

151 __nvvmVerifyProgram = dlsym(RTLD_DEFAULT, 'nvvmVerifyProgram') 3 ctx1abc

152 if __nvvmVerifyProgram == NULL: 2 ctx1ab

153 if handle == NULL: 

154 handle = load_library() (empty)

155 __nvvmVerifyProgram = dlsym(handle, 'nvvmVerifyProgram') 49 ctx1Ubl0m1n2o3pcSTd4e5f6g7h8i9j!k#VIJ,$XYK%L'M(N)O*P+

156  

157 global __nvvmGetCompiledResultSize 

158 __nvvmGetCompiledResultSize = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResultSize') 3 ctx1abc

159 if __nvvmGetCompiledResultSize == NULL: 2 ctx1ab

160 if handle == NULL: 

161 handle = load_library() (empty)

162 __nvvmGetCompiledResultSize = dlsym(handle, 'nvvmGetCompiledResultSize') 

163  

164 global __nvvmGetCompiledResult 

165 __nvvmGetCompiledResult = dlsym(RTLD_DEFAULT, 'nvvmGetCompiledResult') 2 ctx1ab

166 if __nvvmGetCompiledResult == NULL: 2 ctx1ab

167 if handle == NULL: 

168 handle = load_library() 

169 __nvvmGetCompiledResult = dlsym(handle, 'nvvmGetCompiledResult') 

170  

171 global __nvvmGetProgramLogSize 

172 __nvvmGetProgramLogSize = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLogSize') 2 ctx1ab

173 if __nvvmGetProgramLogSize == NULL: 2 ctx1ab

174 if handle == NULL: 

175 handle = load_library() 

176 __nvvmGetProgramLogSize = dlsym(handle, 'nvvmGetProgramLogSize') 

177  

178 global __nvvmGetProgramLog 

179 __nvvmGetProgramLog = dlsym(RTLD_DEFAULT, 'nvvmGetProgramLog') 2 ctx1ab

180 if __nvvmGetProgramLog == NULL: 2 ctx1ab

181 if handle == NULL: 

182 handle = load_library() 

183 __nvvmGetProgramLog = dlsym(handle, 'nvvmGetProgramLog') 

184  

185 global __nvvmLLVMVersion 

186 __nvvmLLVMVersion = dlsym(RTLD_DEFAULT, 'nvvmLLVMVersion') 2 ctx1ab

187 if __nvvmLLVMVersion == NULL: 2 ctx1ab

188 if handle == NULL: 

189 handle = load_library() 

190 __nvvmLLVMVersion = dlsym(handle, 'nvvmLLVMVersion') 

191  

192 __py_nvvm_init = True 2 ctx1ab

193 return 0 2 ctx1ab

194  

195  

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

197 if __py_nvvm_init: 77 ctx1a-Ubl0m1n2o3pcSTd4e5f6g7h8i9j!k#VIJ,$XYK%L'M(N)O*P+Z.s/t:QWRu;vwxyzABCDEFGHqr

198 return 0 77 ctx1a-Ubl0m1n2o3pcSTd4e5f6g7h8i9j!k#VIJ,$XYK%L'M(N)O*P+Z.s/t:QWRu;vwxyzABCDEFGHqr

199  

200 return _init_nvvm() 2 ctx1ab

201  

202  

203cdef dict func_ptrs = None (empty)

204  

205  

206cpdef dict _inspect_function_pointers(): (empty)

207 global func_ptrs 

208 if func_ptrs is not None: 

209 return func_ptrs 

210  

211 _check_or_init_nvvm() 

212 cdef dict data = {} 

213  

214 global __nvvmGetErrorString 

215 data["__nvvmGetErrorString"] = <intptr_t>__nvvmGetErrorString 

216  

217 global __nvvmVersion 

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

219  

220 global __nvvmIRVersion 

221 data["__nvvmIRVersion"] = <intptr_t>__nvvmIRVersion 

222  

223 global __nvvmCreateProgram 

224 data["__nvvmCreateProgram"] = <intptr_t>__nvvmCreateProgram 

225  

226 global __nvvmDestroyProgram 

227 data["__nvvmDestroyProgram"] = <intptr_t>__nvvmDestroyProgram 

228  

229 global __nvvmAddModuleToProgram 

230 data["__nvvmAddModuleToProgram"] = <intptr_t>__nvvmAddModuleToProgram 

231  

232 global __nvvmLazyAddModuleToProgram 

233 data["__nvvmLazyAddModuleToProgram"] = <intptr_t>__nvvmLazyAddModuleToProgram 

234  

235 global __nvvmCompileProgram 

236 data["__nvvmCompileProgram"] = <intptr_t>__nvvmCompileProgram 

237  

238 global __nvvmVerifyProgram 

239 data["__nvvmVerifyProgram"] = <intptr_t>__nvvmVerifyProgram (empty)

240  

241 global __nvvmGetCompiledResultSize 

242 data["__nvvmGetCompiledResultSize"] = <intptr_t>__nvvmGetCompiledResultSize 1 ctx1Y

243  

244 global __nvvmGetCompiledResult 

245 data["__nvvmGetCompiledResult"] = <intptr_t>__nvvmGetCompiledResult 1 ctx1Y

246  

247 global __nvvmGetProgramLogSize 

248 data["__nvvmGetProgramLogSize"] = <intptr_t>__nvvmGetProgramLogSize 

249  

250 global __nvvmGetProgramLog 

251 data["__nvvmGetProgramLog"] = <intptr_t>__nvvmGetProgramLog 19 ctx10123456789!#$%'()*+

252  

253 global __nvvmLLVMVersion 

254 data["__nvvmLLVMVersion"] = <intptr_t>__nvvmLLVMVersion 

255  

256 func_ptrs = data 

257 return data 

258  

259  

260cpdef _inspect_function_pointer(str name): (empty)

261 global func_ptrs 

262 if func_ptrs is None: 27 ctx1UblmnopcSTdefghijkVIJKLMNOP

263 func_ptrs = _inspect_function_pointers() 

264 return func_ptrs[name] 

265  

266  

267############################################################################### 

268# Wrapper functions 

269############################################################################### 

270  

271cdef const char* _nvvmGetErrorString(nvvmResult result) except?NULL nogil: 28 ctx1aUblmnopcSTdefghijkVIJKLMNOP

272 global __nvvmGetErrorString 

273 _check_or_init_nvvm() 1 ctx1,

274 if __nvvmGetErrorString == NULL: 1 ctx1,

275 with gil: 27 ctx1UblmnopcSTdefghijkVIJKLMNOP

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

277 return (<const char* (*)(nvvmResult) noexcept nogil>__nvvmGetErrorString)( 1 ctx1,

278 result) 

279  

280  

281cdef nvvmResult _nvvmVersion(int* major, int* minor) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 21 ctx1almnopcdefghijkKLMNOP

282 global __nvvmVersion 

283 _check_or_init_nvvm() 2 ctx1aY

284 if __nvvmVersion == NULL: 2 ctx1aY

285 with gil: 20 ctx1lmnopcdefghijkKLMNOP

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

287 return (<nvvmResult (*)(int*, int*) noexcept nogil>__nvvmVersion)( 2 ctx1aY

288 major, minor) 

289  

290  

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

292 global __nvvmIRVersion 

293 _check_or_init_nvvm() 25 ctx1a0123456789!#$%'()*+/:;qr

294 if __nvvmIRVersion == NULL: 25 ctx1a0123456789!#$%'()*+/:;qr

295 with gil: 

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

297 return (<nvvmResult (*)(int*, int*, int*, int*) noexcept nogil>__nvvmIRVersion)( 25 ctx1a0123456789!#$%'()*+/:;qr

298 majorIR, minorIR, majorDbg, minorDbg) 

299  

300  

301cdef nvvmResult _nvvmCreateProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 13 ctx1alnpSdefghijk

302 global __nvvmCreateProgram 

303 _check_or_init_nvvm() 50 ctx1aUblmnopcSTdefghijkVIJKLMNOPZstQWRuvwxyzABCDEFGHqr

304 if __nvvmCreateProgram == NULL: 50 ctx1aUblmnopcSTdefghijkVIJKLMNOPZstQWRuvwxyzABCDEFGHqr

305 with gil: 12 ctx1lnpSdefghijk

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

307 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmCreateProgram)( 50 ctx1aUblmnopcSTdefghijkVIJKLMNOPZstQWRuvwxyzABCDEFGHqr

308 prog) 

309  

310  

311cdef nvvmResult _nvvmDestroyProgram(nvvmProgram* prog) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 11 ctx1amocTKLMNOP

312 global __nvvmDestroyProgram 

313 _check_or_init_nvvm() 50 ctx1a-UblmnopcSTdefghijkVIJKLMNOP.stQWuvwxyzABCDEFGHqr

314 if __nvvmDestroyProgram == NULL: 50 ctx1a-UblmnopcSTdefghijkVIJKLMNOP.stQWuvwxyzABCDEFGHqr

315 with gil: 10 ctx1mocTKLMNOP

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

317 return (<nvvmResult (*)(nvvmProgram*) noexcept nogil>__nvvmDestroyProgram)( 50 ctx1a-UblmnopcSTdefghijkVIJKLMNOP.stQWuvwxyzABCDEFGHqr

318 prog) 

319  

320  

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

322 global __nvvmAddModuleToProgram 

323 _check_or_init_nvvm() 43 ctx1almnopcdefghijkKLMNOPZstQWRuvwxyzABCDEFGHqr

324 if __nvvmAddModuleToProgram == NULL: 43 ctx1almnopcdefghijkKLMNOPZstQWRuvwxyzABCDEFGHqr

325 with gil: 9 ctx1defghijkI

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

327 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmAddModuleToProgram)( 43 ctx1almnopcdefghijkKLMNOPZstQWRuvwxyzABCDEFGHqr

328 prog, buffer, size, name) 

329  

330  

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

332 global __nvvmLazyAddModuleToProgram 

333 _check_or_init_nvvm() 

334 if __nvvmLazyAddModuleToProgram == NULL: 

335 with gil: 9 ctx1defghijkI

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

337 return (<nvvmResult (*)(nvvmProgram, const char*, size_t, const char*) noexcept nogil>__nvvmLazyAddModuleToProgram)( 

338 prog, buffer, size, name) 

339  

340  

341cdef nvvmResult _nvvmCompileProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 16 ctx1almnopcdefghijkJ

342 global __nvvmCompileProgram 

343 _check_or_init_nvvm() 32 ctx1alnpSdefghijkstRuvwxyzABCDEFGHqr

344 if __nvvmCompileProgram == NULL: 32 ctx1alnpSdefghijkstRuvwxyzABCDEFGHqr

345 with gil: 15 ctx1lmnopcdefghijkJ

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

347 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmCompileProgram)( 32 ctx1alnpSdefghijkstRuvwxyzABCDEFGHqr

348 prog, numOptions, options) 

349  

350  

351cdef nvvmResult _nvvmVerifyProgram(nvvmProgram prog, int numOptions, const char** options) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 16 ctx1almnopcdefghijkJ

352 global __nvvmVerifyProgram 

353 _check_or_init_nvvm() 31 ctx1amocTKLMNOPstQRuvwxyzABCDEFGHqr

354 if __nvvmVerifyProgram == NULL: 31 ctx1amocTKLMNOPstQRuvwxyzABCDEFGHqr

355 with gil: 15 ctx1lmnopcdefghijkJ

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

357 return (<nvvmResult (*)(nvvmProgram, int, const char**) noexcept nogil>__nvvmVerifyProgram)( 31 ctx1amocTKLMNOPstQRuvwxyzABCDEFGHqr

358 prog, numOptions, options) 

359  

360  

361cdef nvvmResult _nvvmGetCompiledResultSize(nvvmProgram prog, size_t* bufferSizeRet) except?_NVVMRESULT_INTERNAL_LOADING_ERROR nogil: 2 ctx1aX

362 global __nvvmGetCompiledResultSize 

363 _check_or_init_nvvm() 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

364 if __nvvmGetCompiledResultSize == NULL: 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

365 with gil: 1 ctx1X

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

367 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetCompiledResultSize)( 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

368 prog, bufferSizeRet) 

369  

370  

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

372 global __nvvmGetCompiledResult 

373 _check_or_init_nvvm() 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

374 if __nvvmGetCompiledResult == NULL: 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

375 with gil: 

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

377 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetCompiledResult)( 29 ctx1adefghijkIstRuvwxyzABCDEFGHqr

378 prog, buffer) 

379  

380  

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

382 global __nvvmGetProgramLogSize 

383 _check_or_init_nvvm() 16 ctx1lmnopcdefghijkJQ

384 if __nvvmGetProgramLogSize == NULL: 16 ctx1lmnopcdefghijkJQ

385 with gil: 

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

387 return (<nvvmResult (*)(nvvmProgram, size_t*) noexcept nogil>__nvvmGetProgramLogSize)( 16 ctx1lmnopcdefghijkJQ

388 prog, bufferSizeRet) 

389  

390  

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

392 global __nvvmGetProgramLog 

393 _check_or_init_nvvm() 16 ctx1lmnopcdefghijkJQ

394 if __nvvmGetProgramLog == NULL: 16 ctx1lmnopcdefghijkJQ

395 with gil: 

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

397 return (<nvvmResult (*)(nvvmProgram, char*) noexcept nogil>__nvvmGetProgramLog)( 16 ctx1lmnopcdefghijkJQ

398 prog, buffer) 

399  

400  

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

402 global __nvvmLLVMVersion 

403 _check_or_init_nvvm() 1 ctx1X

404 if __nvvmLLVMVersion == NULL: 1 ctx1X

405 with gil: 

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

407 return (<nvvmResult (*)(const char*, int*) noexcept nogil>__nvvmLLVMVersion)( 1 ctx1X

408 arch, major)