Commit 99b954b9ce
Changed files (2)
src
codegen
src/codegen/llvm/bindings.zig
@@ -20,405 +20,405 @@ pub const AttributeIndex = c_uint;
/// Make sure to use the *InContext functions instead of the global ones.
pub const Context = opaque {
pub const create = LLVMContextCreate;
- extern fn LLVMContextCreate() *const Context;
+ extern fn LLVMContextCreate() *Context;
pub const dispose = LLVMContextDispose;
- extern fn LLVMContextDispose(C: *const Context) void;
+ extern fn LLVMContextDispose(C: *Context) void;
pub const createEnumAttribute = LLVMCreateEnumAttribute;
- extern fn LLVMCreateEnumAttribute(*const Context, KindID: c_uint, Val: u64) *const Attribute;
+ extern fn LLVMCreateEnumAttribute(*Context, KindID: c_uint, Val: u64) *Attribute;
pub const createStringAttribute = LLVMCreateStringAttribute;
- extern fn LLVMCreateStringAttribute(*const Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *const Attribute;
+ extern fn LLVMCreateStringAttribute(*Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *Attribute;
pub const pointerType = LLVMPointerTypeInContext;
- extern fn LLVMPointerTypeInContext(C: *const Context, AddressSpace: c_uint) *const Type;
+ extern fn LLVMPointerTypeInContext(C: *Context, AddressSpace: c_uint) *Type;
pub const intType = LLVMIntTypeInContext;
- extern fn LLVMIntTypeInContext(C: *const Context, NumBits: c_uint) *const Type;
+ extern fn LLVMIntTypeInContext(C: *Context, NumBits: c_uint) *Type;
pub const halfType = LLVMHalfTypeInContext;
- extern fn LLVMHalfTypeInContext(C: *const Context) *const Type;
+ extern fn LLVMHalfTypeInContext(C: *Context) *Type;
pub const floatType = LLVMFloatTypeInContext;
- extern fn LLVMFloatTypeInContext(C: *const Context) *const Type;
+ extern fn LLVMFloatTypeInContext(C: *Context) *Type;
pub const doubleType = LLVMDoubleTypeInContext;
- extern fn LLVMDoubleTypeInContext(C: *const Context) *const Type;
+ extern fn LLVMDoubleTypeInContext(C: *Context) *Type;
pub const x86FP80Type = LLVMX86FP80TypeInContext;
- extern fn LLVMX86FP80TypeInContext(C: *const Context) *const Type;
+ extern fn LLVMX86FP80TypeInContext(C: *Context) *Type;
pub const fp128Type = LLVMFP128TypeInContext;
- extern fn LLVMFP128TypeInContext(C: *const Context) *const Type;
+ extern fn LLVMFP128TypeInContext(C: *Context) *Type;
pub const voidType = LLVMVoidTypeInContext;
- extern fn LLVMVoidTypeInContext(C: *const Context) *const Type;
+ extern fn LLVMVoidTypeInContext(C: *Context) *Type;
pub const structType = LLVMStructTypeInContext;
extern fn LLVMStructTypeInContext(
- C: *const Context,
- ElementTypes: [*]const *const Type,
+ C: *Context,
+ ElementTypes: [*]const *Type,
ElementCount: c_uint,
Packed: Bool,
- ) *const Type;
+ ) *Type;
pub const structCreateNamed = LLVMStructCreateNamed;
- extern fn LLVMStructCreateNamed(C: *const Context, Name: [*:0]const u8) *const Type;
+ extern fn LLVMStructCreateNamed(C: *Context, Name: [*:0]const u8) *Type;
pub const constString = LLVMConstStringInContext;
- extern fn LLVMConstStringInContext(C: *const Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *const Value;
+ extern fn LLVMConstStringInContext(C: *Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *Value;
pub const constStruct = LLVMConstStructInContext;
extern fn LLVMConstStructInContext(
- C: *const Context,
- ConstantVals: [*]const *const Value,
+ C: *Context,
+ ConstantVals: [*]const *Value,
Count: c_uint,
Packed: Bool,
- ) *const Value;
+ ) *Value;
pub const createBasicBlock = LLVMCreateBasicBlockInContext;
- extern fn LLVMCreateBasicBlockInContext(C: *const Context, Name: [*:0]const u8) *const BasicBlock;
+ extern fn LLVMCreateBasicBlockInContext(C: *Context, Name: [*:0]const u8) *BasicBlock;
pub const appendBasicBlock = LLVMAppendBasicBlockInContext;
- extern fn LLVMAppendBasicBlockInContext(C: *const Context, Fn: *const Value, Name: [*:0]const u8) *const BasicBlock;
+ extern fn LLVMAppendBasicBlockInContext(C: *Context, Fn: *Value, Name: [*:0]const u8) *BasicBlock;
pub const createBuilder = LLVMCreateBuilderInContext;
- extern fn LLVMCreateBuilderInContext(C: *const Context) *const Builder;
+ extern fn LLVMCreateBuilderInContext(C: *Context) *Builder;
};
pub const Value = opaque {
pub const addAttributeAtIndex = LLVMAddAttributeAtIndex;
- extern fn LLVMAddAttributeAtIndex(*const Value, Idx: AttributeIndex, A: *const Attribute) void;
+ extern fn LLVMAddAttributeAtIndex(*Value, Idx: AttributeIndex, A: *Attribute) void;
pub const removeEnumAttributeAtIndex = LLVMRemoveEnumAttributeAtIndex;
- extern fn LLVMRemoveEnumAttributeAtIndex(F: *const Value, Idx: AttributeIndex, KindID: c_uint) void;
+ extern fn LLVMRemoveEnumAttributeAtIndex(F: *Value, Idx: AttributeIndex, KindID: c_uint) void;
pub const getFirstBasicBlock = LLVMGetFirstBasicBlock;
- extern fn LLVMGetFirstBasicBlock(Fn: *const Value) ?*const BasicBlock;
+ extern fn LLVMGetFirstBasicBlock(Fn: *Value) ?*BasicBlock;
pub const appendExistingBasicBlock = LLVMAppendExistingBasicBlock;
- extern fn LLVMAppendExistingBasicBlock(Fn: *const Value, BB: *const BasicBlock) void;
+ extern fn LLVMAppendExistingBasicBlock(Fn: *Value, BB: *BasicBlock) void;
pub const addIncoming = LLVMAddIncoming;
extern fn LLVMAddIncoming(
- PhiNode: *const Value,
- IncomingValues: [*]const *const Value,
- IncomingBlocks: [*]const *const BasicBlock,
+ PhiNode: *Value,
+ IncomingValues: [*]const *Value,
+ IncomingBlocks: [*]const *BasicBlock,
Count: c_uint,
) void;
pub const getNextInstruction = LLVMGetNextInstruction;
- extern fn LLVMGetNextInstruction(Inst: *const Value) ?*const Value;
+ extern fn LLVMGetNextInstruction(Inst: *Value) ?*Value;
pub const typeOf = LLVMTypeOf;
- extern fn LLVMTypeOf(Val: *const Value) *const Type;
+ extern fn LLVMTypeOf(Val: *Value) *Type;
pub const setGlobalConstant = LLVMSetGlobalConstant;
- extern fn LLVMSetGlobalConstant(GlobalVar: *const Value, IsConstant: Bool) void;
+ extern fn LLVMSetGlobalConstant(GlobalVar: *Value, IsConstant: Bool) void;
pub const setLinkage = LLVMSetLinkage;
- extern fn LLVMSetLinkage(Global: *const Value, Linkage: Linkage) void;
+ extern fn LLVMSetLinkage(Global: *Value, Linkage: Linkage) void;
pub const setVisibility = LLVMSetVisibility;
- extern fn LLVMSetVisibility(Global: *const Value, Linkage: Visibility) void;
+ extern fn LLVMSetVisibility(Global: *Value, Linkage: Visibility) void;
pub const setUnnamedAddr = LLVMSetUnnamedAddr;
- extern fn LLVMSetUnnamedAddr(Global: *const Value, HasUnnamedAddr: Bool) void;
+ extern fn LLVMSetUnnamedAddr(Global: *Value, HasUnnamedAddr: Bool) void;
pub const setThreadLocalMode = LLVMSetThreadLocalMode;
- extern fn LLVMSetThreadLocalMode(Global: *const Value, Mode: ThreadLocalMode) void;
+ extern fn LLVMSetThreadLocalMode(Global: *Value, Mode: ThreadLocalMode) void;
pub const setSection = LLVMSetSection;
- extern fn LLVMSetSection(Global: *const Value, Section: [*:0]const u8) void;
+ extern fn LLVMSetSection(Global: *Value, Section: [*:0]const u8) void;
pub const deleteGlobal = LLVMDeleteGlobal;
- extern fn LLVMDeleteGlobal(GlobalVar: *const Value) void;
+ extern fn LLVMDeleteGlobal(GlobalVar: *Value) void;
pub const getNextGlobalAlias = LLVMGetNextGlobalAlias;
- extern fn LLVMGetNextGlobalAlias(GA: *const Value) *const Value;
+ extern fn LLVMGetNextGlobalAlias(GA: *Value) *Value;
pub const getAliasee = LLVMAliasGetAliasee;
- extern fn LLVMAliasGetAliasee(Alias: *const Value) *const Value;
+ extern fn LLVMAliasGetAliasee(Alias: *Value) *Value;
pub const setAliasee = LLVMAliasSetAliasee;
- extern fn LLVMAliasSetAliasee(Alias: *const Value, Aliasee: *const Value) void;
+ extern fn LLVMAliasSetAliasee(Alias: *Value, Aliasee: *Value) void;
pub const constBitCast = LLVMConstBitCast;
- extern fn LLVMConstBitCast(ConstantVal: *const Value, ToType: *const Type) *const Value;
+ extern fn LLVMConstBitCast(ConstantVal: *Value, ToType: *Type) *Value;
pub const constIntToPtr = LLVMConstIntToPtr;
- extern fn LLVMConstIntToPtr(ConstantVal: *const Value, ToType: *const Type) *const Value;
+ extern fn LLVMConstIntToPtr(ConstantVal: *Value, ToType: *Type) *Value;
pub const constPtrToInt = LLVMConstPtrToInt;
- extern fn LLVMConstPtrToInt(ConstantVal: *const Value, ToType: *const Type) *const Value;
+ extern fn LLVMConstPtrToInt(ConstantVal: *Value, ToType: *Type) *Value;
pub const constShl = LLVMConstShl;
- extern fn LLVMConstShl(LHSConstant: *const Value, RHSConstant: *const Value) *const Value;
+ extern fn LLVMConstShl(LHSConstant: *Value, RHSConstant: *Value) *Value;
pub const constOr = LLVMConstOr;
- extern fn LLVMConstOr(LHSConstant: *const Value, RHSConstant: *const Value) *const Value;
+ extern fn LLVMConstOr(LHSConstant: *Value, RHSConstant: *Value) *Value;
pub const constZExt = LLVMConstZExt;
- extern fn LLVMConstZExt(ConstantVal: *const Value, ToType: *const Type) *const Value;
+ extern fn LLVMConstZExt(ConstantVal: *Value, ToType: *Type) *Value;
pub const constZExtOrBitCast = LLVMConstZExtOrBitCast;
- extern fn LLVMConstZExtOrBitCast(ConstantVal: *const Value, ToType: *const Type) *const Value;
+ extern fn LLVMConstZExtOrBitCast(ConstantVal: *Value, ToType: *Type) *Value;
pub const constNot = LLVMConstNot;
- extern fn LLVMConstNot(ConstantVal: *const Value) *const Value;
+ extern fn LLVMConstNot(ConstantVal: *Value) *Value;
pub const constAdd = LLVMConstAdd;
- extern fn LLVMConstAdd(LHSConstant: *const Value, RHSConstant: *const Value) *const Value;
+ extern fn LLVMConstAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
pub const setWeak = LLVMSetWeak;
- extern fn LLVMSetWeak(CmpXchgInst: *const Value, IsWeak: Bool) void;
+ extern fn LLVMSetWeak(CmpXchgInst: *Value, IsWeak: Bool) void;
pub const setOrdering = LLVMSetOrdering;
- extern fn LLVMSetOrdering(MemoryAccessInst: *const Value, Ordering: AtomicOrdering) void;
+ extern fn LLVMSetOrdering(MemoryAccessInst: *Value, Ordering: AtomicOrdering) void;
pub const setVolatile = LLVMSetVolatile;
- extern fn LLVMSetVolatile(MemoryAccessInst: *const Value, IsVolatile: Bool) void;
+ extern fn LLVMSetVolatile(MemoryAccessInst: *Value, IsVolatile: Bool) void;
pub const setAlignment = LLVMSetAlignment;
- extern fn LLVMSetAlignment(V: *const Value, Bytes: c_uint) void;
+ extern fn LLVMSetAlignment(V: *Value, Bytes: c_uint) void;
pub const getFunctionCallConv = LLVMGetFunctionCallConv;
- extern fn LLVMGetFunctionCallConv(Fn: *const Value) CallConv;
+ extern fn LLVMGetFunctionCallConv(Fn: *Value) CallConv;
pub const setFunctionCallConv = LLVMSetFunctionCallConv;
- extern fn LLVMSetFunctionCallConv(Fn: *const Value, CC: CallConv) void;
+ extern fn LLVMSetFunctionCallConv(Fn: *Value, CC: CallConv) void;
pub const fnSetSubprogram = ZigLLVMFnSetSubprogram;
- extern fn ZigLLVMFnSetSubprogram(f: *const Value, subprogram: *DISubprogram) void;
+ extern fn ZigLLVMFnSetSubprogram(f: *Value, subprogram: *DISubprogram) void;
pub const setValueName = LLVMSetValueName;
- extern fn LLVMSetValueName(Val: *const Value, Name: [*:0]const u8) void;
+ extern fn LLVMSetValueName(Val: *Value, Name: [*:0]const u8) void;
pub const setValueName2 = LLVMSetValueName2;
- extern fn LLVMSetValueName2(Val: *const Value, Name: [*]const u8, NameLen: usize) void;
+ extern fn LLVMSetValueName2(Val: *Value, Name: [*]const u8, NameLen: usize) void;
pub const getValueName = LLVMGetValueName;
- extern fn LLVMGetValueName(Val: *const Value) [*:0]const u8;
+ extern fn LLVMGetValueName(Val: *Value) [*:0]const u8;
pub const takeName = ZigLLVMTakeName;
- extern fn ZigLLVMTakeName(new_owner: *const Value, victim: *const Value) void;
+ extern fn ZigLLVMTakeName(new_owner: *Value, victim: *Value) void;
pub const deleteFunction = LLVMDeleteFunction;
- extern fn LLVMDeleteFunction(Fn: *const Value) void;
+ extern fn LLVMDeleteFunction(Fn: *Value) void;
pub const addSretAttr = ZigLLVMAddSretAttr;
- extern fn ZigLLVMAddSretAttr(fn_ref: *const Value, type_val: *const Type) void;
+ extern fn ZigLLVMAddSretAttr(fn_ref: *Value, type_val: *Type) void;
pub const setCallSret = ZigLLVMSetCallSret;
- extern fn ZigLLVMSetCallSret(Call: *const Value, return_type: *const Type) void;
+ extern fn ZigLLVMSetCallSret(Call: *Value, return_type: *Type) void;
pub const getParam = LLVMGetParam;
- extern fn LLVMGetParam(Fn: *const Value, Index: c_uint) *const Value;
+ extern fn LLVMGetParam(Fn: *Value, Index: c_uint) *Value;
pub const setInitializer = LLVMSetInitializer;
- extern fn LLVMSetInitializer(GlobalVar: *const Value, ConstantVal: *const Value) void;
+ extern fn LLVMSetInitializer(GlobalVar: *Value, ConstantVal: *Value) void;
pub const setDLLStorageClass = LLVMSetDLLStorageClass;
- extern fn LLVMSetDLLStorageClass(Global: *const Value, Class: DLLStorageClass) void;
+ extern fn LLVMSetDLLStorageClass(Global: *Value, Class: DLLStorageClass) void;
pub const addCase = LLVMAddCase;
- extern fn LLVMAddCase(Switch: *const Value, OnVal: *const Value, Dest: *const BasicBlock) void;
+ extern fn LLVMAddCase(Switch: *Value, OnVal: *Value, Dest: *BasicBlock) void;
- pub inline fn isPoison(Val: *const Value) bool {
+ pub inline fn isPoison(Val: *Value) bool {
return LLVMIsPoison(Val).toBool();
}
- extern fn LLVMIsPoison(Val: *const Value) Bool;
+ extern fn LLVMIsPoison(Val: *Value) Bool;
pub const replaceAllUsesWith = LLVMReplaceAllUsesWith;
- extern fn LLVMReplaceAllUsesWith(OldVal: *const Value, NewVal: *const Value) void;
+ extern fn LLVMReplaceAllUsesWith(OldVal: *Value, NewVal: *Value) void;
pub const globalGetValueType = LLVMGlobalGetValueType;
- extern fn LLVMGlobalGetValueType(Global: *const Value) *const Type;
+ extern fn LLVMGlobalGetValueType(Global: *Value) *Type;
pub const getLinkage = LLVMGetLinkage;
- extern fn LLVMGetLinkage(Global: *const Value) Linkage;
+ extern fn LLVMGetLinkage(Global: *Value) Linkage;
pub const getUnnamedAddress = LLVMGetUnnamedAddress;
- extern fn LLVMGetUnnamedAddress(Global: *const Value) Bool;
+ extern fn LLVMGetUnnamedAddress(Global: *Value) Bool;
pub const getAlignment = LLVMGetAlignment;
- extern fn LLVMGetAlignment(V: *const Value) c_uint;
+ extern fn LLVMGetAlignment(V: *Value) c_uint;
pub const addFunctionAttr = ZigLLVMAddFunctionAttr;
- extern fn ZigLLVMAddFunctionAttr(Fn: *const Value, attr_name: [*:0]const u8, attr_value: [*:0]const u8) void;
+ extern fn ZigLLVMAddFunctionAttr(Fn: *Value, attr_name: [*:0]const u8, attr_value: [*:0]const u8) void;
pub const getGEPResultElementType = ZigLLVMGetGEPResultElementType;
- extern fn ZigLLVMGetGEPResultElementType(GEP: *const Value) *const Type;
+ extern fn ZigLLVMGetGEPResultElementType(GEP: *Value) *Type;
pub const addByValAttr = ZigLLVMAddByValAttr;
- extern fn ZigLLVMAddByValAttr(Fn: *const Value, ArgNo: c_uint, type: *const Type) void;
+ extern fn ZigLLVMAddByValAttr(Fn: *Value, ArgNo: c_uint, type: *Type) void;
};
pub const Type = opaque {
pub const constNull = LLVMConstNull;
- extern fn LLVMConstNull(Ty: *const Type) *const Value;
+ extern fn LLVMConstNull(Ty: *Type) *Value;
pub const constAllOnes = LLVMConstAllOnes;
- extern fn LLVMConstAllOnes(Ty: *const Type) *const Value;
+ extern fn LLVMConstAllOnes(Ty: *Type) *Value;
pub const constInt = LLVMConstInt;
- extern fn LLVMConstInt(IntTy: *const Type, N: c_ulonglong, SignExtend: Bool) *const Value;
+ extern fn LLVMConstInt(IntTy: *Type, N: c_ulonglong, SignExtend: Bool) *Value;
pub const constIntOfArbitraryPrecision = LLVMConstIntOfArbitraryPrecision;
- extern fn LLVMConstIntOfArbitraryPrecision(IntTy: *const Type, NumWords: c_uint, Words: [*]const u64) *const Value;
+ extern fn LLVMConstIntOfArbitraryPrecision(IntTy: *Type, NumWords: c_uint, Words: [*]const u64) *Value;
pub const constReal = LLVMConstReal;
- extern fn LLVMConstReal(RealTy: *const Type, N: f64) *const Value;
+ extern fn LLVMConstReal(RealTy: *Type, N: f64) *Value;
pub const constArray = LLVMConstArray;
- extern fn LLVMConstArray(ElementTy: *const Type, ConstantVals: [*]const *const Value, Length: c_uint) *const Value;
+ extern fn LLVMConstArray(ElementTy: *Type, ConstantVals: [*]const *Value, Length: c_uint) *Value;
pub const constNamedStruct = LLVMConstNamedStruct;
extern fn LLVMConstNamedStruct(
- StructTy: *const Type,
- ConstantVals: [*]const *const Value,
+ StructTy: *Type,
+ ConstantVals: [*]const *Value,
Count: c_uint,
- ) *const Value;
+ ) *Value;
pub const getUndef = LLVMGetUndef;
- extern fn LLVMGetUndef(Ty: *const Type) *const Value;
+ extern fn LLVMGetUndef(Ty: *Type) *Value;
pub const pointerType = LLVMPointerType;
- extern fn LLVMPointerType(ElementType: *const Type, AddressSpace: c_uint) *const Type;
+ extern fn LLVMPointerType(ElementType: *Type, AddressSpace: c_uint) *Type;
pub const arrayType = LLVMArrayType;
- extern fn LLVMArrayType(ElementType: *const Type, ElementCount: c_uint) *const Type;
+ extern fn LLVMArrayType(ElementType: *Type, ElementCount: c_uint) *Type;
pub const vectorType = LLVMVectorType;
- extern fn LLVMVectorType(ElementType: *const Type, ElementCount: c_uint) *const Type;
+ extern fn LLVMVectorType(ElementType: *Type, ElementCount: c_uint) *Type;
pub const structSetBody = LLVMStructSetBody;
extern fn LLVMStructSetBody(
- StructTy: *const Type,
- ElementTypes: [*]*const Type,
+ StructTy: *Type,
+ ElementTypes: [*]*Type,
ElementCount: c_uint,
Packed: Bool,
) void;
pub const structGetTypeAtIndex = LLVMStructGetTypeAtIndex;
- extern fn LLVMStructGetTypeAtIndex(StructTy: *const Type, i: c_uint) *const Type;
+ extern fn LLVMStructGetTypeAtIndex(StructTy: *Type, i: c_uint) *Type;
pub const getTypeKind = LLVMGetTypeKind;
- extern fn LLVMGetTypeKind(Ty: *const Type) TypeKind;
+ extern fn LLVMGetTypeKind(Ty: *Type) TypeKind;
pub const getElementType = LLVMGetElementType;
- extern fn LLVMGetElementType(Ty: *const Type) *const Type;
+ extern fn LLVMGetElementType(Ty: *Type) *Type;
pub const countStructElementTypes = LLVMCountStructElementTypes;
- extern fn LLVMCountStructElementTypes(StructTy: *const Type) c_uint;
+ extern fn LLVMCountStructElementTypes(StructTy: *Type) c_uint;
pub const isOpaqueStruct = LLVMIsOpaqueStruct;
- extern fn LLVMIsOpaqueStruct(StructTy: *const Type) Bool;
+ extern fn LLVMIsOpaqueStruct(StructTy: *Type) Bool;
pub const isSized = LLVMTypeIsSized;
- extern fn LLVMTypeIsSized(Ty: *const Type) Bool;
+ extern fn LLVMTypeIsSized(Ty: *Type) Bool;
pub const constInBoundsGEP = LLVMConstInBoundsGEP2;
extern fn LLVMConstInBoundsGEP2(
- Ty: *const Type,
- ConstantVal: *const Value,
- ConstantIndices: [*]const *const Value,
+ Ty: *Type,
+ ConstantVal: *Value,
+ ConstantIndices: [*]const *Value,
NumIndices: c_uint,
- ) *const Value;
+ ) *Value;
};
pub const Module = opaque {
pub const createWithName = LLVMModuleCreateWithNameInContext;
- extern fn LLVMModuleCreateWithNameInContext(ModuleID: [*:0]const u8, C: *const Context) *const Module;
+ extern fn LLVMModuleCreateWithNameInContext(ModuleID: [*:0]const u8, C: *Context) *Module;
pub const dispose = LLVMDisposeModule;
- extern fn LLVMDisposeModule(*const Module) void;
+ extern fn LLVMDisposeModule(*Module) void;
pub const verify = LLVMVerifyModule;
- extern fn LLVMVerifyModule(*const Module, Action: VerifierFailureAction, OutMessage: *[*:0]const u8) Bool;
+ extern fn LLVMVerifyModule(*Module, Action: VerifierFailureAction, OutMessage: *[*:0]const u8) Bool;
pub const setModuleDataLayout = LLVMSetModuleDataLayout;
- extern fn LLVMSetModuleDataLayout(*const Module, *const TargetData) void;
+ extern fn LLVMSetModuleDataLayout(*Module, *TargetData) void;
pub const setModulePICLevel = ZigLLVMSetModulePICLevel;
- extern fn ZigLLVMSetModulePICLevel(module: *const Module) void;
+ extern fn ZigLLVMSetModulePICLevel(module: *Module) void;
pub const setModulePIELevel = ZigLLVMSetModulePIELevel;
- extern fn ZigLLVMSetModulePIELevel(module: *const Module) void;
+ extern fn ZigLLVMSetModulePIELevel(module: *Module) void;
pub const setModuleCodeModel = ZigLLVMSetModuleCodeModel;
- extern fn ZigLLVMSetModuleCodeModel(module: *const Module, code_model: CodeModel) void;
+ extern fn ZigLLVMSetModuleCodeModel(module: *Module, code_model: CodeModel) void;
pub const addFunction = LLVMAddFunction;
- extern fn LLVMAddFunction(*const Module, Name: [*:0]const u8, FunctionTy: *const Type) *const Value;
+ extern fn LLVMAddFunction(*Module, Name: [*:0]const u8, FunctionTy: *Type) *Value;
pub const addFunctionInAddressSpace = ZigLLVMAddFunctionInAddressSpace;
- extern fn ZigLLVMAddFunctionInAddressSpace(*const Module, Name: [*:0]const u8, FunctionTy: *const Type, AddressSpace: c_uint) *const Value;
+ extern fn ZigLLVMAddFunctionInAddressSpace(*Module, Name: [*:0]const u8, FunctionTy: *Type, AddressSpace: c_uint) *Value;
pub const getNamedFunction = LLVMGetNamedFunction;
- extern fn LLVMGetNamedFunction(*const Module, Name: [*:0]const u8) ?*const Value;
+ extern fn LLVMGetNamedFunction(*Module, Name: [*:0]const u8) ?*Value;
pub const getIntrinsicDeclaration = LLVMGetIntrinsicDeclaration;
- extern fn LLVMGetIntrinsicDeclaration(Mod: *const Module, ID: c_uint, ParamTypes: ?[*]const *const Type, ParamCount: usize) *const Value;
+ extern fn LLVMGetIntrinsicDeclaration(Mod: *Module, ID: c_uint, ParamTypes: ?[*]const *Type, ParamCount: usize) *Value;
pub const printToString = LLVMPrintModuleToString;
- extern fn LLVMPrintModuleToString(*const Module) [*:0]const u8;
+ extern fn LLVMPrintModuleToString(*Module) [*:0]const u8;
pub const addGlobal = LLVMAddGlobal;
- extern fn LLVMAddGlobal(M: *const Module, Ty: *const Type, Name: [*:0]const u8) *const Value;
+ extern fn LLVMAddGlobal(M: *Module, Ty: *Type, Name: [*:0]const u8) *Value;
pub const addGlobalInAddressSpace = LLVMAddGlobalInAddressSpace;
- extern fn LLVMAddGlobalInAddressSpace(M: *const Module, Ty: *const Type, Name: [*:0]const u8, AddressSpace: c_uint) *const Value;
+ extern fn LLVMAddGlobalInAddressSpace(M: *Module, Ty: *Type, Name: [*:0]const u8, AddressSpace: c_uint) *Value;
pub const getNamedGlobal = LLVMGetNamedGlobal;
- extern fn LLVMGetNamedGlobal(M: *const Module, Name: [*:0]const u8) ?*const Value;
+ extern fn LLVMGetNamedGlobal(M: *Module, Name: [*:0]const u8) ?*Value;
pub const dump = LLVMDumpModule;
- extern fn LLVMDumpModule(M: *const Module) void;
+ extern fn LLVMDumpModule(M: *Module) void;
pub const getFirstGlobalAlias = LLVMGetFirstGlobalAlias;
- extern fn LLVMGetFirstGlobalAlias(M: *const Module) *const Value;
+ extern fn LLVMGetFirstGlobalAlias(M: *Module) *Value;
pub const getLastGlobalAlias = LLVMGetLastGlobalAlias;
- extern fn LLVMGetLastGlobalAlias(M: *const Module) *const Value;
+ extern fn LLVMGetLastGlobalAlias(M: *Module) *Value;
pub const addAlias = LLVMAddAlias2;
extern fn LLVMAddAlias2(
- M: *const Module,
- Ty: *const Type,
+ M: *Module,
+ Ty: *Type,
AddrSpace: c_uint,
- Aliasee: *const Value,
+ Aliasee: *Value,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const getNamedGlobalAlias = LLVMGetNamedGlobalAlias;
extern fn LLVMGetNamedGlobalAlias(
- M: *const Module,
+ M: *Module,
/// Empirically, LLVM will call strlen() on `Name` and so it
/// must be both null terminated and also have `NameLen` set
/// to the size.
Name: [*:0]const u8,
NameLen: usize,
- ) ?*const Value;
+ ) ?*Value;
pub const setTarget = LLVMSetTarget;
- extern fn LLVMSetTarget(M: *const Module, Triple: [*:0]const u8) void;
+ extern fn LLVMSetTarget(M: *Module, Triple: [*:0]const u8) void;
pub const addModuleDebugInfoFlag = ZigLLVMAddModuleDebugInfoFlag;
- extern fn ZigLLVMAddModuleDebugInfoFlag(module: *const Module) void;
+ extern fn ZigLLVMAddModuleDebugInfoFlag(module: *Module) void;
pub const addModuleCodeViewFlag = ZigLLVMAddModuleCodeViewFlag;
- extern fn ZigLLVMAddModuleCodeViewFlag(module: *const Module) void;
+ extern fn ZigLLVMAddModuleCodeViewFlag(module: *Module) void;
pub const createDIBuilder = ZigLLVMCreateDIBuilder;
- extern fn ZigLLVMCreateDIBuilder(module: *const Module, allow_unresolved: bool) *DIBuilder;
+ extern fn ZigLLVMCreateDIBuilder(module: *Module, allow_unresolved: bool) *DIBuilder;
pub const setModuleInlineAsm2 = LLVMSetModuleInlineAsm2;
- extern fn LLVMSetModuleInlineAsm2(M: *const Module, Asm: [*]const u8, Len: usize) void;
+ extern fn LLVMSetModuleInlineAsm2(M: *Module, Asm: [*]const u8, Len: usize) void;
pub const printModuleToFile = LLVMPrintModuleToFile;
- extern fn LLVMPrintModuleToFile(M: *const Module, Filename: [*:0]const u8, ErrorMessage: *[*:0]const u8) Bool;
+ extern fn LLVMPrintModuleToFile(M: *Module, Filename: [*:0]const u8, ErrorMessage: *[*:0]const u8) Bool;
};
pub const lookupIntrinsicID = LLVMLookupIntrinsicID;
@@ -434,20 +434,20 @@ pub const VerifierFailureAction = enum(c_int) {
};
pub const constNeg = LLVMConstNeg;
-extern fn LLVMConstNeg(ConstantVal: *const Value) *const Value;
+extern fn LLVMConstNeg(ConstantVal: *Value) *Value;
pub const constVector = LLVMConstVector;
extern fn LLVMConstVector(
- ScalarConstantVals: [*]*const Value,
+ ScalarConstantVals: [*]*Value,
Size: c_uint,
-) *const Value;
+) *Value;
pub const getEnumAttributeKindForName = LLVMGetEnumAttributeKindForName;
extern fn LLVMGetEnumAttributeKindForName(Name: [*]const u8, SLen: usize) c_uint;
pub const getInlineAsm = LLVMGetInlineAsm;
extern fn LLVMGetInlineAsm(
- Ty: *const Type,
+ Ty: *Type,
AsmString: [*]const u8,
AsmStringSize: usize,
Constraints: [*]const u8,
@@ -456,15 +456,15 @@ extern fn LLVMGetInlineAsm(
IsAlignStack: Bool,
Dialect: InlineAsmDialect,
CanThrow: Bool,
-) *const Value;
+) *Value;
pub const functionType = LLVMFunctionType;
extern fn LLVMFunctionType(
- ReturnType: *const Type,
- ParamTypes: [*]const *const Type,
+ ReturnType: *Type,
+ ParamTypes: [*]const *Type,
ParamCount: c_uint,
IsVarArg: Bool,
-) *const Type;
+) *Type;
pub const InlineAsmDialect = enum(c_uint) { ATT, Intel };
@@ -472,495 +472,495 @@ pub const Attribute = opaque {};
pub const Builder = opaque {
pub const dispose = LLVMDisposeBuilder;
- extern fn LLVMDisposeBuilder(Builder: *const Builder) void;
+ extern fn LLVMDisposeBuilder(Builder: *Builder) void;
pub const positionBuilder = LLVMPositionBuilder;
extern fn LLVMPositionBuilder(
- Builder: *const Builder,
- Block: *const BasicBlock,
- Instr: *const Value,
+ Builder: *Builder,
+ Block: *BasicBlock,
+ Instr: *Value,
) void;
pub const positionBuilderAtEnd = LLVMPositionBuilderAtEnd;
- extern fn LLVMPositionBuilderAtEnd(Builder: *const Builder, Block: *const BasicBlock) void;
+ extern fn LLVMPositionBuilderAtEnd(Builder: *Builder, Block: *BasicBlock) void;
pub const getInsertBlock = LLVMGetInsertBlock;
- extern fn LLVMGetInsertBlock(Builder: *const Builder) *const BasicBlock;
+ extern fn LLVMGetInsertBlock(Builder: *Builder) *BasicBlock;
pub const buildZExt = LLVMBuildZExt;
extern fn LLVMBuildZExt(
- *const Builder,
- Value: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Value: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildZExtOrBitCast = LLVMBuildZExtOrBitCast;
extern fn LLVMBuildZExtOrBitCast(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildSExt = LLVMBuildSExt;
extern fn LLVMBuildSExt(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildSExtOrBitCast = LLVMBuildSExtOrBitCast;
extern fn LLVMBuildSExtOrBitCast(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildCall = ZigLLVMBuildCall;
extern fn ZigLLVMBuildCall(
- *const Builder,
- *const Type,
- Fn: *const Value,
- Args: [*]const *const Value,
+ *Builder,
+ *Type,
+ Fn: *Value,
+ Args: [*]const *Value,
NumArgs: c_uint,
CC: CallConv,
attr: CallAttr,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildRetVoid = LLVMBuildRetVoid;
- extern fn LLVMBuildRetVoid(*const Builder) *const Value;
+ extern fn LLVMBuildRetVoid(*Builder) *Value;
pub const buildRet = LLVMBuildRet;
- extern fn LLVMBuildRet(*const Builder, V: *const Value) *const Value;
+ extern fn LLVMBuildRet(*Builder, V: *Value) *Value;
pub const buildUnreachable = LLVMBuildUnreachable;
- extern fn LLVMBuildUnreachable(*const Builder) *const Value;
+ extern fn LLVMBuildUnreachable(*Builder) *Value;
pub const buildAlloca = LLVMBuildAlloca;
- extern fn LLVMBuildAlloca(*const Builder, Ty: *const Type, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildAlloca(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
pub const buildStore = LLVMBuildStore;
- extern fn LLVMBuildStore(*const Builder, Val: *const Value, Ptr: *const Value) *const Value;
+ extern fn LLVMBuildStore(*Builder, Val: *Value, Ptr: *Value) *Value;
pub const buildLoad = LLVMBuildLoad2;
- extern fn LLVMBuildLoad2(*const Builder, Ty: *const Type, PointerVal: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildLoad2(*Builder, Ty: *Type, PointerVal: *Value, Name: [*:0]const u8) *Value;
pub const buildNeg = LLVMBuildNeg;
- extern fn LLVMBuildNeg(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNeg(*Builder, V: *Value, Name: [*:0]const u8) *Value;
pub const buildNot = LLVMBuildNot;
- extern fn LLVMBuildNot(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNot(*Builder, V: *Value, Name: [*:0]const u8) *Value;
pub const buildFAdd = LLVMBuildFAdd;
- extern fn LLVMBuildFAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildAdd = LLVMBuildAdd;
- extern fn LLVMBuildAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNSWAdd = LLVMBuildNSWAdd;
- extern fn LLVMBuildNSWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNSWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNUWAdd = LLVMBuildNUWAdd;
- extern fn LLVMBuildNUWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNUWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSAddSat = ZigLLVMBuildSAddSat;
- extern fn ZigLLVMBuildSAddSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSAddSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildUAddSat = ZigLLVMBuildUAddSat;
- extern fn ZigLLVMBuildUAddSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUAddSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFSub = LLVMBuildFSub;
- extern fn LLVMBuildFSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFNeg = LLVMBuildFNeg;
- extern fn LLVMBuildFNeg(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFNeg(*Builder, V: *Value, Name: [*:0]const u8) *Value;
pub const buildSub = LLVMBuildSub;
- extern fn LLVMBuildSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNSWSub = LLVMBuildNSWSub;
- extern fn LLVMBuildNSWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNSWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNUWSub = LLVMBuildNUWSub;
- extern fn LLVMBuildNUWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNUWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSSubSat = ZigLLVMBuildSSubSat;
- extern fn ZigLLVMBuildSSubSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSSubSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildUSubSat = ZigLLVMBuildUSubSat;
- extern fn ZigLLVMBuildUSubSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUSubSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFMul = LLVMBuildFMul;
- extern fn LLVMBuildFMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildMul = LLVMBuildMul;
- extern fn LLVMBuildMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNSWMul = LLVMBuildNSWMul;
- extern fn LLVMBuildNSWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNSWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNUWMul = LLVMBuildNUWMul;
- extern fn LLVMBuildNUWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildNUWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSMulFixSat = ZigLLVMBuildSMulFixSat;
- extern fn ZigLLVMBuildSMulFixSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSMulFixSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildUMulFixSat = ZigLLVMBuildUMulFixSat;
- extern fn ZigLLVMBuildUMulFixSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUMulFixSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildUDiv = LLVMBuildUDiv;
- extern fn LLVMBuildUDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSDiv = LLVMBuildSDiv;
- extern fn LLVMBuildSDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFDiv = LLVMBuildFDiv;
- extern fn LLVMBuildFDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildURem = LLVMBuildURem;
- extern fn LLVMBuildURem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildURem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSRem = LLVMBuildSRem;
- extern fn LLVMBuildSRem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildSRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFRem = LLVMBuildFRem;
- extern fn LLVMBuildFRem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildAnd = LLVMBuildAnd;
- extern fn LLVMBuildAnd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildAnd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildLShr = LLVMBuildLShr;
- extern fn LLVMBuildLShr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildLShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildAShr = LLVMBuildAShr;
- extern fn LLVMBuildAShr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildAShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildLShrExact = ZigLLVMBuildLShrExact;
- extern fn ZigLLVMBuildLShrExact(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildLShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildAShrExact = ZigLLVMBuildAShrExact;
- extern fn ZigLLVMBuildAShrExact(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildAShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildShl = LLVMBuildShl;
- extern fn LLVMBuildShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNUWShl = ZigLLVMBuildNUWShl;
- extern fn ZigLLVMBuildNUWShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildNUWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildNSWShl = ZigLLVMBuildNSWShl;
- extern fn ZigLLVMBuildNSWShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildNSWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildSShlSat = ZigLLVMBuildSShlSat;
- extern fn ZigLLVMBuildSShlSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSShlSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildUShlSat = ZigLLVMBuildUShlSat;
- extern fn ZigLLVMBuildUShlSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUShlSat(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildOr = LLVMBuildOr;
- extern fn LLVMBuildOr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildOr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildXor = LLVMBuildXor;
- extern fn LLVMBuildXor(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildXor(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildIntCast2 = LLVMBuildIntCast2;
- extern fn LLVMBuildIntCast2(*const Builder, Val: *const Value, DestTy: *const Type, IsSigned: Bool, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildIntCast2(*Builder, Val: *Value, DestTy: *Type, IsSigned: Bool, Name: [*:0]const u8) *Value;
pub const buildBitCast = LLVMBuildBitCast;
- extern fn LLVMBuildBitCast(*const Builder, Val: *const Value, DestTy: *const Type, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildBitCast(*Builder, Val: *Value, DestTy: *Type, Name: [*:0]const u8) *Value;
pub const buildInBoundsGEP = LLVMBuildInBoundsGEP2;
extern fn LLVMBuildInBoundsGEP2(
- B: *const Builder,
- Ty: *const Type,
- Pointer: *const Value,
- Indices: [*]const *const Value,
+ B: *Builder,
+ Ty: *Type,
+ Pointer: *Value,
+ Indices: [*]const *Value,
NumIndices: c_uint,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildICmp = LLVMBuildICmp;
- extern fn LLVMBuildICmp(*const Builder, Op: IntPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildICmp(*Builder, Op: IntPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildFCmp = LLVMBuildFCmp;
- extern fn LLVMBuildFCmp(*const Builder, Op: RealPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildFCmp(*Builder, Op: RealPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildBr = LLVMBuildBr;
- extern fn LLVMBuildBr(*const Builder, Dest: *const BasicBlock) *const Value;
+ extern fn LLVMBuildBr(*Builder, Dest: *BasicBlock) *Value;
pub const buildCondBr = LLVMBuildCondBr;
- extern fn LLVMBuildCondBr(*const Builder, If: *const Value, Then: *const BasicBlock, Else: *const BasicBlock) *const Value;
+ extern fn LLVMBuildCondBr(*Builder, If: *Value, Then: *BasicBlock, Else: *BasicBlock) *Value;
pub const buildSwitch = LLVMBuildSwitch;
- extern fn LLVMBuildSwitch(*const Builder, V: *const Value, Else: *const BasicBlock, NumCases: c_uint) *const Value;
+ extern fn LLVMBuildSwitch(*Builder, V: *Value, Else: *BasicBlock, NumCases: c_uint) *Value;
pub const buildPhi = LLVMBuildPhi;
- extern fn LLVMBuildPhi(*const Builder, Ty: *const Type, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildPhi(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
pub const buildExtractValue = LLVMBuildExtractValue;
extern fn LLVMBuildExtractValue(
- *const Builder,
- AggVal: *const Value,
+ *Builder,
+ AggVal: *Value,
Index: c_uint,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildExtractElement = LLVMBuildExtractElement;
extern fn LLVMBuildExtractElement(
- *const Builder,
- VecVal: *const Value,
- Index: *const Value,
+ *Builder,
+ VecVal: *Value,
+ Index: *Value,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildInsertElement = LLVMBuildInsertElement;
extern fn LLVMBuildInsertElement(
- *const Builder,
- VecVal: *const Value,
- EltVal: *const Value,
- Index: *const Value,
+ *Builder,
+ VecVal: *Value,
+ EltVal: *Value,
+ Index: *Value,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildVectorSplat = LLVMBuildVectorSplat;
extern fn LLVMBuildVectorSplat(
- *const Builder,
+ *Builder,
ElementCount: c_uint,
- EltVal: *const Value,
+ EltVal: *Value,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildPtrToInt = LLVMBuildPtrToInt;
extern fn LLVMBuildPtrToInt(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildIntToPtr = LLVMBuildIntToPtr;
extern fn LLVMBuildIntToPtr(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildStructGEP = LLVMBuildStructGEP2;
extern fn LLVMBuildStructGEP2(
- B: *const Builder,
- Ty: *const Type,
- Pointer: *const Value,
+ B: *Builder,
+ Ty: *Type,
+ Pointer: *Value,
Idx: c_uint,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildTrunc = LLVMBuildTrunc;
extern fn LLVMBuildTrunc(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildInsertValue = LLVMBuildInsertValue;
extern fn LLVMBuildInsertValue(
- *const Builder,
- AggVal: *const Value,
- EltVal: *const Value,
+ *Builder,
+ AggVal: *Value,
+ EltVal: *Value,
Index: c_uint,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildAtomicCmpXchg = LLVMBuildAtomicCmpXchg;
extern fn LLVMBuildAtomicCmpXchg(
- builder: *const Builder,
- ptr: *const Value,
- cmp: *const Value,
- new_val: *const Value,
+ builder: *Builder,
+ ptr: *Value,
+ cmp: *Value,
+ new_val: *Value,
success_ordering: AtomicOrdering,
failure_ordering: AtomicOrdering,
is_single_threaded: Bool,
- ) *const Value;
+ ) *Value;
pub const buildSelect = LLVMBuildSelect;
extern fn LLVMBuildSelect(
- *const Builder,
- If: *const Value,
- Then: *const Value,
- Else: *const Value,
+ *Builder,
+ If: *Value,
+ Then: *Value,
+ Else: *Value,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildFence = LLVMBuildFence;
extern fn LLVMBuildFence(
- B: *const Builder,
+ B: *Builder,
ordering: AtomicOrdering,
singleThread: Bool,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildAtomicRmw = LLVMBuildAtomicRMW;
extern fn LLVMBuildAtomicRMW(
- B: *const Builder,
+ B: *Builder,
op: AtomicRMWBinOp,
- PTR: *const Value,
- Val: *const Value,
+ PTR: *Value,
+ Val: *Value,
ordering: AtomicOrdering,
singleThread: Bool,
- ) *const Value;
+ ) *Value;
pub const buildFPToUI = LLVMBuildFPToUI;
extern fn LLVMBuildFPToUI(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildFPToSI = LLVMBuildFPToSI;
extern fn LLVMBuildFPToSI(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildUIToFP = LLVMBuildUIToFP;
extern fn LLVMBuildUIToFP(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildSIToFP = LLVMBuildSIToFP;
extern fn LLVMBuildSIToFP(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildFPTrunc = LLVMBuildFPTrunc;
extern fn LLVMBuildFPTrunc(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildFPExt = LLVMBuildFPExt;
extern fn LLVMBuildFPExt(
- *const Builder,
- Val: *const Value,
- DestTy: *const Type,
+ *Builder,
+ Val: *Value,
+ DestTy: *Type,
Name: [*:0]const u8,
- ) *const Value;
+ ) *Value;
pub const buildMemSet = ZigLLVMBuildMemSet;
extern fn ZigLLVMBuildMemSet(
- B: *const Builder,
- Ptr: *const Value,
- Val: *const Value,
- Len: *const Value,
+ B: *Builder,
+ Ptr: *Value,
+ Val: *Value,
+ Len: *Value,
Align: c_uint,
is_volatile: bool,
- ) *const Value;
+ ) *Value;
pub const buildMemCpy = ZigLLVMBuildMemCpy;
extern fn ZigLLVMBuildMemCpy(
- B: *const Builder,
- Dst: *const Value,
+ B: *Builder,
+ Dst: *Value,
DstAlign: c_uint,
- Src: *const Value,
+ Src: *Value,
SrcAlign: c_uint,
- Size: *const Value,
+ Size: *Value,
is_volatile: bool,
- ) *const Value;
+ ) *Value;
pub const buildMaxNum = ZigLLVMBuildMaxNum;
- extern fn ZigLLVMBuildMaxNum(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildMaxNum(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildMinNum = ZigLLVMBuildMinNum;
- extern fn ZigLLVMBuildMinNum(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildMinNum(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildUMax = ZigLLVMBuildUMax;
- extern fn ZigLLVMBuildUMax(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUMax(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildUMin = ZigLLVMBuildUMin;
- extern fn ZigLLVMBuildUMin(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildUMin(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildSMax = ZigLLVMBuildSMax;
- extern fn ZigLLVMBuildSMax(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSMax(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildSMin = ZigLLVMBuildSMin;
- extern fn ZigLLVMBuildSMin(builder: *const Builder, LHS: *const Value, RHS: *const Value, name: [*:0]const u8) *const Value;
+ extern fn ZigLLVMBuildSMin(builder: *Builder, LHS: *Value, RHS: *Value, name: [*:0]const u8) *Value;
pub const buildExactUDiv = LLVMBuildExactUDiv;
- extern fn LLVMBuildExactUDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildExactUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const buildExactSDiv = LLVMBuildExactSDiv;
- extern fn LLVMBuildExactSDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildExactSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
pub const setCurrentDebugLocation = ZigLLVMSetCurrentDebugLocation2;
- extern fn ZigLLVMSetCurrentDebugLocation2(builder: *const Builder, line: c_uint, column: c_uint, scope: *DIScope, inlined_at: ?*DILocation) void;
+ extern fn ZigLLVMSetCurrentDebugLocation2(builder: *Builder, line: c_uint, column: c_uint, scope: *DIScope, inlined_at: ?*DILocation) void;
pub const clearCurrentDebugLocation = ZigLLVMClearCurrentDebugLocation;
- extern fn ZigLLVMClearCurrentDebugLocation(builder: *const Builder) void;
+ extern fn ZigLLVMClearCurrentDebugLocation(builder: *Builder) void;
pub const getCurrentDebugLocation2 = LLVMGetCurrentDebugLocation2;
- extern fn LLVMGetCurrentDebugLocation2(Builder: *const Builder) *Metadata;
+ extern fn LLVMGetCurrentDebugLocation2(Builder: *Builder) *Metadata;
pub const setCurrentDebugLocation2 = LLVMSetCurrentDebugLocation2;
- extern fn LLVMSetCurrentDebugLocation2(Builder: *const Builder, Loc: *Metadata) void;
+ extern fn LLVMSetCurrentDebugLocation2(Builder: *Builder, Loc: *Metadata) void;
pub const buildShuffleVector = LLVMBuildShuffleVector;
- extern fn LLVMBuildShuffleVector(*const Builder, V1: *const Value, V2: *const Value, Mask: *const Value, Name: [*:0]const u8) *const Value;
+ extern fn LLVMBuildShuffleVector(*Builder, V1: *Value, V2: *Value, Mask: *Value, Name: [*:0]const u8) *Value;
pub const buildAndReduce = ZigLLVMBuildAndReduce;
- extern fn ZigLLVMBuildAndReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildAndReduce(B: *Builder, Val: *Value) *Value;
pub const buildOrReduce = ZigLLVMBuildOrReduce;
- extern fn ZigLLVMBuildOrReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildOrReduce(B: *Builder, Val: *Value) *Value;
pub const buildXorReduce = ZigLLVMBuildXorReduce;
- extern fn ZigLLVMBuildXorReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildXorReduce(B: *Builder, Val: *Value) *Value;
pub const buildIntMaxReduce = ZigLLVMBuildIntMaxReduce;
- extern fn ZigLLVMBuildIntMaxReduce(B: *const Builder, Val: *const Value, is_signed: bool) *const Value;
+ extern fn ZigLLVMBuildIntMaxReduce(B: *Builder, Val: *Value, is_signed: bool) *Value;
pub const buildIntMinReduce = ZigLLVMBuildIntMinReduce;
- extern fn ZigLLVMBuildIntMinReduce(B: *const Builder, Val: *const Value, is_signed: bool) *const Value;
+ extern fn ZigLLVMBuildIntMinReduce(B: *Builder, Val: *Value, is_signed: bool) *Value;
pub const buildFPMaxReduce = ZigLLVMBuildFPMaxReduce;
- extern fn ZigLLVMBuildFPMaxReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildFPMaxReduce(B: *Builder, Val: *Value) *Value;
pub const buildFPMinReduce = ZigLLVMBuildFPMinReduce;
- extern fn ZigLLVMBuildFPMinReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildFPMinReduce(B: *Builder, Val: *Value) *Value;
pub const buildAddReduce = ZigLLVMBuildAddReduce;
- extern fn ZigLLVMBuildAddReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildAddReduce(B: *Builder, Val: *Value) *Value;
pub const buildMulReduce = ZigLLVMBuildMulReduce;
- extern fn ZigLLVMBuildMulReduce(B: *const Builder, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildMulReduce(B: *Builder, Val: *Value) *Value;
pub const buildFPAddReduce = ZigLLVMBuildFPAddReduce;
- extern fn ZigLLVMBuildFPAddReduce(B: *const Builder, Acc: *const Value, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildFPAddReduce(B: *Builder, Acc: *Value, Val: *Value) *Value;
pub const buildFPMulReduce = ZigLLVMBuildFPMulReduce;
- extern fn ZigLLVMBuildFPMulReduce(B: *const Builder, Acc: *const Value, Val: *const Value) *const Value;
+ extern fn ZigLLVMBuildFPMulReduce(B: *Builder, Acc: *Value, Val: *Value) *Value;
pub const setFastMath = ZigLLVMSetFastMath;
- extern fn ZigLLVMSetFastMath(B: *const Builder, on_state: bool) void;
+ extern fn ZigLLVMSetFastMath(B: *Builder, on_state: bool) void;
};
pub const MDString = opaque {
pub const get = LLVMMDStringInContext2;
- extern fn LLVMMDStringInContext2(C: *const Context, Str: [*]const u8, SLen: usize) *MDString;
+ extern fn LLVMMDStringInContext2(C: *Context, Str: [*]const u8, SLen: usize) *MDString;
};
pub const DIScope = opaque {
@@ -1003,16 +1003,16 @@ pub const RealPredicate = enum(c_uint) {
pub const BasicBlock = opaque {
pub const deleteBasicBlock = LLVMDeleteBasicBlock;
- extern fn LLVMDeleteBasicBlock(BB: *const BasicBlock) void;
+ extern fn LLVMDeleteBasicBlock(BB: *BasicBlock) void;
pub const getFirstInstruction = LLVMGetFirstInstruction;
- extern fn LLVMGetFirstInstruction(BB: *const BasicBlock) ?*const Value;
+ extern fn LLVMGetFirstInstruction(BB: *BasicBlock) ?*Value;
};
pub const TargetMachine = opaque {
pub const create = ZigLLVMCreateTargetMachine;
extern fn ZigLLVMCreateTargetMachine(
- T: *const Target,
+ T: *Target,
Triple: [*:0]const u8,
CPU: ?[*:0]const u8,
Features: ?[*:0]const u8,
@@ -1022,15 +1022,15 @@ pub const TargetMachine = opaque {
function_sections: bool,
float_abi: ABIType,
abi_name: ?[*:0]const u8,
- ) *const TargetMachine;
+ ) *TargetMachine;
pub const dispose = LLVMDisposeTargetMachine;
- extern fn LLVMDisposeTargetMachine(T: *const TargetMachine) void;
+ extern fn LLVMDisposeTargetMachine(T: *TargetMachine) void;
pub const emitToFile = ZigLLVMTargetMachineEmitToFile;
extern fn ZigLLVMTargetMachineEmitToFile(
- T: *const TargetMachine,
- M: *const Module,
+ T: *TargetMachine,
+ M: *Module,
ErrorMessage: *[*:0]const u8,
is_debug: bool,
is_small: bool,
@@ -1044,18 +1044,18 @@ pub const TargetMachine = opaque {
) bool;
pub const createTargetDataLayout = LLVMCreateTargetDataLayout;
- extern fn LLVMCreateTargetDataLayout(*const TargetMachine) *const TargetData;
+ extern fn LLVMCreateTargetDataLayout(*TargetMachine) *TargetData;
};
pub const TargetData = opaque {
pub const dispose = LLVMDisposeTargetData;
- extern fn LLVMDisposeTargetData(*const TargetData) void;
+ extern fn LLVMDisposeTargetData(*TargetData) void;
pub const abiAlignmentOfType = LLVMABIAlignmentOfType;
- extern fn LLVMABIAlignmentOfType(TD: *const TargetData, Ty: *const Type) c_uint;
+ extern fn LLVMABIAlignmentOfType(TD: *TargetData, Ty: *Type) c_uint;
pub const abiSizeOfType = LLVMABISizeOfType;
- extern fn LLVMABISizeOfType(TD: *const TargetData, Ty: *const Type) c_ulonglong;
+ extern fn LLVMABISizeOfType(TD: *TargetData, Ty: *Type) c_ulonglong;
};
pub const CodeModel = enum(c_int) {
@@ -1101,7 +1101,7 @@ pub const ABIType = enum(c_int) {
pub const Target = opaque {
pub const getFromTriple = LLVMGetTargetFromTriple;
- extern fn LLVMGetTargetFromTriple(Triple: [*:0]const u8, T: **const Target, ErrorMessage: *[*:0]const u8) Bool;
+ extern fn LLVMGetTargetFromTriple(Triple: [*:0]const u8, T: **Target, ErrorMessage: *[*:0]const u8) Bool;
};
pub extern fn LLVMInitializeAArch64TargetInfo() void;
@@ -1355,7 +1355,7 @@ extern fn ZigLLVMWriteImportLibrary(
) bool;
pub const setCallElemTypeAttr = ZigLLVMSetCallElemTypeAttr;
-extern fn ZigLLVMSetCallElemTypeAttr(Call: *const Value, arg_index: usize, return_type: *const Type) void;
+extern fn ZigLLVMSetCallElemTypeAttr(Call: *Value, arg_index: usize, return_type: *Type) void;
pub const Linkage = enum(c_uint) {
External,
@@ -1854,29 +1854,29 @@ pub const DIBuilder = opaque {
pub const insertDeclareAtEnd = ZigLLVMInsertDeclareAtEnd;
extern fn ZigLLVMInsertDeclareAtEnd(
dib: *DIBuilder,
- storage: *const Value,
+ storage: *Value,
var_info: *DILocalVariable,
debug_loc: *DILocation,
- basic_block_ref: *const BasicBlock,
- ) *const Value;
+ basic_block_ref: *BasicBlock,
+ ) *Value;
pub const insertDeclare = ZigLLVMInsertDeclare;
extern fn ZigLLVMInsertDeclare(
dib: *DIBuilder,
- storage: *const Value,
+ storage: *Value,
var_info: *DILocalVariable,
debug_loc: *DILocation,
- insert_before_instr: *const Value,
- ) *const Value;
+ insert_before_instr: *Value,
+ ) *Value;
pub const insertDbgValueIntrinsicAtEnd = ZigLLVMInsertDbgValueIntrinsicAtEnd;
extern fn ZigLLVMInsertDbgValueIntrinsicAtEnd(
dib: *DIBuilder,
- val: *const Value,
+ val: *Value,
var_info: *DILocalVariable,
debug_loc: *DILocation,
- basic_block_ref: *const BasicBlock,
- ) *const Value;
+ basic_block_ref: *BasicBlock,
+ ) *Value;
};
pub const DIFlags = opaque {
src/codegen/llvm.zig
@@ -316,7 +316,7 @@ pub fn supportsTailCall(target: std.Target) bool {
}
/// TODO can this be done with simpler logic / different API binding?
-fn deleteLlvmGlobal(llvm_global: *const llvm.Value) void {
+fn deleteLlvmGlobal(llvm_global: *llvm.Value) void {
if (llvm_global.globalGetValueType().getTypeKind() == .Function) {
llvm_global.deleteFunction();
return;
@@ -327,7 +327,7 @@ fn deleteLlvmGlobal(llvm_global: *const llvm.Value) void {
pub const Object = struct {
gpa: Allocator,
module: *Module,
- llvm_module: *const llvm.Module,
+ llvm_module: *llvm.Module,
di_builder: ?*llvm.DIBuilder,
/// One of these mappings:
/// - *Module.File => *DIFile
@@ -335,9 +335,9 @@ pub const Object = struct {
/// - *Module.Decl (Non-Fn) => *DIGlobalVariable
di_map: std.AutoHashMapUnmanaged(*const anyopaque, *llvm.DINode),
di_compile_unit: ?*llvm.DICompileUnit,
- context: *const llvm.Context,
- target_machine: *const llvm.TargetMachine,
- target_data: *const llvm.TargetData,
+ context: *llvm.Context,
+ target_machine: *llvm.TargetMachine,
+ target_data: *llvm.TargetData,
target: std.Target,
/// Ideally we would use `llvm_module.getNamedFunction` to go from *Decl to LLVM function,
/// but that has some downsides:
@@ -347,9 +347,9 @@ pub const Object = struct {
/// version of the name and incorrectly get function not found in the llvm module.
/// * it works for functions not all globals.
/// Therefore, this table keeps track of the mapping.
- decl_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *const llvm.Value),
+ decl_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *llvm.Value),
/// Serves the same purpose as `decl_map` but only used for the `is_named_enum_value` instruction.
- named_enum_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *const llvm.Value),
+ named_enum_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *llvm.Value),
/// Maps Zig types to LLVM types. The table memory itself is backed by the GPA of
/// the compiler, but the Type/Value memory here is backed by `type_map_arena`.
/// TODO we need to remove entries from this map in response to incremental compilation
@@ -363,7 +363,7 @@ pub const Object = struct {
/// The LLVM global table which holds the names corresponding to Zig errors.
/// Note that the values are not added until flushModule, when all errors in
/// the compilation are known.
- error_name_table: ?*const llvm.Value,
+ error_name_table: ?*llvm.Value,
/// This map is usually very close to empty. It tracks only the cases when a
/// second extern Decl could not be emitted with the correct name due to a
/// name collision.
@@ -371,7 +371,7 @@ pub const Object = struct {
pub const TypeMap = std.HashMapUnmanaged(
Type,
- *const llvm.Type,
+ *llvm.Type,
Type.HashContext64,
std.hash_map.default_max_load_percentage,
);
@@ -405,7 +405,7 @@ pub const Object = struct {
defer gpa.free(llvm_target_triple);
var error_message: [*:0]const u8 = undefined;
- var target: *const llvm.Target = undefined;
+ var target: *llvm.Target = undefined;
if (llvm.Target.getFromTriple(llvm_target_triple.ptr, &target, &error_message).toBool()) {
defer llvm.disposeMessage(error_message);
@@ -578,7 +578,7 @@ pub const Object = struct {
const llvm_ptr_ty = self.context.intType(8).pointerType(0); // TODO: Address space
const llvm_usize_ty = self.context.intType(target.cpu.arch.ptrBitWidth());
- const type_fields = [_]*const llvm.Type{
+ const type_fields = [_]*llvm.Type{
llvm_ptr_ty,
llvm_usize_ty,
};
@@ -587,7 +587,7 @@ pub const Object = struct {
const slice_alignment = slice_ty.abiAlignment(target);
const error_name_list = mod.error_name_list.items;
- const llvm_errors = try mod.gpa.alloc(*const llvm.Value, error_name_list.len);
+ const llvm_errors = try mod.gpa.alloc(*llvm.Value, error_name_list.len);
defer mod.gpa.free(llvm_errors);
llvm_errors[0] = llvm_slice_ty.getUndef();
@@ -601,7 +601,7 @@ pub const Object = struct {
str_global.setUnnamedAddr(.True);
str_global.setAlignment(1);
- const slice_fields = [_]*const llvm.Value{
+ const slice_fields = [_]*llvm.Value{
str_global.constBitCast(llvm_ptr_ty),
llvm_usize_ty.constInt(name.len, .False),
};
@@ -911,7 +911,7 @@ pub const Object = struct {
// This is the list of args we will use that correspond directly to the AIR arg
// instructions. Depending on the calling convention, this list is not necessarily
// a bijection with the actual LLVM parameters of the function.
- var args = std.ArrayList(*const llvm.Value).init(gpa);
+ var args = std.ArrayList(*llvm.Value).init(gpa);
defer args.deinit();
{
@@ -1028,7 +1028,7 @@ pub const Object = struct {
const param_alignment = param_ty.abiAlignment(target);
const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty);
arg_ptr.setAlignment(param_alignment);
- var field_types_buf: [8]*const llvm.Type = undefined;
+ var field_types_buf: [8]*llvm.Type = undefined;
const field_types = field_types_buf[0..llvm_ints.len];
for (llvm_ints) |int_bits, i| {
field_types[i] = dg.context.intType(int_bits);
@@ -1059,7 +1059,7 @@ pub const Object = struct {
const param_alignment = param_ty.abiAlignment(target);
const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty);
arg_ptr.setAlignment(param_alignment);
- var field_types_buf: [8]*const llvm.Type = undefined;
+ var field_types_buf: [8]*llvm.Type = undefined;
const field_types = field_types_buf[0..llvm_floats.len];
for (llvm_floats) |float_bits, i| {
switch (float_bits) {
@@ -1215,7 +1215,7 @@ pub const Object = struct {
/// TODO replace this with a call to `Module::getNamedValue`. This will require adding
/// a new wrapper in zig_llvm.h/zig_llvm.cpp.
- fn getLlvmGlobal(o: Object, name: [*:0]const u8) ?*const llvm.Value {
+ fn getLlvmGlobal(o: Object, name: [*:0]const u8) ?*llvm.Value {
if (o.llvm_module.getNamedFunction(name)) |x| return x;
if (o.llvm_module.getNamedGlobal(name)) |x| return x;
return null;
@@ -2338,7 +2338,7 @@ pub const Object = struct {
};
pub const DeclGen = struct {
- context: *const llvm.Context,
+ context: *llvm.Context,
object: *Object,
module: *Module,
decl: *Module.Decl,
@@ -2354,7 +2354,7 @@ pub const DeclGen = struct {
return error.CodegenFail;
}
- fn llvmModule(self: *DeclGen) *const llvm.Module {
+ fn llvmModule(self: *DeclGen) *llvm.Module {
return self.object.llvm_module;
}
@@ -2444,7 +2444,7 @@ pub const DeclGen = struct {
/// If the llvm function does not exist, create it.
/// Note that this can be called before the function's semantic analysis has
/// completed, so if any attributes rely on that, they must be done in updateFunc, not here.
- fn resolveLlvmFunction(dg: *DeclGen, decl_index: Module.Decl.Index) !*const llvm.Value {
+ fn resolveLlvmFunction(dg: *DeclGen, decl_index: Module.Decl.Index) !*llvm.Value {
const decl = dg.module.declPtr(decl_index);
const zig_fn_type = decl.ty;
const gop = try dg.object.decl_map.getOrPut(dg.gpa, decl_index);
@@ -2559,7 +2559,7 @@ pub const DeclGen = struct {
return llvm_fn;
}
- fn addCommonFnAttributes(dg: *DeclGen, llvm_fn: *const llvm.Value) void {
+ fn addCommonFnAttributes(dg: *DeclGen, llvm_fn: *llvm.Value) void {
const comp = dg.module.comp;
if (!comp.bin_file.options.red_zone) {
@@ -2599,7 +2599,7 @@ pub const DeclGen = struct {
}
}
- fn resolveGlobalDecl(dg: *DeclGen, decl_index: Module.Decl.Index) Error!*const llvm.Value {
+ fn resolveGlobalDecl(dg: *DeclGen, decl_index: Module.Decl.Index) Error!*llvm.Value {
const gop = try dg.object.decl_map.getOrPut(dg.gpa, decl_index);
if (gop.found_existing) return gop.value_ptr.*;
errdefer assert(dg.object.decl_map.remove(decl_index));
@@ -2661,7 +2661,7 @@ pub const DeclGen = struct {
};
}
- fn isUnnamedType(dg: *DeclGen, ty: Type, val: *const llvm.Value) bool {
+ fn isUnnamedType(dg: *DeclGen, ty: Type, val: *llvm.Value) bool {
// Once `lowerType` succeeds, successive calls to it with the same Zig type
// are guaranteed to succeed. So if a call to `lowerType` fails here it means
// it is the first time lowering the type, which means the value can't possible
@@ -2670,7 +2670,7 @@ pub const DeclGen = struct {
return val.typeOf() != llvm_ty;
}
- fn lowerType(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
+ fn lowerType(dg: *DeclGen, t: Type) Allocator.Error!*llvm.Type {
const llvm_ty = try lowerTypeInner(dg, t);
if (std.debug.runtime_safety and false) check: {
if (t.zigTypeTag() == .Opaque) break :check;
@@ -2688,7 +2688,7 @@ pub const DeclGen = struct {
return llvm_ty;
}
- fn lowerTypeInner(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
+ fn lowerTypeInner(dg: *DeclGen, t: Type) Allocator.Error!*llvm.Type {
const gpa = dg.gpa;
const target = dg.module.getTarget();
switch (t.zigTypeTag()) {
@@ -2719,7 +2719,7 @@ pub const DeclGen = struct {
var buf: Type.SlicePtrFieldTypeBuffer = undefined;
const ptr_type = t.slicePtrFieldType(&buf);
- const fields: [2]*const llvm.Type = .{
+ const fields: [2]*llvm.Type = .{
try dg.lowerType(ptr_type),
try dg.lowerType(Type.usize),
};
@@ -2776,7 +2776,7 @@ pub const DeclGen = struct {
}
comptime assert(optional_layout_version == 3);
- var fields_buf: [3]*const llvm.Type = .{
+ var fields_buf: [3]*llvm.Type = .{
payload_llvm_ty, dg.context.intType(8), undefined,
};
const offset = child_ty.abiSize(target) + 1;
@@ -2802,7 +2802,7 @@ pub const DeclGen = struct {
const payload_size = payload_ty.abiSize(target);
const error_size = Type.anyerror.abiSize(target);
- var fields_buf: [3]*const llvm.Type = undefined;
+ var fields_buf: [3]*llvm.Type = undefined;
if (error_align > payload_align) {
fields_buf[0] = llvm_error_type;
fields_buf[1] = llvm_payload_type;
@@ -2845,7 +2845,7 @@ pub const DeclGen = struct {
const llvm_struct_ty = dg.context.structCreateNamed("");
gop.value_ptr.* = llvm_struct_ty; // must be done before any recursive calls
- var llvm_field_types: std.ArrayListUnmanaged(*const llvm.Type) = .{};
+ var llvm_field_types: std.ArrayListUnmanaged(*llvm.Type) = .{};
defer llvm_field_types.deinit(gpa);
try llvm_field_types.ensureUnusedCapacity(gpa, tuple.types.len);
@@ -2908,7 +2908,7 @@ pub const DeclGen = struct {
assert(struct_obj.haveFieldTypes());
- var llvm_field_types: std.ArrayListUnmanaged(*const llvm.Type) = .{};
+ var llvm_field_types: std.ArrayListUnmanaged(*llvm.Type) = .{};
defer llvm_field_types.deinit(gpa);
try llvm_field_types.ensureUnusedCapacity(gpa, struct_obj.fields.count());
@@ -2991,7 +2991,7 @@ pub const DeclGen = struct {
@intCast(c_uint, layout.abi_size - layout.most_aligned_field_size)
else
@intCast(c_uint, layout.payload_size - layout.most_aligned_field_size);
- const fields: [2]*const llvm.Type = .{
+ const fields: [2]*llvm.Type = .{
llvm_aligned_field_ty,
dg.context.intType(8).arrayType(padding_len),
};
@@ -2999,7 +2999,7 @@ pub const DeclGen = struct {
};
if (layout.tag_size == 0) {
- var llvm_fields: [1]*const llvm.Type = .{llvm_payload_ty};
+ var llvm_fields: [1]*llvm.Type = .{llvm_payload_ty};
llvm_union_ty.structSetBody(&llvm_fields, llvm_fields.len, .False);
return llvm_union_ty;
}
@@ -3007,7 +3007,7 @@ pub const DeclGen = struct {
// Put the tag before or after the payload depending on which one's
// alignment is greater.
- var llvm_fields: [3]*const llvm.Type = undefined;
+ var llvm_fields: [3]*llvm.Type = undefined;
var llvm_fields_len: c_uint = 2;
if (layout.tag_align >= layout.payload_align) {
@@ -3040,12 +3040,12 @@ pub const DeclGen = struct {
}
}
- fn lowerTypeFn(dg: *DeclGen, fn_ty: Type) Allocator.Error!*const llvm.Type {
+ fn lowerTypeFn(dg: *DeclGen, fn_ty: Type) Allocator.Error!*llvm.Type {
const target = dg.module.getTarget();
const fn_info = fn_ty.fnInfo();
const llvm_ret_ty = try lowerFnRetTy(dg, fn_info);
- var llvm_params = std.ArrayList(*const llvm.Type).init(dg.gpa);
+ var llvm_params = std.ArrayList(*llvm.Type).init(dg.gpa);
defer llvm_params.deinit();
if (firstParamSRet(fn_info, target)) {
@@ -3135,7 +3135,7 @@ pub const DeclGen = struct {
/// Use this instead of lowerType when you want to handle correctly the case of elem_ty
/// being a zero bit type, but it should still be lowered as an i8 in such case.
/// There are other similar cases handled here as well.
- fn lowerPtrElemTy(dg: *DeclGen, elem_ty: Type) Allocator.Error!*const llvm.Type {
+ fn lowerPtrElemTy(dg: *DeclGen, elem_ty: Type) Allocator.Error!*llvm.Type {
const lower_elem_ty = switch (elem_ty.zigTypeTag()) {
.Opaque, .Fn => true,
.Array => elem_ty.childType().hasRuntimeBitsIgnoreComptime(),
@@ -3149,7 +3149,7 @@ pub const DeclGen = struct {
return llvm_elem_ty;
}
- fn lowerValue(dg: *DeclGen, tv: TypedValue) Error!*const llvm.Value {
+ fn lowerValue(dg: *DeclGen, tv: TypedValue) Error!*llvm.Value {
if (tv.val.isUndef()) {
const llvm_type = try dg.lowerType(tv.ty);
return llvm_type.getUndef();
@@ -3264,7 +3264,7 @@ pub const DeclGen = struct {
.slice => {
const slice = tv.val.castTag(.slice).?.data;
var buf: Type.SlicePtrFieldTypeBuffer = undefined;
- const fields: [2]*const llvm.Value = .{
+ const fields: [2]*llvm.Value = .{
try dg.lowerValue(.{
.ty = tv.ty.slicePtrFieldType(&buf),
.val = slice.ptr,
@@ -3336,7 +3336,7 @@ pub const DeclGen = struct {
const elem_ty = tv.ty.elemType();
const gpa = dg.gpa;
const len = @intCast(usize, tv.ty.arrayLenIncludingSentinel());
- const llvm_elems = try gpa.alloc(*const llvm.Value, len);
+ const llvm_elems = try gpa.alloc(*llvm.Value, len);
defer gpa.free(llvm_elems);
var need_unnamed = false;
for (elem_vals[0..len]) |elem_val, i| {
@@ -3364,7 +3364,7 @@ pub const DeclGen = struct {
const len = @intCast(usize, tv.ty.arrayLen());
const len_including_sent = len + @boolToInt(sentinel != null);
const gpa = dg.gpa;
- const llvm_elems = try gpa.alloc(*const llvm.Value, len_including_sent);
+ const llvm_elems = try gpa.alloc(*llvm.Value, len_including_sent);
defer gpa.free(llvm_elems);
var need_unnamed = false;
@@ -3398,7 +3398,7 @@ pub const DeclGen = struct {
const elem_ty = tv.ty.elemType();
const sent_val = tv.ty.sentinel().?;
const sentinel = try dg.lowerValue(.{ .ty = elem_ty, .val = sent_val });
- const llvm_elems: [1]*const llvm.Value = .{sentinel};
+ const llvm_elems: [1]*llvm.Value = .{sentinel};
const need_unnamed = dg.isUnnamedType(elem_ty, llvm_elems[0]);
if (need_unnamed) {
return dg.context.constStruct(&llvm_elems, llvm_elems.len, .True);
@@ -3433,7 +3433,7 @@ pub const DeclGen = struct {
assert(payload_ty.zigTypeTag() != .Fn);
const llvm_field_count = llvm_ty.countStructElementTypes();
- var fields_buf: [3]*const llvm.Value = undefined;
+ var fields_buf: [3]*llvm.Value = undefined;
fields_buf[0] = try dg.lowerValue(.{
.ty = payload_ty,
.val = if (tv.val.castTag(.opt_payload)) |pl| pl.data else Value.initTag(.undef),
@@ -3489,7 +3489,7 @@ pub const DeclGen = struct {
.ty = payload_type,
.val = if (tv.val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef),
});
- var fields_buf: [3]*const llvm.Value = undefined;
+ var fields_buf: [3]*llvm.Value = undefined;
const llvm_ty = try dg.lowerType(tv.ty);
const llvm_field_count = llvm_ty.countStructElementTypes();
@@ -3515,7 +3515,7 @@ pub const DeclGen = struct {
if (tv.ty.isTupleOrAnonStruct()) {
const tuple = tv.ty.tupleFields();
- var llvm_fields: std.ArrayListUnmanaged(*const llvm.Value) = .{};
+ var llvm_fields: std.ArrayListUnmanaged(*llvm.Value) = .{};
defer llvm_fields.deinit(gpa);
try llvm_fields.ensureUnusedCapacity(gpa, tuple.types.len);
@@ -3584,7 +3584,7 @@ pub const DeclGen = struct {
const int_llvm_ty = dg.context.intType(@intCast(c_uint, big_bits));
const fields = struct_obj.fields.values();
comptime assert(Type.packed_struct_layout_version == 2);
- var running_int: *const llvm.Value = int_llvm_ty.constNull();
+ var running_int: *llvm.Value = int_llvm_ty.constNull();
var running_bits: u16 = 0;
for (field_vals) |field_val, i| {
const field = fields[i];
@@ -3613,7 +3613,7 @@ pub const DeclGen = struct {
}
const llvm_field_count = llvm_struct_ty.countStructElementTypes();
- var llvm_fields = try std.ArrayListUnmanaged(*const llvm.Value).initCapacity(gpa, llvm_field_count);
+ var llvm_fields = try std.ArrayListUnmanaged(*llvm.Value).initCapacity(gpa, llvm_field_count);
defer llvm_fields.deinit(gpa);
comptime assert(struct_layout_version == 2);
@@ -3706,14 +3706,14 @@ pub const DeclGen = struct {
break :p field;
}
const padding_len = @intCast(c_uint, layout.payload_size - field_size);
- const fields: [2]*const llvm.Value = .{
+ const fields: [2]*llvm.Value = .{
field, dg.context.intType(8).arrayType(padding_len).getUndef(),
};
break :p dg.context.constStruct(&fields, fields.len, .True);
};
if (layout.tag_size == 0) {
- const fields: [1]*const llvm.Value = .{payload};
+ const fields: [1]*llvm.Value = .{payload};
if (need_unnamed) {
return dg.context.constStruct(&fields, fields.len, .False);
} else {
@@ -3724,7 +3724,7 @@ pub const DeclGen = struct {
.ty = tv.ty.unionTagTypeSafety().?,
.val = tag_and_val.tag,
});
- var fields: [3]*const llvm.Value = undefined;
+ var fields: [3]*llvm.Value = undefined;
var fields_len: c_uint = 2;
if (layout.tag_align >= layout.payload_align) {
fields = .{ llvm_tag_value, payload, undefined };
@@ -3749,7 +3749,7 @@ pub const DeclGen = struct {
assert(vector_len == bytes.len or vector_len + 1 == bytes.len);
const elem_ty = tv.ty.elemType();
- const llvm_elems = try dg.gpa.alloc(*const llvm.Value, vector_len);
+ const llvm_elems = try dg.gpa.alloc(*llvm.Value, vector_len);
defer dg.gpa.free(llvm_elems);
for (llvm_elems) |*elem, i| {
var byte_payload: Value.Payload.U64 = .{
@@ -3774,7 +3774,7 @@ pub const DeclGen = struct {
const vector_len = @intCast(usize, tv.ty.arrayLen());
assert(vector_len == elem_vals.len or vector_len + 1 == elem_vals.len);
const elem_ty = tv.ty.elemType();
- const llvm_elems = try dg.gpa.alloc(*const llvm.Value, vector_len);
+ const llvm_elems = try dg.gpa.alloc(*llvm.Value, vector_len);
defer dg.gpa.free(llvm_elems);
for (llvm_elems) |*elem, i| {
elem.* = try dg.lowerValue(.{ .ty = elem_ty, .val = elem_vals[i] });
@@ -3789,7 +3789,7 @@ pub const DeclGen = struct {
const val = tv.val.castTag(.repeated).?.data;
const elem_ty = tv.ty.elemType();
const len = @intCast(usize, tv.ty.arrayLen());
- const llvm_elems = try dg.gpa.alloc(*const llvm.Value, len);
+ const llvm_elems = try dg.gpa.alloc(*llvm.Value, len);
defer dg.gpa.free(llvm_elems);
for (llvm_elems) |*elem| {
elem.* = try dg.lowerValue(.{ .ty = elem_ty, .val = val });
@@ -3821,7 +3821,7 @@ pub const DeclGen = struct {
const ParentPtr = struct {
ty: Type,
- llvm_ptr: *const llvm.Value,
+ llvm_ptr: *llvm.Value,
};
fn lowerParentPtrDecl(
@@ -3829,7 +3829,7 @@ pub const DeclGen = struct {
ptr_val: Value,
decl_index: Module.Decl.Index,
ptr_child_ty: Type,
- ) Error!*const llvm.Value {
+ ) Error!*llvm.Value {
const decl = dg.module.declPtr(decl_index);
dg.module.markDeclAlive(decl);
var ptr_ty_payload: Type.Payload.ElemType = .{
@@ -3846,7 +3846,7 @@ pub const DeclGen = struct {
}
}
- fn lowerParentPtr(dg: *DeclGen, ptr_val: Value, ptr_child_ty: Type) Error!*const llvm.Value {
+ fn lowerParentPtr(dg: *DeclGen, ptr_val: Value, ptr_child_ty: Type) Error!*llvm.Value {
const target = dg.module.getTarget();
var bitcast_needed: bool = undefined;
const llvm_ptr = switch (ptr_val.tag()) {
@@ -3895,7 +3895,7 @@ pub const DeclGen = struct {
0
else
@boolToInt(layout.tag_align >= layout.payload_align);
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_u32.constInt(0, .False),
llvm_u32.constInt(llvm_pl_index, .False),
};
@@ -3926,7 +3926,7 @@ pub const DeclGen = struct {
var ty_buf: Type.Payload.Pointer = undefined;
const llvm_field_index = llvmFieldIndex(parent_ty, field_index, target, &ty_buf).?;
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_u32.constInt(0, .False),
llvm_u32.constInt(llvm_field_index, .False),
};
@@ -3942,7 +3942,7 @@ pub const DeclGen = struct {
bitcast_needed = !elem_ptr.elem_ty.eql(ptr_child_ty, dg.module);
const llvm_usize = try dg.lowerType(Type.usize);
- const indices: [1]*const llvm.Value = .{
+ const indices: [1]*llvm.Value = .{
llvm_usize.constInt(elem_ptr.index, .False),
};
const elem_llvm_ty = try dg.lowerType(elem_ptr.elem_ty);
@@ -3965,7 +3965,7 @@ pub const DeclGen = struct {
}
const llvm_u32 = dg.context.intType(32);
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_u32.constInt(0, .False),
llvm_u32.constInt(0, .False),
};
@@ -3987,7 +3987,7 @@ pub const DeclGen = struct {
const payload_offset: u8 = if (payload_ty.abiAlignment(target) > Type.anyerror.abiSize(target)) 2 else 1;
const llvm_u32 = dg.context.intType(32);
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_u32.constInt(0, .False),
llvm_u32.constInt(payload_offset, .False),
};
@@ -4007,7 +4007,7 @@ pub const DeclGen = struct {
self: *DeclGen,
tv: TypedValue,
decl_index: Module.Decl.Index,
- ) Error!*const llvm.Value {
+ ) Error!*llvm.Value {
if (tv.ty.isSlice()) {
var buf: Type.SlicePtrFieldTypeBuffer = undefined;
const ptr_ty = tv.ty.slicePtrFieldType(&buf);
@@ -4015,7 +4015,7 @@ pub const DeclGen = struct {
.base = .{ .tag = .int_u64 },
.data = tv.val.sliceLen(self.module),
};
- const fields: [2]*const llvm.Value = .{
+ const fields: [2]*llvm.Value = .{
try self.lowerValue(.{
.ty = ptr_ty,
.val = tv.val,
@@ -4060,7 +4060,7 @@ pub const DeclGen = struct {
}
}
- fn lowerPtrToVoid(dg: *DeclGen, ptr_ty: Type) !*const llvm.Value {
+ fn lowerPtrToVoid(dg: *DeclGen, ptr_ty: Type) !*llvm.Value {
const alignment = ptr_ty.ptrInfo().data.@"align";
// Even though we are pointing at something which has zero bits (e.g. `void`),
// Pointers are defined to have bits. So we must return something here.
@@ -4086,19 +4086,19 @@ pub const DeclGen = struct {
return int.constIntToPtr(llvm_ptr_ty);
}
- fn addAttr(dg: DeclGen, val: *const llvm.Value, index: llvm.AttributeIndex, name: []const u8) void {
+ fn addAttr(dg: DeclGen, val: *llvm.Value, index: llvm.AttributeIndex, name: []const u8) void {
return dg.addAttrInt(val, index, name, 0);
}
- fn addArgAttr(dg: DeclGen, fn_val: *const llvm.Value, param_index: u32, attr_name: []const u8) void {
+ fn addArgAttr(dg: DeclGen, fn_val: *llvm.Value, param_index: u32, attr_name: []const u8) void {
return dg.addAttr(fn_val, param_index + 1, attr_name);
}
- fn addArgAttrInt(dg: DeclGen, fn_val: *const llvm.Value, param_index: u32, attr_name: []const u8, int: u64) void {
+ fn addArgAttrInt(dg: DeclGen, fn_val: *llvm.Value, param_index: u32, attr_name: []const u8, int: u64) void {
return dg.addAttrInt(fn_val, param_index + 1, attr_name, int);
}
- fn removeAttr(val: *const llvm.Value, index: llvm.AttributeIndex, name: []const u8) void {
+ fn removeAttr(val: *llvm.Value, index: llvm.AttributeIndex, name: []const u8) void {
const kind_id = llvm.getEnumAttributeKindForName(name.ptr, name.len);
assert(kind_id != 0);
val.removeEnumAttributeAtIndex(index, kind_id);
@@ -4106,7 +4106,7 @@ pub const DeclGen = struct {
fn addAttrInt(
dg: DeclGen,
- val: *const llvm.Value,
+ val: *llvm.Value,
index: llvm.AttributeIndex,
name: []const u8,
int: u64,
@@ -4119,7 +4119,7 @@ pub const DeclGen = struct {
fn addAttrString(
dg: *DeclGen,
- val: *const llvm.Value,
+ val: *llvm.Value,
index: llvm.AttributeIndex,
name: []const u8,
value: []const u8,
@@ -4133,19 +4133,19 @@ pub const DeclGen = struct {
val.addAttributeAtIndex(index, llvm_attr);
}
- fn addFnAttr(dg: DeclGen, val: *const llvm.Value, name: []const u8) void {
+ fn addFnAttr(dg: DeclGen, val: *llvm.Value, name: []const u8) void {
dg.addAttr(val, std.math.maxInt(llvm.AttributeIndex), name);
}
- fn addFnAttrString(dg: *DeclGen, val: *const llvm.Value, name: []const u8, value: []const u8) void {
+ fn addFnAttrString(dg: *DeclGen, val: *llvm.Value, name: []const u8, value: []const u8) void {
dg.addAttrString(val, std.math.maxInt(llvm.AttributeIndex), name, value);
}
- fn removeFnAttr(fn_val: *const llvm.Value, name: []const u8) void {
+ fn removeFnAttr(fn_val: *llvm.Value, name: []const u8) void {
removeAttr(fn_val, std.math.maxInt(llvm.AttributeIndex), name);
}
- fn addFnAttrInt(dg: DeclGen, fn_val: *const llvm.Value, name: []const u8, int: u64) void {
+ fn addFnAttrInt(dg: DeclGen, fn_val: *llvm.Value, name: []const u8, int: u64) void {
return dg.addAttrInt(fn_val, std.math.maxInt(llvm.AttributeIndex), name, int);
}
@@ -4153,7 +4153,7 @@ pub const DeclGen = struct {
/// widen it before using it and then truncate the result.
/// RMW exchange of floating-point values is bitcasted to same-sized integer
/// types to work around a LLVM deficiency when targeting ARM/AArch64.
- fn getAtomicAbiType(dg: *DeclGen, ty: Type, is_rmw_xchg: bool) ?*const llvm.Type {
+ fn getAtomicAbiType(dg: *DeclGen, ty: Type, is_rmw_xchg: bool) ?*llvm.Type {
const target = dg.module.getTarget();
var buffer: Type.Payload.Bits = undefined;
const int_ty = switch (ty.zigTypeTag()) {
@@ -4176,7 +4176,7 @@ pub const DeclGen = struct {
fn addByValParamAttrs(
dg: DeclGen,
- llvm_fn: *const llvm.Value,
+ llvm_fn: *llvm.Value,
param_ty: Type,
param_index: u32,
fn_info: Type.Payload.Function.Data,
@@ -4213,11 +4213,11 @@ pub const DeclGen = struct {
fn addByRefParamAttrs(
dg: DeclGen,
- llvm_fn: *const llvm.Value,
+ llvm_fn: *llvm.Value,
llvm_arg_i: u32,
alignment: u32,
byval_attr: bool,
- param_llvm_ty: *const llvm.Type,
+ param_llvm_ty: *llvm.Type,
) void {
dg.addArgAttr(llvm_fn, llvm_arg_i, "nonnull");
dg.addArgAttr(llvm_fn, llvm_arg_i, "readonly");
@@ -4233,8 +4233,8 @@ pub const FuncGen = struct {
dg: *DeclGen,
air: Air,
liveness: Liveness,
- context: *const llvm.Context,
- builder: *const llvm.Builder,
+ context: *llvm.Context,
+ builder: *llvm.Builder,
di_scope: ?*llvm.DIScope,
di_file: ?*llvm.DIFile,
base_line: u32,
@@ -4250,30 +4250,30 @@ pub const FuncGen = struct {
/// This stores the LLVM values used in a function, such that they can be referred to
/// in other instructions. This table is cleared before every function is generated.
- func_inst_table: std.AutoHashMapUnmanaged(Air.Inst.Ref, *const llvm.Value),
+ func_inst_table: std.AutoHashMapUnmanaged(Air.Inst.Ref, *llvm.Value),
/// If the return type is sret, this is the result pointer. Otherwise null.
/// Note that this can disagree with isByRef for the return type in the case
/// of C ABI functions.
- ret_ptr: ?*const llvm.Value,
+ ret_ptr: ?*llvm.Value,
/// Any function that needs to perform Valgrind client requests needs an array alloca
/// instruction, however a maximum of one per function is needed.
- valgrind_client_request_array: ?*const llvm.Value = null,
+ valgrind_client_request_array: ?*llvm.Value = null,
/// These fields are used to refer to the LLVM value of the function parameters
/// in an Arg instruction.
/// This list may be shorter than the list according to the zig type system;
/// it omits 0-bit types. If the function uses sret as the first parameter,
/// this slice does not include it.
- args: []const *const llvm.Value,
+ args: []const *llvm.Value,
arg_index: c_uint,
- llvm_func: *const llvm.Value,
+ llvm_func: *llvm.Value,
- err_ret_trace: ?*const llvm.Value = null,
+ err_ret_trace: ?*llvm.Value = null,
/// This data structure is used to implement breaking to blocks.
blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
- parent_bb: *const llvm.BasicBlock,
+ parent_bb: *llvm.BasicBlock,
breaks: *BreakList,
}),
@@ -4281,8 +4281,8 @@ pub const FuncGen = struct {
const DbgState = struct { loc: *llvm.DILocation, scope: *llvm.DIScope, base_line: u32 };
const BreakList = std.MultiArrayList(struct {
- bb: *const llvm.BasicBlock,
- val: *const llvm.Value,
+ bb: *llvm.BasicBlock,
+ val: *llvm.Value,
});
fn deinit(self: *FuncGen) void {
@@ -4298,11 +4298,11 @@ pub const FuncGen = struct {
return self.dg.todo(format, args);
}
- fn llvmModule(self: *FuncGen) *const llvm.Module {
+ fn llvmModule(self: *FuncGen) *llvm.Module {
return self.dg.object.llvm_module;
}
- fn resolveInst(self: *FuncGen, inst: Air.Inst.Ref) !*const llvm.Value {
+ fn resolveInst(self: *FuncGen, inst: Air.Inst.Ref) !*llvm.Value {
const gop = try self.func_inst_table.getOrPut(self.dg.gpa, inst);
if (gop.found_existing) return gop.value_ptr.*;
@@ -4336,7 +4336,7 @@ pub const FuncGen = struct {
fn genBody(self: *FuncGen, body: []const Air.Inst.Index) Error!void {
const air_tags = self.air.instructions.items(.tag);
for (body) |inst, i| {
- const opt_value: ?*const llvm.Value = switch (air_tags[inst]) {
+ const opt_value: ?*llvm.Value = switch (air_tags[inst]) {
// zig fmt: off
.add => try self.airAdd(inst, false),
.addwrap => try self.airAddWrap(inst, false),
@@ -4563,7 +4563,7 @@ pub const FuncGen = struct {
}
}
- fn airCall(self: *FuncGen, inst: Air.Inst.Index, attr: llvm.CallAttr) !?*const llvm.Value {
+ fn airCall(self: *FuncGen, inst: Air.Inst.Index, attr: llvm.CallAttr) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args = @ptrCast([]const Air.Inst.Ref, self.air.extra[extra.end..][0..extra.data.args_len]);
@@ -4579,7 +4579,7 @@ pub const FuncGen = struct {
const target = self.dg.module.getTarget();
const sret = firstParamSRet(fn_info, target);
- var llvm_args = std.ArrayList(*const llvm.Value).init(self.gpa);
+ var llvm_args = std.ArrayList(*llvm.Value).init(self.gpa);
defer llvm_args.deinit();
const ret_ptr = if (!sret) null else blk: {
@@ -4693,7 +4693,7 @@ pub const FuncGen = struct {
break :p p;
};
- var field_types_buf: [8]*const llvm.Type = undefined;
+ var field_types_buf: [8]*llvm.Type = undefined;
const field_types = field_types_buf[0..llvm_ints.len];
for (llvm_ints) |int_bits, i| {
field_types[i] = self.dg.context.intType(int_bits);
@@ -4722,7 +4722,7 @@ pub const FuncGen = struct {
break :p p;
};
- var field_types_buf: [8]*const llvm.Type = undefined;
+ var field_types_buf: [8]*llvm.Type = undefined;
const field_types = field_types_buf[0..llvm_floats.len];
for (llvm_floats) |float_bits, i| {
switch (float_bits) {
@@ -4840,7 +4840,7 @@ pub const FuncGen = struct {
}
}
- fn airRet(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airRet(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const un_op = self.air.instructions.items(.data)[inst].un_op;
const ret_ty = self.air.typeOf(un_op);
if (self.ret_ptr) |ret_ptr| {
@@ -4901,7 +4901,7 @@ pub const FuncGen = struct {
return null;
}
- fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const un_op = self.air.instructions.items(.data)[inst].un_op;
const ptr_ty = self.air.typeOf(un_op);
const ret_ty = ptr_ty.childType();
@@ -4936,7 +4936,7 @@ pub const FuncGen = struct {
return null;
}
- fn airCmp(self: *FuncGen, inst: Air.Inst.Index, op: math.CompareOperator, want_fast_math: bool) !?*const llvm.Value {
+ fn airCmp(self: *FuncGen, inst: Air.Inst.Index, op: math.CompareOperator, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -4948,7 +4948,7 @@ pub const FuncGen = struct {
return self.cmp(lhs, rhs, operand_ty, op);
}
- fn airCmpVector(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airCmpVector(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -4963,23 +4963,23 @@ pub const FuncGen = struct {
return self.cmp(lhs, rhs, vec_ty, cmp_op);
}
- fn airCmpLtErrorsLen(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airCmpLtErrorsLen(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
const operand = try self.resolveInst(un_op);
const llvm_fn = try self.getCmpLtErrorsLenFunction();
- const args: [1]*const llvm.Value = .{operand};
+ const args: [1]*llvm.Value = .{operand};
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &args, args.len, .Fast, .Auto, "");
}
fn cmp(
self: *FuncGen,
- lhs: *const llvm.Value,
- rhs: *const llvm.Value,
+ lhs: *llvm.Value,
+ rhs: *llvm.Value,
operand_ty: Type,
op: math.CompareOperator,
- ) Allocator.Error!*const llvm.Value {
+ ) Allocator.Error!*llvm.Value {
var int_buffer: Type.Payload.Bits = undefined;
var opt_buffer: Type.Payload.ElemType = undefined;
@@ -5029,7 +5029,7 @@ pub const FuncGen = struct {
const both_pl_block_end = self.builder.getInsertBlock();
self.builder.positionBuilderAtEnd(end_block);
- const incoming_blocks: [3]*const llvm.BasicBlock = .{
+ const incoming_blocks: [3]*llvm.BasicBlock = .{
both_null_block,
mixed_block,
both_pl_block_end,
@@ -5037,7 +5037,7 @@ pub const FuncGen = struct {
const llvm_i1 = self.context.intType(1);
const llvm_i1_0 = llvm_i1.constInt(0, .False);
const llvm_i1_1 = llvm_i1.constInt(1, .False);
- const incoming_values: [3]*const llvm.Value = .{
+ const incoming_values: [3]*llvm.Value = .{
switch (op) {
.eq => llvm_i1_1,
.neq => llvm_i1_0,
@@ -5075,7 +5075,7 @@ pub const FuncGen = struct {
return self.builder.buildICmp(operation, lhs, rhs, "");
}
- fn airBlock(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airBlock(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
const body = self.air.extra[extra.end..][0..extra.data.body_len];
@@ -5127,7 +5127,7 @@ pub const FuncGen = struct {
return phi_node;
}
- fn airBr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airBr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const branch = self.air.instructions.items(.data)[inst].br;
const block = self.blocks.get(branch.block_inst).?;
@@ -5147,7 +5147,7 @@ pub const FuncGen = struct {
return null;
}
- fn airCondBr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airCondBr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const cond = try self.resolveInst(pl_op.operand);
const extra = self.air.extraData(Air.CondBr, pl_op.payload);
@@ -5168,7 +5168,7 @@ pub const FuncGen = struct {
return null;
}
- fn airTry(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airTry(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const err_union = try self.resolveInst(pl_op.operand);
const extra = self.air.extraData(Air.Try, pl_op.payload);
@@ -5178,7 +5178,7 @@ pub const FuncGen = struct {
return lowerTry(self, err_union, body, err_union_ty, false, result_ty);
}
- fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
const err_union_ptr = try self.resolveInst(extra.data.ptr);
@@ -5190,12 +5190,12 @@ pub const FuncGen = struct {
fn lowerTry(
fg: *FuncGen,
- err_union: *const llvm.Value,
+ err_union: *llvm.Value,
body: []const Air.Inst.Index,
err_union_ty: Type,
operand_is_ptr: bool,
result_ty: Type,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
const payload_ty = err_union_ty.errorUnionPayload();
const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime();
const target = fg.dg.module.getTarget();
@@ -5256,7 +5256,7 @@ pub const FuncGen = struct {
return fg.builder.buildExtractValue(err_union, offset, "");
}
- fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const cond = try self.resolveInst(pl_op.operand);
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
@@ -5305,7 +5305,7 @@ pub const FuncGen = struct {
return null;
}
- fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const loop = self.air.extraData(Air.Block, ty_pl.payload);
const body = self.air.extra[loop.end..][0..loop.data.body_len];
@@ -5327,7 +5327,7 @@ pub const FuncGen = struct {
return null;
}
- fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -5341,7 +5341,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(slice_llvm_ty.getUndef(), len, 1, "");
}
const operand = try self.resolveInst(ty_op.operand);
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_usize.constNull(), llvm_usize.constNull(),
};
const array_llvm_ty = try self.dg.lowerType(array_ty);
@@ -5350,7 +5350,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(partial, len, 1, "");
}
- fn airIntToFloat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airIntToFloat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -5394,22 +5394,22 @@ pub const FuncGen = struct {
compiler_rt_dest_abbrev,
}) catch unreachable;
- var param_types = [1]*const llvm.Type{rt_int_ty};
+ var param_types = [1]*llvm.Type{rt_int_ty};
if (rt_int_bits == 128 and (target.os.tag == .windows and target.cpu.arch == .x86_64)) {
// On Windows x86-64, "ti" functions must use Vector(2, u64) instead of the standard
// i128 calling convention to adhere to the ABI that LLVM expects compiler-rt to have.
const v2i64 = self.context.intType(64).vectorType(2);
extended = self.builder.buildBitCast(extended, v2i64, "");
- param_types = [1]*const llvm.Type{v2i64};
+ param_types = [1]*llvm.Type{v2i64};
}
const libc_fn = self.getLibcFunction(fn_name, ¶m_types, dest_llvm_ty);
- const params = [1]*const llvm.Value{extended};
+ const params = [1]*llvm.Value{extended};
return self.builder.buildCall(libc_fn.globalGetValueType(), libc_fn, ¶ms, params.len, .C, .Auto, "");
}
- fn airFloatToInt(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airFloatToInt(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -5457,9 +5457,9 @@ pub const FuncGen = struct {
}) catch unreachable;
const operand_llvm_ty = try self.dg.lowerType(operand_ty);
- const param_types = [1]*const llvm.Type{operand_llvm_ty};
+ const param_types = [1]*llvm.Type{operand_llvm_ty};
const libc_fn = self.getLibcFunction(fn_name, ¶m_types, libc_ret_ty);
- const params = [1]*const llvm.Value{operand};
+ const params = [1]*llvm.Value{operand};
var result = self.builder.buildCall(libc_fn.globalGetValueType(), libc_fn, ¶ms, params.len, .C, .Auto, "");
@@ -5468,7 +5468,7 @@ pub const FuncGen = struct {
return result;
}
- fn airSliceField(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*const llvm.Value {
+ fn airSliceField(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -5476,7 +5476,7 @@ pub const FuncGen = struct {
return self.builder.buildExtractValue(operand, index, "");
}
- fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*const llvm.Value {
+ fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -5487,7 +5487,7 @@ pub const FuncGen = struct {
return self.builder.buildStructGEP(slice_llvm_ty, slice_ptr, index, "");
}
- fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const slice_ty = self.air.typeOf(bin_op.lhs);
if (!slice_ty.isVolatilePtr() and self.liveness.isUnused(inst)) return null;
@@ -5496,12 +5496,12 @@ pub const FuncGen = struct {
const index = try self.resolveInst(bin_op.rhs);
const llvm_elem_ty = try self.dg.lowerPtrElemTy(slice_ty.childType());
const base_ptr = self.builder.buildExtractValue(slice, 0, "");
- const indices: [1]*const llvm.Value = .{index};
+ const indices: [1]*llvm.Value = .{index};
const ptr = self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
return self.load(ptr, slice_ty);
}
- fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -5511,11 +5511,11 @@ pub const FuncGen = struct {
const index = try self.resolveInst(bin_op.rhs);
const llvm_elem_ty = try self.dg.lowerPtrElemTy(slice_ty.childType());
const base_ptr = self.builder.buildExtractValue(slice, 0, "");
- const indices: [1]*const llvm.Value = .{index};
+ const indices: [1]*llvm.Value = .{index};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
}
- fn airArrayElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airArrayElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -5524,7 +5524,7 @@ pub const FuncGen = struct {
const rhs = try self.resolveInst(bin_op.rhs);
if (isByRef(array_ty)) {
const array_llvm_ty = try self.dg.lowerType(array_ty);
- const indices: [2]*const llvm.Value = .{ self.context.intType(32).constNull(), rhs };
+ const indices: [2]*llvm.Value = .{ self.context.intType(32).constNull(), rhs };
const elem_ptr = self.builder.buildInBoundsGEP(array_llvm_ty, array_llvm_val, &indices, indices.len, "");
const elem_ty = array_ty.childType();
if (isByRef(elem_ty)) {
@@ -5539,7 +5539,7 @@ pub const FuncGen = struct {
return self.builder.buildExtractElement(array_llvm_val, rhs, "");
}
- fn airPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const ptr_ty = self.air.typeOf(bin_op.lhs);
if (!ptr_ty.isVolatilePtr() and self.liveness.isUnused(inst)) return null;
@@ -5550,16 +5550,16 @@ pub const FuncGen = struct {
// TODO: when we go fully opaque pointers in LLVM 16 we can remove this branch
const ptr = if (ptr_ty.isSinglePointer()) ptr: {
// If this is a single-item pointer to an array, we need another index in the GEP.
- const indices: [2]*const llvm.Value = .{ self.context.intType(32).constNull(), rhs };
+ const indices: [2]*llvm.Value = .{ self.context.intType(32).constNull(), rhs };
break :ptr self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
} else ptr: {
- const indices: [1]*const llvm.Value = .{rhs};
+ const indices: [1]*llvm.Value = .{rhs};
break :ptr self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
};
return self.load(ptr, ptr_ty);
}
- fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -5573,15 +5573,15 @@ pub const FuncGen = struct {
const llvm_elem_ty = try self.dg.lowerPtrElemTy(elem_ty);
if (ptr_ty.isSinglePointer()) {
// If this is a single-item pointer to an array, we need another index in the GEP.
- const indices: [2]*const llvm.Value = .{ self.context.intType(32).constNull(), rhs };
+ const indices: [2]*llvm.Value = .{ self.context.intType(32).constNull(), rhs };
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
} else {
- const indices: [1]*const llvm.Value = .{rhs};
+ const indices: [1]*llvm.Value = .{rhs};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
}
}
- fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -5596,7 +5596,7 @@ pub const FuncGen = struct {
self: *FuncGen,
inst: Air.Inst.Index,
field_index: u32,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -5605,7 +5605,7 @@ pub const FuncGen = struct {
return self.fieldPtr(inst, struct_ptr, struct_ptr_ty, field_index);
}
- fn airStructFieldVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airStructFieldVal(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -5683,7 +5683,7 @@ pub const FuncGen = struct {
}
}
- fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -5706,7 +5706,7 @@ pub const FuncGen = struct {
return self.builder.buildIntToPtr(base_ptr_int, res_ty, "");
}
- fn airNot(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airNot(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -5716,13 +5716,13 @@ pub const FuncGen = struct {
return self.builder.buildNot(operand, "");
}
- fn airUnreach(self: *FuncGen, inst: Air.Inst.Index) ?*const llvm.Value {
+ fn airUnreach(self: *FuncGen, inst: Air.Inst.Index) ?*llvm.Value {
_ = inst;
_ = self.builder.buildUnreachable();
return null;
}
- fn airDbgStmt(self: *FuncGen, inst: Air.Inst.Index) ?*const llvm.Value {
+ fn airDbgStmt(self: *FuncGen, inst: Air.Inst.Index) ?*llvm.Value {
const di_scope = self.di_scope orelse return null;
const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
self.prev_dbg_line = @intCast(c_uint, self.base_line + dbg_stmt.line + 1);
@@ -5735,7 +5735,7 @@ pub const FuncGen = struct {
return null;
}
- fn airDbgInlineBegin(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airDbgInlineBegin(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const dib = self.dg.object.di_builder orelse return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -5778,7 +5778,7 @@ pub const FuncGen = struct {
return null;
}
- fn airDbgInlineEnd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airDbgInlineEnd(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.dg.object.di_builder == null) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -5793,7 +5793,7 @@ pub const FuncGen = struct {
return null;
}
- fn airDbgBlockBegin(self: *FuncGen) !?*const llvm.Value {
+ fn airDbgBlockBegin(self: *FuncGen) !?*llvm.Value {
const dib = self.dg.object.di_builder orelse return null;
const old_scope = self.di_scope.?;
try self.dbg_block_stack.append(self.gpa, old_scope);
@@ -5802,13 +5802,13 @@ pub const FuncGen = struct {
return null;
}
- fn airDbgBlockEnd(self: *FuncGen) !?*const llvm.Value {
+ fn airDbgBlockEnd(self: *FuncGen) !?*llvm.Value {
if (self.dg.object.di_builder == null) return null;
self.di_scope = self.dbg_block_stack.pop();
return null;
}
- fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const dib = self.dg.object.di_builder orelse return null;
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const operand = try self.resolveInst(pl_op.operand);
@@ -5834,7 +5834,7 @@ pub const FuncGen = struct {
return null;
}
- fn airDbgVarVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airDbgVarVal(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const dib = self.dg.object.di_builder orelse return null;
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const operand = try self.resolveInst(pl_op.operand);
@@ -5868,7 +5868,7 @@ pub const FuncGen = struct {
return null;
}
- fn airAssembly(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAssembly(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
// Eventually, the Zig compiler needs to be reworked to have inline assembly go
// through the same parsing code regardless of backend, and have LLVM-flavored
// inline assembly be *output* from that assembler.
@@ -5899,15 +5899,15 @@ pub const FuncGen = struct {
// The exact number of return / parameter values depends on which output values
// are passed by reference as indirect outputs (determined below).
const max_return_count = outputs.len;
- const llvm_ret_types = try arena.alloc(*const llvm.Type, max_return_count);
+ const llvm_ret_types = try arena.alloc(*llvm.Type, max_return_count);
const llvm_ret_indirect = try arena.alloc(bool, max_return_count);
const max_param_count = inputs.len + outputs.len;
- const llvm_param_types = try arena.alloc(*const llvm.Type, max_param_count);
- const llvm_param_values = try arena.alloc(*const llvm.Value, max_param_count);
+ const llvm_param_types = try arena.alloc(*llvm.Type, max_param_count);
+ const llvm_param_values = try arena.alloc(*llvm.Value, max_param_count);
// This stores whether we need to add an elementtype attribute and
// if so, the element type itself.
- const llvm_param_attrs = try arena.alloc(?*const llvm.Type, max_param_count);
+ const llvm_param_attrs = try arena.alloc(?*llvm.Type, max_param_count);
const target = self.dg.module.getTarget();
var llvm_ret_i: usize = 0;
@@ -5987,7 +5987,7 @@ pub const FuncGen = struct {
const arg_llvm_value = try self.resolveInst(input);
const arg_ty = self.air.typeOf(input);
- var llvm_elem_ty: ?*const llvm.Type = null;
+ var llvm_elem_ty: ?*llvm.Type = null;
if (isByRef(arg_ty)) {
llvm_elem_ty = try self.dg.lowerPtrElemTy(arg_ty);
if (constraintAllowsMemory(constraint)) {
@@ -6208,7 +6208,7 @@ pub const FuncGen = struct {
inst: Air.Inst.Index,
operand_is_ptr: bool,
pred: llvm.IntPredicate,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -6251,7 +6251,7 @@ pub const FuncGen = struct {
inst: Air.Inst.Index,
op: llvm.IntPredicate,
operand_is_ptr: bool,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -6293,7 +6293,7 @@ pub const FuncGen = struct {
return self.builder.buildICmp(op, loaded, zero, "");
}
- fn airOptionalPayloadPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airOptionalPayloadPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6318,7 +6318,7 @@ pub const FuncGen = struct {
return self.builder.buildStructGEP(optional_llvm_ty, operand, 0, "");
}
- fn airOptionalPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airOptionalPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
comptime assert(optional_layout_version == 3);
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6355,7 +6355,7 @@ pub const FuncGen = struct {
return self.builder.buildStructGEP(optional_llvm_ty, operand, 0, "");
}
- fn airOptionalPayload(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airOptionalPayload(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6377,7 +6377,7 @@ pub const FuncGen = struct {
self: *FuncGen,
inst: Air.Inst.Index,
operand_is_ptr: bool,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6415,7 +6415,7 @@ pub const FuncGen = struct {
self: *FuncGen,
inst: Air.Inst.Index,
operand_is_ptr: bool,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -6452,7 +6452,7 @@ pub const FuncGen = struct {
return self.builder.buildExtractValue(operand, offset, "");
}
- fn airErrUnionPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airErrUnionPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const err_union_ty = self.air.typeOf(ty_op.operand).childType();
@@ -6480,18 +6480,18 @@ pub const FuncGen = struct {
return self.builder.buildStructGEP(err_union_llvm_ty, operand, payload_offset, "");
}
- fn airErrReturnTrace(self: *FuncGen, _: Air.Inst.Index) !?*const llvm.Value {
+ fn airErrReturnTrace(self: *FuncGen, _: Air.Inst.Index) !?*llvm.Value {
return self.err_ret_trace.?;
}
- fn airSetErrReturnTrace(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSetErrReturnTrace(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const un_op = self.air.instructions.items(.data)[inst].un_op;
const operand = try self.resolveInst(un_op);
self.err_ret_trace = operand;
return null;
}
- fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6524,7 +6524,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(partial, non_null_bit, 1, "");
}
- fn airWrapErrUnionPayload(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airWrapErrUnionPayload(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6560,7 +6560,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(partial, operand, payload_offset, "");
}
- fn airWrapErrUnionErr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airWrapErrUnionErr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -6598,31 +6598,31 @@ pub const FuncGen = struct {
return partial;
}
- fn airWasmMemorySize(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airWasmMemorySize(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const index = pl_op.payload;
const llvm_u32 = self.context.intType(32);
const llvm_fn = self.getIntrinsic("llvm.wasm.memory.size", &.{llvm_u32});
- const args: [1]*const llvm.Value = .{llvm_u32.constInt(index, .False)};
+ const args: [1]*llvm.Value = .{llvm_u32.constInt(index, .False)};
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &args, args.len, .Fast, .Auto, "");
}
- fn airWasmMemoryGrow(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airWasmMemoryGrow(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const index = pl_op.payload;
const operand = try self.resolveInst(pl_op.operand);
const llvm_u32 = self.context.intType(32);
const llvm_fn = self.getIntrinsic("llvm.wasm.memory.grow", &.{llvm_u32});
- const args: [2]*const llvm.Value = .{
+ const args: [2]*llvm.Value = .{
llvm_u32.constInt(index, .False),
operand,
};
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &args, args.len, .Fast, .Auto, "");
}
- fn airMin(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMin(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -6635,7 +6635,7 @@ pub const FuncGen = struct {
return self.builder.buildUMin(lhs, rhs, "");
}
- fn airMax(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMax(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -6648,7 +6648,7 @@ pub const FuncGen = struct {
return self.builder.buildUMax(lhs, rhs, "");
}
- fn airSlice(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSlice(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -6670,7 +6670,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(partial, len, 1, "");
}
- fn airAdd(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airAdd(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6685,7 +6685,7 @@ pub const FuncGen = struct {
return self.builder.buildNUWAdd(lhs, rhs, "");
}
- fn airAddWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airAddWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6696,7 +6696,7 @@ pub const FuncGen = struct {
return self.builder.buildAdd(lhs, rhs, "");
}
- fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -6711,7 +6711,7 @@ pub const FuncGen = struct {
return self.builder.buildUAddSat(lhs, rhs, "");
}
- fn airSub(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airSub(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6726,7 +6726,7 @@ pub const FuncGen = struct {
return self.builder.buildNUWSub(lhs, rhs, "");
}
- fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6737,7 +6737,7 @@ pub const FuncGen = struct {
return self.builder.buildSub(lhs, rhs, "");
}
- fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -6751,7 +6751,7 @@ pub const FuncGen = struct {
return self.builder.buildUSubSat(lhs, rhs, "");
}
- fn airMul(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airMul(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6766,7 +6766,7 @@ pub const FuncGen = struct {
return self.builder.buildNUWMul(lhs, rhs, "");
}
- fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6777,7 +6777,7 @@ pub const FuncGen = struct {
return self.builder.buildMul(lhs, rhs, "");
}
- fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -6791,7 +6791,7 @@ pub const FuncGen = struct {
return self.builder.buildUMulFixSat(lhs, rhs, "");
}
- fn airDivFloat(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airDivFloat(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6803,7 +6803,7 @@ pub const FuncGen = struct {
return self.buildFloatOp(.div, inst_ty, 2, .{ lhs, rhs });
}
- fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6821,7 +6821,7 @@ pub const FuncGen = struct {
return self.builder.buildUDiv(lhs, rhs, "");
}
- fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6854,7 +6854,7 @@ pub const FuncGen = struct {
return self.builder.buildUDiv(lhs, rhs, "");
}
- fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6869,7 +6869,7 @@ pub const FuncGen = struct {
return self.builder.buildExactUDiv(lhs, rhs, "");
}
- fn airRem(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airRem(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6884,7 +6884,7 @@ pub const FuncGen = struct {
return self.builder.buildURem(lhs, rhs, "");
}
- fn airMod(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airMod(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -6914,7 +6914,7 @@ pub const FuncGen = struct {
return self.builder.buildURem(lhs, rhs, "");
}
- fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -6925,17 +6925,17 @@ pub const FuncGen = struct {
const llvm_elem_ty = try self.dg.lowerPtrElemTy(ptr_ty.childType());
if (ptr_ty.ptrSize() == .One) {
// It's a pointer to an array, so according to LLVM we need an extra GEP index.
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
self.context.intType(32).constNull(), offset,
};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
} else {
- const indices: [1]*const llvm.Value = .{offset};
+ const indices: [1]*llvm.Value = .{offset};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
}
}
- fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -6947,12 +6947,12 @@ pub const FuncGen = struct {
const llvm_elem_ty = try self.dg.lowerPtrElemTy(ptr_ty.childType());
if (ptr_ty.ptrSize() == .One) {
// It's a pointer to an array, so according to LLVM we need an extra GEP index.
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
self.context.intType(32).constNull(), negative_offset,
};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
} else {
- const indices: [1]*const llvm.Value = .{negative_offset};
+ const indices: [1]*llvm.Value = .{negative_offset};
return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
}
}
@@ -6962,7 +6962,7 @@ pub const FuncGen = struct {
inst: Air.Inst.Index,
signed_intrinsic: []const u8,
unsigned_intrinsic: []const u8,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -6984,7 +6984,7 @@ pub const FuncGen = struct {
const tg = self.dg.module.getTarget();
const llvm_fn = self.getIntrinsic(intrinsic_name, &.{llvm_lhs_ty});
- const result_struct = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &[_]*const llvm.Value{ lhs, rhs }, 2, .Fast, .Auto, "");
+ const result_struct = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &[_]*llvm.Value{ lhs, rhs }, 2, .Fast, .Auto, "");
const result = self.builder.buildExtractValue(result_struct, 0, "");
const overflow_bit = self.builder.buildExtractValue(result_struct, 1, "");
@@ -7018,11 +7018,11 @@ pub const FuncGen = struct {
fn buildElementwiseCall(
self: *FuncGen,
- llvm_fn: *const llvm.Value,
- args_vectors: []const *const llvm.Value,
- result_vector: *const llvm.Value,
+ llvm_fn: *llvm.Value,
+ args_vectors: []const *llvm.Value,
+ result_vector: *llvm.Value,
vector_len: usize,
- ) !*const llvm.Value {
+ ) !*llvm.Value {
const args_len = @intCast(c_uint, args_vectors.len);
const llvm_i32 = self.context.intType(32);
assert(args_len <= 3);
@@ -7032,7 +7032,7 @@ pub const FuncGen = struct {
while (i < vector_len) : (i += 1) {
const index_i32 = llvm_i32.constInt(i, .False);
- var args: [3]*const llvm.Value = undefined;
+ var args: [3]*llvm.Value = undefined;
for (args_vectors) |arg_vector, k| {
args[k] = self.builder.buildExtractElement(arg_vector, index_i32, "");
}
@@ -7045,9 +7045,9 @@ pub const FuncGen = struct {
fn getLibcFunction(
self: *FuncGen,
fn_name: [:0]const u8,
- param_types: []const *const llvm.Type,
- return_type: *const llvm.Type,
- ) *const llvm.Value {
+ param_types: []const *llvm.Type,
+ return_type: *llvm.Type,
+ ) *llvm.Value {
return self.dg.object.llvm_module.getNamedFunction(fn_name.ptr) orelse b: {
const alias = self.dg.object.llvm_module.getNamedGlobalAlias(fn_name.ptr, fn_name.len);
break :b if (alias) |a| a.getAliasee() else null;
@@ -7105,8 +7105,8 @@ pub const FuncGen = struct {
self: *FuncGen,
pred: math.CompareOperator,
ty: Type,
- params: [2]*const llvm.Value,
- ) !*const llvm.Value {
+ params: [2]*llvm.Value,
+ ) !*llvm.Value {
const target = self.dg.module.getTarget();
const scalar_ty = ty.scalarType();
const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
@@ -7138,7 +7138,7 @@ pub const FuncGen = struct {
fn_base_name, compiler_rt_float_abbrev,
}) catch unreachable;
- const param_types = [2]*const llvm.Type{ scalar_llvm_ty, scalar_llvm_ty };
+ const param_types = [2]*llvm.Type{ scalar_llvm_ty, scalar_llvm_ty };
const llvm_i32 = self.context.intType(32);
const libc_fn = self.getLibcFunction(fn_name, param_types[0..], llvm_i32);
@@ -7206,8 +7206,8 @@ pub const FuncGen = struct {
comptime op: FloatOp,
ty: Type,
comptime params_len: usize,
- params: [params_len]*const llvm.Value,
- ) !*const llvm.Value {
+ params: [params_len]*llvm.Value,
+ ) !*llvm.Value {
const target = self.dg.module.getTarget();
const scalar_ty = ty.scalarType();
const llvm_ty = try self.dg.lowerType(ty);
@@ -7278,10 +7278,10 @@ pub const FuncGen = struct {
};
};
- const llvm_fn: *const llvm.Value = switch (strat) {
+ const llvm_fn: *llvm.Value = switch (strat) {
.intrinsic => |fn_name| self.getIntrinsic(fn_name, &.{llvm_ty}),
.libc => |fn_name| b: {
- const param_types = [3]*const llvm.Type{ scalar_llvm_ty, scalar_llvm_ty, scalar_llvm_ty };
+ const param_types = [3]*llvm.Type{ scalar_llvm_ty, scalar_llvm_ty, scalar_llvm_ty };
const libc_fn = self.getLibcFunction(fn_name, param_types[0..params.len], scalar_llvm_ty);
if (ty.zigTypeTag() == .Vector) {
const result = llvm_ty.getUndef();
@@ -7294,7 +7294,7 @@ pub const FuncGen = struct {
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, ¶ms, params_len, .C, .Auto, "");
}
- fn airMulAdd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMulAdd(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
@@ -7308,7 +7308,7 @@ pub const FuncGen = struct {
return self.buildFloatOp(.fma, ty, 3, .{ mulend1, mulend2, addend });
}
- fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7368,7 +7368,7 @@ pub const FuncGen = struct {
return self.builder.buildInsertValue(partial, overflow_bit, overflow_index, "");
}
- fn airAnd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAnd(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7377,7 +7377,7 @@ pub const FuncGen = struct {
return self.builder.buildAnd(lhs, rhs, "");
}
- fn airOr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airOr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7386,7 +7386,7 @@ pub const FuncGen = struct {
return self.builder.buildOr(lhs, rhs, "");
}
- fn airXor(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airXor(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7395,7 +7395,7 @@ pub const FuncGen = struct {
return self.builder.buildXor(lhs, rhs, "");
}
- fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7418,7 +7418,7 @@ pub const FuncGen = struct {
return self.builder.buildNUWShl(lhs, casted_rhs, "");
}
- fn airShl(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airShl(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7440,7 +7440,7 @@ pub const FuncGen = struct {
return self.builder.buildShl(lhs, casted_rhs, "");
}
- fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7485,7 +7485,7 @@ pub const FuncGen = struct {
}
}
- fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) !?*const llvm.Value {
+ fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -7521,7 +7521,7 @@ pub const FuncGen = struct {
}
}
- fn airIntCast(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airIntCast(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7546,7 +7546,7 @@ pub const FuncGen = struct {
}
}
- fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -7555,7 +7555,7 @@ pub const FuncGen = struct {
return self.builder.buildTrunc(operand, dest_llvm_ty, "");
}
- fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7573,7 +7573,7 @@ pub const FuncGen = struct {
return self.builder.buildFPTrunc(operand, dest_llvm_ty, "");
}
- fn airFpext(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airFpext(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7591,7 +7591,7 @@ pub const FuncGen = struct {
return self.builder.buildFPExt(operand, dest_llvm_ty, "");
}
- fn airPtrToInt(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPtrToInt(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7601,7 +7601,7 @@ pub const FuncGen = struct {
return self.builder.buildPtrToInt(operand, dest_llvm_ty, "");
}
- fn airBitCast(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airBitCast(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -7645,7 +7645,7 @@ pub const FuncGen = struct {
while (i < vector_len) : (i += 1) {
const index_usize = llvm_usize.constInt(i, .False);
const index_u32 = llvm_u32.constInt(i, .False);
- const indexes: [2]*const llvm.Value = .{ zero, index_usize };
+ const indexes: [2]*llvm.Value = .{ zero, index_usize };
const elem_ptr = self.builder.buildInBoundsGEP(llvm_dest_ty, array_ptr, &indexes, indexes.len, "");
const elem = self.builder.buildExtractElement(operand, index_u32, "");
_ = self.builder.buildStore(elem, elem_ptr);
@@ -7682,7 +7682,7 @@ pub const FuncGen = struct {
while (i < vector_len) : (i += 1) {
const index_usize = llvm_usize.constInt(i, .False);
const index_u32 = llvm_u32.constInt(i, .False);
- const indexes: [2]*const llvm.Value = .{ zero, index_usize };
+ const indexes: [2]*llvm.Value = .{ zero, index_usize };
const elem_ptr = self.builder.buildInBoundsGEP(array_llvm_ty, operand, &indexes, indexes.len, "");
const elem = self.builder.buildLoad(elem_llvm_ty, elem_ptr, "");
vector = self.builder.buildInsertElement(vector, elem, index_u32, "");
@@ -7731,7 +7731,7 @@ pub const FuncGen = struct {
return self.builder.buildBitCast(operand, llvm_dest_ty, "");
}
- fn airBoolToInt(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airBoolToInt(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst))
return null;
@@ -7740,7 +7740,7 @@ pub const FuncGen = struct {
return operand;
}
- fn airArg(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airArg(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const arg_val = self.args[self.arg_index];
self.arg_index += 1;
@@ -7787,7 +7787,7 @@ pub const FuncGen = struct {
} else unreachable;
}
- fn airAlloc(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAlloc(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ptr_ty = self.air.typeOfIndex(inst);
const pointee_type = ptr_ty.childType();
@@ -7801,7 +7801,7 @@ pub const FuncGen = struct {
return alloca_inst;
}
- fn airRetPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airRetPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ptr_ty = self.air.typeOfIndex(inst);
const ret_ty = ptr_ty.childType();
@@ -7816,11 +7816,11 @@ pub const FuncGen = struct {
/// Use this instead of builder.buildAlloca, because this function makes sure to
/// put the alloca instruction at the top of the function!
- fn buildAlloca(self: *FuncGen, llvm_ty: *const llvm.Type) *const llvm.Value {
+ fn buildAlloca(self: *FuncGen, llvm_ty: *llvm.Type) *llvm.Value {
return buildAllocaInner(self.builder, self.llvm_func, self.di_scope != null, llvm_ty);
}
- fn airStore(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airStore(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const dest_ptr = try self.resolveInst(bin_op.lhs);
const ptr_ty = self.air.typeOf(bin_op.lhs);
@@ -7873,7 +7873,7 @@ pub const FuncGen = struct {
inst: Air.Inst.Index,
body: []const Air.Inst.Index,
body_i: usize,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const ptr_ty = self.air.typeOf(ty_op.operand);
elide: {
@@ -7899,14 +7899,14 @@ pub const FuncGen = struct {
return self.load(ptr, ptr_ty);
}
- fn airBreakpoint(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airBreakpoint(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
_ = inst;
const llvm_fn = self.getIntrinsic("llvm.debugtrap", &.{});
_ = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, undefined, 0, .C, .Auto, "");
return null;
}
- fn airRetAddr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airRetAddr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const llvm_usize = try self.dg.lowerType(Type.usize);
@@ -7918,30 +7918,30 @@ pub const FuncGen = struct {
const llvm_i32 = self.context.intType(32);
const llvm_fn = self.getIntrinsic("llvm.returnaddress", &.{});
- const params = [_]*const llvm.Value{llvm_i32.constNull()};
+ const params = [_]*llvm.Value{llvm_i32.constNull()};
const ptr_val = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
}
- fn airFrameAddress(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airFrameAddress(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const llvm_i32 = self.context.intType(32);
const llvm_fn_name = "llvm.frameaddress.p0";
const llvm_fn = self.dg.object.llvm_module.getNamedFunction(llvm_fn_name) orelse blk: {
const llvm_p0i8 = self.context.intType(8).pointerType(0);
- const param_types = [_]*const llvm.Type{llvm_i32};
+ const param_types = [_]*llvm.Type{llvm_i32};
const fn_type = llvm.functionType(llvm_p0i8, ¶m_types, param_types.len, .False);
break :blk self.dg.object.llvm_module.addFunction(llvm_fn_name, fn_type);
};
- const params = [_]*const llvm.Value{llvm_i32.constNull()};
+ const params = [_]*llvm.Value{llvm_i32.constNull()};
const ptr_val = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
const llvm_usize = try self.dg.lowerType(Type.usize);
return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
}
- fn airFence(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airFence(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const atomic_order = self.air.instructions.items(.data)[inst].fence;
const llvm_memory_order = toLlvmAtomicOrdering(atomic_order);
const single_threaded = llvm.Bool.fromBool(self.single_threaded);
@@ -7949,7 +7949,7 @@ pub const FuncGen = struct {
return null;
}
- fn airCmpxchg(self: *FuncGen, inst: Air.Inst.Index, is_weak: bool) !?*const llvm.Value {
+ fn airCmpxchg(self: *FuncGen, inst: Air.Inst.Index, is_weak: bool) !?*llvm.Value {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
var ptr = try self.resolveInst(extra.ptr);
@@ -7996,7 +7996,7 @@ pub const FuncGen = struct {
return buildOptional(self, optional_ty, payload, non_null_bit);
}
- fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;
const ptr = try self.resolveInst(pl_op.operand);
@@ -8053,7 +8053,7 @@ pub const FuncGen = struct {
return self.builder.buildIntToPtr(uncasted_result, operand_llvm_ty, "");
}
- fn airAtomicLoad(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAtomicLoad(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const atomic_load = self.air.instructions.items(.data)[inst].atomic_load;
const ptr = try self.resolveInst(atomic_load.ptr);
const ptr_ty = self.air.typeOf(atomic_load.ptr);
@@ -8090,7 +8090,7 @@ pub const FuncGen = struct {
self: *FuncGen,
inst: Air.Inst.Index,
ordering: llvm.AtomicOrdering,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const ptr_ty = self.air.typeOf(bin_op.lhs);
const operand_ty = ptr_ty.childType();
@@ -8112,7 +8112,7 @@ pub const FuncGen = struct {
return null;
}
- fn airMemset(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMemset(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const dest_ptr = try self.resolveInst(pl_op.operand);
@@ -8134,7 +8134,7 @@ pub const FuncGen = struct {
return null;
}
- fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const dest_ptr = try self.resolveInst(pl_op.operand);
@@ -8158,7 +8158,7 @@ pub const FuncGen = struct {
return null;
}
- fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const un_ty = self.air.typeOf(bin_op.lhs).childType();
const target = self.dg.module.getTarget();
@@ -8179,7 +8179,7 @@ pub const FuncGen = struct {
return null;
}
- fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -8205,7 +8205,7 @@ pub const FuncGen = struct {
}
}
- fn airUnaryOp(self: *FuncGen, inst: Air.Inst.Index, comptime op: FloatOp) !?*const llvm.Value {
+ fn airUnaryOp(self: *FuncGen, inst: Air.Inst.Index, comptime op: FloatOp) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -8215,7 +8215,7 @@ pub const FuncGen = struct {
return self.buildFloatOp(op, operand_ty, 1, .{operand});
}
- fn airNeg(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airNeg(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -8226,7 +8226,7 @@ pub const FuncGen = struct {
return self.buildFloatOp(.neg, operand_ty, 1, .{operand});
}
- fn airClzCtz(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*const llvm.Value {
+ fn airClzCtz(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -8237,7 +8237,7 @@ pub const FuncGen = struct {
const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const fn_val = self.getIntrinsic(llvm_fn_name, &.{operand_llvm_ty});
- const params = [_]*const llvm.Value{ operand, llvm_i1.constNull() };
+ const params = [_]*llvm.Value{ operand, llvm_i1.constNull() };
const wrong_size_result = self.builder.buildCall(fn_val.globalGetValueType(), fn_val, ¶ms, params.len, .C, .Auto, "");
const result_ty = self.air.typeOfIndex(inst);
const result_llvm_ty = try self.dg.lowerType(result_ty);
@@ -8254,14 +8254,14 @@ pub const FuncGen = struct {
}
}
- fn airBitOp(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*const llvm.Value {
+ fn airBitOp(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand_ty = self.air.typeOf(ty_op.operand);
const operand = try self.resolveInst(ty_op.operand);
- const params = [_]*const llvm.Value{operand};
+ const params = [_]*llvm.Value{operand};
const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const fn_val = self.getIntrinsic(llvm_fn_name, &.{operand_llvm_ty});
@@ -8281,7 +8281,7 @@ pub const FuncGen = struct {
}
}
- fn airByteSwap(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*const llvm.Value {
+ fn airByteSwap(self: *FuncGen, inst: Air.Inst.Index, llvm_fn_name: []const u8) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const target = self.dg.module.getTarget();
@@ -8301,7 +8301,7 @@ pub const FuncGen = struct {
const vec_len = operand_ty.vectorLen();
operand_llvm_ty = scalar_llvm_ty.vectorType(vec_len);
- const shifts = try self.gpa.alloc(*const llvm.Value, vec_len);
+ const shifts = try self.gpa.alloc(*llvm.Value, vec_len);
defer self.gpa.free(shifts);
for (shifts) |*elem| {
@@ -8319,7 +8319,7 @@ pub const FuncGen = struct {
bits = bits + 8;
}
- const params = [_]*const llvm.Value{operand};
+ const params = [_]*llvm.Value{operand};
const fn_val = self.getIntrinsic(llvm_fn_name, &.{operand_llvm_ty});
const wrong_size_result = self.builder.buildCall(fn_val.globalGetValueType(), fn_val, ¶ms, params.len, .C, .Auto, "");
@@ -8336,7 +8336,7 @@ pub const FuncGen = struct {
}
}
- fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -8372,10 +8372,10 @@ pub const FuncGen = struct {
self.builder.positionBuilderAtEnd(end_block);
const llvm_type = self.dg.context.intType(1);
- const incoming_values: [2]*const llvm.Value = .{
+ const incoming_values: [2]*llvm.Value = .{
llvm_type.constInt(1, .False), llvm_type.constInt(0, .False),
};
- const incoming_blocks: [2]*const llvm.BasicBlock = .{
+ const incoming_blocks: [2]*llvm.BasicBlock = .{
valid_block, invalid_block,
};
const phi_node = self.builder.buildPhi(llvm_type, "");
@@ -8383,7 +8383,7 @@ pub const FuncGen = struct {
return phi_node;
}
- fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -8391,11 +8391,11 @@ pub const FuncGen = struct {
const enum_ty = self.air.typeOf(un_op);
const llvm_fn = try self.getIsNamedEnumValueFunction(enum_ty);
- const params = [_]*const llvm.Value{operand};
+ const params = [_]*llvm.Value{operand};
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
}
- fn getIsNamedEnumValueFunction(self: *FuncGen, enum_ty: Type) !*const llvm.Value {
+ fn getIsNamedEnumValueFunction(self: *FuncGen, enum_ty: Type) !*llvm.Value {
const enum_decl = enum_ty.getOwnerDecl();
// TODO: detect when the type changes and re-emit this function.
@@ -8414,7 +8414,7 @@ pub const FuncGen = struct {
var int_tag_type_buffer: Type.Payload.Bits = undefined;
const int_tag_ty = enum_ty.intTagType(&int_tag_type_buffer);
- const param_types = [_]*const llvm.Type{try self.dg.lowerType(int_tag_ty)};
+ const param_types = [_]*llvm.Type{try self.dg.lowerType(int_tag_ty)};
const llvm_ret_ty = try self.dg.lowerType(Type.bool);
const fn_type = llvm.functionType(llvm_ret_ty, ¶m_types, param_types.len, .False);
@@ -8464,7 +8464,7 @@ pub const FuncGen = struct {
return fn_val;
}
- fn airTagName(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airTagName(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -8472,11 +8472,11 @@ pub const FuncGen = struct {
const enum_ty = self.air.typeOf(un_op);
const llvm_fn = try self.getEnumTagNameFunction(enum_ty);
- const params = [_]*const llvm.Value{operand};
+ const params = [_]*llvm.Value{operand};
return self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
}
- fn getEnumTagNameFunction(self: *FuncGen, enum_ty: Type) !*const llvm.Value {
+ fn getEnumTagNameFunction(self: *FuncGen, enum_ty: Type) !*llvm.Value {
const enum_decl = enum_ty.getOwnerDecl();
// TODO: detect when the type changes and re-emit this function.
@@ -8501,7 +8501,7 @@ pub const FuncGen = struct {
var int_tag_type_buffer: Type.Payload.Bits = undefined;
const int_tag_ty = enum_ty.intTagType(&int_tag_type_buffer);
- const param_types = [_]*const llvm.Type{try self.dg.lowerType(int_tag_ty)};
+ const param_types = [_]*llvm.Type{try self.dg.lowerType(int_tag_ty)};
const fn_type = llvm.functionType(llvm_ret_ty, ¶m_types, param_types.len, .False);
const fn_val = self.dg.object.llvm_module.addFunction(llvm_fn_name, fn_type);
@@ -8528,7 +8528,7 @@ pub const FuncGen = struct {
const tag_int_value = fn_val.getParam(0);
const switch_instr = self.builder.buildSwitch(tag_int_value, bad_value_block, @intCast(c_uint, fields.count()));
- const array_ptr_indices = [_]*const llvm.Value{
+ const array_ptr_indices = [_]*llvm.Value{
usize_llvm_ty.constNull(), usize_llvm_ty.constNull(),
};
@@ -8542,7 +8542,7 @@ pub const FuncGen = struct {
str_global.setUnnamedAddr(.True);
str_global.setAlignment(1);
- const slice_fields = [_]*const llvm.Value{
+ const slice_fields = [_]*llvm.Value{
str_init_llvm_ty.constInBoundsGEP(str_global, &array_ptr_indices, array_ptr_indices.len),
usize_llvm_ty.constInt(name.len, .False),
};
@@ -8578,7 +8578,7 @@ pub const FuncGen = struct {
return fn_val;
}
- fn getCmpLtErrorsLenFunction(self: *FuncGen) !*const llvm.Value {
+ fn getCmpLtErrorsLenFunction(self: *FuncGen) !*llvm.Value {
if (self.dg.object.llvm_module.getNamedFunction(lt_errors_fn_name)) |llvm_fn| {
return llvm_fn;
}
@@ -8587,7 +8587,7 @@ pub const FuncGen = struct {
const ret_llvm_ty = try self.dg.lowerType(Type.bool);
const anyerror_llvm_ty = try self.dg.lowerType(Type.anyerror);
- const param_types = [_]*const llvm.Type{anyerror_llvm_ty};
+ const param_types = [_]*llvm.Type{anyerror_llvm_ty};
const fn_type = llvm.functionType(ret_llvm_ty, ¶m_types, param_types.len, .False);
const llvm_fn = self.dg.object.llvm_module.addFunction(lt_errors_fn_name, fn_type);
@@ -8597,7 +8597,7 @@ pub const FuncGen = struct {
return llvm_fn;
}
- fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
@@ -8608,12 +8608,12 @@ pub const FuncGen = struct {
const error_name_table_ptr = try self.getErrorNameTable();
const ptr_slice_llvm_ty = slice_llvm_ty.pointerType(0);
const error_name_table = self.builder.buildLoad(ptr_slice_llvm_ty, error_name_table_ptr, "");
- const indices = [_]*const llvm.Value{operand};
+ const indices = [_]*llvm.Value{operand};
const error_name_ptr = self.builder.buildInBoundsGEP(slice_llvm_ty, error_name_table, &indices, indices.len, "");
return self.builder.buildLoad(slice_llvm_ty, error_name_ptr, "");
}
- fn airSplat(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSplat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
@@ -8623,7 +8623,7 @@ pub const FuncGen = struct {
return self.builder.buildVectorSplat(len, scalar, "");
}
- fn airSelect(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airSelect(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
@@ -8635,7 +8635,7 @@ pub const FuncGen = struct {
return self.builder.buildSelect(pred, a, b, "");
}
- fn airShuffle(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airShuffle(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -8651,7 +8651,7 @@ pub const FuncGen = struct {
// when changing code, so Zig uses negative numbers to index the
// second vector. These start at -1 and go down, and are easiest to use
// with the ~ operator. Here we convert between the two formats.
- const values = try self.gpa.alloc(*const llvm.Value, mask_len);
+ const values = try self.gpa.alloc(*llvm.Value, mask_len);
defer self.gpa.free(values);
const llvm_i32 = self.context.intType(32);
@@ -8672,7 +8672,7 @@ pub const FuncGen = struct {
return self.builder.buildShuffleVector(a, b, llvm_mask_value, "");
}
- fn airReduce(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*const llvm.Value {
+ fn airReduce(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
self.builder.setFastMath(want_fast_math);
@@ -8717,7 +8717,7 @@ pub const FuncGen = struct {
}
}
- fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -8746,7 +8746,7 @@ pub const FuncGen = struct {
const int_llvm_ty = self.dg.context.intType(@intCast(c_uint, big_bits));
const fields = struct_obj.fields.values();
comptime assert(Type.packed_struct_layout_version == 2);
- var running_int: *const llvm.Value = int_llvm_ty.constNull();
+ var running_int: *llvm.Value = int_llvm_ty.constNull();
var running_bits: u16 = 0;
for (elements) |elem, i| {
const field = fields[i];
@@ -8780,7 +8780,7 @@ pub const FuncGen = struct {
// even if we fully populate the fields.
alloca_inst.setAlignment(result_ty.abiAlignment(target));
- var indices: [2]*const llvm.Value = .{ llvm_u32.constNull(), undefined };
+ var indices: [2]*llvm.Value = .{ llvm_u32.constNull(), undefined };
for (elements) |elem, i| {
if (result_ty.structFieldValueComptime(i) != null) continue;
@@ -8829,7 +8829,7 @@ pub const FuncGen = struct {
const elem_ptr_ty = Type.initPayload(&elem_ptr_payload.base);
for (elements) |elem, i| {
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_usize.constNull(),
llvm_usize.constInt(@intCast(c_uint, i), .False),
};
@@ -8838,7 +8838,7 @@ pub const FuncGen = struct {
self.store(elem_ptr, elem_ptr_ty, llvm_elem, .NotAtomic);
}
if (array_info.sentinel) |sent_val| {
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
llvm_usize.constNull(),
llvm_usize.constInt(@intCast(c_uint, array_info.len), .False),
};
@@ -8857,7 +8857,7 @@ pub const FuncGen = struct {
}
}
- fn airUnionInit(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airUnionInit(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
@@ -8910,17 +8910,17 @@ pub const FuncGen = struct {
break :p field_llvm_ty;
}
const padding_len = @intCast(c_uint, layout.payload_size - field_size);
- const fields: [2]*const llvm.Type = .{
+ const fields: [2]*llvm.Type = .{
field_llvm_ty, self.context.intType(8).arrayType(padding_len),
};
break :p self.context.structType(&fields, fields.len, .False);
};
if (layout.tag_size == 0) {
- const fields: [1]*const llvm.Type = .{payload};
+ const fields: [1]*llvm.Type = .{payload};
break :t self.context.structType(&fields, fields.len, .False);
}
const tag_llvm_ty = try self.dg.lowerType(union_obj.tag_ty);
- var fields: [3]*const llvm.Type = undefined;
+ var fields: [3]*llvm.Type = undefined;
var fields_len: c_uint = 2;
if (layout.tag_align >= layout.payload_align) {
fields = .{ tag_llvm_ty, payload, undefined };
@@ -8949,7 +8949,7 @@ pub const FuncGen = struct {
};
const field_ptr_ty = Type.initPayload(&field_ptr_payload.base);
if (layout.tag_size == 0) {
- const indices: [3]*const llvm.Value = .{
+ const indices: [3]*llvm.Value = .{
index_type.constNull(),
index_type.constNull(),
index_type.constNull(),
@@ -8961,7 +8961,7 @@ pub const FuncGen = struct {
}
{
- const indices: [3]*const llvm.Value = .{
+ const indices: [3]*llvm.Value = .{
index_type.constNull(),
index_type.constInt(@boolToInt(layout.tag_align >= layout.payload_align), .False),
index_type.constNull(),
@@ -8971,7 +8971,7 @@ pub const FuncGen = struct {
self.store(field_ptr, field_ptr_ty, llvm_payload, .NotAtomic);
}
{
- const indices: [2]*const llvm.Value = .{
+ const indices: [2]*llvm.Value = .{
index_type.constNull(),
index_type.constInt(@boolToInt(layout.tag_align < layout.payload_align), .False),
};
@@ -8985,7 +8985,7 @@ pub const FuncGen = struct {
return result_ptr;
}
- fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+ fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
const prefetch = self.air.instructions.items(.data)[inst].prefetch;
comptime assert(@enumToInt(std.builtin.PrefetchOptions.Rw.read) == 0);
@@ -9026,7 +9026,7 @@ pub const FuncGen = struct {
const fn_val = self.dg.object.llvm_module.getNamedFunction(llvm_fn_name) orelse blk: {
// declare void @llvm.prefetch(i8*, i32, i32, i32)
const llvm_void = self.context.voidType();
- const param_types = [_]*const llvm.Type{
+ const param_types = [_]*llvm.Type{
llvm_ptr_u8, llvm_u32, llvm_u32, llvm_u32,
};
const fn_type = llvm.functionType(llvm_void, ¶m_types, param_types.len, .False);
@@ -9036,7 +9036,7 @@ pub const FuncGen = struct {
const ptr = try self.resolveInst(prefetch.ptr);
const ptr_u8 = self.builder.buildBitCast(ptr, llvm_ptr_u8, "");
- const params = [_]*const llvm.Value{
+ const params = [_]*llvm.Value{
ptr_u8,
llvm_u32.constInt(@enumToInt(prefetch.rw), .False),
llvm_u32.constInt(prefetch.locality, .False),
@@ -9048,17 +9048,17 @@ pub const FuncGen = struct {
fn softF80TruncOrExt(
self: *FuncGen,
- operand: *const llvm.Value,
+ operand: *llvm.Value,
src_bits: u16,
dest_bits: u16,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
const target = self.dg.module.getTarget();
- var param_llvm_ty: *const llvm.Type = self.context.intType(80);
- var ret_llvm_ty: *const llvm.Type = param_llvm_ty;
+ var param_llvm_ty: *llvm.Type = self.context.intType(80);
+ var ret_llvm_ty: *llvm.Type = param_llvm_ty;
var fn_name: [*:0]const u8 = undefined;
var arg = operand;
- var final_cast: ?*const llvm.Type = null;
+ var final_cast: ?*llvm.Type = null;
assert(src_bits == 80 or dest_bits == 80);
@@ -9116,18 +9116,18 @@ pub const FuncGen = struct {
}
const llvm_fn = self.dg.object.llvm_module.getNamedFunction(fn_name) orelse f: {
- const param_types = [_]*const llvm.Type{param_llvm_ty};
+ const param_types = [_]*llvm.Type{param_llvm_ty};
const fn_type = llvm.functionType(ret_llvm_ty, ¶m_types, param_types.len, .False);
break :f self.dg.object.llvm_module.addFunction(fn_name, fn_type);
};
- var args: [1]*const llvm.Value = .{arg};
+ var args: [1]*llvm.Value = .{arg};
const result = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &args, args.len, .C, .Auto, "");
const final_cast_llvm_ty = final_cast orelse return result;
return self.builder.buildBitCast(result, final_cast_llvm_ty, "");
}
- fn getErrorNameTable(self: *FuncGen) !*const llvm.Value {
+ fn getErrorNameTable(self: *FuncGen) !*llvm.Value {
if (self.dg.object.error_name_table) |table| {
return table;
}
@@ -9151,10 +9151,10 @@ pub const FuncGen = struct {
/// Assumes the optional is not pointer-like and payload has bits.
fn optIsNonNull(
self: *FuncGen,
- opt_llvm_ty: *const llvm.Type,
- opt_handle: *const llvm.Value,
+ opt_llvm_ty: *llvm.Type,
+ opt_handle: *llvm.Value,
is_by_ref: bool,
- ) *const llvm.Value {
+ ) *llvm.Value {
const non_null_llvm_ty = self.context.intType(8);
const field = b: {
if (is_by_ref) {
@@ -9171,10 +9171,10 @@ pub const FuncGen = struct {
/// Assumes the optional is not pointer-like and payload has bits.
fn optPayloadHandle(
fg: *FuncGen,
- opt_llvm_ty: *const llvm.Type,
- opt_handle: *const llvm.Value,
+ opt_llvm_ty: *llvm.Type,
+ opt_handle: *llvm.Value,
opt_ty: Type,
- ) !*const llvm.Value {
+ ) !*llvm.Value {
var buf: Type.Payload.ElemType = undefined;
const payload_ty = opt_ty.optionalChild(&buf);
@@ -9200,9 +9200,9 @@ pub const FuncGen = struct {
fn buildOptional(
self: *FuncGen,
optional_ty: Type,
- payload: *const llvm.Value,
- non_null_bit: *const llvm.Value,
- ) !?*const llvm.Value {
+ payload: *llvm.Value,
+ non_null_bit: *llvm.Value,
+ ) !?*llvm.Value {
const optional_llvm_ty = try self.dg.lowerType(optional_ty);
const non_null_field = self.builder.buildZExt(non_null_bit, self.dg.context.intType(8), "");
@@ -9233,10 +9233,10 @@ pub const FuncGen = struct {
fn fieldPtr(
self: *FuncGen,
inst: Air.Inst.Index,
- struct_ptr: *const llvm.Value,
+ struct_ptr: *llvm.Value,
struct_ptr_ty: Type,
field_index: u32,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
if (self.liveness.isUnused(inst)) return null;
const target = self.dg.object.target;
@@ -9268,7 +9268,7 @@ pub const FuncGen = struct {
const ptr_as_bytes = self.builder.buildBitCast(struct_ptr, byte_llvm_ty.pointerType(0), "");
const llvm_usize = try self.dg.lowerType(Type.usize);
const llvm_index = llvm_usize.constInt(byte_offset, .False);
- const indices: [1]*const llvm.Value = .{llvm_index};
+ const indices: [1]*llvm.Value = .{llvm_index};
const new_ptr = self.builder.buildInBoundsGEP(byte_llvm_ty, ptr_as_bytes, &indices, indices.len, "");
return self.builder.buildBitCast(new_ptr, result_llvm_ty, "");
},
@@ -9285,7 +9285,7 @@ pub const FuncGen = struct {
// the struct.
const llvm_usize = try self.dg.lowerType(Type.usize);
const llvm_index = llvm_usize.constInt(1, .False);
- const indices: [1]*const llvm.Value = .{llvm_index};
+ const indices: [1]*llvm.Value = .{llvm_index};
return self.builder.buildInBoundsGEP(struct_llvm_ty, struct_ptr, &indices, indices.len, "");
}
},
@@ -9298,9 +9298,9 @@ pub const FuncGen = struct {
fn unionFieldPtr(
self: *FuncGen,
inst: Air.Inst.Index,
- union_ptr: *const llvm.Value,
+ union_ptr: *llvm.Value,
union_ty: Type,
- ) !?*const llvm.Value {
+ ) !?*llvm.Value {
const target = self.dg.module.getTarget();
const layout = union_ty.unionGetLayout(target);
const result_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
@@ -9313,7 +9313,7 @@ pub const FuncGen = struct {
return self.builder.buildBitCast(union_field_ptr, result_llvm_ty, "");
}
- fn getIntrinsic(self: *FuncGen, name: []const u8, types: []const *const llvm.Type) *const llvm.Value {
+ fn getIntrinsic(self: *FuncGen, name: []const u8, types: []const *llvm.Type) *llvm.Value {
const id = llvm.lookupIntrinsicID(name.ptr, name.len);
assert(id != 0);
return self.llvmModule().getIntrinsicDeclaration(id, types.ptr, types.len);
@@ -9322,7 +9322,7 @@ pub const FuncGen = struct {
/// This function always performs a copy. For isByRef=true types, it creates a new
/// alloca and copies the value into it, then returns the alloca instruction.
/// For isByRef=false types, it creates a load instruction and returns it.
- fn load(self: *FuncGen, ptr: *const llvm.Value, ptr_ty: Type) !?*const llvm.Value {
+ fn load(self: *FuncGen, ptr: *llvm.Value, ptr_ty: Type) !?*llvm.Value {
const info = ptr_ty.ptrInfo().data;
if (!info.pointee_type.hasRuntimeBitsIgnoreComptime()) return null;
@@ -9396,9 +9396,9 @@ pub const FuncGen = struct {
fn store(
self: *FuncGen,
- ptr: *const llvm.Value,
+ ptr: *llvm.Value,
ptr_ty: Type,
- elem: *const llvm.Value,
+ elem: *llvm.Value,
ordering: llvm.AtomicOrdering,
) void {
const info = ptr_ty.ptrInfo().data;
@@ -9463,7 +9463,7 @@ pub const FuncGen = struct {
);
}
- fn valgrindMarkUndef(fg: *FuncGen, ptr: *const llvm.Value, len: *const llvm.Value) void {
+ fn valgrindMarkUndef(fg: *FuncGen, ptr: *llvm.Value, len: *llvm.Value) void {
const VG_USERREQ__MAKE_MEM_UNDEFINED = 1296236545;
const target = fg.dg.module.getTarget();
const usize_llvm_ty = fg.context.intType(target.cpu.arch.ptrBitWidth());
@@ -9475,14 +9475,14 @@ pub const FuncGen = struct {
fn valgrindClientRequest(
fg: *FuncGen,
- default_value: *const llvm.Value,
- request: *const llvm.Value,
- a1: *const llvm.Value,
- a2: *const llvm.Value,
- a3: *const llvm.Value,
- a4: *const llvm.Value,
- a5: *const llvm.Value,
- ) *const llvm.Value {
+ default_value: *llvm.Value,
+ request: *llvm.Value,
+ a1: *llvm.Value,
+ a2: *llvm.Value,
+ a3: *llvm.Value,
+ a4: *llvm.Value,
+ a5: *llvm.Value,
+ ) *llvm.Value {
const target = fg.dg.module.getTarget();
if (!target_util.hasValgrindSupport(target)) return default_value;
@@ -9498,10 +9498,10 @@ pub const FuncGen = struct {
fg.valgrind_client_request_array = array_ptr;
break :a array_ptr;
};
- const array_elements = [_]*const llvm.Value{ request, a1, a2, a3, a4, a5 };
+ const array_elements = [_]*llvm.Value{ request, a1, a2, a3, a4, a5 };
const zero = usize_llvm_ty.constInt(0, .False);
for (array_elements) |elem, i| {
- const indexes = [_]*const llvm.Value{
+ const indexes = [_]*llvm.Value{
zero, usize_llvm_ty.constInt(@intCast(c_uint, i), .False),
};
const elem_ptr = fg.builder.buildInBoundsGEP(array_llvm_ty, array_ptr, &indexes, indexes.len, "");
@@ -9518,8 +9518,8 @@ pub const FuncGen = struct {
const asm_constraints = "={rdx},{rax},0,~{cc},~{memory}";
const array_ptr_as_usize = fg.builder.buildPtrToInt(array_ptr, usize_llvm_ty, "");
- const args = [_]*const llvm.Value{ array_ptr_as_usize, default_value };
- const param_types = [_]*const llvm.Type{ usize_llvm_ty, usize_llvm_ty };
+ const args = [_]*llvm.Value{ array_ptr_as_usize, default_value };
+ const param_types = [_]*llvm.Type{ usize_llvm_ty, usize_llvm_ty };
const fn_llvm_ty = llvm.functionType(usize_llvm_ty, ¶m_types, args.len, .False);
const asm_fn = llvm.getInlineAsm(
fn_llvm_ty,
@@ -9898,7 +9898,7 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool
/// In order to support the C calling convention, some return types need to be lowered
/// completely differently in the function prototype to honor the C ABI, and then
/// be effectively bitcasted to the actual return type.
-fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.Type {
+fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
if (!fn_info.return_type.hasRuntimeBitsIgnoreComptime()) {
// If the return type is an error set or an error union, then we make this
// anyerror return type instead, so that it can be coerced into a function
@@ -9945,7 +9945,7 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
if (classes[0] == .memory) {
return dg.context.voidType();
}
- var llvm_types_buffer: [8]*const llvm.Type = undefined;
+ var llvm_types_buffer: [8]*llvm.Type = undefined;
var llvm_types_index: u32 = 0;
for (classes) |class| {
switch (class) {
@@ -10488,11 +10488,11 @@ fn compilerRtIntBits(bits: u16) u16 {
}
fn buildAllocaInner(
- builder: *const llvm.Builder,
- llvm_func: *const llvm.Value,
+ builder: *llvm.Builder,
+ llvm_func: *llvm.Value,
di_scope_non_null: bool,
- llvm_ty: *const llvm.Type,
-) *const llvm.Value {
+ llvm_ty: *llvm.Type,
+) *llvm.Value {
const prev_block = builder.getInsertBlock();
const prev_debug_location = builder.getCurrentDebugLocation2();
defer {