authorgravatar for liljaanton2001@gmail.comantlilja <liljaanton2001@gmail.com> 2024-02-21 17:54:00+01:00
committergravatar for liljaanton2001@gmail.comantlilja <liljaanton2001@gmail.com> 2024-02-21 17:54:00+01:00
log713a555aa157ae6f8d55f7bd381f414b54028637
tree005bbe3c23e0a868406bca358b14d83719c274e9
parentf6d275b14e7097708c8f719fc2378a9ce79731fc

LLVM: Remove unused from llvm/bindings.zig and zig_llvm.h/.cpp

3 files changed, 0 insertions(+), 2235 deletions(-)

src/codegen/llvm/bindings.zig-1418
......@@ -15,7 +15,6 @@ pub const Bool = enum(c_int) {
1515 return b != .False;
1616 }
1717};
18pub const AttributeIndex = c_uint;
1918
2019pub const MemoryBuffer = opaque {
2120 pub const createMemoryBufferWithMemoryRange = LLVMCreateMemoryBufferWithMemoryRange;
......@@ -36,382 +35,14 @@ pub const Context = opaque {
3635 pub const parseBitcodeInContext2 = LLVMParseBitcodeInContext2;
3736 extern fn LLVMParseBitcodeInContext2(C: *Context, MemBuf: *MemoryBuffer, OutModule: **Module) Bool;
3837
39 pub const createEnumAttribute = LLVMCreateEnumAttribute;
40 extern fn LLVMCreateEnumAttribute(C: *Context, KindID: c_uint, Val: u64) *Attribute;
41
42 pub const createTypeAttribute = LLVMCreateTypeAttribute;
43 extern fn LLVMCreateTypeAttribute(C: *Context, KindID: c_uint, Type: *Type) *Attribute;
44
45 pub const createStringAttribute = LLVMCreateStringAttribute;
46 extern fn LLVMCreateStringAttribute(C: *Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *Attribute;
47
48 pub const pointerType = LLVMPointerTypeInContext;
49 extern fn LLVMPointerTypeInContext(C: *Context, AddressSpace: c_uint) *Type;
50
51 pub const intType = LLVMIntTypeInContext;
52 extern fn LLVMIntTypeInContext(C: *Context, NumBits: c_uint) *Type;
53
54 pub const halfType = LLVMHalfTypeInContext;
55 extern fn LLVMHalfTypeInContext(C: *Context) *Type;
56
57 pub const bfloatType = LLVMBFloatTypeInContext;
58 extern fn LLVMBFloatTypeInContext(C: *Context) *Type;
59
60 pub const floatType = LLVMFloatTypeInContext;
61 extern fn LLVMFloatTypeInContext(C: *Context) *Type;
62
63 pub const doubleType = LLVMDoubleTypeInContext;
64 extern fn LLVMDoubleTypeInContext(C: *Context) *Type;
65
66 pub const fp128Type = LLVMFP128TypeInContext;
67 extern fn LLVMFP128TypeInContext(C: *Context) *Type;
68
69 pub const x86_fp80Type = LLVMX86FP80TypeInContext;
70 extern fn LLVMX86FP80TypeInContext(C: *Context) *Type;
71
72 pub const ppc_fp128Type = LLVMPPCFP128TypeInContext;
73 extern fn LLVMPPCFP128TypeInContext(C: *Context) *Type;
74
75 pub const x86_amxType = LLVMX86AMXTypeInContext;
76 extern fn LLVMX86AMXTypeInContext(C: *Context) *Type;
77
78 pub const x86_mmxType = LLVMX86MMXTypeInContext;
79 extern fn LLVMX86MMXTypeInContext(C: *Context) *Type;
80
81 pub const voidType = LLVMVoidTypeInContext;
82 extern fn LLVMVoidTypeInContext(C: *Context) *Type;
83
84 pub const labelType = LLVMLabelTypeInContext;
85 extern fn LLVMLabelTypeInContext(C: *Context) *Type;
86
87 pub const tokenType = LLVMTokenTypeInContext;
88 extern fn LLVMTokenTypeInContext(C: *Context) *Type;
89
90 pub const metadataType = LLVMMetadataTypeInContext;
91 extern fn LLVMMetadataTypeInContext(C: *Context) *Type;
92
93 pub const structType = LLVMStructTypeInContext;
94 extern fn LLVMStructTypeInContext(
95 C: *Context,
96 ElementTypes: [*]const *Type,
97 ElementCount: c_uint,
98 Packed: Bool,
99 ) *Type;
100
101 pub const structCreateNamed = LLVMStructCreateNamed;
102 extern fn LLVMStructCreateNamed(C: *Context, Name: [*:0]const u8) *Type;
103
104 pub const constString = LLVMConstStringInContext;
105 extern fn LLVMConstStringInContext(C: *Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *Value;
106
107 pub const appendBasicBlock = LLVMAppendBasicBlockInContext;
108 extern fn LLVMAppendBasicBlockInContext(C: *Context, Fn: *Value, Name: [*:0]const u8) *BasicBlock;
109
110 pub const createBuilder = LLVMCreateBuilderInContext;
111 extern fn LLVMCreateBuilderInContext(C: *Context) *Builder;
112
11338 pub const setOptBisectLimit = ZigLLVMSetOptBisectLimit;
11439 extern fn ZigLLVMSetOptBisectLimit(C: *Context, limit: c_int) void;
11540};
11641
117pub const Value = opaque {
118 pub const addAttributeAtIndex = LLVMAddAttributeAtIndex;
119 extern fn LLVMAddAttributeAtIndex(F: *Value, Idx: AttributeIndex, A: *Attribute) void;
120
121 pub const removeEnumAttributeAtIndex = LLVMRemoveEnumAttributeAtIndex;
122 extern fn LLVMRemoveEnumAttributeAtIndex(F: *Value, Idx: AttributeIndex, KindID: c_uint) void;
123
124 pub const removeStringAttributeAtIndex = LLVMRemoveStringAttributeAtIndex;
125 extern fn LLVMRemoveStringAttributeAtIndex(F: *Value, Idx: AttributeIndex, K: [*]const u8, KLen: c_uint) void;
126
127 pub const getFirstBasicBlock = LLVMGetFirstBasicBlock;
128 extern fn LLVMGetFirstBasicBlock(Fn: *Value) ?*BasicBlock;
129
130 pub const addIncoming = LLVMAddIncoming;
131 extern fn LLVMAddIncoming(
132 PhiNode: *Value,
133 IncomingValues: [*]const *Value,
134 IncomingBlocks: [*]const *BasicBlock,
135 Count: c_uint,
136 ) void;
137
138 pub const setGlobalConstant = LLVMSetGlobalConstant;
139 extern fn LLVMSetGlobalConstant(GlobalVar: *Value, IsConstant: Bool) void;
140
141 pub const setLinkage = LLVMSetLinkage;
142 extern fn LLVMSetLinkage(Global: *Value, Linkage: Linkage) void;
143
144 pub const setVisibility = LLVMSetVisibility;
145 extern fn LLVMSetVisibility(Global: *Value, Linkage: Visibility) void;
146
147 pub const setUnnamedAddr = LLVMSetUnnamedAddr;
148 extern fn LLVMSetUnnamedAddr(Global: *Value, HasUnnamedAddr: Bool) void;
149
150 pub const setThreadLocalMode = LLVMSetThreadLocalMode;
151 extern fn LLVMSetThreadLocalMode(Global: *Value, Mode: ThreadLocalMode) void;
152
153 pub const setSection = LLVMSetSection;
154 extern fn LLVMSetSection(Global: *Value, Section: [*:0]const u8) void;
155
156 pub const removeGlobalValue = ZigLLVMRemoveGlobalValue;
157 extern fn ZigLLVMRemoveGlobalValue(GlobalVal: *Value) void;
158
159 pub const eraseGlobalValue = ZigLLVMEraseGlobalValue;
160 extern fn ZigLLVMEraseGlobalValue(GlobalVal: *Value) void;
161
162 pub const deleteGlobalValue = ZigLLVMDeleteGlobalValue;
163 extern fn ZigLLVMDeleteGlobalValue(GlobalVal: *Value) void;
164
165 pub const setAliasee = LLVMAliasSetAliasee;
166 extern fn LLVMAliasSetAliasee(Alias: *Value, Aliasee: *Value) void;
167
168 pub const constAdd = LLVMConstAdd;
169 extern fn LLVMConstAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
170
171 pub const constNSWAdd = LLVMConstNSWAdd;
172 extern fn LLVMConstNSWAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
173
174 pub const constNUWAdd = LLVMConstNUWAdd;
175 extern fn LLVMConstNUWAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
176
177 pub const constSub = LLVMConstSub;
178 extern fn LLVMConstSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
179
180 pub const constNSWSub = LLVMConstNSWSub;
181 extern fn LLVMConstNSWSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
182
183 pub const constNUWSub = LLVMConstNUWSub;
184 extern fn LLVMConstNUWSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
185
186 pub const constMul = LLVMConstMul;
187 extern fn LLVMConstMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
188
189 pub const constNSWMul = LLVMConstNSWMul;
190 extern fn LLVMConstNSWMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
191
192 pub const constNUWMul = LLVMConstNUWMul;
193 extern fn LLVMConstNUWMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
194
195 pub const constAnd = LLVMConstAnd;
196 extern fn LLVMConstAnd(LHSConstant: *Value, RHSConstant: *Value) *Value;
197
198 pub const constOr = LLVMConstOr;
199 extern fn LLVMConstOr(LHSConstant: *Value, RHSConstant: *Value) *Value;
200
201 pub const constXor = LLVMConstXor;
202 extern fn LLVMConstXor(LHSConstant: *Value, RHSConstant: *Value) *Value;
203
204 pub const constShl = LLVMConstShl;
205 extern fn LLVMConstShl(LHSConstant: *Value, RHSConstant: *Value) *Value;
206
207 pub const constLShr = LLVMConstLShr;
208 extern fn LLVMConstLShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
209
210 pub const constAShr = LLVMConstAShr;
211 extern fn LLVMConstAShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
212
213 pub const constTrunc = LLVMConstTrunc;
214 extern fn LLVMConstTrunc(ConstantVal: *Value, ToType: *Type) *Value;
215
216 pub const constSExt = LLVMConstSExt;
217 extern fn LLVMConstSExt(ConstantVal: *Value, ToType: *Type) *Value;
218
219 pub const constZExt = LLVMConstZExt;
220 extern fn LLVMConstZExt(ConstantVal: *Value, ToType: *Type) *Value;
221
222 pub const constFPTrunc = LLVMConstFPTrunc;
223 extern fn LLVMConstFPTrunc(ConstantVal: *Value, ToType: *Type) *Value;
224
225 pub const constFPExt = LLVMConstFPExt;
226 extern fn LLVMConstFPExt(ConstantVal: *Value, ToType: *Type) *Value;
227
228 pub const constUIToFP = LLVMConstUIToFP;
229 extern fn LLVMConstUIToFP(ConstantVal: *Value, ToType: *Type) *Value;
230
231 pub const constSIToFP = LLVMConstSIToFP;
232 extern fn LLVMConstSIToFP(ConstantVal: *Value, ToType: *Type) *Value;
233
234 pub const constFPToUI = LLVMConstFPToUI;
235 extern fn LLVMConstFPToUI(ConstantVal: *Value, ToType: *Type) *Value;
236
237 pub const constFPToSI = LLVMConstFPToSI;
238 extern fn LLVMConstFPToSI(ConstantVal: *Value, ToType: *Type) *Value;
239
240 pub const constPtrToInt = LLVMConstPtrToInt;
241 extern fn LLVMConstPtrToInt(ConstantVal: *Value, ToType: *Type) *Value;
242
243 pub const constIntToPtr = LLVMConstIntToPtr;
244 extern fn LLVMConstIntToPtr(ConstantVal: *Value, ToType: *Type) *Value;
245
246 pub const constBitCast = LLVMConstBitCast;
247 extern fn LLVMConstBitCast(ConstantVal: *Value, ToType: *Type) *Value;
248
249 pub const constAddrSpaceCast = LLVMConstAddrSpaceCast;
250 extern fn LLVMConstAddrSpaceCast(ConstantVal: *Value, ToType: *Type) *Value;
251
252 pub const constExtractElement = LLVMConstExtractElement;
253 extern fn LLVMConstExtractElement(VectorConstant: *Value, IndexConstant: *Value) *Value;
254
255 pub const constInsertElement = LLVMConstInsertElement;
256 extern fn LLVMConstInsertElement(
257 VectorConstant: *Value,
258 ElementValueConstant: *Value,
259 IndexConstant: *Value,
260 ) *Value;
261
262 pub const constShuffleVector = LLVMConstShuffleVector;
263 extern fn LLVMConstShuffleVector(
264 VectorAConstant: *Value,
265 VectorBConstant: *Value,
266 MaskConstant: *Value,
267 ) *Value;
268
269 pub const isConstant = LLVMIsConstant;
270 extern fn LLVMIsConstant(Val: *Value) Bool;
271
272 pub const blockAddress = LLVMBlockAddress;
273 extern fn LLVMBlockAddress(F: *Value, BB: *BasicBlock) *Value;
274
275 pub const setWeak = LLVMSetWeak;
276 extern fn LLVMSetWeak(CmpXchgInst: *Value, IsWeak: Bool) void;
277
278 pub const setOrdering = LLVMSetOrdering;
279 extern fn LLVMSetOrdering(MemoryAccessInst: *Value, Ordering: AtomicOrdering) void;
280
281 pub const setVolatile = LLVMSetVolatile;
282 extern fn LLVMSetVolatile(MemoryAccessInst: *Value, IsVolatile: Bool) void;
283
284 pub const setAlignment = LLVMSetAlignment;
285 extern fn LLVMSetAlignment(V: *Value, Bytes: c_uint) void;
286
287 pub const getAlignment = LLVMGetAlignment;
288 extern fn LLVMGetAlignment(V: *Value) c_uint;
289
290 pub const setFunctionCallConv = LLVMSetFunctionCallConv;
291 extern fn LLVMSetFunctionCallConv(Fn: *Value, CC: CallConv) void;
292
293 pub const setInstructionCallConv = LLVMSetInstructionCallConv;
294 extern fn LLVMSetInstructionCallConv(Instr: *Value, CC: CallConv) void;
295
296 pub const setTailCallKind = ZigLLVMSetTailCallKind;
297 extern fn ZigLLVMSetTailCallKind(CallInst: *Value, TailCallKind: TailCallKind) void;
298
299 pub const addCallSiteAttribute = LLVMAddCallSiteAttribute;
300 extern fn LLVMAddCallSiteAttribute(C: *Value, Idx: AttributeIndex, A: *Attribute) void;
301
302 pub const fnSetSubprogram = ZigLLVMFnSetSubprogram;
303 extern fn ZigLLVMFnSetSubprogram(f: *Value, subprogram: *DISubprogram) void;
304
305 pub const setValueName = LLVMSetValueName2;
306 extern fn LLVMSetValueName2(Val: *Value, Name: [*]const u8, NameLen: usize) void;
307
308 pub const takeName = ZigLLVMTakeName;
309 extern fn ZigLLVMTakeName(new_owner: *Value, victim: *Value) void;
310
311 pub const getParam = LLVMGetParam;
312 extern fn LLVMGetParam(Fn: *Value, Index: c_uint) *Value;
313
314 pub const setInitializer = ZigLLVMSetInitializer;
315 extern fn ZigLLVMSetInitializer(GlobalVar: *Value, ConstantVal: ?*Value) void;
316
317 pub const setDLLStorageClass = LLVMSetDLLStorageClass;
318 extern fn LLVMSetDLLStorageClass(Global: *Value, Class: DLLStorageClass) void;
319
320 pub const addCase = LLVMAddCase;
321 extern fn LLVMAddCase(Switch: *Value, OnVal: *Value, Dest: *BasicBlock) void;
322
323 pub const replaceAllUsesWith = LLVMReplaceAllUsesWith;
324 extern fn LLVMReplaceAllUsesWith(OldVal: *Value, NewVal: *Value) void;
325
326 pub const attachMetaData = ZigLLVMAttachMetaData;
327 extern fn ZigLLVMAttachMetaData(GlobalVar: *Value, DIG: *DIGlobalVariableExpression) void;
328
329 pub const dump = LLVMDumpValue;
330 extern fn LLVMDumpValue(Val: *Value) void;
331};
332
333pub const Type = opaque {
334 pub const constNull = LLVMConstNull;
335 extern fn LLVMConstNull(Ty: *Type) *Value;
336
337 pub const constInt = LLVMConstInt;
338 extern fn LLVMConstInt(IntTy: *Type, N: c_ulonglong, SignExtend: Bool) *Value;
339
340 pub const constIntOfArbitraryPrecision = LLVMConstIntOfArbitraryPrecision;
341 extern fn LLVMConstIntOfArbitraryPrecision(IntTy: *Type, NumWords: c_uint, Words: [*]const u64) *Value;
342
343 pub const constReal = LLVMConstReal;
344 extern fn LLVMConstReal(RealTy: *Type, N: f64) *Value;
345
346 pub const constArray2 = LLVMConstArray2;
347 extern fn LLVMConstArray2(ElementTy: *Type, ConstantVals: [*]const *Value, Length: u64) *Value;
348
349 pub const constNamedStruct = LLVMConstNamedStruct;
350 extern fn LLVMConstNamedStruct(
351 StructTy: *Type,
352 ConstantVals: [*]const *Value,
353 Count: c_uint,
354 ) *Value;
355
356 pub const getUndef = LLVMGetUndef;
357 extern fn LLVMGetUndef(Ty: *Type) *Value;
358
359 pub const getPoison = LLVMGetPoison;
360 extern fn LLVMGetPoison(Ty: *Type) *Value;
361
362 pub const arrayType2 = LLVMArrayType2;
363 extern fn LLVMArrayType2(ElementType: *Type, ElementCount: u64) *Type;
364
365 pub const vectorType = LLVMVectorType;
366 extern fn LLVMVectorType(ElementType: *Type, ElementCount: c_uint) *Type;
367
368 pub const scalableVectorType = LLVMScalableVectorType;
369 extern fn LLVMScalableVectorType(ElementType: *Type, ElementCount: c_uint) *Type;
370
371 pub const structSetBody = LLVMStructSetBody;
372 extern fn LLVMStructSetBody(
373 StructTy: *Type,
374 ElementTypes: [*]*Type,
375 ElementCount: c_uint,
376 Packed: Bool,
377 ) void;
378
379 pub const isSized = LLVMTypeIsSized;
380 extern fn LLVMTypeIsSized(Ty: *Type) Bool;
381
382 pub const constGEP = LLVMConstGEP2;
383 extern fn LLVMConstGEP2(
384 Ty: *Type,
385 ConstantVal: *Value,
386 ConstantIndices: [*]const *Value,
387 NumIndices: c_uint,
388 ) *Value;
389
390 pub const constInBoundsGEP = LLVMConstInBoundsGEP2;
391 extern fn LLVMConstInBoundsGEP2(
392 Ty: *Type,
393 ConstantVal: *Value,
394 ConstantIndices: [*]const *Value,
395 NumIndices: c_uint,
396 ) *Value;
397
398 pub const dump = LLVMDumpType;
399 extern fn LLVMDumpType(Ty: *Type) void;
400};
401
40242pub const Module = opaque {
403 pub const createWithName = LLVMModuleCreateWithNameInContext;
404 extern fn LLVMModuleCreateWithNameInContext(ModuleID: [*:0]const u8, C: *Context) *Module;
405
40643 pub const dispose = LLVMDisposeModule;
40744 extern fn LLVMDisposeModule(*Module) void;
40845
409 pub const verify = LLVMVerifyModule;
410 extern fn LLVMVerifyModule(*Module, Action: VerifierFailureAction, OutMessage: *[*:0]const u8) Bool;
411
412 pub const setModuleDataLayout = LLVMSetModuleDataLayout;
413 extern fn LLVMSetModuleDataLayout(*Module, *TargetData) void;
414
41546 pub const setModulePICLevel = ZigLLVMSetModulePICLevel;
41647 extern fn ZigLLVMSetModulePICLevel(module: *Module) void;
41748
......@@ -420,508 +51,11 @@ pub const Module = opaque {
42051
42152 pub const setModuleCodeModel = ZigLLVMSetModuleCodeModel;
42253 extern fn ZigLLVMSetModuleCodeModel(module: *Module, code_model: CodeModel) void;
423
424 pub const addFunctionInAddressSpace = ZigLLVMAddFunctionInAddressSpace;
425 extern fn ZigLLVMAddFunctionInAddressSpace(*Module, Name: [*:0]const u8, FunctionTy: *Type, AddressSpace: c_uint) *Value;
426
427 pub const printToString = LLVMPrintModuleToString;
428 extern fn LLVMPrintModuleToString(*Module) [*:0]const u8;
429
430 pub const addGlobalInAddressSpace = LLVMAddGlobalInAddressSpace;
431 extern fn LLVMAddGlobalInAddressSpace(M: *Module, Ty: *Type, Name: [*:0]const u8, AddressSpace: c_uint) *Value;
432
433 pub const dump = LLVMDumpModule;
434 extern fn LLVMDumpModule(M: *Module) void;
435
436 pub const addAlias = LLVMAddAlias2;
437 extern fn LLVMAddAlias2(
438 M: *Module,
439 Ty: *Type,
440 AddrSpace: c_uint,
441 Aliasee: *Value,
442 Name: [*:0]const u8,
443 ) *Value;
444
445 pub const setTarget = LLVMSetTarget;
446 extern fn LLVMSetTarget(M: *Module, Triple: [*:0]const u8) void;
447
448 pub const addModuleDebugInfoFlag = ZigLLVMAddModuleDebugInfoFlag;
449 extern fn ZigLLVMAddModuleDebugInfoFlag(module: *Module, dwarf64: bool) void;
450
451 pub const addModuleCodeViewFlag = ZigLLVMAddModuleCodeViewFlag;
452 extern fn ZigLLVMAddModuleCodeViewFlag(module: *Module) void;
453
454 pub const createDIBuilder = ZigLLVMCreateDIBuilder;
455 extern fn ZigLLVMCreateDIBuilder(module: *Module, allow_unresolved: bool) *DIBuilder;
456
457 pub const setModuleInlineAsm = LLVMSetModuleInlineAsm2;
458 extern fn LLVMSetModuleInlineAsm2(M: *Module, Asm: [*]const u8, Len: usize) void;
459
460 pub const printModuleToFile = LLVMPrintModuleToFile;
461 extern fn LLVMPrintModuleToFile(M: *Module, Filename: [*:0]const u8, ErrorMessage: *[*:0]const u8) Bool;
462
463 pub const writeBitcodeToFile = LLVMWriteBitcodeToFile;
464 extern fn LLVMWriteBitcodeToFile(M: *Module, Path: [*:0]const u8) c_int;
46554};
46655
46756pub const disposeMessage = LLVMDisposeMessage;
46857extern fn LLVMDisposeMessage(Message: [*:0]const u8) void;
46958
470pub const VerifierFailureAction = enum(c_int) {
471 AbortProcess,
472 PrintMessage,
473 ReturnStatus,
474};
475
476pub const constVector = LLVMConstVector;
477extern fn LLVMConstVector(
478 ScalarConstantVals: [*]*Value,
479 Size: c_uint,
480) *Value;
481
482pub const constICmp = LLVMConstICmp;
483extern fn LLVMConstICmp(Predicate: IntPredicate, LHSConstant: *Value, RHSConstant: *Value) *Value;
484
485pub const constFCmp = LLVMConstFCmp;
486extern fn LLVMConstFCmp(Predicate: RealPredicate, LHSConstant: *Value, RHSConstant: *Value) *Value;
487
488pub const getEnumAttributeKindForName = LLVMGetEnumAttributeKindForName;
489extern fn LLVMGetEnumAttributeKindForName(Name: [*]const u8, SLen: usize) c_uint;
490
491pub const getInlineAsm = LLVMGetInlineAsm;
492extern fn LLVMGetInlineAsm(
493 Ty: *Type,
494 AsmString: [*]const u8,
495 AsmStringSize: usize,
496 Constraints: [*]const u8,
497 ConstraintsSize: usize,
498 HasSideEffects: Bool,
499 IsAlignStack: Bool,
500 Dialect: InlineAsmDialect,
501 CanThrow: Bool,
502) *Value;
503
504pub const functionType = LLVMFunctionType;
505extern fn LLVMFunctionType(
506 ReturnType: *Type,
507 ParamTypes: [*]const *Type,
508 ParamCount: c_uint,
509 IsVarArg: Bool,
510) *Type;
511
512pub const InlineAsmDialect = enum(c_uint) { ATT, Intel };
513
514pub const Attribute = opaque {};
515
516pub const Builder = opaque {
517 pub const dispose = LLVMDisposeBuilder;
518 extern fn LLVMDisposeBuilder(Builder: *Builder) void;
519
520 pub const positionBuilder = LLVMPositionBuilder;
521 extern fn LLVMPositionBuilder(
522 Builder: *Builder,
523 Block: *BasicBlock,
524 Instr: ?*Value,
525 ) void;
526
527 pub const buildZExt = LLVMBuildZExt;
528 extern fn LLVMBuildZExt(
529 *Builder,
530 Value: *Value,
531 DestTy: *Type,
532 Name: [*:0]const u8,
533 ) *Value;
534
535 pub const buildSExt = LLVMBuildSExt;
536 extern fn LLVMBuildSExt(
537 *Builder,
538 Val: *Value,
539 DestTy: *Type,
540 Name: [*:0]const u8,
541 ) *Value;
542
543 pub const buildCall = LLVMBuildCall2;
544 extern fn LLVMBuildCall2(
545 *Builder,
546 *Type,
547 Fn: *Value,
548 Args: [*]const *Value,
549 NumArgs: c_uint,
550 Name: [*:0]const u8,
551 ) *Value;
552
553 pub const buildRetVoid = LLVMBuildRetVoid;
554 extern fn LLVMBuildRetVoid(*Builder) *Value;
555
556 pub const buildRet = LLVMBuildRet;
557 extern fn LLVMBuildRet(*Builder, V: *Value) *Value;
558
559 pub const buildUnreachable = LLVMBuildUnreachable;
560 extern fn LLVMBuildUnreachable(*Builder) *Value;
561
562 pub const buildAlloca = LLVMBuildAlloca;
563 extern fn LLVMBuildAlloca(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
564
565 pub const buildStore = LLVMBuildStore;
566 extern fn LLVMBuildStore(*Builder, Val: *Value, Ptr: *Value) *Value;
567
568 pub const buildLoad = LLVMBuildLoad2;
569 extern fn LLVMBuildLoad2(*Builder, Ty: *Type, PointerVal: *Value, Name: [*:0]const u8) *Value;
570
571 pub const buildFAdd = LLVMBuildFAdd;
572 extern fn LLVMBuildFAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
573
574 pub const buildAdd = LLVMBuildAdd;
575 extern fn LLVMBuildAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
576
577 pub const buildNSWAdd = LLVMBuildNSWAdd;
578 extern fn LLVMBuildNSWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
579
580 pub const buildNUWAdd = LLVMBuildNUWAdd;
581 extern fn LLVMBuildNUWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
582
583 pub const buildFSub = LLVMBuildFSub;
584 extern fn LLVMBuildFSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
585
586 pub const buildFNeg = LLVMBuildFNeg;
587 extern fn LLVMBuildFNeg(*Builder, V: *Value, Name: [*:0]const u8) *Value;
588
589 pub const buildSub = LLVMBuildSub;
590 extern fn LLVMBuildSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
591
592 pub const buildNSWSub = LLVMBuildNSWSub;
593 extern fn LLVMBuildNSWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
594
595 pub const buildNUWSub = LLVMBuildNUWSub;
596 extern fn LLVMBuildNUWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
597
598 pub const buildFMul = LLVMBuildFMul;
599 extern fn LLVMBuildFMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
600
601 pub const buildMul = LLVMBuildMul;
602 extern fn LLVMBuildMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
603
604 pub const buildNSWMul = LLVMBuildNSWMul;
605 extern fn LLVMBuildNSWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
606
607 pub const buildNUWMul = LLVMBuildNUWMul;
608 extern fn LLVMBuildNUWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
609
610 pub const buildUDiv = LLVMBuildUDiv;
611 extern fn LLVMBuildUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
612
613 pub const buildSDiv = LLVMBuildSDiv;
614 extern fn LLVMBuildSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
615
616 pub const buildFDiv = LLVMBuildFDiv;
617 extern fn LLVMBuildFDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
618
619 pub const buildURem = LLVMBuildURem;
620 extern fn LLVMBuildURem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
621
622 pub const buildSRem = LLVMBuildSRem;
623 extern fn LLVMBuildSRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
624
625 pub const buildFRem = LLVMBuildFRem;
626 extern fn LLVMBuildFRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
627
628 pub const buildAnd = LLVMBuildAnd;
629 extern fn LLVMBuildAnd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
630
631 pub const buildLShr = LLVMBuildLShr;
632 extern fn LLVMBuildLShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
633
634 pub const buildAShr = LLVMBuildAShr;
635 extern fn LLVMBuildAShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
636
637 pub const buildLShrExact = ZigLLVMBuildLShrExact;
638 extern fn ZigLLVMBuildLShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
639
640 pub const buildAShrExact = ZigLLVMBuildAShrExact;
641 extern fn ZigLLVMBuildAShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
642
643 pub const buildShl = LLVMBuildShl;
644 extern fn LLVMBuildShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
645
646 pub const buildNUWShl = ZigLLVMBuildNUWShl;
647 extern fn ZigLLVMBuildNUWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
648
649 pub const buildNSWShl = ZigLLVMBuildNSWShl;
650 extern fn ZigLLVMBuildNSWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
651
652 pub const buildOr = LLVMBuildOr;
653 extern fn LLVMBuildOr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
654
655 pub const buildXor = LLVMBuildXor;
656 extern fn LLVMBuildXor(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
657
658 pub const buildBitCast = LLVMBuildBitCast;
659 extern fn LLVMBuildBitCast(*Builder, Val: *Value, DestTy: *Type, Name: [*:0]const u8) *Value;
660
661 pub const buildGEP = LLVMBuildGEP2;
662 extern fn LLVMBuildGEP2(
663 B: *Builder,
664 Ty: *Type,
665 Pointer: *Value,
666 Indices: [*]const *Value,
667 NumIndices: c_uint,
668 Name: [*:0]const u8,
669 ) *Value;
670
671 pub const buildInBoundsGEP = LLVMBuildInBoundsGEP2;
672 extern fn LLVMBuildInBoundsGEP2(
673 B: *Builder,
674 Ty: *Type,
675 Pointer: *Value,
676 Indices: [*]const *Value,
677 NumIndices: c_uint,
678 Name: [*:0]const u8,
679 ) *Value;
680
681 pub const buildICmp = LLVMBuildICmp;
682 extern fn LLVMBuildICmp(*Builder, Op: IntPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
683
684 pub const buildFCmp = LLVMBuildFCmp;
685 extern fn LLVMBuildFCmp(*Builder, Op: RealPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
686
687 pub const buildBr = LLVMBuildBr;
688 extern fn LLVMBuildBr(*Builder, Dest: *BasicBlock) *Value;
689
690 pub const buildCondBr = LLVMBuildCondBr;
691 extern fn LLVMBuildCondBr(*Builder, If: *Value, Then: *BasicBlock, Else: *BasicBlock) *Value;
692
693 pub const buildSwitch = LLVMBuildSwitch;
694 extern fn LLVMBuildSwitch(*Builder, V: *Value, Else: *BasicBlock, NumCases: c_uint) *Value;
695
696 pub const buildPhi = LLVMBuildPhi;
697 extern fn LLVMBuildPhi(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
698
699 pub const buildExtractValue = LLVMBuildExtractValue;
700 extern fn LLVMBuildExtractValue(
701 *Builder,
702 AggVal: *Value,
703 Index: c_uint,
704 Name: [*:0]const u8,
705 ) *Value;
706
707 pub const buildExtractElement = LLVMBuildExtractElement;
708 extern fn LLVMBuildExtractElement(
709 *Builder,
710 VecVal: *Value,
711 Index: *Value,
712 Name: [*:0]const u8,
713 ) *Value;
714
715 pub const buildInsertElement = LLVMBuildInsertElement;
716 extern fn LLVMBuildInsertElement(
717 *Builder,
718 VecVal: *Value,
719 EltVal: *Value,
720 Index: *Value,
721 Name: [*:0]const u8,
722 ) *Value;
723
724 pub const buildPtrToInt = LLVMBuildPtrToInt;
725 extern fn LLVMBuildPtrToInt(
726 *Builder,
727 Val: *Value,
728 DestTy: *Type,
729 Name: [*:0]const u8,
730 ) *Value;
731
732 pub const buildIntToPtr = LLVMBuildIntToPtr;
733 extern fn LLVMBuildIntToPtr(
734 *Builder,
735 Val: *Value,
736 DestTy: *Type,
737 Name: [*:0]const u8,
738 ) *Value;
739
740 pub const buildTrunc = LLVMBuildTrunc;
741 extern fn LLVMBuildTrunc(
742 *Builder,
743 Val: *Value,
744 DestTy: *Type,
745 Name: [*:0]const u8,
746 ) *Value;
747
748 pub const buildInsertValue = LLVMBuildInsertValue;
749 extern fn LLVMBuildInsertValue(
750 *Builder,
751 AggVal: *Value,
752 EltVal: *Value,
753 Index: c_uint,
754 Name: [*:0]const u8,
755 ) *Value;
756
757 pub const buildAtomicCmpXchg = LLVMBuildAtomicCmpXchg;
758 extern fn LLVMBuildAtomicCmpXchg(
759 builder: *Builder,
760 ptr: *Value,
761 cmp: *Value,
762 new_val: *Value,
763 success_ordering: AtomicOrdering,
764 failure_ordering: AtomicOrdering,
765 is_single_threaded: Bool,
766 ) *Value;
767
768 pub const buildSelect = LLVMBuildSelect;
769 extern fn LLVMBuildSelect(
770 *Builder,
771 If: *Value,
772 Then: *Value,
773 Else: *Value,
774 Name: [*:0]const u8,
775 ) *Value;
776
777 pub const buildFence = LLVMBuildFence;
778 extern fn LLVMBuildFence(
779 B: *Builder,
780 ordering: AtomicOrdering,
781 singleThread: Bool,
782 Name: [*:0]const u8,
783 ) *Value;
784
785 pub const buildAtomicRmw = LLVMBuildAtomicRMW;
786 extern fn LLVMBuildAtomicRMW(
787 B: *Builder,
788 op: AtomicRMWBinOp,
789 PTR: *Value,
790 Val: *Value,
791 ordering: AtomicOrdering,
792 singleThread: Bool,
793 ) *Value;
794
795 pub const buildFPToUI = LLVMBuildFPToUI;
796 extern fn LLVMBuildFPToUI(
797 *Builder,
798 Val: *Value,
799 DestTy: *Type,
800 Name: [*:0]const u8,
801 ) *Value;
802
803 pub const buildFPToSI = LLVMBuildFPToSI;
804 extern fn LLVMBuildFPToSI(
805 *Builder,
806 Val: *Value,
807 DestTy: *Type,
808 Name: [*:0]const u8,
809 ) *Value;
810
811 pub const buildUIToFP = LLVMBuildUIToFP;
812 extern fn LLVMBuildUIToFP(
813 *Builder,
814 Val: *Value,
815 DestTy: *Type,
816 Name: [*:0]const u8,
817 ) *Value;
818
819 pub const buildSIToFP = LLVMBuildSIToFP;
820 extern fn LLVMBuildSIToFP(
821 *Builder,
822 Val: *Value,
823 DestTy: *Type,
824 Name: [*:0]const u8,
825 ) *Value;
826
827 pub const buildFPTrunc = LLVMBuildFPTrunc;
828 extern fn LLVMBuildFPTrunc(
829 *Builder,
830 Val: *Value,
831 DestTy: *Type,
832 Name: [*:0]const u8,
833 ) *Value;
834
835 pub const buildFPExt = LLVMBuildFPExt;
836 extern fn LLVMBuildFPExt(
837 *Builder,
838 Val: *Value,
839 DestTy: *Type,
840 Name: [*:0]const u8,
841 ) *Value;
842
843 pub const buildExactUDiv = LLVMBuildExactUDiv;
844 extern fn LLVMBuildExactUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
845
846 pub const buildExactSDiv = LLVMBuildExactSDiv;
847 extern fn LLVMBuildExactSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
848
849 pub const setCurrentDebugLocation = ZigLLVMSetCurrentDebugLocation2;
850 extern fn ZigLLVMSetCurrentDebugLocation2(builder: *Builder, line: c_uint, column: c_uint, scope: *DIScope, inlined_at: ?*DILocation) void;
851
852 pub const clearCurrentDebugLocation = ZigLLVMClearCurrentDebugLocation;
853 extern fn ZigLLVMClearCurrentDebugLocation(builder: *Builder) void;
854
855 pub const getCurrentDebugLocation2 = LLVMGetCurrentDebugLocation2;
856 extern fn LLVMGetCurrentDebugLocation2(Builder: *Builder) *Metadata;
857
858 pub const setCurrentDebugLocation2 = LLVMSetCurrentDebugLocation2;
859 extern fn LLVMSetCurrentDebugLocation2(Builder: *Builder, Loc: *Metadata) void;
860
861 pub const buildShuffleVector = LLVMBuildShuffleVector;
862 extern fn LLVMBuildShuffleVector(*Builder, V1: *Value, V2: *Value, Mask: *Value, Name: [*:0]const u8) *Value;
863
864 pub const setFastMath = ZigLLVMSetFastMath;
865 extern fn ZigLLVMSetFastMath(B: *Builder, on_state: bool) void;
866
867 pub const buildAddrSpaceCast = LLVMBuildAddrSpaceCast;
868 extern fn LLVMBuildAddrSpaceCast(B: *Builder, Val: *Value, DestTy: *Type, Name: [*:0]const u8) *Value;
869
870 pub const buildAllocaInAddressSpace = ZigLLVMBuildAllocaInAddressSpace;
871 extern fn ZigLLVMBuildAllocaInAddressSpace(B: *Builder, Ty: *Type, AddressSpace: c_uint, Name: [*:0]const u8) *Value;
872
873 pub const buildVAArg = LLVMBuildVAArg;
874 extern fn LLVMBuildVAArg(*Builder, List: *Value, Ty: *Type, Name: [*:0]const u8) *Value;
875};
876
877pub const MDString = opaque {
878 pub const get = LLVMMDStringInContext2;
879 extern fn LLVMMDStringInContext2(C: *Context, Str: [*]const u8, SLen: usize) *MDString;
880};
881
882pub const DIScope = opaque {
883 pub const toNode = ZigLLVMScopeToNode;
884 extern fn ZigLLVMScopeToNode(scope: *DIScope) *DINode;
885};
886
887pub const DINode = opaque {};
888pub const Metadata = opaque {};
889
890pub const IntPredicate = enum(c_uint) {
891 EQ = 32,
892 NE = 33,
893 UGT = 34,
894 UGE = 35,
895 ULT = 36,
896 ULE = 37,
897 SGT = 38,
898 SGE = 39,
899 SLT = 40,
900 SLE = 41,
901};
902
903pub const RealPredicate = enum(c_uint) {
904 OEQ = 1,
905 OGT = 2,
906 OGE = 3,
907 OLT = 4,
908 OLE = 5,
909 ONE = 6,
910 ORD = 7,
911 UNO = 8,
912 UEQ = 9,
913 UGT = 10,
914 UGE = 11,
915 ULT = 12,
916 ULE = 13,
917 UNE = 14,
918};
919
920pub const BasicBlock = opaque {
921 pub const deleteBasicBlock = LLVMDeleteBasicBlock;
922 extern fn LLVMDeleteBasicBlock(BB: *BasicBlock) void;
923};
924
92559pub const TargetMachine = opaque {
92660 pub const create = ZigLLVMCreateTargetMachine;
92761 extern fn ZigLLVMCreateTargetMachine(
......@@ -956,23 +90,11 @@ pub const TargetMachine = opaque {
95690 llvm_ir_filename: ?[*:0]const u8,
95791 bitcode_filename: ?[*:0]const u8,
95892 ) bool;
959
960 pub const createTargetDataLayout = LLVMCreateTargetDataLayout;
961 extern fn LLVMCreateTargetDataLayout(*TargetMachine) *TargetData;
96293};
96394
96495pub const TargetData = opaque {
96596 pub const dispose = LLVMDisposeTargetData;
96697 extern fn LLVMDisposeTargetData(*TargetData) void;
967
968 pub const abiAlignmentOfType = LLVMABIAlignmentOfType;
969 extern fn LLVMABIAlignmentOfType(TD: *TargetData, Ty: *Type) c_uint;
970
971 pub const abiSizeOfType = LLVMABISizeOfType;
972 extern fn LLVMABISizeOfType(TD: *TargetData, Ty: *Type) c_ulonglong;
973
974 pub const stringRep = LLVMCopyStringRepOfTargetData;
975 extern fn LLVMCopyStringRepOfTargetData(TD: *TargetData) [*:0]const u8;
97698};
97799
978100pub const CodeModel = enum(c_int) {
......@@ -1002,11 +124,6 @@ pub const RelocMode = enum(c_int) {
1002124 ROPI_RWPI,
1003125};
1004126
1005pub const CodeGenFileType = enum(c_int) {
1006 AssemblyFile,
1007 ObjectFile,
1008};
1009
1010127pub const ABIType = enum(c_int) {
1011128 /// Target-specific (either soft or hard depending on triple, etc).
1012129 Default,
......@@ -1278,541 +395,6 @@ extern fn ZigLLVMWriteImportLibrary(
1278395 kill_at: bool,
1279396) bool;
1280397
1281pub const Linkage = enum(c_uint) {
1282 External,
1283 AvailableExternally,
1284 LinkOnceAny,
1285 LinkOnceODR,
1286 LinkOnceODRAutoHide,
1287 WeakAny,
1288 WeakODR,
1289 Appending,
1290 Internal,
1291 Private,
1292 DLLImport,
1293 DLLExport,
1294 ExternalWeak,
1295 Ghost,
1296 Common,
1297 LinkerPrivate,
1298 LinkerPrivateWeak,
1299};
1300
1301pub const Visibility = enum(c_uint) {
1302 Default,
1303 Hidden,
1304 Protected,
1305};
1306
1307pub const ThreadLocalMode = enum(c_uint) {
1308 NotThreadLocal,
1309 GeneralDynamicTLSModel,
1310 LocalDynamicTLSModel,
1311 InitialExecTLSModel,
1312 LocalExecTLSModel,
1313};
1314
1315pub const AtomicOrdering = enum(c_uint) {
1316 NotAtomic = 0,
1317 Unordered = 1,
1318 Monotonic = 2,
1319 Acquire = 4,
1320 Release = 5,
1321 AcquireRelease = 6,
1322 SequentiallyConsistent = 7,
1323};
1324
1325pub const AtomicRMWBinOp = enum(c_int) {
1326 Xchg,
1327 Add,
1328 Sub,
1329 And,
1330 Nand,
1331 Or,
1332 Xor,
1333 Max,
1334 Min,
1335 UMax,
1336 UMin,
1337 FAdd,
1338 FSub,
1339 FMax,
1340 FMin,
1341};
1342
1343pub const CallConv = enum(c_uint) {
1344 C = 0,
1345 Fast = 8,
1346 Cold = 9,
1347 GHC = 10,
1348 HiPE = 11,
1349 WebKit_JS = 12,
1350 AnyReg = 13,
1351 PreserveMost = 14,
1352 PreserveAll = 15,
1353 Swift = 16,
1354 CXX_FAST_TLS = 17,
1355
1356 X86_StdCall = 64,
1357 X86_FastCall = 65,
1358 ARM_APCS = 66,
1359 ARM_AAPCS = 67,
1360 ARM_AAPCS_VFP = 68,
1361 MSP430_INTR = 69,
1362 X86_ThisCall = 70,
1363 PTX_Kernel = 71,
1364 PTX_Device = 72,
1365 SPIR_FUNC = 75,
1366 SPIR_KERNEL = 76,
1367 Intel_OCL_BI = 77,
1368 X86_64_SysV = 78,
1369 Win64 = 79,
1370 X86_VectorCall = 80,
1371 HHVM = 81,
1372 HHVM_C = 82,
1373 X86_INTR = 83,
1374 AVR_INTR = 84,
1375 AVR_SIGNAL = 85,
1376 AVR_BUILTIN = 86,
1377 AMDGPU_VS = 87,
1378 AMDGPU_GS = 88,
1379 AMDGPU_PS = 89,
1380 AMDGPU_CS = 90,
1381 AMDGPU_KERNEL = 91,
1382 X86_RegCall = 92,
1383 AMDGPU_HS = 93,
1384 MSP430_BUILTIN = 94,
1385 AMDGPU_LS = 95,
1386 AMDGPU_ES = 96,
1387 AArch64_VectorCall = 97,
1388};
1389
1390pub const CallAttr = enum(c_int) {
1391 Auto,
1392 NeverTail,
1393 NeverInline,
1394 AlwaysTail,
1395 AlwaysInline,
1396};
1397
1398pub const TailCallKind = enum(c_uint) {
1399 None,
1400 Tail,
1401 MustTail,
1402 NoTail,
1403};
1404
1405pub const DLLStorageClass = enum(c_uint) {
1406 Default,
1407 DLLImport,
1408 DLLExport,
1409};
1410
1411pub const address_space = struct {
1412 pub const default: c_uint = 0;
1413
1414 // See llvm/lib/Target/X86/X86.h
1415 pub const x86_64 = x86;
1416 pub const x86 = struct {
1417 pub const gs: c_uint = 256;
1418 pub const fs: c_uint = 257;
1419 pub const ss: c_uint = 258;
1420
1421 pub const ptr32_sptr: c_uint = 270;
1422 pub const ptr32_uptr: c_uint = 271;
1423 pub const ptr64: c_uint = 272;
1424 };
1425
1426 // See llvm/lib/Target/AVR/AVR.h
1427 pub const avr = struct {
1428 pub const flash: c_uint = 1;
1429 pub const flash1: c_uint = 2;
1430 pub const flash2: c_uint = 3;
1431 pub const flash3: c_uint = 4;
1432 pub const flash4: c_uint = 5;
1433 pub const flash5: c_uint = 6;
1434 };
1435
1436 // See llvm/lib/Target/NVPTX/NVPTX.h
1437 pub const nvptx = struct {
1438 pub const generic: c_uint = 0;
1439 pub const global: c_uint = 1;
1440 pub const constant: c_uint = 2;
1441 pub const shared: c_uint = 3;
1442 pub const param: c_uint = 4;
1443 pub const local: c_uint = 5;
1444 };
1445
1446 // See llvm/lib/Target/AMDGPU/AMDGPU.h
1447 pub const amdgpu = struct {
1448 pub const flat: c_uint = 0;
1449 pub const global: c_uint = 1;
1450 pub const region: c_uint = 2;
1451 pub const local: c_uint = 3;
1452 pub const constant: c_uint = 4;
1453 pub const private: c_uint = 5;
1454 pub const constant_32bit: c_uint = 6;
1455 pub const buffer_fat_pointer: c_uint = 7;
1456 pub const param_d: c_uint = 6;
1457 pub const param_i: c_uint = 7;
1458 pub const constant_buffer_0: c_uint = 8;
1459 pub const constant_buffer_1: c_uint = 9;
1460 pub const constant_buffer_2: c_uint = 10;
1461 pub const constant_buffer_3: c_uint = 11;
1462 pub const constant_buffer_4: c_uint = 12;
1463 pub const constant_buffer_5: c_uint = 13;
1464 pub const constant_buffer_6: c_uint = 14;
1465 pub const constant_buffer_7: c_uint = 15;
1466 pub const constant_buffer_8: c_uint = 16;
1467 pub const constant_buffer_9: c_uint = 17;
1468 pub const constant_buffer_10: c_uint = 18;
1469 pub const constant_buffer_11: c_uint = 19;
1470 pub const constant_buffer_12: c_uint = 20;
1471 pub const constant_buffer_13: c_uint = 21;
1472 pub const constant_buffer_14: c_uint = 22;
1473 pub const constant_buffer_15: c_uint = 23;
1474 };
1475
1476 // See llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypetilities.h
1477 pub const wasm = struct {
1478 pub const variable: c_uint = 1;
1479 pub const externref: c_uint = 10;
1480 pub const funcref: c_uint = 20;
1481 };
1482};
1483
1484pub const DIEnumerator = opaque {};
1485pub const DILocalVariable = opaque {};
1486pub const DILocation = opaque {};
1487pub const DIGlobalExpression = opaque {};
1488
1489pub const DIGlobalVariable = opaque {
1490 pub const toNode = ZigLLVMGlobalVariableToNode;
1491 extern fn ZigLLVMGlobalVariableToNode(global_variable: *DIGlobalVariable) *DINode;
1492
1493 pub const replaceLinkageName = ZigLLVMGlobalVariableReplaceLinkageName;
1494 extern fn ZigLLVMGlobalVariableReplaceLinkageName(global_variable: *DIGlobalVariable, linkage_name: *MDString) void;
1495};
1496pub const DIGlobalVariableExpression = opaque {
1497 pub const getVariable = ZigLLVMGlobalGetVariable;
1498 extern fn ZigLLVMGlobalGetVariable(global_variable: *DIGlobalVariableExpression) *DIGlobalVariable;
1499};
1500pub const DIType = opaque {
1501 pub const toScope = ZigLLVMTypeToScope;
1502 extern fn ZigLLVMTypeToScope(ty: *DIType) *DIScope;
1503
1504 pub const toNode = ZigLLVMTypeToNode;
1505 extern fn ZigLLVMTypeToNode(ty: *DIType) *DINode;
1506};
1507pub const DIFile = opaque {
1508 pub const toScope = ZigLLVMFileToScope;
1509 extern fn ZigLLVMFileToScope(difile: *DIFile) *DIScope;
1510
1511 pub const toNode = ZigLLVMFileToNode;
1512 extern fn ZigLLVMFileToNode(difile: *DIFile) *DINode;
1513};
1514pub const DILexicalBlock = opaque {
1515 pub const toScope = ZigLLVMLexicalBlockToScope;
1516 extern fn ZigLLVMLexicalBlockToScope(lexical_block: *DILexicalBlock) *DIScope;
1517
1518 pub const toNode = ZigLLVMLexicalBlockToNode;
1519 extern fn ZigLLVMLexicalBlockToNode(lexical_block: *DILexicalBlock) *DINode;
1520};
1521pub const DICompileUnit = opaque {
1522 pub const toScope = ZigLLVMCompileUnitToScope;
1523 extern fn ZigLLVMCompileUnitToScope(compile_unit: *DICompileUnit) *DIScope;
1524
1525 pub const toNode = ZigLLVMCompileUnitToNode;
1526 extern fn ZigLLVMCompileUnitToNode(compile_unit: *DICompileUnit) *DINode;
1527};
1528pub const DISubprogram = opaque {
1529 pub const toScope = ZigLLVMSubprogramToScope;
1530 extern fn ZigLLVMSubprogramToScope(subprogram: *DISubprogram) *DIScope;
1531
1532 pub const toNode = ZigLLVMSubprogramToNode;
1533 extern fn ZigLLVMSubprogramToNode(subprogram: *DISubprogram) *DINode;
1534
1535 pub const replaceLinkageName = ZigLLVMSubprogramReplaceLinkageName;
1536 extern fn ZigLLVMSubprogramReplaceLinkageName(subprogram: *DISubprogram, linkage_name: *MDString) void;
1537};
1538
1539pub const getDebugLoc = ZigLLVMGetDebugLoc2;
1540extern fn ZigLLVMGetDebugLoc2(line: c_uint, col: c_uint, scope: *DIScope, inlined_at: ?*DILocation) *DILocation;
1541
1542pub const DIBuilder = opaque {
1543 pub const dispose = ZigLLVMDisposeDIBuilder;
1544 extern fn ZigLLVMDisposeDIBuilder(dib: *DIBuilder) void;
1545
1546 pub const finalize = ZigLLVMDIBuilderFinalize;
1547 extern fn ZigLLVMDIBuilderFinalize(dib: *DIBuilder) void;
1548
1549 pub const createPointerType = ZigLLVMCreateDebugPointerType;
1550 extern fn ZigLLVMCreateDebugPointerType(
1551 dib: *DIBuilder,
1552 pointee_type: *DIType,
1553 size_in_bits: u64,
1554 align_in_bits: u64,
1555 name: [*:0]const u8,
1556 ) *DIType;
1557
1558 pub const createBasicType = ZigLLVMCreateDebugBasicType;
1559 extern fn ZigLLVMCreateDebugBasicType(
1560 dib: *DIBuilder,
1561 name: [*:0]const u8,
1562 size_in_bits: u64,
1563 encoding: c_uint,
1564 ) *DIType;
1565
1566 pub const createArrayType = ZigLLVMCreateDebugArrayType;
1567 extern fn ZigLLVMCreateDebugArrayType(
1568 dib: *DIBuilder,
1569 size_in_bits: u64,
1570 align_in_bits: u64,
1571 elem_type: *DIType,
1572 elem_count: i64,
1573 ) *DIType;
1574
1575 pub const createEnumerator = ZigLLVMCreateDebugEnumerator;
1576 extern fn ZigLLVMCreateDebugEnumerator(
1577 dib: *DIBuilder,
1578 name: [*:0]const u8,
1579 val: u64,
1580 is_unsigned: bool,
1581 ) *DIEnumerator;
1582
1583 pub const createEnumerator2 = ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision;
1584 extern fn ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision(
1585 dib: *DIBuilder,
1586 name: [*:0]const u8,
1587 num_words: c_uint,
1588 words: [*]const u64,
1589 bits: c_uint,
1590 is_unsigned: bool,
1591 ) *DIEnumerator;
1592
1593 pub const createEnumerationType = ZigLLVMCreateDebugEnumerationType;
1594 extern fn ZigLLVMCreateDebugEnumerationType(
1595 dib: *DIBuilder,
1596 scope: *DIScope,
1597 name: [*:0]const u8,
1598 file: *DIFile,
1599 line_number: c_uint,
1600 size_in_bits: u64,
1601 align_in_bits: u64,
1602 enumerator_array: [*]const *DIEnumerator,
1603 enumerator_array_len: c_int,
1604 underlying_type: *DIType,
1605 unique_id: [*:0]const u8,
1606 ) *DIType;
1607
1608 pub const createStructType = ZigLLVMCreateDebugStructType;
1609 extern fn ZigLLVMCreateDebugStructType(
1610 dib: *DIBuilder,
1611 scope: *DIScope,
1612 name: [*:0]const u8,
1613 file: ?*DIFile,
1614 line_number: c_uint,
1615 size_in_bits: u64,
1616 align_in_bits: u64,
1617 flags: c_uint,
1618 derived_from: ?*DIType,
1619 types_array: [*]const *DIType,
1620 types_array_len: c_int,
1621 run_time_lang: c_uint,
1622 vtable_holder: ?*DIType,
1623 unique_id: [*:0]const u8,
1624 ) *DIType;
1625
1626 pub const createUnionType = ZigLLVMCreateDebugUnionType;
1627 extern fn ZigLLVMCreateDebugUnionType(
1628 dib: *DIBuilder,
1629 scope: *DIScope,
1630 name: [*:0]const u8,
1631 file: ?*DIFile,
1632 line_number: c_uint,
1633 size_in_bits: u64,
1634 align_in_bits: u64,
1635 flags: c_uint,
1636 types_array: [*]const *DIType,
1637 types_array_len: c_int,
1638 run_time_lang: c_uint,
1639 unique_id: [*:0]const u8,
1640 ) *DIType;
1641
1642 pub const createMemberType = ZigLLVMCreateDebugMemberType;
1643 extern fn ZigLLVMCreateDebugMemberType(
1644 dib: *DIBuilder,
1645 scope: *DIScope,
1646 name: [*:0]const u8,
1647 file: ?*DIFile,
1648 line: c_uint,
1649 size_in_bits: u64,
1650 align_in_bits: u64,
1651 offset_in_bits: u64,
1652 flags: c_uint,
1653 ty: *DIType,
1654 ) *DIType;
1655
1656 pub const createReplaceableCompositeType = ZigLLVMCreateReplaceableCompositeType;
1657 extern fn ZigLLVMCreateReplaceableCompositeType(
1658 dib: *DIBuilder,
1659 tag: c_uint,
1660 name: [*:0]const u8,
1661 scope: *DIScope,
1662 file: ?*DIFile,
1663 line: c_uint,
1664 ) *DIType;
1665
1666 pub const createForwardDeclType = ZigLLVMCreateDebugForwardDeclType;
1667 extern fn ZigLLVMCreateDebugForwardDeclType(
1668 dib: *DIBuilder,
1669 tag: c_uint,
1670 name: [*:0]const u8,
1671 scope: ?*DIScope,
1672 file: ?*DIFile,
1673 line: c_uint,
1674 ) *DIType;
1675
1676 pub const replaceTemporary = ZigLLVMReplaceTemporary;
1677 extern fn ZigLLVMReplaceTemporary(dib: *DIBuilder, ty: *DIType, replacement: *DIType) void;
1678
1679 pub const replaceDebugArrays = ZigLLVMReplaceDebugArrays;
1680 extern fn ZigLLVMReplaceDebugArrays(
1681 dib: *DIBuilder,
1682 ty: *DIType,
1683 types_array: [*]const *DIType,
1684 types_array_len: c_int,
1685 ) void;
1686
1687 pub const createSubroutineType = ZigLLVMCreateSubroutineType;
1688 extern fn ZigLLVMCreateSubroutineType(
1689 dib: *DIBuilder,
1690 types_array: [*]const *DIType,
1691 types_array_len: c_int,
1692 flags: c_uint,
1693 ) *DIType;
1694
1695 pub const createAutoVariable = ZigLLVMCreateAutoVariable;
1696 extern fn ZigLLVMCreateAutoVariable(
1697 dib: *DIBuilder,
1698 scope: *DIScope,
1699 name: [*:0]const u8,
1700 file: *DIFile,
1701 line_no: c_uint,
1702 ty: *DIType,
1703 always_preserve: bool,
1704 flags: c_uint,
1705 ) *DILocalVariable;
1706
1707 pub const createGlobalVariableExpression = ZigLLVMCreateGlobalVariableExpression;
1708 extern fn ZigLLVMCreateGlobalVariableExpression(
1709 dib: *DIBuilder,
1710 scope: *DIScope,
1711 name: [*:0]const u8,
1712 linkage_name: [*:0]const u8,
1713 file: *DIFile,
1714 line_no: c_uint,
1715 di_type: *DIType,
1716 is_local_to_unit: bool,
1717 ) *DIGlobalVariableExpression;
1718
1719 pub const createParameterVariable = ZigLLVMCreateParameterVariable;
1720 extern fn ZigLLVMCreateParameterVariable(
1721 dib: *DIBuilder,
1722 scope: *DIScope,
1723 name: [*:0]const u8,
1724 file: *DIFile,
1725 line_no: c_uint,
1726 ty: *DIType,
1727 always_preserve: bool,
1728 flags: c_uint,
1729 arg_no: c_uint,
1730 ) *DILocalVariable;
1731
1732 pub const createLexicalBlock = ZigLLVMCreateLexicalBlock;
1733 extern fn ZigLLVMCreateLexicalBlock(
1734 dib: *DIBuilder,
1735 scope: *DIScope,
1736 file: *DIFile,
1737 line: c_uint,
1738 col: c_uint,
1739 ) *DILexicalBlock;
1740
1741 pub const createCompileUnit = ZigLLVMCreateCompileUnit;
1742 extern fn ZigLLVMCreateCompileUnit(
1743 dib: *DIBuilder,
1744 lang: c_uint,
1745 difile: *DIFile,
1746 producer: [*:0]const u8,
1747 is_optimized: bool,
1748 flags: [*:0]const u8,
1749 runtime_version: c_uint,
1750 split_name: [*:0]const u8,
1751 dwo_id: u64,
1752 emit_debug_info: bool,
1753 ) *DICompileUnit;
1754
1755 pub const createFile = ZigLLVMCreateFile;
1756 extern fn ZigLLVMCreateFile(
1757 dib: *DIBuilder,
1758 filename: [*:0]const u8,
1759 directory: [*:0]const u8,
1760 ) *DIFile;
1761
1762 pub const createFunction = ZigLLVMCreateFunction;
1763 extern fn ZigLLVMCreateFunction(
1764 dib: *DIBuilder,
1765 scope: *DIScope,
1766 name: [*:0]const u8,
1767 linkage_name: [*:0]const u8,
1768 file: *DIFile,
1769 lineno: c_uint,
1770 fn_di_type: *DIType,
1771 is_local_to_unit: bool,
1772 is_definition: bool,
1773 scope_line: c_uint,
1774 flags: c_uint,
1775 is_optimized: bool,
1776 decl_subprogram: ?*DISubprogram,
1777 ) *DISubprogram;
1778
1779 pub const createVectorType = ZigLLVMDIBuilderCreateVectorType;
1780 extern fn ZigLLVMDIBuilderCreateVectorType(
1781 dib: *DIBuilder,
1782 SizeInBits: u64,
1783 AlignInBits: u32,
1784 Ty: *DIType,
1785 elem_count: u32,
1786 ) *DIType;
1787
1788 pub const insertDeclareAtEnd = ZigLLVMInsertDeclareAtEnd;
1789 extern fn ZigLLVMInsertDeclareAtEnd(
1790 dib: *DIBuilder,
1791 storage: *Value,
1792 var_info: *DILocalVariable,
1793 debug_loc: *DILocation,
1794 basic_block_ref: *BasicBlock,
1795 ) *Value;
1796
1797 pub const insertDeclare = ZigLLVMInsertDeclare;
1798 extern fn ZigLLVMInsertDeclare(
1799 dib: *DIBuilder,
1800 storage: *Value,
1801 var_info: *DILocalVariable,
1802 debug_loc: *DILocation,
1803 insert_before_instr: *Value,
1804 ) *Value;
1805
1806 pub const insertDbgValueIntrinsicAtEnd = ZigLLVMInsertDbgValueIntrinsicAtEnd;
1807 extern fn ZigLLVMInsertDbgValueIntrinsicAtEnd(
1808 dib: *DIBuilder,
1809 val: *Value,
1810 var_info: *DILocalVariable,
1811 debug_loc: *DILocation,
1812 basic_block_ref: *BasicBlock,
1813 ) *Value;
1814};
1815
1816398pub const DIFlags = opaque {
1817399 pub const Zero = 0;
1818400 pub const Private = 1;
src/zig_llvm.cpp-624
......@@ -24,9 +24,7 @@
2424#include <llvm/Analysis/TargetLibraryInfo.h>
2525#include <llvm/Analysis/TargetTransformInfo.h>
2626#include <llvm/Bitcode/BitcodeWriter.h>
27#include <llvm/IR/DIBuilder.h>
2827#include <llvm/IR/DiagnosticInfo.h>
29#include <llvm/IR/IRBuilder.h>
3028#include <llvm/IR/InlineAsm.h>
3129#include <llvm/IR/Instructions.h>
3230#include <llvm/IR/LegacyPassManager.h>
......@@ -382,566 +380,10 @@ void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit) {
382380 unwrap(context_ref)->setOptPassGate(opt_bisect);
383381}
384382
385LLVMValueRef ZigLLVMAddFunctionInAddressSpace(LLVMModuleRef M, const char *Name, LLVMTypeRef FunctionTy, unsigned AddressSpace) {
386 Function* func = Function::Create(unwrap<FunctionType>(FunctionTy), GlobalValue::ExternalLinkage, AddressSpace, Name, unwrap(M));
387 return wrap(func);
388}
389
390void ZigLLVMSetTailCallKind(LLVMValueRef Call, enum ZigLLVMTailCallKind TailCallKind) {
391 CallInst::TailCallKind TCK;
392 switch (TailCallKind) {
393 case ZigLLVMTailCallKindNone:
394 TCK = CallInst::TCK_None;
395 break;
396 case ZigLLVMTailCallKindTail:
397 TCK = CallInst::TCK_Tail;
398 break;
399 case ZigLLVMTailCallKindMustTail:
400 TCK = CallInst::TCK_MustTail;
401 break;
402 case ZigLLVMTailCallKindNoTail:
403 TCK = CallInst::TCK_NoTail;
404 break;
405 }
406 unwrap<CallInst>(Call)->setTailCallKind(TCK);
407}
408
409void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
410 assert( isa<Function>(unwrap(fn)) );
411 Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
412 unwrapped_function->setSubprogram(reinterpret_cast<DISubprogram*>(subprogram));
413}
414
415
416ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
417 uint64_t size_in_bits, uint64_t align_in_bits, const char *name)
418{
419 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createPointerType(
420 reinterpret_cast<DIType*>(pointee_type), size_in_bits, align_in_bits, std::optional<unsigned>(), name);
421 return reinterpret_cast<ZigLLVMDIType*>(di_type);
422}
423
424ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
425 uint64_t size_in_bits, unsigned encoding)
426{
427 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createBasicType(
428 name, size_in_bits, encoding);
429 return reinterpret_cast<ZigLLVMDIType*>(di_type);
430}
431
432struct ZigLLVMDIType *ZigLLVMDIBuilderCreateVectorType(struct ZigLLVMDIBuilder *dibuilder,
433 uint64_t SizeInBits, uint32_t AlignInBits, struct ZigLLVMDIType *Ty, uint32_t elem_count)
434{
435 SmallVector<Metadata *, 1> subrange;
436 subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
437 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createVectorType(
438 SizeInBits,
439 AlignInBits,
440 reinterpret_cast<DIType*>(Ty),
441 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
442 return reinterpret_cast<ZigLLVMDIType*>(di_type);
443}
444
445ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder, uint64_t size_in_bits,
446 uint64_t align_in_bits, ZigLLVMDIType *elem_type, int64_t elem_count)
447{
448 SmallVector<Metadata *, 1> subrange;
449 subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
450 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createArrayType(
451 size_in_bits, align_in_bits,
452 reinterpret_cast<DIType*>(elem_type),
453 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
454 return reinterpret_cast<ZigLLVMDIType*>(di_type);
455}
456
457ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(ZigLLVMDIBuilder *dibuilder, const char *name, uint64_t val, bool isUnsigned) {
458 DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name, val, isUnsigned);
459 return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
460}
461
462ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision(ZigLLVMDIBuilder *dibuilder,
463 const char *name, unsigned NumWords, const uint64_t Words[], unsigned int bits, bool isUnsigned)
464{
465 DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name,
466 APSInt(APInt(bits, ArrayRef(Words, NumWords)), isUnsigned));
467 return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
468}
469
470ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
471 const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
472 uint64_t align_in_bits, ZigLLVMDIEnumerator **enumerator_array, int enumerator_array_len,
473 ZigLLVMDIType *underlying_type, const char *unique_id)
474{
475 SmallVector<Metadata *, 8> fields;
476 for (int i = 0; i < enumerator_array_len; i += 1) {
477 DIEnumerator *dienumerator = reinterpret_cast<DIEnumerator*>(enumerator_array[i]);
478 fields.push_back(dienumerator);
479 }
480 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerationType(
481 reinterpret_cast<DIScope*>(scope),
482 name,
483 reinterpret_cast<DIFile*>(file),
484 line_number, size_in_bits, align_in_bits,
485 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
486 reinterpret_cast<DIType*>(underlying_type),
487 unique_id);
488 return reinterpret_cast<ZigLLVMDIType*>(di_type);
489}
490
491ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
492 const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
493 uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type)
494{
495 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
496 reinterpret_cast<DIScope*>(scope),
497 name,
498 reinterpret_cast<DIFile*>(file),
499 line, size_in_bits, align_in_bits, offset_in_bits,
500 static_cast<DINode::DIFlags>(flags),
501 reinterpret_cast<DIType*>(type));
502 return reinterpret_cast<ZigLLVMDIType*>(di_type);
503}
504
505ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
506 const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
507 uint64_t align_in_bits, unsigned flags, ZigLLVMDIType **types_array, int types_array_len,
508 unsigned run_time_lang, const char *unique_id)
509{
510 SmallVector<Metadata *, 8> fields;
511 for (int i = 0; i < types_array_len; i += 1) {
512 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
513 fields.push_back(ditype);
514 }
515 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
516 reinterpret_cast<DIScope*>(scope),
517 name,
518 reinterpret_cast<DIFile*>(file),
519 line_number, size_in_bits, align_in_bits,
520 static_cast<DINode::DIFlags>(flags),
521 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
522 run_time_lang, unique_id);
523 return reinterpret_cast<ZigLLVMDIType*>(di_type);
524}
525
526ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
527 const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
528 uint64_t align_in_bits, unsigned flags, ZigLLVMDIType *derived_from,
529 ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang, ZigLLVMDIType *vtable_holder,
530 const char *unique_id)
531{
532 SmallVector<Metadata *, 8> fields;
533 for (int i = 0; i < types_array_len; i += 1) {
534 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
535 fields.push_back(ditype);
536 }
537 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
538 reinterpret_cast<DIScope*>(scope),
539 name,
540 reinterpret_cast<DIFile*>(file),
541 line_number, size_in_bits, align_in_bits,
542 static_cast<DINode::DIFlags>(flags),
543 reinterpret_cast<DIType*>(derived_from),
544 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
545 run_time_lang,
546 reinterpret_cast<DIType*>(vtable_holder),
547 unique_id);
548 return reinterpret_cast<ZigLLVMDIType*>(di_type);
549}
550
551ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
552 const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
553{
554 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createReplaceableCompositeType(
555 tag, name,
556 reinterpret_cast<DIScope*>(scope),
557 reinterpret_cast<DIFile*>(file),
558 line);
559 return reinterpret_cast<ZigLLVMDIType*>(di_type);
560}
561
562ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
563 const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
564{
565 DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createForwardDecl(
566 tag, name,
567 reinterpret_cast<DIScope*>(scope),
568 reinterpret_cast<DIFile*>(file),
569 line);
570 return reinterpret_cast<ZigLLVMDIType*>(di_type);
571}
572
573void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
574 ZigLLVMDIType *replacement)
575{
576 reinterpret_cast<DIBuilder*>(dibuilder)->replaceTemporary(
577 TempDIType(reinterpret_cast<DIType*>(type)),
578 reinterpret_cast<DIType*>(replacement));
579}
580
581void ZigLLVMReplaceDebugArrays(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
582 ZigLLVMDIType **types_array, int types_array_len)
583{
584 SmallVector<Metadata *, 8> fields;
585 for (int i = 0; i < types_array_len; i += 1) {
586 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
587 fields.push_back(ditype);
588 }
589 DICompositeType *composite_type = (DICompositeType*)reinterpret_cast<DIType*>(type);
590 reinterpret_cast<DIBuilder*>(dibuilder)->replaceArrays(
591 composite_type,
592 reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields));
593}
594
595ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
596 ZigLLVMDIType **types_array, int types_array_len, unsigned flags)
597{
598 SmallVector<Metadata *, 8> types;
599 for (int i = 0; i < types_array_len; i += 1) {
600 DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
601 types.push_back(ditype);
602 }
603 DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
604 DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
605 dibuilder->getOrCreateTypeArray(types),
606 static_cast<DINode::DIFlags>(flags));
607 DIType *ditype = subroutine_type;
608 return reinterpret_cast<ZigLLVMDIType*>(ditype);
609}
610
611unsigned ZigLLVMEncoding_DW_ATE_unsigned(void) {
612 return dwarf::DW_ATE_unsigned;
613}
614
615unsigned ZigLLVMEncoding_DW_ATE_signed(void) {
616 return dwarf::DW_ATE_signed;
617}
618
619unsigned ZigLLVMEncoding_DW_ATE_float(void) {
620 return dwarf::DW_ATE_float;
621}
622
623unsigned ZigLLVMEncoding_DW_ATE_boolean(void) {
624 return dwarf::DW_ATE_boolean;
625}
626
627unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void) {
628 return dwarf::DW_ATE_unsigned_char;
629}
630
631unsigned ZigLLVMEncoding_DW_ATE_signed_char(void) {
632 return dwarf::DW_ATE_signed_char;
633}
634
635unsigned ZigLLVMLang_DW_LANG_C99(void) {
636 return dwarf::DW_LANG_C99;
637}
638
639unsigned ZigLLVMTag_DW_variable(void) {
640 return dwarf::DW_TAG_variable;
641}
642
643unsigned ZigLLVMTag_DW_structure_type(void) {
644 return dwarf::DW_TAG_structure_type;
645}
646
647unsigned ZigLLVMTag_DW_enumeration_type(void) {
648 return dwarf::DW_TAG_enumeration_type;
649}
650
651unsigned ZigLLVMTag_DW_union_type(void) {
652 return dwarf::DW_TAG_union_type;
653}
654
655ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved) {
656 DIBuilder *di_builder = new(std::nothrow) DIBuilder(*unwrap(module), allow_unresolved);
657 if (di_builder == nullptr)
658 return nullptr;
659 return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
660}
661
662void ZigLLVMDisposeDIBuilder(ZigLLVMDIBuilder *dbuilder) {
663 DIBuilder *di_builder = reinterpret_cast<DIBuilder *>(dbuilder);
664 delete di_builder;
665}
666
667void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder,
668 unsigned int line, unsigned int column, ZigLLVMDIScope *scope)
669{
670 DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
671 DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, column, di_scope, nullptr, false);
672 unwrap(builder)->SetCurrentDebugLocation(debug_loc);
673}
674
675void ZigLLVMSetCurrentDebugLocation2(LLVMBuilderRef builder, unsigned int line,
676 unsigned int column, ZigLLVMDIScope *scope, ZigLLVMDILocation *inlined_at)
677{
678 DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
679 DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, column, di_scope,
680 reinterpret_cast<DILocation *>(inlined_at), false);
681 unwrap(builder)->SetCurrentDebugLocation(debug_loc);
682}
683
684void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder) {
685 unwrap(builder)->SetCurrentDebugLocation(DebugLoc());
686}
687
688
689ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope,
690 ZigLLVMDIFile *file, unsigned line, unsigned col)
691{
692 DILexicalBlock *result = reinterpret_cast<DIBuilder*>(dbuilder)->createLexicalBlock(
693 reinterpret_cast<DIScope*>(scope),
694 reinterpret_cast<DIFile*>(file),
695 line,
696 col);
697 return reinterpret_cast<ZigLLVMDILexicalBlock*>(result);
698}
699
700ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
701 ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
702 ZigLLVMDIType *type, bool always_preserve, unsigned flags)
703{
704 DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
705 reinterpret_cast<DIScope*>(scope),
706 name,
707 reinterpret_cast<DIFile*>(file),
708 line_no,
709 reinterpret_cast<DIType*>(type),
710 always_preserve,
711 static_cast<DINode::DIFlags>(flags));
712 return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
713}
714
715ZigLLVMDIGlobalVariableExpression *ZigLLVMCreateGlobalVariableExpression(ZigLLVMDIBuilder *dbuilder,
716 ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
717 unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit)
718{
719 return reinterpret_cast<ZigLLVMDIGlobalVariableExpression*>(reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariableExpression(
720 reinterpret_cast<DIScope*>(scope),
721 name,
722 linkage_name,
723 reinterpret_cast<DIFile*>(file),
724 line_no,
725 reinterpret_cast<DIType*>(di_type),
726 is_local_to_unit));
727}
728
729ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
730 ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
731 ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
732{
733 assert(arg_no != 0);
734 DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
735 reinterpret_cast<DIScope*>(scope),
736 name,
737 arg_no,
738 reinterpret_cast<DIFile*>(file),
739 line_no,
740 reinterpret_cast<DIType*>(type),
741 always_preserve,
742 static_cast<DINode::DIFlags>(flags));
743 return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
744}
745
746ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block) {
747 DIScope *scope = reinterpret_cast<DILexicalBlock*>(lexical_block);
748 return reinterpret_cast<ZigLLVMDIScope*>(scope);
749}
750
751ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit) {
752 DIScope *scope = reinterpret_cast<DICompileUnit*>(compile_unit);
753 return reinterpret_cast<ZigLLVMDIScope*>(scope);
754}
755
756ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile) {
757 DIScope *scope = reinterpret_cast<DIFile*>(difile);
758 return reinterpret_cast<ZigLLVMDIScope*>(scope);
759}
760
761ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram) {
762 DIScope *scope = reinterpret_cast<DISubprogram*>(subprogram);
763 return reinterpret_cast<ZigLLVMDIScope*>(scope);
764}
765
766ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
767 DIScope *scope = reinterpret_cast<DIType*>(type);
768 return reinterpret_cast<ZigLLVMDIScope*>(scope);
769}
770
771ZigLLVMDINode *ZigLLVMLexicalBlockToNode(ZigLLVMDILexicalBlock *lexical_block) {
772 DINode *node = reinterpret_cast<DILexicalBlock*>(lexical_block);
773 return reinterpret_cast<ZigLLVMDINode*>(node);
774}
775
776ZigLLVMDINode *ZigLLVMCompileUnitToNode(ZigLLVMDICompileUnit *compile_unit) {
777 DINode *node = reinterpret_cast<DICompileUnit*>(compile_unit);
778 return reinterpret_cast<ZigLLVMDINode*>(node);
779}
780
781ZigLLVMDINode *ZigLLVMFileToNode(ZigLLVMDIFile *difile) {
782 DINode *node = reinterpret_cast<DIFile*>(difile);
783 return reinterpret_cast<ZigLLVMDINode*>(node);
784}
785
786ZigLLVMDINode *ZigLLVMSubprogramToNode(ZigLLVMDISubprogram *subprogram) {
787 DINode *node = reinterpret_cast<DISubprogram*>(subprogram);
788 return reinterpret_cast<ZigLLVMDINode*>(node);
789}
790
791ZigLLVMDINode *ZigLLVMTypeToNode(ZigLLVMDIType *type) {
792 DINode *node = reinterpret_cast<DIType*>(type);
793 return reinterpret_cast<ZigLLVMDINode*>(node);
794}
795
796ZigLLVMDINode *ZigLLVMScopeToNode(ZigLLVMDIScope *scope) {
797 DINode *node = reinterpret_cast<DIScope*>(scope);
798 return reinterpret_cast<ZigLLVMDINode*>(node);
799}
800
801ZigLLVMDINode *ZigLLVMGlobalVariableToNode(ZigLLVMDIGlobalVariable *global_variable) {
802 DINode *node = reinterpret_cast<DIGlobalVariable*>(global_variable);
803 return reinterpret_cast<ZigLLVMDINode*>(node);
804}
805
806void ZigLLVMSubprogramReplaceLinkageName(ZigLLVMDISubprogram *subprogram,
807 ZigLLVMMDString *linkage_name)
808{
809 MDString *linkage_name_md = reinterpret_cast<MDString*>(linkage_name);
810 reinterpret_cast<DISubprogram*>(subprogram)->replaceLinkageName(linkage_name_md);
811}
812
813void ZigLLVMGlobalVariableReplaceLinkageName(ZigLLVMDIGlobalVariable *global_variable,
814 ZigLLVMMDString *linkage_name)
815{
816 Metadata *linkage_name_md = reinterpret_cast<MDString*>(linkage_name);
817 // NOTE: Operand index must match llvm::DIGlobalVariable
818 reinterpret_cast<DIGlobalVariable*>(global_variable)->replaceOperandWith(5, linkage_name_md);
819}
820
821ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
822 unsigned lang, ZigLLVMDIFile *difile, const char *producer,
823 bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
824 uint64_t dwo_id, bool emit_debug_info)
825{
826 DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit(
827 lang,
828 reinterpret_cast<DIFile*>(difile),
829 producer, is_optimized, flags, runtime_version, split_name,
830 (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug),
831 dwo_id);
832 return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
833}
834
835
836ZigLLVMDIFile *ZigLLVMCreateFile(ZigLLVMDIBuilder *dibuilder, const char *filename, const char *directory) {
837 DIFile *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFile(filename, directory);
838 return reinterpret_cast<ZigLLVMDIFile*>(result);
839}
840
841ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
842 const char *name, const char *linkage_name, ZigLLVMDIFile *file, unsigned lineno,
843 ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
844 unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
845{
846 DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
847 DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
848 reinterpret_cast<DIScope*>(scope),
849 name, linkage_name,
850 reinterpret_cast<DIFile*>(file),
851 lineno,
852 di_sub_type,
853 scope_line,
854 static_cast<DINode::DIFlags>(flags),
855 DISubprogram::toSPFlags(is_local_to_unit, is_definition, is_optimized),
856 nullptr,
857 reinterpret_cast<DISubprogram *>(decl_subprogram),
858 nullptr);
859 return reinterpret_cast<ZigLLVMDISubprogram*>(result);
860}
861
862void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder) {
863 reinterpret_cast<DIBuilder*>(dibuilder)->finalize();
864}
865
866LLVMValueRef ZigLLVMInsertDeclareAtEnd(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
867 ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref)
868{
869 Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
870 unwrap(storage),
871 reinterpret_cast<DILocalVariable *>(var_info),
872 reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
873 reinterpret_cast<DILocation*>(debug_loc),
874 static_cast<BasicBlock*>(unwrap(basic_block_ref)));
875 return wrap(result);
876}
877
878LLVMValueRef ZigLLVMInsertDbgValueIntrinsicAtEnd(ZigLLVMDIBuilder *dib, LLVMValueRef val,
879 ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc,
880 LLVMBasicBlockRef basic_block_ref)
881{
882 Instruction *result = reinterpret_cast<DIBuilder*>(dib)->insertDbgValueIntrinsic(
883 unwrap(val),
884 reinterpret_cast<DILocalVariable *>(var_info),
885 reinterpret_cast<DIBuilder*>(dib)->createExpression(),
886 reinterpret_cast<DILocation*>(debug_loc),
887 static_cast<BasicBlock*>(unwrap(basic_block_ref)));
888 return wrap(result);
889}
890
891LLVMValueRef ZigLLVMInsertDeclare(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
892 ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr)
893{
894 Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
895 unwrap(storage),
896 reinterpret_cast<DILocalVariable *>(var_info),
897 reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
898 reinterpret_cast<DILocation*>(debug_loc),
899 static_cast<Instruction*>(unwrap(insert_before_instr)));
900 return wrap(result);
901}
902
903ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col, ZigLLVMDIScope *scope) {
904 DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
905 DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, col, di_scope, nullptr, false);
906 return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
907}
908
909ZigLLVMDILocation *ZigLLVMGetDebugLoc2(unsigned line, unsigned col, ZigLLVMDIScope *scope,
910 ZigLLVMDILocation *inlined_at) {
911 DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
912 DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, col, di_scope,
913 reinterpret_cast<DILocation *>(inlined_at), false);
914 return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
915}
916
917void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
918 if (on_state) {
919 FastMathFlags fmf;
920 fmf.setFast();
921 unwrap(builder_wrapped)->setFastMathFlags(fmf);
922 } else {
923 unwrap(builder_wrapped)->clearFastMathFlags();
924 }
925}
926
927383void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
928384 cl::ParseCommandLineOptions(argc, argv);
929385}
930386
931void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module, bool produce_dwarf64) {
932 unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
933 unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
934
935 if (produce_dwarf64) {
936 unwrap(module)->addModuleFlag(Module::Warning, "DWARF64", 1);
937 }
938}
939
940void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module) {
941 unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
942 unwrap(module)->addModuleFlag(Module::Warning, "CodeView", 1);
943}
944
945387void ZigLLVMSetModulePICLevel(LLVMModuleRef module) {
946388 unwrap(module)->setPICLevel(PICLevel::Level::BigPIC);
947389}
......@@ -956,35 +398,6 @@ void ZigLLVMSetModuleCodeModel(LLVMModuleRef module, LLVMCodeModel code_model) {
956398 assert(!JIT);
957399}
958400
959LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
960 const char *name)
961{
962 return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, false, true));
963}
964
965LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
966 const char *name)
967{
968 return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, true, false));
969}
970
971LLVMValueRef ZigLLVMBuildLShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
972 const char *name)
973{
974 return wrap(unwrap(builder)->CreateLShr(unwrap(LHS), unwrap(RHS), name, true));
975}
976
977LLVMValueRef ZigLLVMBuildAShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
978 const char *name)
979{
980 return wrap(unwrap(builder)->CreateAShr(unwrap(LHS), unwrap(RHS), name, true));
981}
982
983LLVMValueRef ZigLLVMBuildAllocaInAddressSpace(LLVMBuilderRef builder, LLVMTypeRef Ty,
984 unsigned AddressSpace, const char *Name) {
985 return wrap(unwrap(builder)->CreateAlloca(unwrap(Ty), AddressSpace, nullptr, Name));
986}
987
988401bool ZigLLVMWriteImportLibrary(const char *def_path, const ZigLLVM_ArchType arch,
989402 const char *output_lib_path, bool kill_at)
990403{
......@@ -1134,43 +547,6 @@ bool ZigLLDLinkWasm(int argc, const char **argv, bool can_exit_early, bool disab
1134547 return lld::wasm::link(args, llvm::outs(), llvm::errs(), can_exit_early, disable_output);
1135548}
1136549
1137void ZigLLVMTakeName(LLVMValueRef new_owner, LLVMValueRef victim) {
1138 unwrap(new_owner)->takeName(unwrap(victim));
1139}
1140
1141void ZigLLVMRemoveGlobalValue(LLVMValueRef GlobalVal) {
1142 unwrap<GlobalValue>(GlobalVal)->removeFromParent();
1143}
1144
1145void ZigLLVMEraseGlobalValue(LLVMValueRef GlobalVal) {
1146 unwrap<GlobalValue>(GlobalVal)->eraseFromParent();
1147}
1148
1149void ZigLLVMDeleteGlobalValue(LLVMValueRef GlobalVal) {
1150 auto *GV = unwrap<GlobalValue>(GlobalVal);
1151 assert(GV->getParent() == nullptr);
1152 switch (GV->getValueID()) {
1153#define HANDLE_GLOBAL_VALUE(NAME) \
1154 case Value::NAME##Val: \
1155 delete static_cast<NAME *>(GV); \
1156 break;
1157#include <llvm/IR/Value.def>
1158 default: llvm_unreachable("Expected global value");
1159 }
1160}
1161
1162void ZigLLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
1163 unwrap<GlobalVariable>(GlobalVar)->setInitializer(ConstantVal ? unwrap<Constant>(ConstantVal) : nullptr);
1164}
1165
1166ZigLLVMDIGlobalVariable* ZigLLVMGlobalGetVariable(ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
1167 return reinterpret_cast<ZigLLVMDIGlobalVariable*>(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression)->getVariable());
1168}
1169
1170void ZigLLVMAttachMetaData(LLVMValueRef Val, ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
1171 unwrap<GlobalVariable>(Val)->addDebugInfo(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression));
1172}
1173
1174550static_assert((Triple::ArchType)ZigLLVM_UnknownArch == Triple::UnknownArch, "");
1175551static_assert((Triple::ArchType)ZigLLVM_arm == Triple::arm, "");
1176552static_assert((Triple::ArchType)ZigLLVM_armeb == Triple::armeb, "");
src/zig_llvm.h-193
......@@ -24,24 +24,6 @@
2424// ATTENTION: If you modify this file, be sure to update the corresponding
2525// extern function declarations in the self-hosted compiler.
2626
27struct ZigLLVMDIType;
28struct ZigLLVMDIBuilder;
29struct ZigLLVMDICompileUnit;
30struct ZigLLVMDIScope;
31struct ZigLLVMDIFile;
32struct ZigLLVMDILexicalBlock;
33struct ZigLLVMDISubprogram;
34struct ZigLLVMDISubroutineType;
35struct ZigLLVMDILocalVariable;
36struct ZigLLVMDIGlobalVariableExpression;
37struct ZigLLVMDIGlobalVariable;
38struct ZigLLVMDIGlobalExpression;
39struct ZigLLVMDILocation;
40struct ZigLLVMDIEnumerator;
41struct ZigLLVMInsertionPoint;
42struct ZigLLVMDINode;
43struct ZigLLVMMDString;
44
4527ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
4628 char **error_message, bool is_debug,
4729 bool is_small, bool time_report, bool tsan, bool lto,
......@@ -62,9 +44,6 @@ ZIG_EXTERN_C LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, co
6244
6345ZIG_EXTERN_C void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit);
6446
65ZIG_EXTERN_C LLVMValueRef ZigLLVMAddFunctionInAddressSpace(LLVMModuleRef M, const char *Name,
66 LLVMTypeRef FunctionTy, unsigned AddressSpace);
67
6847enum ZigLLVMTailCallKind {
6948 ZigLLVMTailCallKindNone,
7049 ZigLLVMTailCallKindTail,
......@@ -72,8 +51,6 @@ enum ZigLLVMTailCallKind {
7251 ZigLLVMTailCallKindNoTail,
7352};
7453
75ZIG_EXTERN_C void ZigLLVMSetTailCallKind(LLVMValueRef Call, enum ZigLLVMTailCallKind TailCallKind);
76
7754enum ZigLLVM_CallingConv {
7855 ZigLLVM_C = 0,
7956 ZigLLVM_Fast = 8,
......@@ -122,176 +99,12 @@ enum ZigLLVM_CallingConv {
12299 ZigLLVM_MaxID = 1023,
123100};
124101
125ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
126 const char *name);
127ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
128 const char *name);
129ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildLShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
130 const char *name);
131ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildAShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
132 const char *name);
133
134ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildAllocaInAddressSpace(LLVMBuilderRef builder, LLVMTypeRef Ty, unsigned AddressSpace,
135 const char *Name);
136
137ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugPointerType(struct ZigLLVMDIBuilder *dibuilder,
138 struct ZigLLVMDIType *pointee_type, uint64_t size_in_bits, uint64_t align_in_bits, const char *name);
139
140ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugBasicType(struct ZigLLVMDIBuilder *dibuilder, const char *name,
141 uint64_t size_in_bits, unsigned encoding);
142
143ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugArrayType(struct ZigLLVMDIBuilder *dibuilder,
144 uint64_t size_in_bits, uint64_t align_in_bits, struct ZigLLVMDIType *elem_type,
145 int64_t elem_count);
146
147ZIG_EXTERN_C struct ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(struct ZigLLVMDIBuilder *dibuilder,
148 const char *name, uint64_t val, bool isUnsigned);
149
150
151ZIG_EXTERN_C struct ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision(struct ZigLLVMDIBuilder *dibuilder,
152 const char *name, unsigned NumWords, const uint64_t Words[], unsigned int bits, bool isUnsigned);
153
154ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(struct ZigLLVMDIBuilder *dibuilder,
155 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line_number,
156 uint64_t size_in_bits, uint64_t align_in_bits, struct ZigLLVMDIEnumerator **enumerator_array,
157 int enumerator_array_len, struct ZigLLVMDIType *underlying_type, const char *unique_id);
158
159ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugStructType(struct ZigLLVMDIBuilder *dibuilder,
160 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line_number,
161 uint64_t size_in_bits, uint64_t align_in_bits, unsigned flags, struct ZigLLVMDIType *derived_from,
162 struct ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang,
163 struct ZigLLVMDIType *vtable_holder, const char *unique_id);
164
165ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugUnionType(struct ZigLLVMDIBuilder *dibuilder,
166 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line_number,
167 uint64_t size_in_bits, uint64_t align_in_bits, unsigned flags, struct ZigLLVMDIType **types_array,
168 int types_array_len, unsigned run_time_lang, const char *unique_id);
169
170ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugMemberType(struct ZigLLVMDIBuilder *dibuilder,
171 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line,
172 uint64_t size_in_bits, uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags,
173 struct ZigLLVMDIType *type);
174
175ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(struct ZigLLVMDIBuilder *dibuilder,
176 unsigned tag, const char *name, struct ZigLLVMDIScope *scope, struct ZigLLVMDIFile *file, unsigned line);
177
178ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(struct ZigLLVMDIBuilder *dibuilder, unsigned tag,
179 const char *name, struct ZigLLVMDIScope *scope, struct ZigLLVMDIFile *file, unsigned line);
180
181ZIG_EXTERN_C void ZigLLVMReplaceTemporary(struct ZigLLVMDIBuilder *dibuilder, struct ZigLLVMDIType *type,
182 struct ZigLLVMDIType *replacement);
183
184ZIG_EXTERN_C void ZigLLVMReplaceDebugArrays(struct ZigLLVMDIBuilder *dibuilder, struct ZigLLVMDIType *type,
185 struct ZigLLVMDIType **types_array, int types_array_len);
186
187ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateSubroutineType(struct ZigLLVMDIBuilder *dibuilder_wrapped,
188 struct ZigLLVMDIType **types_array, int types_array_len, unsigned flags);
189
190ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_unsigned(void);
191ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_signed(void);
192ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_float(void);
193ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_boolean(void);
194ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void);
195ZIG_EXTERN_C unsigned ZigLLVMEncoding_DW_ATE_signed_char(void);
196ZIG_EXTERN_C unsigned ZigLLVMLang_DW_LANG_C99(void);
197ZIG_EXTERN_C unsigned ZigLLVMTag_DW_variable(void);
198ZIG_EXTERN_C unsigned ZigLLVMTag_DW_structure_type(void);
199ZIG_EXTERN_C unsigned ZigLLVMTag_DW_enumeration_type(void);
200ZIG_EXTERN_C unsigned ZigLLVMTag_DW_union_type(void);
201
202ZIG_EXTERN_C struct ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
203ZIG_EXTERN_C void ZigLLVMDisposeDIBuilder(struct ZigLLVMDIBuilder *dbuilder);
204ZIG_EXTERN_C void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module, bool produce_dwarf64);
205ZIG_EXTERN_C void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module);
206102ZIG_EXTERN_C void ZigLLVMSetModulePICLevel(LLVMModuleRef module);
207103ZIG_EXTERN_C void ZigLLVMSetModulePIELevel(LLVMModuleRef module);
208104ZIG_EXTERN_C void ZigLLVMSetModuleCodeModel(LLVMModuleRef module, LLVMCodeModel code_model);
209105
210ZIG_EXTERN_C void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder,
211 unsigned int line, unsigned int column, struct ZigLLVMDIScope *scope);
212ZIG_EXTERN_C void ZigLLVMSetCurrentDebugLocation2(LLVMBuilderRef builder, unsigned int line,
213 unsigned int column, struct ZigLLVMDIScope *scope, struct ZigLLVMDILocation *inlined_at);
214ZIG_EXTERN_C void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder);
215
216ZIG_EXTERN_C struct ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(struct ZigLLVMDILexicalBlock *lexical_block);
217ZIG_EXTERN_C struct ZigLLVMDIScope *ZigLLVMCompileUnitToScope(struct ZigLLVMDICompileUnit *compile_unit);
218ZIG_EXTERN_C struct ZigLLVMDIScope *ZigLLVMFileToScope(struct ZigLLVMDIFile *difile);
219ZIG_EXTERN_C struct ZigLLVMDIScope *ZigLLVMSubprogramToScope(struct ZigLLVMDISubprogram *subprogram);
220ZIG_EXTERN_C struct ZigLLVMDIScope *ZigLLVMTypeToScope(struct ZigLLVMDIType *type);
221
222ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMLexicalBlockToNode(struct ZigLLVMDILexicalBlock *lexical_block);
223ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMCompileUnitToNode(struct ZigLLVMDICompileUnit *compile_unit);
224ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMFileToNode(struct ZigLLVMDIFile *difile);
225ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMSubprogramToNode(struct ZigLLVMDISubprogram *subprogram);
226ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMTypeToNode(struct ZigLLVMDIType *type);
227ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMScopeToNode(struct ZigLLVMDIScope *scope);
228ZIG_EXTERN_C struct ZigLLVMDINode *ZigLLVMGlobalVariableToNode(struct ZigLLVMDIGlobalVariable *global_variable);
229
230ZIG_EXTERN_C void ZigLLVMSubprogramReplaceLinkageName(struct ZigLLVMDISubprogram *subprogram,
231 struct ZigLLVMMDString *linkage_name);
232ZIG_EXTERN_C void ZigLLVMGlobalVariableReplaceLinkageName(struct ZigLLVMDIGlobalVariable *global_variable,
233 struct ZigLLVMMDString *linkage_name);
234
235ZIG_EXTERN_C struct ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(struct ZigLLVMDIBuilder *dbuilder,
236 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line_no,
237 struct ZigLLVMDIType *type, bool always_preserve, unsigned flags);
238
239ZIG_EXTERN_C struct ZigLLVMDIGlobalVariableExpression *ZigLLVMCreateGlobalVariableExpression(struct ZigLLVMDIBuilder *dbuilder,
240 struct ZigLLVMDIScope *scope, const char *name, const char *linkage_name, struct ZigLLVMDIFile *file,
241 unsigned line_no, struct ZigLLVMDIType *di_type, bool is_local_to_unit);
242
243ZIG_EXTERN_C struct ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(struct ZigLLVMDIBuilder *dbuilder,
244 struct ZigLLVMDIScope *scope, const char *name, struct ZigLLVMDIFile *file, unsigned line_no,
245 struct ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no);
246
247ZIG_EXTERN_C struct ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(struct ZigLLVMDIBuilder *dbuilder,
248 struct ZigLLVMDIScope *scope, struct ZigLLVMDIFile *file, unsigned line, unsigned col);
249
250ZIG_EXTERN_C struct ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(struct ZigLLVMDIBuilder *dibuilder,
251 unsigned lang, struct ZigLLVMDIFile *difile, const char *producer,
252 bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
253 uint64_t dwo_id, bool emit_debug_info);
254
255ZIG_EXTERN_C struct ZigLLVMDIFile *ZigLLVMCreateFile(struct ZigLLVMDIBuilder *dibuilder, const char *filename,
256 const char *directory);
257
258ZIG_EXTERN_C struct ZigLLVMDISubprogram *ZigLLVMCreateFunction(struct ZigLLVMDIBuilder *dibuilder,
259 struct ZigLLVMDIScope *scope, const char *name, const char *linkage_name, struct ZigLLVMDIFile *file,
260 unsigned lineno, struct ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition,
261 unsigned scope_line, unsigned flags, bool is_optimized, struct ZigLLVMDISubprogram *decl_subprogram);
262
263ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMDIBuilderCreateVectorType(struct ZigLLVMDIBuilder *dibuilder,
264 uint64_t SizeInBits, uint32_t AlignInBits, struct ZigLLVMDIType *Ty, uint32_t elem_count);
265
266ZIG_EXTERN_C void ZigLLVMFnSetSubprogram(LLVMValueRef fn, struct ZigLLVMDISubprogram *subprogram);
267
268ZIG_EXTERN_C void ZigLLVMDIBuilderFinalize(struct ZigLLVMDIBuilder *dibuilder);
269
270ZIG_EXTERN_C struct ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col,
271 struct ZigLLVMDIScope *scope);
272ZIG_EXTERN_C struct ZigLLVMDILocation *ZigLLVMGetDebugLoc2(unsigned line, unsigned col,
273 struct ZigLLVMDIScope *scope, struct ZigLLVMDILocation *inlined_at);
274
275ZIG_EXTERN_C LLVMValueRef ZigLLVMInsertDeclareAtEnd(struct ZigLLVMDIBuilder *dib,
276 LLVMValueRef storage, struct ZigLLVMDILocalVariable *var_info,
277 struct ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref);
278
279ZIG_EXTERN_C LLVMValueRef ZigLLVMInsertDeclare(struct ZigLLVMDIBuilder *dib,
280 LLVMValueRef storage, struct ZigLLVMDILocalVariable *var_info,
281 struct ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr);
282
283ZIG_EXTERN_C LLVMValueRef ZigLLVMInsertDbgValueIntrinsicAtEnd(struct ZigLLVMDIBuilder *dib,
284 LLVMValueRef val, struct ZigLLVMDILocalVariable *var_info,
285 struct ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref);
286
287ZIG_EXTERN_C void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state);
288
289106ZIG_EXTERN_C void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv);
290107
291ZIG_EXTERN_C ZigLLVMDIGlobalVariable* ZigLLVMGlobalGetVariable(ZigLLVMDIGlobalVariableExpression *global_variable_expression);
292ZIG_EXTERN_C void ZigLLVMAttachMetaData(LLVMValueRef Val, ZigLLVMDIGlobalVariableExpression *global_variable_expression);
293
294
295108// synchronize with llvm/include/ADT/Triple.h::ArchType
296109// synchronize with std.Target.Cpu.Arch
297110// synchronize with codegen/llvm/bindings.zig::ArchType
......@@ -494,12 +307,6 @@ enum ZigLLVM_ObjectFormatType {
494307 ZigLLVM_XCOFF,
495308};
496309
497ZIG_EXTERN_C void ZigLLVMTakeName(LLVMValueRef new_owner, LLVMValueRef victim);
498ZIG_EXTERN_C void ZigLLVMRemoveGlobalValue(LLVMValueRef GlobalVal);
499ZIG_EXTERN_C void ZigLLVMEraseGlobalValue(LLVMValueRef GlobalVal);
500ZIG_EXTERN_C void ZigLLVMDeleteGlobalValue(LLVMValueRef GlobalVal);
501ZIG_EXTERN_C void ZigLLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
502
503310#define ZigLLVM_DIFlags_Zero 0U
504311#define ZigLLVM_DIFlags_Private 1U
505312#define ZigLLVM_DIFlags_Protected 2U