Commit 713a555aa1

@@ -15,7 +15,6 @@ pub const Bool = enum(c_int) {
         return b != .False;
     }
 };
-pub const AttributeIndex = c_uint;
 
 pub const MemoryBuffer = opaque {
     pub const createMemoryBufferWithMemoryRange = LLVMCreateMemoryBufferWithMemoryRange;
@@ -36,382 +35,14 @@ pub const Context = opaque {
     pub const parseBitcodeInContext2 = LLVMParseBitcodeInContext2;
     extern fn LLVMParseBitcodeInContext2(C: *Context, MemBuf: *MemoryBuffer, OutModule: **Module) Bool;
 
-    pub const createEnumAttribute = LLVMCreateEnumAttribute;
-    extern fn LLVMCreateEnumAttribute(C: *Context, KindID: c_uint, Val: u64) *Attribute;
-
-    pub const createTypeAttribute = LLVMCreateTypeAttribute;
-    extern fn LLVMCreateTypeAttribute(C: *Context, KindID: c_uint, Type: *Type) *Attribute;
-
-    pub const createStringAttribute = LLVMCreateStringAttribute;
-    extern fn LLVMCreateStringAttribute(C: *Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *Attribute;
-
-    pub const pointerType = LLVMPointerTypeInContext;
-    extern fn LLVMPointerTypeInContext(C: *Context, AddressSpace: c_uint) *Type;
-
-    pub const intType = LLVMIntTypeInContext;
-    extern fn LLVMIntTypeInContext(C: *Context, NumBits: c_uint) *Type;
-
-    pub const halfType = LLVMHalfTypeInContext;
-    extern fn LLVMHalfTypeInContext(C: *Context) *Type;
-
-    pub const bfloatType = LLVMBFloatTypeInContext;
-    extern fn LLVMBFloatTypeInContext(C: *Context) *Type;
-
-    pub const floatType = LLVMFloatTypeInContext;
-    extern fn LLVMFloatTypeInContext(C: *Context) *Type;
-
-    pub const doubleType = LLVMDoubleTypeInContext;
-    extern fn LLVMDoubleTypeInContext(C: *Context) *Type;
-
-    pub const fp128Type = LLVMFP128TypeInContext;
-    extern fn LLVMFP128TypeInContext(C: *Context) *Type;
-
-    pub const x86_fp80Type = LLVMX86FP80TypeInContext;
-    extern fn LLVMX86FP80TypeInContext(C: *Context) *Type;
-
-    pub const ppc_fp128Type = LLVMPPCFP128TypeInContext;
-    extern fn LLVMPPCFP128TypeInContext(C: *Context) *Type;
-
-    pub const x86_amxType = LLVMX86AMXTypeInContext;
-    extern fn LLVMX86AMXTypeInContext(C: *Context) *Type;
-
-    pub const x86_mmxType = LLVMX86MMXTypeInContext;
-    extern fn LLVMX86MMXTypeInContext(C: *Context) *Type;
-
-    pub const voidType = LLVMVoidTypeInContext;
-    extern fn LLVMVoidTypeInContext(C: *Context) *Type;
-
-    pub const labelType = LLVMLabelTypeInContext;
-    extern fn LLVMLabelTypeInContext(C: *Context) *Type;
-
-    pub const tokenType = LLVMTokenTypeInContext;
-    extern fn LLVMTokenTypeInContext(C: *Context) *Type;
-
-    pub const metadataType = LLVMMetadataTypeInContext;
-    extern fn LLVMMetadataTypeInContext(C: *Context) *Type;
-
-    pub const structType = LLVMStructTypeInContext;
-    extern fn LLVMStructTypeInContext(
-        C: *Context,
-        ElementTypes: [*]const *Type,
-        ElementCount: c_uint,
-        Packed: Bool,
-    ) *Type;
-
-    pub const structCreateNamed = LLVMStructCreateNamed;
-    extern fn LLVMStructCreateNamed(C: *Context, Name: [*:0]const u8) *Type;
-
-    pub const constString = LLVMConstStringInContext;
-    extern fn LLVMConstStringInContext(C: *Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *Value;
-
-    pub const appendBasicBlock = LLVMAppendBasicBlockInContext;
-    extern fn LLVMAppendBasicBlockInContext(C: *Context, Fn: *Value, Name: [*:0]const u8) *BasicBlock;
-
-    pub const createBuilder = LLVMCreateBuilderInContext;
-    extern fn LLVMCreateBuilderInContext(C: *Context) *Builder;
-
     pub const setOptBisectLimit = ZigLLVMSetOptBisectLimit;
     extern fn ZigLLVMSetOptBisectLimit(C: *Context, limit: c_int) void;
 };
 
-pub const Value = opaque {
-    pub const addAttributeAtIndex = LLVMAddAttributeAtIndex;
-    extern fn LLVMAddAttributeAtIndex(F: *Value, Idx: AttributeIndex, A: *Attribute) void;
-
-    pub const removeEnumAttributeAtIndex = LLVMRemoveEnumAttributeAtIndex;
-    extern fn LLVMRemoveEnumAttributeAtIndex(F: *Value, Idx: AttributeIndex, KindID: c_uint) void;
-
-    pub const removeStringAttributeAtIndex = LLVMRemoveStringAttributeAtIndex;
-    extern fn LLVMRemoveStringAttributeAtIndex(F: *Value, Idx: AttributeIndex, K: [*]const u8, KLen: c_uint) void;
-
-    pub const getFirstBasicBlock = LLVMGetFirstBasicBlock;
-    extern fn LLVMGetFirstBasicBlock(Fn: *Value) ?*BasicBlock;
-
-    pub const addIncoming = LLVMAddIncoming;
-    extern fn LLVMAddIncoming(
-        PhiNode: *Value,
-        IncomingValues: [*]const *Value,
-        IncomingBlocks: [*]const *BasicBlock,
-        Count: c_uint,
-    ) void;
-
-    pub const setGlobalConstant = LLVMSetGlobalConstant;
-    extern fn LLVMSetGlobalConstant(GlobalVar: *Value, IsConstant: Bool) void;
-
-    pub const setLinkage = LLVMSetLinkage;
-    extern fn LLVMSetLinkage(Global: *Value, Linkage: Linkage) void;
-
-    pub const setVisibility = LLVMSetVisibility;
-    extern fn LLVMSetVisibility(Global: *Value, Linkage: Visibility) void;
-
-    pub const setUnnamedAddr = LLVMSetUnnamedAddr;
-    extern fn LLVMSetUnnamedAddr(Global: *Value, HasUnnamedAddr: Bool) void;
-
-    pub const setThreadLocalMode = LLVMSetThreadLocalMode;
-    extern fn LLVMSetThreadLocalMode(Global: *Value, Mode: ThreadLocalMode) void;
-
-    pub const setSection = LLVMSetSection;
-    extern fn LLVMSetSection(Global: *Value, Section: [*:0]const u8) void;
-
-    pub const removeGlobalValue = ZigLLVMRemoveGlobalValue;
-    extern fn ZigLLVMRemoveGlobalValue(GlobalVal: *Value) void;
-
-    pub const eraseGlobalValue = ZigLLVMEraseGlobalValue;
-    extern fn ZigLLVMEraseGlobalValue(GlobalVal: *Value) void;
-
-    pub const deleteGlobalValue = ZigLLVMDeleteGlobalValue;
-    extern fn ZigLLVMDeleteGlobalValue(GlobalVal: *Value) void;
-
-    pub const setAliasee = LLVMAliasSetAliasee;
-    extern fn LLVMAliasSetAliasee(Alias: *Value, Aliasee: *Value) void;
-
-    pub const constAdd = LLVMConstAdd;
-    extern fn LLVMConstAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNSWAdd = LLVMConstNSWAdd;
-    extern fn LLVMConstNSWAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNUWAdd = LLVMConstNUWAdd;
-    extern fn LLVMConstNUWAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constSub = LLVMConstSub;
-    extern fn LLVMConstSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNSWSub = LLVMConstNSWSub;
-    extern fn LLVMConstNSWSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNUWSub = LLVMConstNUWSub;
-    extern fn LLVMConstNUWSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constMul = LLVMConstMul;
-    extern fn LLVMConstMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNSWMul = LLVMConstNSWMul;
-    extern fn LLVMConstNSWMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constNUWMul = LLVMConstNUWMul;
-    extern fn LLVMConstNUWMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constAnd = LLVMConstAnd;
-    extern fn LLVMConstAnd(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constOr = LLVMConstOr;
-    extern fn LLVMConstOr(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constXor = LLVMConstXor;
-    extern fn LLVMConstXor(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constShl = LLVMConstShl;
-    extern fn LLVMConstShl(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constLShr = LLVMConstLShr;
-    extern fn LLVMConstLShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constAShr = LLVMConstAShr;
-    extern fn LLVMConstAShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constTrunc = LLVMConstTrunc;
-    extern fn LLVMConstTrunc(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constSExt = LLVMConstSExt;
-    extern fn LLVMConstSExt(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constZExt = LLVMConstZExt;
-    extern fn LLVMConstZExt(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constFPTrunc = LLVMConstFPTrunc;
-    extern fn LLVMConstFPTrunc(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constFPExt = LLVMConstFPExt;
-    extern fn LLVMConstFPExt(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constUIToFP = LLVMConstUIToFP;
-    extern fn LLVMConstUIToFP(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constSIToFP = LLVMConstSIToFP;
-    extern fn LLVMConstSIToFP(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constFPToUI = LLVMConstFPToUI;
-    extern fn LLVMConstFPToUI(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constFPToSI = LLVMConstFPToSI;
-    extern fn LLVMConstFPToSI(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constPtrToInt = LLVMConstPtrToInt;
-    extern fn LLVMConstPtrToInt(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constIntToPtr = LLVMConstIntToPtr;
-    extern fn LLVMConstIntToPtr(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constBitCast = LLVMConstBitCast;
-    extern fn LLVMConstBitCast(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constAddrSpaceCast = LLVMConstAddrSpaceCast;
-    extern fn LLVMConstAddrSpaceCast(ConstantVal: *Value, ToType: *Type) *Value;
-
-    pub const constExtractElement = LLVMConstExtractElement;
-    extern fn LLVMConstExtractElement(VectorConstant: *Value, IndexConstant: *Value) *Value;
-
-    pub const constInsertElement = LLVMConstInsertElement;
-    extern fn LLVMConstInsertElement(
-        VectorConstant: *Value,
-        ElementValueConstant: *Value,
-        IndexConstant: *Value,
-    ) *Value;
-
-    pub const constShuffleVector = LLVMConstShuffleVector;
-    extern fn LLVMConstShuffleVector(
-        VectorAConstant: *Value,
-        VectorBConstant: *Value,
-        MaskConstant: *Value,
-    ) *Value;
-
-    pub const isConstant = LLVMIsConstant;
-    extern fn LLVMIsConstant(Val: *Value) Bool;
-
-    pub const blockAddress = LLVMBlockAddress;
-    extern fn LLVMBlockAddress(F: *Value, BB: *BasicBlock) *Value;
-
-    pub const setWeak = LLVMSetWeak;
-    extern fn LLVMSetWeak(CmpXchgInst: *Value, IsWeak: Bool) void;
-
-    pub const setOrdering = LLVMSetOrdering;
-    extern fn LLVMSetOrdering(MemoryAccessInst: *Value, Ordering: AtomicOrdering) void;
-
-    pub const setVolatile = LLVMSetVolatile;
-    extern fn LLVMSetVolatile(MemoryAccessInst: *Value, IsVolatile: Bool) void;
-
-    pub const setAlignment = LLVMSetAlignment;
-    extern fn LLVMSetAlignment(V: *Value, Bytes: c_uint) void;
-
-    pub const getAlignment = LLVMGetAlignment;
-    extern fn LLVMGetAlignment(V: *Value) c_uint;
-
-    pub const setFunctionCallConv = LLVMSetFunctionCallConv;
-    extern fn LLVMSetFunctionCallConv(Fn: *Value, CC: CallConv) void;
-
-    pub const setInstructionCallConv = LLVMSetInstructionCallConv;
-    extern fn LLVMSetInstructionCallConv(Instr: *Value, CC: CallConv) void;
-
-    pub const setTailCallKind = ZigLLVMSetTailCallKind;
-    extern fn ZigLLVMSetTailCallKind(CallInst: *Value, TailCallKind: TailCallKind) void;
-
-    pub const addCallSiteAttribute = LLVMAddCallSiteAttribute;
-    extern fn LLVMAddCallSiteAttribute(C: *Value, Idx: AttributeIndex, A: *Attribute) void;
-
-    pub const fnSetSubprogram = ZigLLVMFnSetSubprogram;
-    extern fn ZigLLVMFnSetSubprogram(f: *Value, subprogram: *DISubprogram) void;
-
-    pub const setValueName = LLVMSetValueName2;
-    extern fn LLVMSetValueName2(Val: *Value, Name: [*]const u8, NameLen: usize) void;
-
-    pub const takeName = ZigLLVMTakeName;
-    extern fn ZigLLVMTakeName(new_owner: *Value, victim: *Value) void;
-
-    pub const getParam = LLVMGetParam;
-    extern fn LLVMGetParam(Fn: *Value, Index: c_uint) *Value;
-
-    pub const setInitializer = ZigLLVMSetInitializer;
-    extern fn ZigLLVMSetInitializer(GlobalVar: *Value, ConstantVal: ?*Value) void;
-
-    pub const setDLLStorageClass = LLVMSetDLLStorageClass;
-    extern fn LLVMSetDLLStorageClass(Global: *Value, Class: DLLStorageClass) void;
-
-    pub const addCase = LLVMAddCase;
-    extern fn LLVMAddCase(Switch: *Value, OnVal: *Value, Dest: *BasicBlock) void;
-
-    pub const replaceAllUsesWith = LLVMReplaceAllUsesWith;
-    extern fn LLVMReplaceAllUsesWith(OldVal: *Value, NewVal: *Value) void;
-
-    pub const attachMetaData = ZigLLVMAttachMetaData;
-    extern fn ZigLLVMAttachMetaData(GlobalVar: *Value, DIG: *DIGlobalVariableExpression) void;
-
-    pub const dump = LLVMDumpValue;
-    extern fn LLVMDumpValue(Val: *Value) void;
-};
-
-pub const Type = opaque {
-    pub const constNull = LLVMConstNull;
-    extern fn LLVMConstNull(Ty: *Type) *Value;
-
-    pub const constInt = LLVMConstInt;
-    extern fn LLVMConstInt(IntTy: *Type, N: c_ulonglong, SignExtend: Bool) *Value;
-
-    pub const constIntOfArbitraryPrecision = LLVMConstIntOfArbitraryPrecision;
-    extern fn LLVMConstIntOfArbitraryPrecision(IntTy: *Type, NumWords: c_uint, Words: [*]const u64) *Value;
-
-    pub const constReal = LLVMConstReal;
-    extern fn LLVMConstReal(RealTy: *Type, N: f64) *Value;
-
-    pub const constArray2 = LLVMConstArray2;
-    extern fn LLVMConstArray2(ElementTy: *Type, ConstantVals: [*]const *Value, Length: u64) *Value;
-
-    pub const constNamedStruct = LLVMConstNamedStruct;
-    extern fn LLVMConstNamedStruct(
-        StructTy: *Type,
-        ConstantVals: [*]const *Value,
-        Count: c_uint,
-    ) *Value;
-
-    pub const getUndef = LLVMGetUndef;
-    extern fn LLVMGetUndef(Ty: *Type) *Value;
-
-    pub const getPoison = LLVMGetPoison;
-    extern fn LLVMGetPoison(Ty: *Type) *Value;
-
-    pub const arrayType2 = LLVMArrayType2;
-    extern fn LLVMArrayType2(ElementType: *Type, ElementCount: u64) *Type;
-
-    pub const vectorType = LLVMVectorType;
-    extern fn LLVMVectorType(ElementType: *Type, ElementCount: c_uint) *Type;
-
-    pub const scalableVectorType = LLVMScalableVectorType;
-    extern fn LLVMScalableVectorType(ElementType: *Type, ElementCount: c_uint) *Type;
-
-    pub const structSetBody = LLVMStructSetBody;
-    extern fn LLVMStructSetBody(
-        StructTy: *Type,
-        ElementTypes: [*]*Type,
-        ElementCount: c_uint,
-        Packed: Bool,
-    ) void;
-
-    pub const isSized = LLVMTypeIsSized;
-    extern fn LLVMTypeIsSized(Ty: *Type) Bool;
-
-    pub const constGEP = LLVMConstGEP2;
-    extern fn LLVMConstGEP2(
-        Ty: *Type,
-        ConstantVal: *Value,
-        ConstantIndices: [*]const *Value,
-        NumIndices: c_uint,
-    ) *Value;
-
-    pub const constInBoundsGEP = LLVMConstInBoundsGEP2;
-    extern fn LLVMConstInBoundsGEP2(
-        Ty: *Type,
-        ConstantVal: *Value,
-        ConstantIndices: [*]const *Value,
-        NumIndices: c_uint,
-    ) *Value;
-
-    pub const dump = LLVMDumpType;
-    extern fn LLVMDumpType(Ty: *Type) void;
-};
-
 pub const Module = opaque {
-    pub const createWithName = LLVMModuleCreateWithNameInContext;
-    extern fn LLVMModuleCreateWithNameInContext(ModuleID: [*:0]const u8, C: *Context) *Module;
-
     pub const dispose = LLVMDisposeModule;
     extern fn LLVMDisposeModule(*Module) void;
 
-    pub const verify = LLVMVerifyModule;
-    extern fn LLVMVerifyModule(*Module, Action: VerifierFailureAction, OutMessage: *[*:0]const u8) Bool;
-
-    pub const setModuleDataLayout = LLVMSetModuleDataLayout;
-    extern fn LLVMSetModuleDataLayout(*Module, *TargetData) void;
-
     pub const setModulePICLevel = ZigLLVMSetModulePICLevel;
     extern fn ZigLLVMSetModulePICLevel(module: *Module) void;
 
@@ -420,508 +51,11 @@ pub const Module = opaque {
 
     pub const setModuleCodeModel = ZigLLVMSetModuleCodeModel;
     extern fn ZigLLVMSetModuleCodeModel(module: *Module, code_model: CodeModel) void;
-
-    pub const addFunctionInAddressSpace = ZigLLVMAddFunctionInAddressSpace;
-    extern fn ZigLLVMAddFunctionInAddressSpace(*Module, Name: [*:0]const u8, FunctionTy: *Type, AddressSpace: c_uint) *Value;
-
-    pub const printToString = LLVMPrintModuleToString;
-    extern fn LLVMPrintModuleToString(*Module) [*:0]const u8;
-
-    pub const addGlobalInAddressSpace = LLVMAddGlobalInAddressSpace;
-    extern fn LLVMAddGlobalInAddressSpace(M: *Module, Ty: *Type, Name: [*:0]const u8, AddressSpace: c_uint) *Value;
-
-    pub const dump = LLVMDumpModule;
-    extern fn LLVMDumpModule(M: *Module) void;
-
-    pub const addAlias = LLVMAddAlias2;
-    extern fn LLVMAddAlias2(
-        M: *Module,
-        Ty: *Type,
-        AddrSpace: c_uint,
-        Aliasee: *Value,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const setTarget = LLVMSetTarget;
-    extern fn LLVMSetTarget(M: *Module, Triple: [*:0]const u8) void;
-
-    pub const addModuleDebugInfoFlag = ZigLLVMAddModuleDebugInfoFlag;
-    extern fn ZigLLVMAddModuleDebugInfoFlag(module: *Module, dwarf64: bool) void;
-
-    pub const addModuleCodeViewFlag = ZigLLVMAddModuleCodeViewFlag;
-    extern fn ZigLLVMAddModuleCodeViewFlag(module: *Module) void;
-
-    pub const createDIBuilder = ZigLLVMCreateDIBuilder;
-    extern fn ZigLLVMCreateDIBuilder(module: *Module, allow_unresolved: bool) *DIBuilder;
-
-    pub const setModuleInlineAsm = LLVMSetModuleInlineAsm2;
-    extern fn LLVMSetModuleInlineAsm2(M: *Module, Asm: [*]const u8, Len: usize) void;
-
-    pub const printModuleToFile = LLVMPrintModuleToFile;
-    extern fn LLVMPrintModuleToFile(M: *Module, Filename: [*:0]const u8, ErrorMessage: *[*:0]const u8) Bool;
-
-    pub const writeBitcodeToFile = LLVMWriteBitcodeToFile;
-    extern fn LLVMWriteBitcodeToFile(M: *Module, Path: [*:0]const u8) c_int;
 };
 
 pub const disposeMessage = LLVMDisposeMessage;
 extern fn LLVMDisposeMessage(Message: [*:0]const u8) void;
 
-pub const VerifierFailureAction = enum(c_int) {
-    AbortProcess,
-    PrintMessage,
-    ReturnStatus,
-};
-
-pub const constVector = LLVMConstVector;
-extern fn LLVMConstVector(
-    ScalarConstantVals: [*]*Value,
-    Size: c_uint,
-) *Value;
-
-pub const constICmp = LLVMConstICmp;
-extern fn LLVMConstICmp(Predicate: IntPredicate, LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-pub const constFCmp = LLVMConstFCmp;
-extern fn LLVMConstFCmp(Predicate: RealPredicate, LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-pub const getEnumAttributeKindForName = LLVMGetEnumAttributeKindForName;
-extern fn LLVMGetEnumAttributeKindForName(Name: [*]const u8, SLen: usize) c_uint;
-
-pub const getInlineAsm = LLVMGetInlineAsm;
-extern fn LLVMGetInlineAsm(
-    Ty: *Type,
-    AsmString: [*]const u8,
-    AsmStringSize: usize,
-    Constraints: [*]const u8,
-    ConstraintsSize: usize,
-    HasSideEffects: Bool,
-    IsAlignStack: Bool,
-    Dialect: InlineAsmDialect,
-    CanThrow: Bool,
-) *Value;
-
-pub const functionType = LLVMFunctionType;
-extern fn LLVMFunctionType(
-    ReturnType: *Type,
-    ParamTypes: [*]const *Type,
-    ParamCount: c_uint,
-    IsVarArg: Bool,
-) *Type;
-
-pub const InlineAsmDialect = enum(c_uint) { ATT, Intel };
-
-pub const Attribute = opaque {};
-
-pub const Builder = opaque {
-    pub const dispose = LLVMDisposeBuilder;
-    extern fn LLVMDisposeBuilder(Builder: *Builder) void;
-
-    pub const positionBuilder = LLVMPositionBuilder;
-    extern fn LLVMPositionBuilder(
-        Builder: *Builder,
-        Block: *BasicBlock,
-        Instr: ?*Value,
-    ) void;
-
-    pub const buildZExt = LLVMBuildZExt;
-    extern fn LLVMBuildZExt(
-        *Builder,
-        Value: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildSExt = LLVMBuildSExt;
-    extern fn LLVMBuildSExt(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildCall = LLVMBuildCall2;
-    extern fn LLVMBuildCall2(
-        *Builder,
-        *Type,
-        Fn: *Value,
-        Args: [*]const *Value,
-        NumArgs: c_uint,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildRetVoid = LLVMBuildRetVoid;
-    extern fn LLVMBuildRetVoid(*Builder) *Value;
-
-    pub const buildRet = LLVMBuildRet;
-    extern fn LLVMBuildRet(*Builder, V: *Value) *Value;
-
-    pub const buildUnreachable = LLVMBuildUnreachable;
-    extern fn LLVMBuildUnreachable(*Builder) *Value;
-
-    pub const buildAlloca = LLVMBuildAlloca;
-    extern fn LLVMBuildAlloca(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
-
-    pub const buildStore = LLVMBuildStore;
-    extern fn LLVMBuildStore(*Builder, Val: *Value, Ptr: *Value) *Value;
-
-    pub const buildLoad = LLVMBuildLoad2;
-    extern fn LLVMBuildLoad2(*Builder, Ty: *Type, PointerVal: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFAdd = LLVMBuildFAdd;
-    extern fn LLVMBuildFAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildAdd = LLVMBuildAdd;
-    extern fn LLVMBuildAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNSWAdd = LLVMBuildNSWAdd;
-    extern fn LLVMBuildNSWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNUWAdd = LLVMBuildNUWAdd;
-    extern fn LLVMBuildNUWAdd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFSub = LLVMBuildFSub;
-    extern fn LLVMBuildFSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFNeg = LLVMBuildFNeg;
-    extern fn LLVMBuildFNeg(*Builder, V: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildSub = LLVMBuildSub;
-    extern fn LLVMBuildSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNSWSub = LLVMBuildNSWSub;
-    extern fn LLVMBuildNSWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNUWSub = LLVMBuildNUWSub;
-    extern fn LLVMBuildNUWSub(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFMul = LLVMBuildFMul;
-    extern fn LLVMBuildFMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildMul = LLVMBuildMul;
-    extern fn LLVMBuildMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNSWMul = LLVMBuildNSWMul;
-    extern fn LLVMBuildNSWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNUWMul = LLVMBuildNUWMul;
-    extern fn LLVMBuildNUWMul(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildUDiv = LLVMBuildUDiv;
-    extern fn LLVMBuildUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildSDiv = LLVMBuildSDiv;
-    extern fn LLVMBuildSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFDiv = LLVMBuildFDiv;
-    extern fn LLVMBuildFDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildURem = LLVMBuildURem;
-    extern fn LLVMBuildURem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildSRem = LLVMBuildSRem;
-    extern fn LLVMBuildSRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFRem = LLVMBuildFRem;
-    extern fn LLVMBuildFRem(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildAnd = LLVMBuildAnd;
-    extern fn LLVMBuildAnd(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildLShr = LLVMBuildLShr;
-    extern fn LLVMBuildLShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildAShr = LLVMBuildAShr;
-    extern fn LLVMBuildAShr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildLShrExact = ZigLLVMBuildLShrExact;
-    extern fn ZigLLVMBuildLShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildAShrExact = ZigLLVMBuildAShrExact;
-    extern fn ZigLLVMBuildAShrExact(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildShl = LLVMBuildShl;
-    extern fn LLVMBuildShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNUWShl = ZigLLVMBuildNUWShl;
-    extern fn ZigLLVMBuildNUWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildNSWShl = ZigLLVMBuildNSWShl;
-    extern fn ZigLLVMBuildNSWShl(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildOr = LLVMBuildOr;
-    extern fn LLVMBuildOr(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildXor = LLVMBuildXor;
-    extern fn LLVMBuildXor(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildBitCast = LLVMBuildBitCast;
-    extern fn LLVMBuildBitCast(*Builder, Val: *Value, DestTy: *Type, Name: [*:0]const u8) *Value;
-
-    pub const buildGEP = LLVMBuildGEP2;
-    extern fn LLVMBuildGEP2(
-        B: *Builder,
-        Ty: *Type,
-        Pointer: *Value,
-        Indices: [*]const *Value,
-        NumIndices: c_uint,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildInBoundsGEP = LLVMBuildInBoundsGEP2;
-    extern fn LLVMBuildInBoundsGEP2(
-        B: *Builder,
-        Ty: *Type,
-        Pointer: *Value,
-        Indices: [*]const *Value,
-        NumIndices: c_uint,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildICmp = LLVMBuildICmp;
-    extern fn LLVMBuildICmp(*Builder, Op: IntPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildFCmp = LLVMBuildFCmp;
-    extern fn LLVMBuildFCmp(*Builder, Op: RealPredicate, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildBr = LLVMBuildBr;
-    extern fn LLVMBuildBr(*Builder, Dest: *BasicBlock) *Value;
-
-    pub const buildCondBr = LLVMBuildCondBr;
-    extern fn LLVMBuildCondBr(*Builder, If: *Value, Then: *BasicBlock, Else: *BasicBlock) *Value;
-
-    pub const buildSwitch = LLVMBuildSwitch;
-    extern fn LLVMBuildSwitch(*Builder, V: *Value, Else: *BasicBlock, NumCases: c_uint) *Value;
-
-    pub const buildPhi = LLVMBuildPhi;
-    extern fn LLVMBuildPhi(*Builder, Ty: *Type, Name: [*:0]const u8) *Value;
-
-    pub const buildExtractValue = LLVMBuildExtractValue;
-    extern fn LLVMBuildExtractValue(
-        *Builder,
-        AggVal: *Value,
-        Index: c_uint,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildExtractElement = LLVMBuildExtractElement;
-    extern fn LLVMBuildExtractElement(
-        *Builder,
-        VecVal: *Value,
-        Index: *Value,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildInsertElement = LLVMBuildInsertElement;
-    extern fn LLVMBuildInsertElement(
-        *Builder,
-        VecVal: *Value,
-        EltVal: *Value,
-        Index: *Value,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildPtrToInt = LLVMBuildPtrToInt;
-    extern fn LLVMBuildPtrToInt(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildIntToPtr = LLVMBuildIntToPtr;
-    extern fn LLVMBuildIntToPtr(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildTrunc = LLVMBuildTrunc;
-    extern fn LLVMBuildTrunc(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildInsertValue = LLVMBuildInsertValue;
-    extern fn LLVMBuildInsertValue(
-        *Builder,
-        AggVal: *Value,
-        EltVal: *Value,
-        Index: c_uint,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildAtomicCmpXchg = LLVMBuildAtomicCmpXchg;
-    extern fn LLVMBuildAtomicCmpXchg(
-        builder: *Builder,
-        ptr: *Value,
-        cmp: *Value,
-        new_val: *Value,
-        success_ordering: AtomicOrdering,
-        failure_ordering: AtomicOrdering,
-        is_single_threaded: Bool,
-    ) *Value;
-
-    pub const buildSelect = LLVMBuildSelect;
-    extern fn LLVMBuildSelect(
-        *Builder,
-        If: *Value,
-        Then: *Value,
-        Else: *Value,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildFence = LLVMBuildFence;
-    extern fn LLVMBuildFence(
-        B: *Builder,
-        ordering: AtomicOrdering,
-        singleThread: Bool,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildAtomicRmw = LLVMBuildAtomicRMW;
-    extern fn LLVMBuildAtomicRMW(
-        B: *Builder,
-        op: AtomicRMWBinOp,
-        PTR: *Value,
-        Val: *Value,
-        ordering: AtomicOrdering,
-        singleThread: Bool,
-    ) *Value;
-
-    pub const buildFPToUI = LLVMBuildFPToUI;
-    extern fn LLVMBuildFPToUI(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildFPToSI = LLVMBuildFPToSI;
-    extern fn LLVMBuildFPToSI(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildUIToFP = LLVMBuildUIToFP;
-    extern fn LLVMBuildUIToFP(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildSIToFP = LLVMBuildSIToFP;
-    extern fn LLVMBuildSIToFP(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildFPTrunc = LLVMBuildFPTrunc;
-    extern fn LLVMBuildFPTrunc(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildFPExt = LLVMBuildFPExt;
-    extern fn LLVMBuildFPExt(
-        *Builder,
-        Val: *Value,
-        DestTy: *Type,
-        Name: [*:0]const u8,
-    ) *Value;
-
-    pub const buildExactUDiv = LLVMBuildExactUDiv;
-    extern fn LLVMBuildExactUDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const buildExactSDiv = LLVMBuildExactSDiv;
-    extern fn LLVMBuildExactSDiv(*Builder, LHS: *Value, RHS: *Value, Name: [*:0]const u8) *Value;
-
-    pub const setCurrentDebugLocation = ZigLLVMSetCurrentDebugLocation2;
-    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: *Builder) void;
-
-    pub const getCurrentDebugLocation2 = LLVMGetCurrentDebugLocation2;
-    extern fn LLVMGetCurrentDebugLocation2(Builder: *Builder) *Metadata;
-
-    pub const setCurrentDebugLocation2 = LLVMSetCurrentDebugLocation2;
-    extern fn LLVMSetCurrentDebugLocation2(Builder: *Builder, Loc: *Metadata) void;
-
-    pub const buildShuffleVector = LLVMBuildShuffleVector;
-    extern fn LLVMBuildShuffleVector(*Builder, V1: *Value, V2: *Value, Mask: *Value, Name: [*:0]const u8) *Value;
-
-    pub const setFastMath = ZigLLVMSetFastMath;
-    extern fn ZigLLVMSetFastMath(B: *Builder, on_state: bool) void;
-
-    pub const buildAddrSpaceCast = LLVMBuildAddrSpaceCast;
-    extern fn LLVMBuildAddrSpaceCast(B: *Builder, Val: *Value, DestTy: *Type, Name: [*:0]const u8) *Value;
-
-    pub const buildAllocaInAddressSpace = ZigLLVMBuildAllocaInAddressSpace;
-    extern fn ZigLLVMBuildAllocaInAddressSpace(B: *Builder, Ty: *Type, AddressSpace: c_uint, Name: [*:0]const u8) *Value;
-
-    pub const buildVAArg = LLVMBuildVAArg;
-    extern fn LLVMBuildVAArg(*Builder, List: *Value, Ty: *Type, Name: [*:0]const u8) *Value;
-};
-
-pub const MDString = opaque {
-    pub const get = LLVMMDStringInContext2;
-    extern fn LLVMMDStringInContext2(C: *Context, Str: [*]const u8, SLen: usize) *MDString;
-};
-
-pub const DIScope = opaque {
-    pub const toNode = ZigLLVMScopeToNode;
-    extern fn ZigLLVMScopeToNode(scope: *DIScope) *DINode;
-};
-
-pub const DINode = opaque {};
-pub const Metadata = opaque {};
-
-pub const IntPredicate = enum(c_uint) {
-    EQ = 32,
-    NE = 33,
-    UGT = 34,
-    UGE = 35,
-    ULT = 36,
-    ULE = 37,
-    SGT = 38,
-    SGE = 39,
-    SLT = 40,
-    SLE = 41,
-};
-
-pub const RealPredicate = enum(c_uint) {
-    OEQ = 1,
-    OGT = 2,
-    OGE = 3,
-    OLT = 4,
-    OLE = 5,
-    ONE = 6,
-    ORD = 7,
-    UNO = 8,
-    UEQ = 9,
-    UGT = 10,
-    UGE = 11,
-    ULT = 12,
-    ULE = 13,
-    UNE = 14,
-};
-
-pub const BasicBlock = opaque {
-    pub const deleteBasicBlock = LLVMDeleteBasicBlock;
-    extern fn LLVMDeleteBasicBlock(BB: *BasicBlock) void;
-};
-
 pub const TargetMachine = opaque {
     pub const create = ZigLLVMCreateTargetMachine;
     extern fn ZigLLVMCreateTargetMachine(
@@ -956,23 +90,11 @@ pub const TargetMachine = opaque {
         llvm_ir_filename: ?[*:0]const u8,
         bitcode_filename: ?[*:0]const u8,
     ) bool;
-
-    pub const createTargetDataLayout = LLVMCreateTargetDataLayout;
-    extern fn LLVMCreateTargetDataLayout(*TargetMachine) *TargetData;
 };
 
 pub const TargetData = opaque {
     pub const dispose = LLVMDisposeTargetData;
     extern fn LLVMDisposeTargetData(*TargetData) void;
-
-    pub const abiAlignmentOfType = LLVMABIAlignmentOfType;
-    extern fn LLVMABIAlignmentOfType(TD: *TargetData, Ty: *Type) c_uint;
-
-    pub const abiSizeOfType = LLVMABISizeOfType;
-    extern fn LLVMABISizeOfType(TD: *TargetData, Ty: *Type) c_ulonglong;
-
-    pub const stringRep = LLVMCopyStringRepOfTargetData;
-    extern fn LLVMCopyStringRepOfTargetData(TD: *TargetData) [*:0]const u8;
 };
 
 pub const CodeModel = enum(c_int) {
@@ -1002,11 +124,6 @@ pub const RelocMode = enum(c_int) {
     ROPI_RWPI,
 };
 
-pub const CodeGenFileType = enum(c_int) {
-    AssemblyFile,
-    ObjectFile,
-};
-
 pub const ABIType = enum(c_int) {
     /// Target-specific (either soft or hard depending on triple, etc).
     Default,
@@ -1278,541 +395,6 @@ extern fn ZigLLVMWriteImportLibrary(
     kill_at: bool,
 ) bool;
 
-pub const Linkage = enum(c_uint) {
-    External,
-    AvailableExternally,
-    LinkOnceAny,
-    LinkOnceODR,
-    LinkOnceODRAutoHide,
-    WeakAny,
-    WeakODR,
-    Appending,
-    Internal,
-    Private,
-    DLLImport,
-    DLLExport,
-    ExternalWeak,
-    Ghost,
-    Common,
-    LinkerPrivate,
-    LinkerPrivateWeak,
-};
-
-pub const Visibility = enum(c_uint) {
-    Default,
-    Hidden,
-    Protected,
-};
-
-pub const ThreadLocalMode = enum(c_uint) {
-    NotThreadLocal,
-    GeneralDynamicTLSModel,
-    LocalDynamicTLSModel,
-    InitialExecTLSModel,
-    LocalExecTLSModel,
-};
-
-pub const AtomicOrdering = enum(c_uint) {
-    NotAtomic = 0,
-    Unordered = 1,
-    Monotonic = 2,
-    Acquire = 4,
-    Release = 5,
-    AcquireRelease = 6,
-    SequentiallyConsistent = 7,
-};
-
-pub const AtomicRMWBinOp = enum(c_int) {
-    Xchg,
-    Add,
-    Sub,
-    And,
-    Nand,
-    Or,
-    Xor,
-    Max,
-    Min,
-    UMax,
-    UMin,
-    FAdd,
-    FSub,
-    FMax,
-    FMin,
-};
-
-pub const CallConv = enum(c_uint) {
-    C = 0,
-    Fast = 8,
-    Cold = 9,
-    GHC = 10,
-    HiPE = 11,
-    WebKit_JS = 12,
-    AnyReg = 13,
-    PreserveMost = 14,
-    PreserveAll = 15,
-    Swift = 16,
-    CXX_FAST_TLS = 17,
-
-    X86_StdCall = 64,
-    X86_FastCall = 65,
-    ARM_APCS = 66,
-    ARM_AAPCS = 67,
-    ARM_AAPCS_VFP = 68,
-    MSP430_INTR = 69,
-    X86_ThisCall = 70,
-    PTX_Kernel = 71,
-    PTX_Device = 72,
-    SPIR_FUNC = 75,
-    SPIR_KERNEL = 76,
-    Intel_OCL_BI = 77,
-    X86_64_SysV = 78,
-    Win64 = 79,
-    X86_VectorCall = 80,
-    HHVM = 81,
-    HHVM_C = 82,
-    X86_INTR = 83,
-    AVR_INTR = 84,
-    AVR_SIGNAL = 85,
-    AVR_BUILTIN = 86,
-    AMDGPU_VS = 87,
-    AMDGPU_GS = 88,
-    AMDGPU_PS = 89,
-    AMDGPU_CS = 90,
-    AMDGPU_KERNEL = 91,
-    X86_RegCall = 92,
-    AMDGPU_HS = 93,
-    MSP430_BUILTIN = 94,
-    AMDGPU_LS = 95,
-    AMDGPU_ES = 96,
-    AArch64_VectorCall = 97,
-};
-
-pub const CallAttr = enum(c_int) {
-    Auto,
-    NeverTail,
-    NeverInline,
-    AlwaysTail,
-    AlwaysInline,
-};
-
-pub const TailCallKind = enum(c_uint) {
-    None,
-    Tail,
-    MustTail,
-    NoTail,
-};
-
-pub const DLLStorageClass = enum(c_uint) {
-    Default,
-    DLLImport,
-    DLLExport,
-};
-
-pub const address_space = struct {
-    pub const default: c_uint = 0;
-
-    // See llvm/lib/Target/X86/X86.h
-    pub const x86_64 = x86;
-    pub const x86 = struct {
-        pub const gs: c_uint = 256;
-        pub const fs: c_uint = 257;
-        pub const ss: c_uint = 258;
-
-        pub const ptr32_sptr: c_uint = 270;
-        pub const ptr32_uptr: c_uint = 271;
-        pub const ptr64: c_uint = 272;
-    };
-
-    // See llvm/lib/Target/AVR/AVR.h
-    pub const avr = struct {
-        pub const flash: c_uint = 1;
-        pub const flash1: c_uint = 2;
-        pub const flash2: c_uint = 3;
-        pub const flash3: c_uint = 4;
-        pub const flash4: c_uint = 5;
-        pub const flash5: c_uint = 6;
-    };
-
-    // See llvm/lib/Target/NVPTX/NVPTX.h
-    pub const nvptx = struct {
-        pub const generic: c_uint = 0;
-        pub const global: c_uint = 1;
-        pub const constant: c_uint = 2;
-        pub const shared: c_uint = 3;
-        pub const param: c_uint = 4;
-        pub const local: c_uint = 5;
-    };
-
-    // See llvm/lib/Target/AMDGPU/AMDGPU.h
-    pub const amdgpu = struct {
-        pub const flat: c_uint = 0;
-        pub const global: c_uint = 1;
-        pub const region: c_uint = 2;
-        pub const local: c_uint = 3;
-        pub const constant: c_uint = 4;
-        pub const private: c_uint = 5;
-        pub const constant_32bit: c_uint = 6;
-        pub const buffer_fat_pointer: c_uint = 7;
-        pub const param_d: c_uint = 6;
-        pub const param_i: c_uint = 7;
-        pub const constant_buffer_0: c_uint = 8;
-        pub const constant_buffer_1: c_uint = 9;
-        pub const constant_buffer_2: c_uint = 10;
-        pub const constant_buffer_3: c_uint = 11;
-        pub const constant_buffer_4: c_uint = 12;
-        pub const constant_buffer_5: c_uint = 13;
-        pub const constant_buffer_6: c_uint = 14;
-        pub const constant_buffer_7: c_uint = 15;
-        pub const constant_buffer_8: c_uint = 16;
-        pub const constant_buffer_9: c_uint = 17;
-        pub const constant_buffer_10: c_uint = 18;
-        pub const constant_buffer_11: c_uint = 19;
-        pub const constant_buffer_12: c_uint = 20;
-        pub const constant_buffer_13: c_uint = 21;
-        pub const constant_buffer_14: c_uint = 22;
-        pub const constant_buffer_15: c_uint = 23;
-    };
-
-    // See llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypetilities.h
-    pub const wasm = struct {
-        pub const variable: c_uint = 1;
-        pub const externref: c_uint = 10;
-        pub const funcref: c_uint = 20;
-    };
-};
-
-pub const DIEnumerator = opaque {};
-pub const DILocalVariable = opaque {};
-pub const DILocation = opaque {};
-pub const DIGlobalExpression = opaque {};
-
-pub const DIGlobalVariable = opaque {
-    pub const toNode = ZigLLVMGlobalVariableToNode;
-    extern fn ZigLLVMGlobalVariableToNode(global_variable: *DIGlobalVariable) *DINode;
-
-    pub const replaceLinkageName = ZigLLVMGlobalVariableReplaceLinkageName;
-    extern fn ZigLLVMGlobalVariableReplaceLinkageName(global_variable: *DIGlobalVariable, linkage_name: *MDString) void;
-};
-pub const DIGlobalVariableExpression = opaque {
-    pub const getVariable = ZigLLVMGlobalGetVariable;
-    extern fn ZigLLVMGlobalGetVariable(global_variable: *DIGlobalVariableExpression) *DIGlobalVariable;
-};
-pub const DIType = opaque {
-    pub const toScope = ZigLLVMTypeToScope;
-    extern fn ZigLLVMTypeToScope(ty: *DIType) *DIScope;
-
-    pub const toNode = ZigLLVMTypeToNode;
-    extern fn ZigLLVMTypeToNode(ty: *DIType) *DINode;
-};
-pub const DIFile = opaque {
-    pub const toScope = ZigLLVMFileToScope;
-    extern fn ZigLLVMFileToScope(difile: *DIFile) *DIScope;
-
-    pub const toNode = ZigLLVMFileToNode;
-    extern fn ZigLLVMFileToNode(difile: *DIFile) *DINode;
-};
-pub const DILexicalBlock = opaque {
-    pub const toScope = ZigLLVMLexicalBlockToScope;
-    extern fn ZigLLVMLexicalBlockToScope(lexical_block: *DILexicalBlock) *DIScope;
-
-    pub const toNode = ZigLLVMLexicalBlockToNode;
-    extern fn ZigLLVMLexicalBlockToNode(lexical_block: *DILexicalBlock) *DINode;
-};
-pub const DICompileUnit = opaque {
-    pub const toScope = ZigLLVMCompileUnitToScope;
-    extern fn ZigLLVMCompileUnitToScope(compile_unit: *DICompileUnit) *DIScope;
-
-    pub const toNode = ZigLLVMCompileUnitToNode;
-    extern fn ZigLLVMCompileUnitToNode(compile_unit: *DICompileUnit) *DINode;
-};
-pub const DISubprogram = opaque {
-    pub const toScope = ZigLLVMSubprogramToScope;
-    extern fn ZigLLVMSubprogramToScope(subprogram: *DISubprogram) *DIScope;
-
-    pub const toNode = ZigLLVMSubprogramToNode;
-    extern fn ZigLLVMSubprogramToNode(subprogram: *DISubprogram) *DINode;
-
-    pub const replaceLinkageName = ZigLLVMSubprogramReplaceLinkageName;
-    extern fn ZigLLVMSubprogramReplaceLinkageName(subprogram: *DISubprogram, linkage_name: *MDString) void;
-};
-
-pub const getDebugLoc = ZigLLVMGetDebugLoc2;
-extern fn ZigLLVMGetDebugLoc2(line: c_uint, col: c_uint, scope: *DIScope, inlined_at: ?*DILocation) *DILocation;
-
-pub const DIBuilder = opaque {
-    pub const dispose = ZigLLVMDisposeDIBuilder;
-    extern fn ZigLLVMDisposeDIBuilder(dib: *DIBuilder) void;
-
-    pub const finalize = ZigLLVMDIBuilderFinalize;
-    extern fn ZigLLVMDIBuilderFinalize(dib: *DIBuilder) void;
-
-    pub const createPointerType = ZigLLVMCreateDebugPointerType;
-    extern fn ZigLLVMCreateDebugPointerType(
-        dib: *DIBuilder,
-        pointee_type: *DIType,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        name: [*:0]const u8,
-    ) *DIType;
-
-    pub const createBasicType = ZigLLVMCreateDebugBasicType;
-    extern fn ZigLLVMCreateDebugBasicType(
-        dib: *DIBuilder,
-        name: [*:0]const u8,
-        size_in_bits: u64,
-        encoding: c_uint,
-    ) *DIType;
-
-    pub const createArrayType = ZigLLVMCreateDebugArrayType;
-    extern fn ZigLLVMCreateDebugArrayType(
-        dib: *DIBuilder,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        elem_type: *DIType,
-        elem_count: i64,
-    ) *DIType;
-
-    pub const createEnumerator = ZigLLVMCreateDebugEnumerator;
-    extern fn ZigLLVMCreateDebugEnumerator(
-        dib: *DIBuilder,
-        name: [*:0]const u8,
-        val: u64,
-        is_unsigned: bool,
-    ) *DIEnumerator;
-
-    pub const createEnumerator2 = ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision;
-    extern fn ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision(
-        dib: *DIBuilder,
-        name: [*:0]const u8,
-        num_words: c_uint,
-        words: [*]const u64,
-        bits: c_uint,
-        is_unsigned: bool,
-    ) *DIEnumerator;
-
-    pub const createEnumerationType = ZigLLVMCreateDebugEnumerationType;
-    extern fn ZigLLVMCreateDebugEnumerationType(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: *DIFile,
-        line_number: c_uint,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        enumerator_array: [*]const *DIEnumerator,
-        enumerator_array_len: c_int,
-        underlying_type: *DIType,
-        unique_id: [*:0]const u8,
-    ) *DIType;
-
-    pub const createStructType = ZigLLVMCreateDebugStructType;
-    extern fn ZigLLVMCreateDebugStructType(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: ?*DIFile,
-        line_number: c_uint,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        flags: c_uint,
-        derived_from: ?*DIType,
-        types_array: [*]const *DIType,
-        types_array_len: c_int,
-        run_time_lang: c_uint,
-        vtable_holder: ?*DIType,
-        unique_id: [*:0]const u8,
-    ) *DIType;
-
-    pub const createUnionType = ZigLLVMCreateDebugUnionType;
-    extern fn ZigLLVMCreateDebugUnionType(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: ?*DIFile,
-        line_number: c_uint,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        flags: c_uint,
-        types_array: [*]const *DIType,
-        types_array_len: c_int,
-        run_time_lang: c_uint,
-        unique_id: [*:0]const u8,
-    ) *DIType;
-
-    pub const createMemberType = ZigLLVMCreateDebugMemberType;
-    extern fn ZigLLVMCreateDebugMemberType(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: ?*DIFile,
-        line: c_uint,
-        size_in_bits: u64,
-        align_in_bits: u64,
-        offset_in_bits: u64,
-        flags: c_uint,
-        ty: *DIType,
-    ) *DIType;
-
-    pub const createReplaceableCompositeType = ZigLLVMCreateReplaceableCompositeType;
-    extern fn ZigLLVMCreateReplaceableCompositeType(
-        dib: *DIBuilder,
-        tag: c_uint,
-        name: [*:0]const u8,
-        scope: *DIScope,
-        file: ?*DIFile,
-        line: c_uint,
-    ) *DIType;
-
-    pub const createForwardDeclType = ZigLLVMCreateDebugForwardDeclType;
-    extern fn ZigLLVMCreateDebugForwardDeclType(
-        dib: *DIBuilder,
-        tag: c_uint,
-        name: [*:0]const u8,
-        scope: ?*DIScope,
-        file: ?*DIFile,
-        line: c_uint,
-    ) *DIType;
-
-    pub const replaceTemporary = ZigLLVMReplaceTemporary;
-    extern fn ZigLLVMReplaceTemporary(dib: *DIBuilder, ty: *DIType, replacement: *DIType) void;
-
-    pub const replaceDebugArrays = ZigLLVMReplaceDebugArrays;
-    extern fn ZigLLVMReplaceDebugArrays(
-        dib: *DIBuilder,
-        ty: *DIType,
-        types_array: [*]const *DIType,
-        types_array_len: c_int,
-    ) void;
-
-    pub const createSubroutineType = ZigLLVMCreateSubroutineType;
-    extern fn ZigLLVMCreateSubroutineType(
-        dib: *DIBuilder,
-        types_array: [*]const *DIType,
-        types_array_len: c_int,
-        flags: c_uint,
-    ) *DIType;
-
-    pub const createAutoVariable = ZigLLVMCreateAutoVariable;
-    extern fn ZigLLVMCreateAutoVariable(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: *DIFile,
-        line_no: c_uint,
-        ty: *DIType,
-        always_preserve: bool,
-        flags: c_uint,
-    ) *DILocalVariable;
-
-    pub const createGlobalVariableExpression = ZigLLVMCreateGlobalVariableExpression;
-    extern fn ZigLLVMCreateGlobalVariableExpression(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        linkage_name: [*:0]const u8,
-        file: *DIFile,
-        line_no: c_uint,
-        di_type: *DIType,
-        is_local_to_unit: bool,
-    ) *DIGlobalVariableExpression;
-
-    pub const createParameterVariable = ZigLLVMCreateParameterVariable;
-    extern fn ZigLLVMCreateParameterVariable(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        file: *DIFile,
-        line_no: c_uint,
-        ty: *DIType,
-        always_preserve: bool,
-        flags: c_uint,
-        arg_no: c_uint,
-    ) *DILocalVariable;
-
-    pub const createLexicalBlock = ZigLLVMCreateLexicalBlock;
-    extern fn ZigLLVMCreateLexicalBlock(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        file: *DIFile,
-        line: c_uint,
-        col: c_uint,
-    ) *DILexicalBlock;
-
-    pub const createCompileUnit = ZigLLVMCreateCompileUnit;
-    extern fn ZigLLVMCreateCompileUnit(
-        dib: *DIBuilder,
-        lang: c_uint,
-        difile: *DIFile,
-        producer: [*:0]const u8,
-        is_optimized: bool,
-        flags: [*:0]const u8,
-        runtime_version: c_uint,
-        split_name: [*:0]const u8,
-        dwo_id: u64,
-        emit_debug_info: bool,
-    ) *DICompileUnit;
-
-    pub const createFile = ZigLLVMCreateFile;
-    extern fn ZigLLVMCreateFile(
-        dib: *DIBuilder,
-        filename: [*:0]const u8,
-        directory: [*:0]const u8,
-    ) *DIFile;
-
-    pub const createFunction = ZigLLVMCreateFunction;
-    extern fn ZigLLVMCreateFunction(
-        dib: *DIBuilder,
-        scope: *DIScope,
-        name: [*:0]const u8,
-        linkage_name: [*:0]const u8,
-        file: *DIFile,
-        lineno: c_uint,
-        fn_di_type: *DIType,
-        is_local_to_unit: bool,
-        is_definition: bool,
-        scope_line: c_uint,
-        flags: c_uint,
-        is_optimized: bool,
-        decl_subprogram: ?*DISubprogram,
-    ) *DISubprogram;
-
-    pub const createVectorType = ZigLLVMDIBuilderCreateVectorType;
-    extern fn ZigLLVMDIBuilderCreateVectorType(
-        dib: *DIBuilder,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        Ty: *DIType,
-        elem_count: u32,
-    ) *DIType;
-
-    pub const insertDeclareAtEnd = ZigLLVMInsertDeclareAtEnd;
-    extern fn ZigLLVMInsertDeclareAtEnd(
-        dib: *DIBuilder,
-        storage: *Value,
-        var_info: *DILocalVariable,
-        debug_loc: *DILocation,
-        basic_block_ref: *BasicBlock,
-    ) *Value;
-
-    pub const insertDeclare = ZigLLVMInsertDeclare;
-    extern fn ZigLLVMInsertDeclare(
-        dib: *DIBuilder,
-        storage: *Value,
-        var_info: *DILocalVariable,
-        debug_loc: *DILocation,
-        insert_before_instr: *Value,
-    ) *Value;
-
-    pub const insertDbgValueIntrinsicAtEnd = ZigLLVMInsertDbgValueIntrinsicAtEnd;
-    extern fn ZigLLVMInsertDbgValueIntrinsicAtEnd(
-        dib: *DIBuilder,
-        val: *Value,
-        var_info: *DILocalVariable,
-        debug_loc: *DILocation,
-        basic_block_ref: *BasicBlock,
-    ) *Value;
-};
-
 pub const DIFlags = opaque {
     pub const Zero = 0;
     pub const Private = 1;

@@ -24,9 +24,7 @@
 #include <llvm/Analysis/TargetLibraryInfo.h>
 #include <llvm/Analysis/TargetTransformInfo.h>
 #include <llvm/Bitcode/BitcodeWriter.h>
-#include <llvm/IR/DIBuilder.h>
 #include <llvm/IR/DiagnosticInfo.h>
-#include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/InlineAsm.h>
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/LegacyPassManager.h>
@@ -382,566 +380,10 @@ void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit) {
     unwrap(context_ref)->setOptPassGate(opt_bisect);
 }
 
-LLVMValueRef ZigLLVMAddFunctionInAddressSpace(LLVMModuleRef M, const char *Name, LLVMTypeRef FunctionTy, unsigned AddressSpace) {
-    Function* func = Function::Create(unwrap<FunctionType>(FunctionTy), GlobalValue::ExternalLinkage, AddressSpace, Name, unwrap(M));
-    return wrap(func);
-}
-
-void ZigLLVMSetTailCallKind(LLVMValueRef Call, enum ZigLLVMTailCallKind TailCallKind) {
-    CallInst::TailCallKind TCK;
-    switch (TailCallKind) {
-        case ZigLLVMTailCallKindNone:
-            TCK = CallInst::TCK_None;
-            break;
-        case ZigLLVMTailCallKindTail:
-            TCK = CallInst::TCK_Tail;
-            break;
-        case ZigLLVMTailCallKindMustTail:
-            TCK = CallInst::TCK_MustTail;
-            break;
-        case ZigLLVMTailCallKindNoTail:
-            TCK = CallInst::TCK_NoTail;
-            break;
-    }
-    unwrap<CallInst>(Call)->setTailCallKind(TCK);
-}
-
-void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
-    assert( isa<Function>(unwrap(fn)) );
-    Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
-    unwrapped_function->setSubprogram(reinterpret_cast<DISubprogram*>(subprogram));
-}
-
-
-ZigLLVMDIType *ZigLLVMCreateDebugPointerType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *pointee_type,
-        uint64_t size_in_bits, uint64_t align_in_bits, const char *name)
-{
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createPointerType(
-            reinterpret_cast<DIType*>(pointee_type), size_in_bits, align_in_bits, std::optional<unsigned>(), name);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugBasicType(ZigLLVMDIBuilder *dibuilder, const char *name,
-        uint64_t size_in_bits, unsigned encoding)
-{
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createBasicType(
-            name, size_in_bits, encoding);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-struct ZigLLVMDIType *ZigLLVMDIBuilderCreateVectorType(struct ZigLLVMDIBuilder *dibuilder,
-        uint64_t SizeInBits, uint32_t AlignInBits, struct ZigLLVMDIType *Ty, uint32_t elem_count)
-{
-    SmallVector<Metadata *, 1> subrange;
-    subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createVectorType(
-            SizeInBits,
-            AlignInBits,
-            reinterpret_cast<DIType*>(Ty),
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugArrayType(ZigLLVMDIBuilder *dibuilder, uint64_t size_in_bits,
-        uint64_t align_in_bits, ZigLLVMDIType *elem_type, int64_t elem_count)
-{
-    SmallVector<Metadata *, 1> subrange;
-    subrange.push_back(reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateSubrange(0, elem_count));
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createArrayType(
-            size_in_bits, align_in_bits,
-            reinterpret_cast<DIType*>(elem_type),
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(subrange));
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumerator(ZigLLVMDIBuilder *dibuilder, const char *name, uint64_t val, bool isUnsigned) {
-    DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name, val, isUnsigned);
-    return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
-}
-
-ZigLLVMDIEnumerator *ZigLLVMCreateDebugEnumeratorOfArbitraryPrecision(ZigLLVMDIBuilder *dibuilder,
-    const char *name, unsigned NumWords, const uint64_t Words[], unsigned int bits, bool isUnsigned)
-{
-    DIEnumerator *di_enumerator = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerator(name,
-        APSInt(APInt(bits, ArrayRef(Words, NumWords)), isUnsigned));
-    return reinterpret_cast<ZigLLVMDIEnumerator*>(di_enumerator);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugEnumerationType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
-        const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
-        uint64_t align_in_bits, ZigLLVMDIEnumerator **enumerator_array, int enumerator_array_len,
-        ZigLLVMDIType *underlying_type, const char *unique_id)
-{
-    SmallVector<Metadata *, 8> fields;
-    for (int i = 0; i < enumerator_array_len; i += 1) {
-        DIEnumerator *dienumerator = reinterpret_cast<DIEnumerator*>(enumerator_array[i]);
-        fields.push_back(dienumerator);
-    }
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createEnumerationType(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            reinterpret_cast<DIFile*>(file),
-            line_number, size_in_bits, align_in_bits,
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
-            reinterpret_cast<DIType*>(underlying_type),
-            unique_id);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugMemberType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
-        const char *name, ZigLLVMDIFile *file, unsigned line, uint64_t size_in_bits,
-        uint64_t align_in_bits, uint64_t offset_in_bits, unsigned flags, ZigLLVMDIType *type)
-{
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createMemberType(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            reinterpret_cast<DIFile*>(file),
-            line, size_in_bits, align_in_bits, offset_in_bits,
-            static_cast<DINode::DIFlags>(flags),
-            reinterpret_cast<DIType*>(type));
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugUnionType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
-        const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
-        uint64_t align_in_bits, unsigned flags, ZigLLVMDIType **types_array, int types_array_len,
-        unsigned run_time_lang, const char *unique_id)
-{
-    SmallVector<Metadata *, 8> fields;
-    for (int i = 0; i < types_array_len; i += 1) {
-        DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
-        fields.push_back(ditype);
-    }
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createUnionType(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            reinterpret_cast<DIFile*>(file),
-            line_number, size_in_bits, align_in_bits,
-            static_cast<DINode::DIFlags>(flags),
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
-            run_time_lang, unique_id);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugStructType(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
-        const char *name, ZigLLVMDIFile *file, unsigned line_number, uint64_t size_in_bits,
-        uint64_t align_in_bits, unsigned flags, ZigLLVMDIType *derived_from,
-        ZigLLVMDIType **types_array, int types_array_len, unsigned run_time_lang, ZigLLVMDIType *vtable_holder,
-        const char *unique_id)
-{
-    SmallVector<Metadata *, 8> fields;
-    for (int i = 0; i < types_array_len; i += 1) {
-        DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
-        fields.push_back(ditype);
-    }
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createStructType(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            reinterpret_cast<DIFile*>(file),
-            line_number, size_in_bits, align_in_bits,
-            static_cast<DINode::DIFlags>(flags),
-            reinterpret_cast<DIType*>(derived_from),
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields),
-            run_time_lang,
-            reinterpret_cast<DIType*>(vtable_holder),
-            unique_id);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateReplaceableCompositeType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
-        const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
-{
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createReplaceableCompositeType(
-            tag, name,
-            reinterpret_cast<DIScope*>(scope),
-            reinterpret_cast<DIFile*>(file),
-            line);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-ZigLLVMDIType *ZigLLVMCreateDebugForwardDeclType(ZigLLVMDIBuilder *dibuilder, unsigned tag,
-        const char *name, ZigLLVMDIScope *scope, ZigLLVMDIFile *file, unsigned line)
-{
-    DIType *di_type = reinterpret_cast<DIBuilder*>(dibuilder)->createForwardDecl(
-            tag, name,
-            reinterpret_cast<DIScope*>(scope),
-            reinterpret_cast<DIFile*>(file),
-            line);
-    return reinterpret_cast<ZigLLVMDIType*>(di_type);
-}
-
-void ZigLLVMReplaceTemporary(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
-        ZigLLVMDIType *replacement)
-{
-    reinterpret_cast<DIBuilder*>(dibuilder)->replaceTemporary(
-            TempDIType(reinterpret_cast<DIType*>(type)),
-            reinterpret_cast<DIType*>(replacement));
-}
-
-void ZigLLVMReplaceDebugArrays(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIType *type,
-        ZigLLVMDIType **types_array, int types_array_len)
-{
-    SmallVector<Metadata *, 8> fields;
-    for (int i = 0; i < types_array_len; i += 1) {
-        DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
-        fields.push_back(ditype);
-    }
-    DICompositeType *composite_type = (DICompositeType*)reinterpret_cast<DIType*>(type);
-    reinterpret_cast<DIBuilder*>(dibuilder)->replaceArrays(
-            composite_type,
-            reinterpret_cast<DIBuilder*>(dibuilder)->getOrCreateArray(fields));
-}
-
-ZigLLVMDIType *ZigLLVMCreateSubroutineType(ZigLLVMDIBuilder *dibuilder_wrapped,
-        ZigLLVMDIType **types_array, int types_array_len, unsigned flags)
-{
-    SmallVector<Metadata *, 8> types;
-    for (int i = 0; i < types_array_len; i += 1) {
-        DIType *ditype = reinterpret_cast<DIType*>(types_array[i]);
-        types.push_back(ditype);
-    }
-    DIBuilder *dibuilder = reinterpret_cast<DIBuilder*>(dibuilder_wrapped);
-    DISubroutineType *subroutine_type = dibuilder->createSubroutineType(
-            dibuilder->getOrCreateTypeArray(types),
-            static_cast<DINode::DIFlags>(flags));
-    DIType *ditype = subroutine_type;
-    return reinterpret_cast<ZigLLVMDIType*>(ditype);
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_unsigned(void) {
-    return dwarf::DW_ATE_unsigned;
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_signed(void) {
-    return dwarf::DW_ATE_signed;
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_float(void) {
-    return dwarf::DW_ATE_float;
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_boolean(void) {
-    return dwarf::DW_ATE_boolean;
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_unsigned_char(void) {
-    return dwarf::DW_ATE_unsigned_char;
-}
-
-unsigned ZigLLVMEncoding_DW_ATE_signed_char(void) {
-    return dwarf::DW_ATE_signed_char;
-}
-
-unsigned ZigLLVMLang_DW_LANG_C99(void) {
-    return dwarf::DW_LANG_C99;
-}
-
-unsigned ZigLLVMTag_DW_variable(void) {
-    return dwarf::DW_TAG_variable;
-}
-
-unsigned ZigLLVMTag_DW_structure_type(void) {
-    return dwarf::DW_TAG_structure_type;
-}
-
-unsigned ZigLLVMTag_DW_enumeration_type(void) {
-    return dwarf::DW_TAG_enumeration_type;
-}
-
-unsigned ZigLLVMTag_DW_union_type(void) {
-    return dwarf::DW_TAG_union_type;
-}
-
-ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved) {
-    DIBuilder *di_builder = new(std::nothrow) DIBuilder(*unwrap(module), allow_unresolved);
-    if (di_builder == nullptr)
-        return nullptr;
-    return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
-}
-
-void ZigLLVMDisposeDIBuilder(ZigLLVMDIBuilder *dbuilder) {
-    DIBuilder *di_builder = reinterpret_cast<DIBuilder *>(dbuilder);
-    delete di_builder;
-}
-
-void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder,
-        unsigned int line, unsigned int column, ZigLLVMDIScope *scope)
-{
-    DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
-    DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, column, di_scope, nullptr, false);
-    unwrap(builder)->SetCurrentDebugLocation(debug_loc);
-}
-
-void ZigLLVMSetCurrentDebugLocation2(LLVMBuilderRef builder, unsigned int line,
-        unsigned int column, ZigLLVMDIScope *scope, ZigLLVMDILocation *inlined_at)
-{
-    DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
-    DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, column, di_scope,
-        reinterpret_cast<DILocation *>(inlined_at), false);
-    unwrap(builder)->SetCurrentDebugLocation(debug_loc);
-}
-
-void ZigLLVMClearCurrentDebugLocation(LLVMBuilderRef builder) {
-    unwrap(builder)->SetCurrentDebugLocation(DebugLoc());
-}
-
-
-ZigLLVMDILexicalBlock *ZigLLVMCreateLexicalBlock(ZigLLVMDIBuilder *dbuilder, ZigLLVMDIScope *scope,
-        ZigLLVMDIFile *file, unsigned line, unsigned col)
-{
-    DILexicalBlock *result = reinterpret_cast<DIBuilder*>(dbuilder)->createLexicalBlock(
-            reinterpret_cast<DIScope*>(scope),
-            reinterpret_cast<DIFile*>(file),
-            line,
-            col);
-    return reinterpret_cast<ZigLLVMDILexicalBlock*>(result);
-}
-
-ZigLLVMDILocalVariable *ZigLLVMCreateAutoVariable(ZigLLVMDIBuilder *dbuilder,
-        ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
-        ZigLLVMDIType *type, bool always_preserve, unsigned flags)
-{
-    DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createAutoVariable(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            reinterpret_cast<DIFile*>(file),
-            line_no,
-            reinterpret_cast<DIType*>(type),
-            always_preserve,
-            static_cast<DINode::DIFlags>(flags));
-    return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
-}
-
-ZigLLVMDIGlobalVariableExpression *ZigLLVMCreateGlobalVariableExpression(ZigLLVMDIBuilder *dbuilder,
-    ZigLLVMDIScope *scope, const char *name, const char *linkage_name, ZigLLVMDIFile *file,
-    unsigned line_no, ZigLLVMDIType *di_type, bool is_local_to_unit)
-{
-    return reinterpret_cast<ZigLLVMDIGlobalVariableExpression*>(reinterpret_cast<DIBuilder*>(dbuilder)->createGlobalVariableExpression(
-        reinterpret_cast<DIScope*>(scope),
-        name,
-        linkage_name,
-        reinterpret_cast<DIFile*>(file),
-        line_no,
-        reinterpret_cast<DIType*>(di_type),
-        is_local_to_unit));
-}
-
-ZigLLVMDILocalVariable *ZigLLVMCreateParameterVariable(ZigLLVMDIBuilder *dbuilder,
-        ZigLLVMDIScope *scope, const char *name, ZigLLVMDIFile *file, unsigned line_no,
-        ZigLLVMDIType *type, bool always_preserve, unsigned flags, unsigned arg_no)
-{
-    assert(arg_no != 0);
-    DILocalVariable *result = reinterpret_cast<DIBuilder*>(dbuilder)->createParameterVariable(
-            reinterpret_cast<DIScope*>(scope),
-            name,
-            arg_no,
-            reinterpret_cast<DIFile*>(file),
-            line_no,
-            reinterpret_cast<DIType*>(type),
-            always_preserve,
-            static_cast<DINode::DIFlags>(flags));
-    return reinterpret_cast<ZigLLVMDILocalVariable*>(result);
-}
-
-ZigLLVMDIScope *ZigLLVMLexicalBlockToScope(ZigLLVMDILexicalBlock *lexical_block) {
-    DIScope *scope = reinterpret_cast<DILexicalBlock*>(lexical_block);
-    return reinterpret_cast<ZigLLVMDIScope*>(scope);
-}
-
-ZigLLVMDIScope *ZigLLVMCompileUnitToScope(ZigLLVMDICompileUnit *compile_unit) {
-    DIScope *scope = reinterpret_cast<DICompileUnit*>(compile_unit);
-    return reinterpret_cast<ZigLLVMDIScope*>(scope);
-}
-
-ZigLLVMDIScope *ZigLLVMFileToScope(ZigLLVMDIFile *difile) {
-    DIScope *scope = reinterpret_cast<DIFile*>(difile);
-    return reinterpret_cast<ZigLLVMDIScope*>(scope);
-}
-
-ZigLLVMDIScope *ZigLLVMSubprogramToScope(ZigLLVMDISubprogram *subprogram) {
-    DIScope *scope = reinterpret_cast<DISubprogram*>(subprogram);
-    return reinterpret_cast<ZigLLVMDIScope*>(scope);
-}
-
-ZigLLVMDIScope *ZigLLVMTypeToScope(ZigLLVMDIType *type) {
-    DIScope *scope = reinterpret_cast<DIType*>(type);
-    return reinterpret_cast<ZigLLVMDIScope*>(scope);
-}
-
-ZigLLVMDINode *ZigLLVMLexicalBlockToNode(ZigLLVMDILexicalBlock *lexical_block) {
-    DINode *node = reinterpret_cast<DILexicalBlock*>(lexical_block);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMCompileUnitToNode(ZigLLVMDICompileUnit *compile_unit) {
-    DINode *node = reinterpret_cast<DICompileUnit*>(compile_unit);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMFileToNode(ZigLLVMDIFile *difile) {
-    DINode *node = reinterpret_cast<DIFile*>(difile);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMSubprogramToNode(ZigLLVMDISubprogram *subprogram) {
-    DINode *node = reinterpret_cast<DISubprogram*>(subprogram);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMTypeToNode(ZigLLVMDIType *type) {
-    DINode *node = reinterpret_cast<DIType*>(type);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMScopeToNode(ZigLLVMDIScope *scope) {
-    DINode *node = reinterpret_cast<DIScope*>(scope);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-ZigLLVMDINode *ZigLLVMGlobalVariableToNode(ZigLLVMDIGlobalVariable *global_variable) {
-    DINode *node = reinterpret_cast<DIGlobalVariable*>(global_variable);
-    return reinterpret_cast<ZigLLVMDINode*>(node);
-}
-
-void ZigLLVMSubprogramReplaceLinkageName(ZigLLVMDISubprogram *subprogram,
-        ZigLLVMMDString *linkage_name)
-{
-    MDString *linkage_name_md = reinterpret_cast<MDString*>(linkage_name);
-    reinterpret_cast<DISubprogram*>(subprogram)->replaceLinkageName(linkage_name_md);
-}
-
-void ZigLLVMGlobalVariableReplaceLinkageName(ZigLLVMDIGlobalVariable *global_variable,
-        ZigLLVMMDString *linkage_name)
-{
-    Metadata *linkage_name_md = reinterpret_cast<MDString*>(linkage_name);
-    // NOTE: Operand index must match llvm::DIGlobalVariable
-    reinterpret_cast<DIGlobalVariable*>(global_variable)->replaceOperandWith(5, linkage_name_md);
-}
-
-ZigLLVMDICompileUnit *ZigLLVMCreateCompileUnit(ZigLLVMDIBuilder *dibuilder,
-        unsigned lang, ZigLLVMDIFile *difile, const char *producer,
-        bool is_optimized, const char *flags, unsigned runtime_version, const char *split_name,
-        uint64_t dwo_id, bool emit_debug_info)
-{
-    DICompileUnit *result = reinterpret_cast<DIBuilder*>(dibuilder)->createCompileUnit(
-            lang,
-            reinterpret_cast<DIFile*>(difile),
-            producer, is_optimized, flags, runtime_version, split_name,
-            (emit_debug_info ? DICompileUnit::DebugEmissionKind::FullDebug : DICompileUnit::DebugEmissionKind::NoDebug),
-            dwo_id);
-    return reinterpret_cast<ZigLLVMDICompileUnit*>(result);
-}
-
-
-ZigLLVMDIFile *ZigLLVMCreateFile(ZigLLVMDIBuilder *dibuilder, const char *filename, const char *directory) {
-    DIFile *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFile(filename, directory);
-    return reinterpret_cast<ZigLLVMDIFile*>(result);
-}
-
-ZigLLVMDISubprogram *ZigLLVMCreateFunction(ZigLLVMDIBuilder *dibuilder, ZigLLVMDIScope *scope,
-        const char *name, const char *linkage_name, ZigLLVMDIFile *file, unsigned lineno,
-        ZigLLVMDIType *fn_di_type, bool is_local_to_unit, bool is_definition, unsigned scope_line,
-        unsigned flags, bool is_optimized, ZigLLVMDISubprogram *decl_subprogram)
-{
-    DISubroutineType *di_sub_type = static_cast<DISubroutineType*>(reinterpret_cast<DIType*>(fn_di_type));
-    DISubprogram *result = reinterpret_cast<DIBuilder*>(dibuilder)->createFunction(
-            reinterpret_cast<DIScope*>(scope),
-            name, linkage_name,
-            reinterpret_cast<DIFile*>(file),
-            lineno,
-            di_sub_type,
-            scope_line,
-            static_cast<DINode::DIFlags>(flags),
-            DISubprogram::toSPFlags(is_local_to_unit, is_definition, is_optimized),
-            nullptr,
-            reinterpret_cast<DISubprogram *>(decl_subprogram),
-            nullptr);
-    return reinterpret_cast<ZigLLVMDISubprogram*>(result);
-}
-
-void ZigLLVMDIBuilderFinalize(ZigLLVMDIBuilder *dibuilder) {
-    reinterpret_cast<DIBuilder*>(dibuilder)->finalize();
-}
-
-LLVMValueRef ZigLLVMInsertDeclareAtEnd(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
-        ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMBasicBlockRef basic_block_ref)
-{
-    Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
-            unwrap(storage),
-            reinterpret_cast<DILocalVariable *>(var_info),
-            reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
-            reinterpret_cast<DILocation*>(debug_loc),
-            static_cast<BasicBlock*>(unwrap(basic_block_ref)));
-    return wrap(result);
-}
-
-LLVMValueRef ZigLLVMInsertDbgValueIntrinsicAtEnd(ZigLLVMDIBuilder *dib, LLVMValueRef val,
-        ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc,
-        LLVMBasicBlockRef basic_block_ref)
-{
-    Instruction *result = reinterpret_cast<DIBuilder*>(dib)->insertDbgValueIntrinsic(
-            unwrap(val),
-            reinterpret_cast<DILocalVariable *>(var_info),
-            reinterpret_cast<DIBuilder*>(dib)->createExpression(),
-            reinterpret_cast<DILocation*>(debug_loc),
-            static_cast<BasicBlock*>(unwrap(basic_block_ref)));
-    return wrap(result);
-}
-
-LLVMValueRef ZigLLVMInsertDeclare(ZigLLVMDIBuilder *dibuilder, LLVMValueRef storage,
-        ZigLLVMDILocalVariable *var_info, ZigLLVMDILocation *debug_loc, LLVMValueRef insert_before_instr)
-{
-    Instruction *result = reinterpret_cast<DIBuilder*>(dibuilder)->insertDeclare(
-            unwrap(storage),
-            reinterpret_cast<DILocalVariable *>(var_info),
-            reinterpret_cast<DIBuilder*>(dibuilder)->createExpression(),
-            reinterpret_cast<DILocation*>(debug_loc),
-            static_cast<Instruction*>(unwrap(insert_before_instr)));
-    return wrap(result);
-}
-
-ZigLLVMDILocation *ZigLLVMGetDebugLoc(unsigned line, unsigned col, ZigLLVMDIScope *scope) {
-    DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
-    DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, col, di_scope, nullptr, false);
-    return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
-}
-
-ZigLLVMDILocation *ZigLLVMGetDebugLoc2(unsigned line, unsigned col, ZigLLVMDIScope *scope,
-        ZigLLVMDILocation *inlined_at) {
-    DIScope* di_scope = reinterpret_cast<DIScope*>(scope);
-    DebugLoc debug_loc = DILocation::get(di_scope->getContext(), line, col, di_scope,
-        reinterpret_cast<DILocation *>(inlined_at), false);
-    return reinterpret_cast<ZigLLVMDILocation*>(debug_loc.get());
-}
-
-void ZigLLVMSetFastMath(LLVMBuilderRef builder_wrapped, bool on_state) {
-    if (on_state) {
-        FastMathFlags fmf;
-        fmf.setFast();
-        unwrap(builder_wrapped)->setFastMathFlags(fmf);
-    } else {
-        unwrap(builder_wrapped)->clearFastMathFlags();
-    }
-}
-
 void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
     cl::ParseCommandLineOptions(argc, argv);
 }
 
-void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module, bool produce_dwarf64) {
-    unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
-    unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
-
-    if (produce_dwarf64) {
-        unwrap(module)->addModuleFlag(Module::Warning, "DWARF64", 1);
-    }
-}
-
-void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module) {
-    unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
-    unwrap(module)->addModuleFlag(Module::Warning, "CodeView", 1);
-}
-
 void ZigLLVMSetModulePICLevel(LLVMModuleRef module) {
     unwrap(module)->setPICLevel(PICLevel::Level::BigPIC);
 }
@@ -956,35 +398,6 @@ void ZigLLVMSetModuleCodeModel(LLVMModuleRef module, LLVMCodeModel code_model) {
     assert(!JIT);
 }
 
-LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
-        const char *name)
-{
-    return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, false, true));
-}
-
-LLVMValueRef ZigLLVMBuildNUWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
-        const char *name)
-{
-    return wrap(unwrap(builder)->CreateShl(unwrap(LHS), unwrap(RHS), name, true, false));
-}
-
-LLVMValueRef ZigLLVMBuildLShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
-        const char *name)
-{
-    return wrap(unwrap(builder)->CreateLShr(unwrap(LHS), unwrap(RHS), name, true));
-}
-
-LLVMValueRef ZigLLVMBuildAShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
-        const char *name)
-{
-    return wrap(unwrap(builder)->CreateAShr(unwrap(LHS), unwrap(RHS), name, true));
-}
-
-LLVMValueRef ZigLLVMBuildAllocaInAddressSpace(LLVMBuilderRef builder, LLVMTypeRef Ty,
-        unsigned AddressSpace, const char *Name) {
-  return wrap(unwrap(builder)->CreateAlloca(unwrap(Ty), AddressSpace, nullptr, Name));
-}
-
 bool ZigLLVMWriteImportLibrary(const char *def_path, const ZigLLVM_ArchType arch,
                                const char *output_lib_path, bool kill_at)
 {
@@ -1134,43 +547,6 @@ bool ZigLLDLinkWasm(int argc, const char **argv, bool can_exit_early, bool disab
     return lld::wasm::link(args, llvm::outs(), llvm::errs(), can_exit_early, disable_output);
 }
 
-void ZigLLVMTakeName(LLVMValueRef new_owner, LLVMValueRef victim) {
-    unwrap(new_owner)->takeName(unwrap(victim));
-}
-
-void ZigLLVMRemoveGlobalValue(LLVMValueRef GlobalVal) {
-    unwrap<GlobalValue>(GlobalVal)->removeFromParent();
-}
-
-void ZigLLVMEraseGlobalValue(LLVMValueRef GlobalVal) {
-    unwrap<GlobalValue>(GlobalVal)->eraseFromParent();
-}
-
-void ZigLLVMDeleteGlobalValue(LLVMValueRef GlobalVal) {
-    auto *GV = unwrap<GlobalValue>(GlobalVal);
-    assert(GV->getParent() == nullptr);
-    switch (GV->getValueID()) {
-#define HANDLE_GLOBAL_VALUE(NAME) \
-        case Value::NAME##Val: \
-            delete static_cast<NAME *>(GV); \
-            break;
-#include <llvm/IR/Value.def>
-        default: llvm_unreachable("Expected global value");
-    }
-}
-
-void ZigLLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
-    unwrap<GlobalVariable>(GlobalVar)->setInitializer(ConstantVal ? unwrap<Constant>(ConstantVal) : nullptr);
-}
-
-ZigLLVMDIGlobalVariable* ZigLLVMGlobalGetVariable(ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
-    return reinterpret_cast<ZigLLVMDIGlobalVariable*>(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression)->getVariable());
-}
-
-void ZigLLVMAttachMetaData(LLVMValueRef Val, ZigLLVMDIGlobalVariableExpression *global_variable_expression) {
-    unwrap<GlobalVariable>(Val)->addDebugInfo(reinterpret_cast<DIGlobalVariableExpression*>(global_variable_expression));
-}
-
 static_assert((Triple::ArchType)ZigLLVM_UnknownArch == Triple::UnknownArch, "");
 static_assert((Triple::ArchType)ZigLLVM_arm == Triple::arm, "");
 static_assert((Triple::ArchType)ZigLLVM_armeb == Triple::armeb, "");