import std::vec; import std::str; import std::str::rustrt::sbuf; import llvm::ModuleRef; import llvm::ContextRef; import llvm::TypeRef; import llvm::TypeHandleRef; import llvm::ValueRef; import llvm::BasicBlockRef; import llvm::BuilderRef; import llvm::ModuleProviderRef; import llvm::MemoryBufferRef; import llvm::PassManagerRef; import llvm::UseRef; import llvm::TargetDataRef; import llvm::Linkage; import llvm::Attribute; import llvm::Visibility; import llvm::CallConv; import llvm::IntPredicate; import llvm::RealPredicate; import llvm::Opcode; import llvm::ObjectFileRef; import llvm::SectionIteratorRef; type ULongLong = u64; type LongLong = i64; type Long = i32; type Bool = int; const True: Bool = 1; const False: Bool = 0; // Consts for the LLVM CallConv type, pre-cast to uint. // FIXME: figure out a way to merge these with the native // typedef and/or a tag type in the native module below. const LLVMCCallConv: uint = 0u; const LLVMFastCallConv: uint = 8u; const LLVMColdCallConv: uint = 9u; const LLVMX86StdcallCallConv: uint = 64u; const LLVMX86FastcallCallConv: uint = 65u; const LLVMDefaultVisibility: uint = 0u; const LLVMHiddenVisibility: uint = 1u; const LLVMProtectedVisibility: uint = 2u; const LLVMExternalLinkage: uint = 0u; const LLVMAvailableExternallyLinkage: uint = 1u; const LLVMLinkOnceAnyLinkage: uint = 2u; const LLVMLinkOnceODRLinkage: uint = 3u; const LLVMWeakAnyLinkage: uint = 4u; const LLVMWeakODRLinkage: uint = 5u; const LLVMAppendingLinkage: uint = 6u; const LLVMInternalLinkage: uint = 7u; const LLVMPrivateLinkage: uint = 8u; const LLVMDLLImportLinkage: uint = 9u; const LLVMDLLExportLinkage: uint = 10u; const LLVMExternalWeakLinkage: uint = 11u; const LLVMGhostLinkage: uint = 12u; const LLVMCommonLinkage: uint = 13u; const LLVMLinkerPrivateLinkage: uint = 14u; const LLVMLinkerPrivateWeakLinkage: uint = 15u; const LLVMZExtAttribute: uint = 1u; const LLVMSExtAttribute: uint = 2u; const LLVMNoReturnAttribute: uint = 4u; const LLVMInRegAttribute: uint = 8u; const LLVMStructRetAttribute: uint = 16u; const LLVMNoUnwindAttribute: uint = 32u; const LLVMNoAliasAttribute: uint = 64u; const LLVMByValAttribute: uint = 128u; const LLVMNestAttribute: uint = 256u; const LLVMReadNoneAttribute: uint = 512u; const LLVMReadOnlyAttribute: uint = 1024u; const LLVMNoInlineAttribute: uint = 2048u; const LLVMAlwaysInlineAttribute: uint = 4096u; const LLVMOptimizeForSizeAttribute: uint = 8192u; const LLVMStackProtectAttribute: uint = 16384u; const LLVMStackProtectReqAttribute: uint = 32768u; const LLVMAlignmentAttribute: uint = 2031616u; // 31 << 16 const LLVMNoCaptureAttribute: uint = 2097152u; const LLVMNoRedZoneAttribute: uint = 4194304u; const LLVMNoImplicitFloatAttribute: uint = 8388608u; const LLVMNakedAttribute: uint = 16777216u; const LLVMInlineHintAttribute: uint = 33554432u; const LLVMStackAttribute: uint = 469762048u; // 7 << 26 const LLVMUWTableAttribute: uint = 1073741824u; // 1 << 30 // Consts for the LLVM IntPredicate type, pre-cast to uint. // FIXME: as above. const LLVMIntEQ: uint = 32u; const LLVMIntNE: uint = 33u; const LLVMIntUGT: uint = 34u; const LLVMIntUGE: uint = 35u; const LLVMIntULT: uint = 36u; const LLVMIntULE: uint = 37u; const LLVMIntSGT: uint = 38u; const LLVMIntSGE: uint = 39u; const LLVMIntSLT: uint = 40u; const LLVMIntSLE: uint = 41u; // Consts for the LLVM RealPredicate type, pre-case to uint. // FIXME: as above. const LLVMRealOEQ: uint = 1u; const LLVMRealOGT: uint = 2u; const LLVMRealOGE: uint = 3u; const LLVMRealOLT: uint = 4u; const LLVMRealOLE: uint = 5u; const LLVMRealONE: uint = 6u; const LLVMRealORD: uint = 7u; const LLVMRealUNO: uint = 8u; const LLVMRealUEQ: uint = 9u; const LLVMRealUGT: uint = 10u; const LLVMRealUGE: uint = 11u; const LLVMRealULT: uint = 12u; const LLVMRealULE: uint = 13u; const LLVMRealUNE: uint = 14u; #[link_args = "-Lrustllvm"] native "cdecl" mod llvm = "rustllvm" { type ModuleRef; type ContextRef; type TypeRef; type TypeHandleRef; type ValueRef; type BasicBlockRef; type BuilderRef; type ModuleProviderRef; type MemoryBufferRef; type PassManagerRef; type PassManagerBuilderRef; type UseRef; type TargetDataRef; /* FIXME: These are enums in the C header. Represent them how, in rust? */ type Linkage; type Attribute; type Visibility; type CallConv; type IntPredicate; type RealPredicate; type Opcode; /* Create and destroy contexts. */ fn LLVMContextCreate() -> ContextRef; fn LLVMGetGlobalContext() -> ContextRef; fn LLVMContextDispose(C: ContextRef); fn LLVMGetMDKindIDInContext(C: ContextRef, Name: sbuf, SLen: uint) -> uint; fn LLVMGetMDKindID(Name: sbuf, SLen: uint) -> uint; /* Create and destroy modules. */ fn LLVMModuleCreateWithNameInContext(ModuleID: sbuf, C: ContextRef) -> ModuleRef; fn LLVMDisposeModule(M: ModuleRef); /** Data layout. See Module::getDataLayout. */ fn LLVMGetDataLayout(M: ModuleRef) -> sbuf; fn LLVMSetDataLayout(M: ModuleRef, Triple: sbuf); /** Target triple. See Module::getTargetTriple. */ fn LLVMGetTarget(M: ModuleRef) -> sbuf; fn LLVMSetTarget(M: ModuleRef, Triple: sbuf); /** See Module::dump. */ fn LLVMDumpModule(M: ModuleRef); /** See Module::setModuleInlineAsm. */ fn LLVMSetModuleInlineAsm(M: ModuleRef, Asm: sbuf); /** See llvm::LLVMTypeKind::getTypeID. */ // FIXME: returning int rather than TypeKind because // we directly inspect the values, and casting from // a native doesn't work yet (only *to* a native). fn LLVMGetTypeKind(Ty: TypeRef) -> int; /** See llvm::LLVMType::getContext. */ fn LLVMGetTypeContext(Ty: TypeRef) -> ContextRef; /* Operations on integer types */ fn LLVMInt1TypeInContext(C: ContextRef) -> TypeRef; fn LLVMInt8TypeInContext(C: ContextRef) -> TypeRef; fn LLVMInt16TypeInContext(C: ContextRef) -> TypeRef; fn LLVMInt32TypeInContext(C: ContextRef) -> TypeRef; fn LLVMInt64TypeInContext(C: ContextRef) -> TypeRef; fn LLVMIntTypeInContext(C: ContextRef, NumBits: uint) -> TypeRef; fn LLVMInt1Type() -> TypeRef; fn LLVMInt8Type() -> TypeRef; fn LLVMInt16Type() -> TypeRef; fn LLVMInt32Type() -> TypeRef; fn LLVMInt64Type() -> TypeRef; fn LLVMIntType(NumBits: uint) -> TypeRef; fn LLVMGetIntTypeWidth(IntegerTy: TypeRef) -> uint; /* Operations on real types */ fn LLVMFloatTypeInContext(C: ContextRef) -> TypeRef; fn LLVMDoubleTypeInContext(C: ContextRef) -> TypeRef; fn LLVMX86FP80TypeInContext(C: ContextRef) -> TypeRef; fn LLVMFP128TypeInContext(C: ContextRef) -> TypeRef; fn LLVMPPCFP128TypeInContext(C: ContextRef) -> TypeRef; fn LLVMFloatType() -> TypeRef; fn LLVMDoubleType() -> TypeRef; fn LLVMX86FP80Type() -> TypeRef; fn LLVMFP128Type() -> TypeRef; fn LLVMPPCFP128Type() -> TypeRef; /* Operations on function types */ fn LLVMFunctionType(ReturnType: TypeRef, ParamTypes: *TypeRef, ParamCount: uint, IsVarArg: Bool) -> TypeRef; fn LLVMIsFunctionVarArg(FunctionTy: TypeRef) -> Bool; fn LLVMGetReturnType(FunctionTy: TypeRef) -> TypeRef; fn LLVMCountParamTypes(FunctionTy: TypeRef) -> uint; fn LLVMGetParamTypes(FunctionTy: TypeRef, Dest: *TypeRef); /* Operations on struct types */ fn LLVMStructTypeInContext(C: ContextRef, ElementTypes: *TypeRef, ElementCount: uint, Packed: Bool) -> TypeRef; fn LLVMStructType(ElementTypes: *TypeRef, ElementCount: uint, Packed: Bool) -> TypeRef; fn LLVMCountStructElementTypes(StructTy: TypeRef) -> uint; fn LLVMGetStructElementTypes(StructTy: TypeRef, Dest: *TypeRef); fn LLVMIsPackedStruct(StructTy: TypeRef) -> Bool; /* Operations on array, pointer, and vector types (sequence types) */ fn LLVMArrayType(ElementType: TypeRef, ElementCount: uint) -> TypeRef; fn LLVMPointerType(ElementType: TypeRef, AddressSpace: uint) -> TypeRef; fn LLVMVectorType(ElementType: TypeRef, ElementCount: uint) -> TypeRef; fn LLVMGetElementType(Ty: TypeRef) -> TypeRef; fn LLVMGetArrayLength(ArrayTy: TypeRef) -> uint; fn LLVMGetPointerAddressSpace(PointerTy: TypeRef) -> uint; fn LLVMGetVectorSize(VectorTy: TypeRef) -> uint; /* Operations on other types */ fn LLVMVoidTypeInContext(C: ContextRef) -> TypeRef; fn LLVMLabelTypeInContext(C: ContextRef) -> TypeRef; fn LLVMVoidType() -> TypeRef; fn LLVMLabelType() -> TypeRef; /* Operations on all values */ fn LLVMTypeOf(Val: ValueRef) -> TypeRef; fn LLVMGetValueName(Val: ValueRef) -> sbuf; fn LLVMSetValueName(Val: ValueRef, Name: sbuf); fn LLVMDumpValue(Val: ValueRef); fn LLVMReplaceAllUsesWith(OldVal: ValueRef, NewVal: ValueRef); fn LLVMHasMetadata(Val: ValueRef) -> int; fn LLVMGetMetadata(Val: ValueRef, KindID: uint) -> ValueRef; fn LLVMSetMetadata(Val: ValueRef, KindID: uint, Node: ValueRef); /* Operations on Uses */ fn LLVMGetFirstUse(Val: ValueRef) -> UseRef; fn LLVMGetNextUse(U: UseRef) -> UseRef; fn LLVMGetUser(U: UseRef) -> ValueRef; fn LLVMGetUsedValue(U: UseRef) -> ValueRef; /* Operations on Users */ fn LLVMGetOperand(Val: ValueRef, Index: uint) -> ValueRef; /* Operations on constants of any type */ fn LLVMConstNull(Ty: TypeRef) -> ValueRef; /* all zeroes */ fn LLVMConstAllOnes(Ty: TypeRef) -> ValueRef; /* only for int/vector */ fn LLVMGetUndef(Ty: TypeRef) -> ValueRef; fn LLVMIsConstant(Val: ValueRef) -> Bool; fn LLVMIsNull(Val: ValueRef) -> Bool; fn LLVMIsUndef(Val: ValueRef) -> Bool; fn LLVMConstPointerNull(Ty: TypeRef) -> ValueRef; /* Operations on metadata */ fn LLVMMDStringInContext(C: ContextRef, Str: sbuf, SLen: uint) -> ValueRef; fn LLVMMDString(Str: sbuf, SLen: uint) -> ValueRef; fn LLVMMDNodeInContext(C: ContextRef, Vals: *ValueRef, Count: uint) -> ValueRef; fn LLVMMDNode(Vals: *ValueRef, Count: uint) -> ValueRef; /* Operations on scalar constants */ fn LLVMConstInt(IntTy: TypeRef, N: ULongLong, SignExtend: Bool) -> ValueRef; // FIXME: radix is actually u8, but our native layer can't handle this // yet. lucky for us we're little-endian. Small miracles. fn LLVMConstIntOfString(IntTy: TypeRef, Text: sbuf, Radix: int) -> ValueRef; fn LLVMConstIntOfStringAndSize(IntTy: TypeRef, Text: sbuf, SLen: uint, Radix: u8) -> ValueRef; fn LLVMConstReal(RealTy: TypeRef, N: f64) -> ValueRef; fn LLVMConstRealOfString(RealTy: TypeRef, Text: sbuf) -> ValueRef; fn LLVMConstRealOfStringAndSize(RealTy: TypeRef, Text: sbuf, SLen: uint) -> ValueRef; fn LLVMConstIntGetZExtValue(ConstantVal: ValueRef) -> ULongLong; fn LLVMConstIntGetSExtValue(ConstantVal: ValueRef) -> LongLong; /* Operations on composite constants */ fn LLVMConstStringInContext(C: ContextRef, Str: sbuf, Length: uint, DontNullTerminate: Bool) -> ValueRef; fn LLVMConstStructInContext(C: ContextRef, ConstantVals: *ValueRef, Count: uint, Packed: Bool) -> ValueRef; fn LLVMConstString(Str: sbuf, Length: uint, DontNullTerminate: Bool) -> ValueRef; fn LLVMConstArray(ElementTy: TypeRef, ConstantVals: *ValueRef, Length: uint) -> ValueRef; fn LLVMConstStruct(ConstantVals: *ValueRef, Count: uint, Packed: Bool) -> ValueRef; fn LLVMConstVector(ScalarConstantVals: *ValueRef, Size: uint) -> ValueRef; /* Constant expressions */ fn LLVMAlignOf(Ty: TypeRef) -> ValueRef; fn LLVMSizeOf(Ty: TypeRef) -> ValueRef; fn LLVMConstNeg(ConstantVal: ValueRef) -> ValueRef; fn LLVMConstNSWNeg(ConstantVal: ValueRef) -> ValueRef; fn LLVMConstNUWNeg(ConstantVal: ValueRef) -> ValueRef; fn LLVMConstFNeg(ConstantVal: ValueRef) -> ValueRef; fn LLVMConstNot(ConstantVal: ValueRef) -> ValueRef; fn LLVMConstAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNSWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNUWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstFAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNSWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNUWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstFSub(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNSWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstNUWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstFMul(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstUDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstExactSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstFDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstURem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstSRem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstFRem(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstAnd(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstOr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstXor(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstShl(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstLShr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstAShr(LHSConstant: ValueRef, RHSConstant: ValueRef) -> ValueRef; fn LLVMConstGEP(ConstantVal: ValueRef, ConstantIndices: *uint, NumIndices: uint) -> ValueRef; fn LLVMConstInBoundsGEP(ConstantVal: ValueRef, ConstantIndices: *uint, NumIndices: uint) -> ValueRef; fn LLVMConstTrunc(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstSExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstZExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstFPTrunc(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstFPExt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstUIToFP(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstSIToFP(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstFPToUI(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstFPToSI(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstPtrToInt(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstIntToPtr(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstZExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstSExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstTruncOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstPointerCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstIntCast(ConstantVal: ValueRef, ToType: TypeRef, isSigned: Bool) -> ValueRef; fn LLVMConstFPCast(ConstantVal: ValueRef, ToType: TypeRef) -> ValueRef; fn LLVMConstSelect(ConstantCondition: ValueRef, ConstantIfTrue: ValueRef, ConstantIfFalse: ValueRef) -> ValueRef; fn LLVMConstExtractElement(VectorConstant: ValueRef, IndexConstant: ValueRef) -> ValueRef; fn LLVMConstInsertElement(VectorConstant: ValueRef, ElementValueConstant: ValueRef, IndexConstant: ValueRef) -> ValueRef; fn LLVMConstShuffleVector(VectorAConstant: ValueRef, VectorBConstant: ValueRef, MaskConstant: ValueRef) -> ValueRef; fn LLVMConstExtractValue(AggConstant: ValueRef, IdxList: *uint, NumIdx: uint) -> ValueRef; fn LLVMConstInsertValue(AggConstant: ValueRef, ElementValueConstant: ValueRef, IdxList: *uint, NumIdx: uint) -> ValueRef; fn LLVMConstInlineAsm(Ty: TypeRef, AsmString: sbuf, Constraints: sbuf, HasSideEffects: Bool, IsAlignStack: Bool) -> ValueRef; fn LLVMBlockAddress(F: ValueRef, BB: BasicBlockRef) -> ValueRef; /* Operations on global variables, functions, and aliases (globals) */ fn LLVMGetGlobalParent(Global: ValueRef) -> ModuleRef; fn LLVMIsDeclaration(Global: ValueRef) -> Bool; fn LLVMGetLinkage(Global: ValueRef) -> Linkage; fn LLVMSetLinkage(Global: ValueRef, Link: Linkage); fn LLVMGetSection(Global: ValueRef) -> sbuf; fn LLVMSetSection(Global: ValueRef, Section: sbuf); fn LLVMGetVisibility(Global: ValueRef) -> Visibility; fn LLVMSetVisibility(Global: ValueRef, Viz: Visibility); fn LLVMGetAlignment(Global: ValueRef) -> uint; fn LLVMSetAlignment(Global: ValueRef, Bytes: uint); /* Operations on global variables */ fn LLVMAddGlobal(M: ModuleRef, Ty: TypeRef, Name: sbuf) -> ValueRef; fn LLVMAddGlobalInAddressSpace(M: ModuleRef, Ty: TypeRef, Name: sbuf, AddressSpace: uint) -> ValueRef; fn LLVMGetNamedGlobal(M: ModuleRef, Name: sbuf) -> ValueRef; fn LLVMGetFirstGlobal(M: ModuleRef) -> ValueRef; fn LLVMGetLastGlobal(M: ModuleRef) -> ValueRef; fn LLVMGetNextGlobal(GlobalVar: ValueRef) -> ValueRef; fn LLVMGetPreviousGlobal(GlobalVar: ValueRef) -> ValueRef; fn LLVMDeleteGlobal(GlobalVar: ValueRef); fn LLVMGetInitializer(GlobalVar: ValueRef) -> ValueRef; fn LLVMSetInitializer(GlobalVar: ValueRef, ConstantVal: ValueRef); fn LLVMIsThreadLocal(GlobalVar: ValueRef) -> Bool; fn LLVMSetThreadLocal(GlobalVar: ValueRef, IsThreadLocal: Bool); fn LLVMIsGlobalConstant(GlobalVar: ValueRef) -> Bool; fn LLVMSetGlobalConstant(GlobalVar: ValueRef, IsConstant: Bool); /* Operations on aliases */ fn LLVMAddAlias(M: ModuleRef, Ty: TypeRef, Aliasee: ValueRef, Name: sbuf) -> ValueRef; /* Operations on functions */ fn LLVMAddFunction(M: ModuleRef, Name: sbuf, FunctionTy: TypeRef) -> ValueRef; fn LLVMGetNamedFunction(M: ModuleRef, Name: sbuf) -> ValueRef; fn LLVMGetFirstFunction(M: ModuleRef) -> ValueRef; fn LLVMGetLastFunction(M: ModuleRef) -> ValueRef; fn LLVMGetNextFunction(Fn: ValueRef) -> ValueRef; fn LLVMGetPreviousFunction(Fn: ValueRef) -> ValueRef; fn LLVMDeleteFunction(Fn: ValueRef); fn LLVMGetIntrinsicID(Fn: ValueRef) -> uint; fn LLVMGetFunctionCallConv(Fn: ValueRef) -> uint; fn LLVMSetFunctionCallConv(Fn: ValueRef, CC: uint); fn LLVMGetGC(Fn: ValueRef) -> sbuf; fn LLVMSetGC(Fn: ValueRef, Name: sbuf); fn LLVMAddFunctionAttr(Fn: ValueRef, PA: Attribute); fn LLVMGetFunctionAttr(Fn: ValueRef) -> Attribute; fn LLVMRemoveFunctionAttr(Fn: ValueRef, PA: Attribute); /* Operations on parameters */ fn LLVMCountParams(Fn: ValueRef) -> uint; fn LLVMGetParams(Fn: ValueRef, Params: *ValueRef); fn LLVMGetParam(Fn: ValueRef, Index: uint) -> ValueRef; fn LLVMGetParamParent(Inst: ValueRef) -> ValueRef; fn LLVMGetFirstParam(Fn: ValueRef) -> ValueRef; fn LLVMGetLastParam(Fn: ValueRef) -> ValueRef; fn LLVMGetNextParam(Arg: ValueRef) -> ValueRef; fn LLVMGetPreviousParam(Arg: ValueRef) -> ValueRef; fn LLVMAddAttribute(Arg: ValueRef, PA: Attribute); fn LLVMRemoveAttribute(Arg: ValueRef, PA: Attribute); fn LLVMGetAttribute(Arg: ValueRef) -> Attribute; fn LLVMSetParamAlignment(Arg: ValueRef, align: uint); /* Operations on basic blocks */ fn LLVMBasicBlockAsValue(BB: BasicBlockRef) -> ValueRef; fn LLVMValueIsBasicBlock(Val: ValueRef) -> Bool; fn LLVMValueAsBasicBlock(Val: ValueRef) -> BasicBlockRef; fn LLVMGetBasicBlockParent(BB: BasicBlockRef) -> ValueRef; fn LLVMCountBasicBlocks(Fn: ValueRef) -> uint; fn LLVMGetBasicBlocks(Fn: ValueRef, BasicBlocks: *ValueRef); fn LLVMGetFirstBasicBlock(Fn: ValueRef) -> BasicBlockRef; fn LLVMGetLastBasicBlock(Fn: ValueRef) -> BasicBlockRef; fn LLVMGetNextBasicBlock(BB: BasicBlockRef) -> BasicBlockRef; fn LLVMGetPreviousBasicBlock(BB: BasicBlockRef) -> BasicBlockRef; fn LLVMGetEntryBasicBlock(Fn: ValueRef) -> BasicBlockRef; fn LLVMAppendBasicBlockInContext(C: ContextRef, Fn: ValueRef, Name: sbuf) -> BasicBlockRef; fn LLVMInsertBasicBlockInContext(C: ContextRef, BB: BasicBlockRef, Name: sbuf) -> BasicBlockRef; fn LLVMAppendBasicBlock(Fn: ValueRef, Name: sbuf) -> BasicBlockRef; fn LLVMInsertBasicBlock(InsertBeforeBB: BasicBlockRef, Name: sbuf) -> BasicBlockRef; fn LLVMDeleteBasicBlock(BB: BasicBlockRef); /* Operations on instructions */ fn LLVMGetInstructionParent(Inst: ValueRef) -> BasicBlockRef; fn LLVMGetFirstInstruction(BB: BasicBlockRef) -> ValueRef; fn LLVMGetLastInstruction(BB: BasicBlockRef) -> ValueRef; fn LLVMGetNextInstruction(Inst: ValueRef) -> ValueRef; fn LLVMGetPreviousInstruction(Inst: ValueRef) -> ValueRef; /* Operations on call sites */ fn LLVMSetInstructionCallConv(Instr: ValueRef, CC: uint); fn LLVMGetInstructionCallConv(Instr: ValueRef) -> uint; fn LLVMAddInstrAttribute(Instr: ValueRef, index: uint, IA: Attribute); fn LLVMRemoveInstrAttribute(Instr: ValueRef, index: uint, IA: Attribute); fn LLVMSetInstrParamAlignment(Instr: ValueRef, index: uint, align: uint); /* Operations on call instructions (only) */ fn LLVMIsTailCall(CallInst: ValueRef) -> Bool; fn LLVMSetTailCall(CallInst: ValueRef, IsTailCall: Bool); /* Operations on phi nodes */ fn LLVMAddIncoming(PhiNode: ValueRef, IncomingValues: *ValueRef, IncomingBlocks: *BasicBlockRef, Count: uint); fn LLVMCountIncoming(PhiNode: ValueRef) -> uint; fn LLVMGetIncomingValue(PhiNode: ValueRef, Index: uint) -> ValueRef; fn LLVMGetIncomingBlock(PhiNode: ValueRef, Index: uint) -> BasicBlockRef; /* Instruction builders */ fn LLVMCreateBuilderInContext(C: ContextRef) -> BuilderRef; fn LLVMCreateBuilder() -> BuilderRef; fn LLVMPositionBuilder(Builder: BuilderRef, Block: BasicBlockRef, Instr: ValueRef); fn LLVMPositionBuilderBefore(Builder: BuilderRef, Instr: ValueRef); fn LLVMPositionBuilderAtEnd(Builder: BuilderRef, Block: BasicBlockRef); fn LLVMGetInsertBlock(Builder: BuilderRef) -> BasicBlockRef; fn LLVMClearInsertionPosition(Builder: BuilderRef); fn LLVMInsertIntoBuilder(Builder: BuilderRef, Instr: ValueRef); fn LLVMInsertIntoBuilderWithName(Builder: BuilderRef, Instr: ValueRef, Name: sbuf); fn LLVMDisposeBuilder(Builder: BuilderRef); /* Metadata */ fn LLVMSetCurrentDebugLocation(Builder: BuilderRef, L: ValueRef); fn LLVMGetCurrentDebugLocation(Builder: BuilderRef) -> ValueRef; fn LLVMSetInstDebugLocation(Builder: BuilderRef, Inst: ValueRef); /* Terminators */ fn LLVMBuildRetVoid(B: BuilderRef) -> ValueRef; fn LLVMBuildRet(B: BuilderRef, V: ValueRef) -> ValueRef; fn LLVMBuildAggregateRet(B: BuilderRef, RetVals: *ValueRef, N: uint) -> ValueRef; fn LLVMBuildBr(B: BuilderRef, Dest: BasicBlockRef) -> ValueRef; fn LLVMBuildCondBr(B: BuilderRef, If: ValueRef, Then: BasicBlockRef, Else: BasicBlockRef) -> ValueRef; fn LLVMBuildSwitch(B: BuilderRef, V: ValueRef, Else: BasicBlockRef, NumCases: uint) -> ValueRef; fn LLVMBuildIndirectBr(B: BuilderRef, Addr: ValueRef, NumDests: uint) -> ValueRef; fn LLVMBuildInvoke(B: BuilderRef, Fn: ValueRef, Args: *ValueRef, NumArgs: uint, Then: BasicBlockRef, Catch: BasicBlockRef, Name: sbuf) -> ValueRef; fn LLVMBuildUnreachable(B: BuilderRef) -> ValueRef; /* Add a case to the switch instruction */ fn LLVMAddCase(Switch: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef); /* Add a destination to the indirectbr instruction */ fn LLVMAddDestination(IndirectBr: ValueRef, Dest: BasicBlockRef); /* Arithmetic */ fn LLVMBuildAdd(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNSWAdd(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNUWAdd(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFAdd(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildSub(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNSWSub(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNUWSub(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFSub(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildMul(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNSWMul(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNUWMul(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFMul(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildUDiv(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildSDiv(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildExactSDiv(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFDiv(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildURem(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildSRem(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFRem(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildShl(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildLShr(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildAShr(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildAnd(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildOr(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildXor(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildBinOp(B: BuilderRef, Op: Opcode, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNeg(B: BuilderRef, V: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNSWNeg(B: BuilderRef, V: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNUWNeg(B: BuilderRef, V: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFNeg(B: BuilderRef, V: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildNot(B: BuilderRef, V: ValueRef, Name: sbuf) -> ValueRef; /* Memory */ fn LLVMBuildMalloc(B: BuilderRef, Ty: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildArrayMalloc(B: BuilderRef, Ty: TypeRef, Val: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildArrayAlloca(B: BuilderRef, Ty: TypeRef, Val: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFree(B: BuilderRef, PointerVal: ValueRef) -> ValueRef; fn LLVMBuildLoad(B: BuilderRef, PointerVal: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildStore(B: BuilderRef, Val: ValueRef, Ptr: ValueRef) -> ValueRef; fn LLVMBuildGEP(B: BuilderRef, Pointer: ValueRef, Indices: *ValueRef, NumIndices: uint, Name: sbuf) -> ValueRef; fn LLVMBuildInBoundsGEP(B: BuilderRef, Pointer: ValueRef, Indices: *ValueRef, NumIndices: uint, Name: sbuf) -> ValueRef; fn LLVMBuildStructGEP(B: BuilderRef, Pointer: ValueRef, Idx: uint, Name: sbuf) -> ValueRef; fn LLVMBuildGlobalString(B: BuilderRef, Str: sbuf, Name: sbuf) -> ValueRef; fn LLVMBuildGlobalStringPtr(B: BuilderRef, Str: sbuf, Name: sbuf) -> ValueRef; /* Casts */ fn LLVMBuildTrunc(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildZExt(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildSExt(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildFPToUI(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildFPToSI(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildUIToFP(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildSIToFP(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildFPTrunc(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildFPExt(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildPtrToInt(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildIntToPtr(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildBitCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildZExtOrBitCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildSExtOrBitCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildTruncOrBitCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildCast(B: BuilderRef, Op: Opcode, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildPointerCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildIntCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildFPCast(B: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef; /* Comparisons */ fn LLVMBuildICmp(B: BuilderRef, Op: uint, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildFCmp(B: BuilderRef, Op: uint, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; /* Miscellaneous instructions */ fn LLVMBuildPhi(B: BuilderRef, Ty: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildCall(B: BuilderRef, Fn: ValueRef, Args: *ValueRef, NumArgs: uint, Name: sbuf) -> ValueRef; fn LLVMBuildSelect(B: BuilderRef, If: ValueRef, Then: ValueRef, Else: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildVAArg(B: BuilderRef, list: ValueRef, Ty: TypeRef, Name: sbuf) -> ValueRef; fn LLVMBuildExtractElement(B: BuilderRef, VecVal: ValueRef, Index: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildInsertElement(B: BuilderRef, VecVal: ValueRef, EltVal: ValueRef, Index: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildShuffleVector(B: BuilderRef, V1: ValueRef, V2: ValueRef, Mask: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildExtractValue(B: BuilderRef, AggVal: ValueRef, Index: uint, Name: sbuf) -> ValueRef; fn LLVMBuildInsertValue(B: BuilderRef, AggVal: ValueRef, EltVal: ValueRef, Index: uint, Name: sbuf) -> ValueRef; fn LLVMBuildIsNull(B: BuilderRef, Val: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildIsNotNull(B: BuilderRef, Val: ValueRef, Name: sbuf) -> ValueRef; fn LLVMBuildPtrDiff(B: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: sbuf) -> ValueRef; /* Selected entries from the downcasts. */ fn LLVMIsATerminatorInst(Inst: ValueRef) -> ValueRef; /** Writes a module to the specified path. Returns 0 on success. */ fn LLVMWriteBitcodeToFile(M: ModuleRef, Path: sbuf) -> int; /** Creates target data from a target layout string. */ fn LLVMCreateTargetData(StringRep: sbuf) -> TargetDataRef; /** Adds the target data to the given pass manager. The pass manager references the target data only weakly. */ fn LLVMAddTargetData(TD: TargetDataRef, PM: PassManagerRef); /** Returns the size of a type. FIXME: rv is actually a ULongLong! */ fn LLVMStoreSizeOfType(TD: TargetDataRef, Ty: TypeRef) -> uint; /** Returns the alignment of a type. */ fn LLVMPreferredAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) -> uint; /** Disposes target data. */ fn LLVMDisposeTargetData(TD: TargetDataRef); /** Creates a pass manager. */ fn LLVMCreatePassManager() -> PassManagerRef; /** Disposes a pass manager. */ fn LLVMDisposePassManager(PM: PassManagerRef); /** Runs a pass manager on a module. */ fn LLVMRunPassManager(PM: PassManagerRef, M: ModuleRef) -> Bool; /** Adds a verification pass. */ fn LLVMAddVerifierPass(PM: PassManagerRef); fn LLVMAddGlobalOptimizerPass(PM: PassManagerRef); fn LLVMAddIPSCCPPass(PM: PassManagerRef); fn LLVMAddDeadArgEliminationPass(PM: PassManagerRef); fn LLVMAddInstructionCombiningPass(PM: PassManagerRef); fn LLVMAddCFGSimplificationPass(PM: PassManagerRef); fn LLVMAddFunctionInliningPass(PM: PassManagerRef); fn LLVMAddFunctionAttrsPass(PM: PassManagerRef); fn LLVMAddScalarReplAggregatesPass(PM: PassManagerRef); fn LLVMAddScalarReplAggregatesPassSSA(PM: PassManagerRef); fn LLVMAddJumpThreadingPass(PM: PassManagerRef); fn LLVMAddConstantPropagationPass(PM: PassManagerRef); fn LLVMAddReassociatePass(PM: PassManagerRef); fn LLVMAddLoopRotatePass(PM: PassManagerRef); fn LLVMAddLICMPass(PM: PassManagerRef); fn LLVMAddLoopUnswitchPass(PM: PassManagerRef); fn LLVMAddLoopDeletionPass(PM: PassManagerRef); fn LLVMAddLoopUnrollPass(PM: PassManagerRef); fn LLVMAddGVNPass(PM: PassManagerRef); fn LLVMAddMemCpyOptPass(PM: PassManagerRef); fn LLVMAddSCCPPass(PM: PassManagerRef); fn LLVMAddDeadStoreEliminationPass(PM: PassManagerRef); fn LLVMAddStripDeadPrototypesPass(PM: PassManagerRef); fn LLVMAddConstantMergePass(PM: PassManagerRef); fn LLVMAddArgumentPromotionPass(PM: PassManagerRef); fn LLVMAddTailCallEliminationPass(PM: PassManagerRef); fn LLVMAddIndVarSimplifyPass(PM: PassManagerRef); fn LLVMAddAggressiveDCEPass(PM: PassManagerRef); fn LLVMAddGlobalDCEPass(PM: PassManagerRef); fn LLVMAddCorrelatedValuePropagationPass(PM: PassManagerRef); fn LLVMAddPruneEHPass(PM: PassManagerRef); fn LLVMAddSimplifyLibCallsPass(PM: PassManagerRef); fn LLVMAddLoopIdiomPass(PM: PassManagerRef); fn LLVMAddEarlyCSEPass(PM: PassManagerRef); fn LLVMAddTypeBasedAliasAnalysisPass(PM: PassManagerRef); fn LLVMAddBasicAliasAnalysisPass(PM: PassManagerRef); fn LLVMPassManagerBuilderCreate() -> PassManagerBuilderRef; fn LLVMPassManagerBuilderDispose(PMB: PassManagerBuilderRef); fn LLVMPassManagerBuilderSetOptLevel(PMB: PassManagerBuilderRef, OptimizationLevel: uint); fn LLVMPassManagerBuilderSetSizeLevel(PMB: PassManagerBuilderRef, Value: Bool); fn LLVMPassManagerBuilderSetDisableUnitAtATime(PMB: PassManagerBuilderRef, Value: Bool); fn LLVMPassManagerBuilderSetDisableUnrollLoops(PMB: PassManagerBuilderRef, Value: Bool); fn LLVMPassManagerBuilderSetDisableSimplifyLibCalls(PMB: PassManagerBuilderRef, Value: Bool); fn LLVMPassManagerBuilderUseInlinerWithThreshold(PMB: PassManagerBuilderRef, threshold: uint); fn LLVMPassManagerBuilderPopulateModulePassManager(PMB: PassManagerBuilderRef, PM: PassManagerRef); fn LLVMPassManagerBuilderPopulateFunctionPassManager(PMB: PassManagerBuilderRef, PM: PassManagerRef); /** Destroys a memory buffer. */ fn LLVMDisposeMemoryBuffer(MemBuf: MemoryBufferRef); /* Stuff that's in rustllvm/ because it's not upstream yet. */ type ObjectFileRef; type SectionIteratorRef; /** Opens an object file. */ fn LLVMCreateObjectFile(MemBuf: MemoryBufferRef) -> ObjectFileRef; /** Closes an object file. */ fn LLVMDisposeObjectFile(ObjectFile: ObjectFileRef); /** Enumerates the sections in an object file. */ fn LLVMGetSections(ObjectFile: ObjectFileRef) -> SectionIteratorRef; /** Destroys a section iterator. */ fn LLVMDisposeSectionIterator(SI: SectionIteratorRef); /** Returns true if the section iterator is at the end of the section list: */ fn LLVMIsSectionIteratorAtEnd(ObjectFile: ObjectFileRef, SI: SectionIteratorRef) -> Bool; /** Moves the section iterator to point to the next section. */ fn LLVMMoveToNextSection(SI: SectionIteratorRef); /** Returns the current section name. */ fn LLVMGetSectionName(SI: SectionIteratorRef) -> sbuf; /** Returns the current section size. FIXME: The return value is actually a uint64_t! */ fn LLVMGetSectionSize(SI: SectionIteratorRef) -> uint; /** Returns the current section contents as a string buffer. */ fn LLVMGetSectionContents(SI: SectionIteratorRef) -> sbuf; /** Reads the given file and returns it as a memory buffer. Use LLVMDisposeMemoryBuffer() to get rid of it. */ fn LLVMRustCreateMemoryBufferWithContentsOfFile(Path: sbuf) -> MemoryBufferRef; /* FIXME: The FileType is an enum.*/ fn LLVMRustWriteOutputFile(PM: PassManagerRef, M: ModuleRef, Triple: sbuf, Output: sbuf, FileType: int, OptLevel: int); /** Returns a string describing the last error caused by an LLVMRust* call. */ fn LLVMRustGetLastError() -> sbuf; /** Returns a string describing the hosts triple */ fn LLVMRustGetHostTriple() -> sbuf; /** Parses the bitcode in the given memory buffer. */ fn LLVMRustParseBitcode(MemBuf: MemoryBufferRef) -> ModuleRef; /** FiXME: Hacky adaptor for lack of ULongLong in FFI: */ fn LLVMRustConstSmallInt(IntTy: TypeRef, N: uint, SignExtend: Bool) -> ValueRef; /** Turn on LLVM pass-timing. */ fn LLVMRustEnableTimePasses(); /** Print the pass timings since static dtors aren't picking them up. */ fn LLVMRustPrintPassTimings(); fn LLVMStructCreateNamed(C: ContextRef, Name: sbuf) -> TypeRef; fn LLVMStructSetBody(StructTy: TypeRef, ElementTypes: *TypeRef, ElementCount: uint, Packed: Bool); fn LLVMConstNamedStruct(S: TypeRef, ConstantVals: *ValueRef, Count: uint) -> ValueRef; /** Links LLVM modules together. `Src` is destroyed by this call and must never be referenced again. */ fn LLVMLinkModules(Dest: ModuleRef, Src: ModuleRef) -> Bool; } /* Slightly more terse object-interface to LLVM's 'builder' functions. For the * most part, build.Foo() wraps LLVMBuildFoo(), threading the correct * BuilderRef B into place. A BuilderRef is a cursor-like LLVM value that * inserts instructions for a particular BasicBlockRef at a particular * position; for our purposes, it always inserts at the end of the basic block * it's attached to. */ resource BuilderRef_res(B: BuilderRef) { llvm::LLVMDisposeBuilder(B); } obj builder(B: BuilderRef, terminated: @mutable bool, // Stored twice so that we don't have to constantly deref res: @BuilderRef_res) { /* Terminators */ fn RetVoid() -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildRetVoid(B); } fn Ret(V: ValueRef) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildRet(B, V); } fn AggregateRet(RetVals: &[ValueRef]) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildAggregateRet(B, vec::to_ptr(RetVals), vec::len(RetVals)); } fn Br(Dest: BasicBlockRef) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildBr(B, Dest); } fn CondBr(If: ValueRef, Then: BasicBlockRef, Else: BasicBlockRef) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildCondBr(B, If, Then, Else); } fn Switch(V: ValueRef, Else: BasicBlockRef, NumCases: uint) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildSwitch(B, V, Else, NumCases); } fn IndirectBr(Addr: ValueRef, NumDests: uint) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildIndirectBr(B, Addr, NumDests); } fn Invoke(Fn: ValueRef, Args: &[ValueRef], Then: BasicBlockRef, Catch: BasicBlockRef) -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildInvoke(B, Fn, vec::to_ptr(Args), vec::len(Args), Then, Catch, str::buf("")); } fn Unreachable() -> ValueRef { assert (!*terminated); *terminated = true; ret llvm::LLVMBuildUnreachable(B); } /* Arithmetic */ fn Add(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildAdd(B, LHS, RHS, str::buf("")); } fn NSWAdd(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNSWAdd(B, LHS, RHS, str::buf("")); } fn NUWAdd(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNUWAdd(B, LHS, RHS, str::buf("")); } fn FAdd(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFAdd(B, LHS, RHS, str::buf("")); } fn Sub(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSub(B, LHS, RHS, str::buf("")); } fn NSWSub(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNSWSub(B, LHS, RHS, str::buf("")); } fn NUWSub(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNUWSub(B, LHS, RHS, str::buf("")); } fn FSub(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFSub(B, LHS, RHS, str::buf("")); } fn Mul(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildMul(B, LHS, RHS, str::buf("")); } fn NSWMul(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNSWMul(B, LHS, RHS, str::buf("")); } fn NUWMul(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNUWMul(B, LHS, RHS, str::buf("")); } fn FMul(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFMul(B, LHS, RHS, str::buf("")); } fn UDiv(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildUDiv(B, LHS, RHS, str::buf("")); } fn SDiv(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSDiv(B, LHS, RHS, str::buf("")); } fn ExactSDiv(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildExactSDiv(B, LHS, RHS, str::buf("")); } fn FDiv(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFDiv(B, LHS, RHS, str::buf("")); } fn URem(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildURem(B, LHS, RHS, str::buf("")); } fn SRem(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSRem(B, LHS, RHS, str::buf("")); } fn FRem(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFRem(B, LHS, RHS, str::buf("")); } fn Shl(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildShl(B, LHS, RHS, str::buf("")); } fn LShr(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildLShr(B, LHS, RHS, str::buf("")); } fn AShr(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildAShr(B, LHS, RHS, str::buf("")); } fn And(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildAnd(B, LHS, RHS, str::buf("")); } fn Or(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildOr(B, LHS, RHS, str::buf("")); } fn Xor(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildXor(B, LHS, RHS, str::buf("")); } fn BinOp(Op: Opcode, LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildBinOp(B, Op, LHS, RHS, str::buf("")); } fn Neg(V: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNeg(B, V, str::buf("")); } fn NSWNeg(V: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNSWNeg(B, V, str::buf("")); } fn NUWNeg(V: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNUWNeg(B, V, str::buf("")); } fn FNeg(V: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFNeg(B, V, str::buf("")); } fn Not(V: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildNot(B, V, str::buf("")); } /* Memory */ fn Malloc(Ty: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildMalloc(B, Ty, str::buf("")); } fn ArrayMalloc(Ty: TypeRef, Val: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildArrayMalloc(B, Ty, Val, str::buf("")); } fn Alloca(Ty: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildAlloca(B, Ty, str::buf("")); } fn ArrayAlloca(Ty: TypeRef, Val: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildArrayAlloca(B, Ty, Val, str::buf("")); } fn Free(PointerVal: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFree(B, PointerVal); } fn Load(PointerVal: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildLoad(B, PointerVal, str::buf("")); } fn Store(Val: ValueRef, Ptr: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildStore(B, Val, Ptr); } fn GEP(Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildGEP(B, Pointer, vec::to_ptr(Indices), vec::len(Indices), str::buf("")); } fn InBoundsGEP(Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildInBoundsGEP(B, Pointer, vec::to_ptr(Indices), vec::len(Indices), str::buf("")); } fn StructGEP(Pointer: ValueRef, Idx: uint) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildStructGEP(B, Pointer, Idx, str::buf("")); } fn GlobalString(_Str: sbuf) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildGlobalString(B, _Str, str::buf("")); } fn GlobalStringPtr(_Str: sbuf) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildGlobalStringPtr(B, _Str, str::buf("")); } /* Casts */ fn Trunc(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildTrunc(B, Val, DestTy, str::buf("")); } fn ZExt(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildZExt(B, Val, DestTy, str::buf("")); } fn SExt(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSExt(B, Val, DestTy, str::buf("")); } fn FPToUI(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFPToUI(B, Val, DestTy, str::buf("")); } fn FPToSI(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFPToSI(B, Val, DestTy, str::buf("")); } fn UIToFP(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildUIToFP(B, Val, DestTy, str::buf("")); } fn SIToFP(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSIToFP(B, Val, DestTy, str::buf("")); } fn FPTrunc(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFPTrunc(B, Val, DestTy, str::buf("")); } fn FPExt(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFPExt(B, Val, DestTy, str::buf("")); } fn PtrToInt(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildPtrToInt(B, Val, DestTy, str::buf("")); } fn IntToPtr(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildIntToPtr(B, Val, DestTy, str::buf("")); } fn BitCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildBitCast(B, Val, DestTy, str::buf("")); } fn ZExtOrBitCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, str::buf("")); } fn SExtOrBitCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, str::buf("")); } fn TruncOrBitCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, str::buf("")); } fn Cast(Op: Opcode, Val: ValueRef, DestTy: TypeRef, Name: sbuf) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildCast(B, Op, Val, DestTy, str::buf("")); } fn PointerCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildPointerCast(B, Val, DestTy, str::buf("")); } fn IntCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildIntCast(B, Val, DestTy, str::buf("")); } fn FPCast(Val: ValueRef, DestTy: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFPCast(B, Val, DestTy, str::buf("")); } /* Comparisons */ fn ICmp(Op: uint, LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildICmp(B, Op, LHS, RHS, str::buf("")); } fn FCmp(Op: uint, LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildFCmp(B, Op, LHS, RHS, str::buf("")); } /* Miscellaneous instructions */ fn Phi(Ty: TypeRef, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef { assert (!*terminated); let phi = llvm::LLVMBuildPhi(B, Ty, str::buf("")); assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs)); llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs), vec::len(vals)); ret phi; } fn AddIncomingToPhi(phi: ValueRef, vals: &[ValueRef], bbs: &[BasicBlockRef]) { assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs)); llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs), vec::len(vals)); } fn Call(Fn: ValueRef, Args: &[ValueRef]) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args), str::buf("")); } fn FastCall(Fn: ValueRef, Args: &[ValueRef]) -> ValueRef { assert (!*terminated); let v = llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args), str::buf("")); llvm::LLVMSetInstructionCallConv(v, LLVMFastCallConv); ret v; } fn CallWithConv(Fn: ValueRef, Args: &[ValueRef], Conv: uint) -> ValueRef { assert (!*terminated); let v = llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args), str::buf("")); llvm::LLVMSetInstructionCallConv(v, Conv); ret v; } fn Select(If: ValueRef, Then: ValueRef, Else: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildSelect(B, If, Then, Else, str::buf("")); } fn VAArg(list: ValueRef, Ty: TypeRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildVAArg(B, list, Ty, str::buf("")); } fn ExtractElement(VecVal: ValueRef, Index: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildExtractElement(B, VecVal, Index, str::buf("")); } fn InsertElement(VecVal: ValueRef, EltVal: ValueRef, Index: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index, str::buf("")); } fn ShuffleVector(V1: ValueRef, V2: ValueRef, Mask: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, str::buf("")); } fn ExtractValue(AggVal: ValueRef, Index: uint) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildExtractValue(B, AggVal, Index, str::buf("")); } fn InsertValue(AggVal: ValueRef, EltVal: ValueRef, Index: uint) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index, str::buf("")); } fn IsNull(Val: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildIsNull(B, Val, str::buf("")); } fn IsNotNull(Val: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildIsNotNull(B, Val, str::buf("")); } fn PtrDiff(LHS: ValueRef, RHS: ValueRef) -> ValueRef { assert (!*terminated); ret llvm::LLVMBuildPtrDiff(B, LHS, RHS, str::buf("")); } fn Trap() -> ValueRef { assert (!*terminated); let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(B); let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB); let M: ModuleRef = llvm::LLVMGetGlobalParent(FN); let T: ValueRef = llvm::LLVMGetNamedFunction(M, str::buf("llvm.trap")); assert (T as int != 0); let Args: [ValueRef] = ~[]; ret llvm::LLVMBuildCall(B, T, vec::to_ptr(Args), vec::len(Args), str::buf("")); } fn is_terminated() -> bool { ret *terminated; } } fn new_builder(llbb: BasicBlockRef) -> builder { let llbuild: BuilderRef = llvm::LLVMCreateBuilder(); llvm::LLVMPositionBuilderAtEnd(llbuild, llbb); ret builder(llbuild, @mutable false, @BuilderRef_res(llbuild)); } /* Memory-managed object interface to type handles. */ obj type_names(type_names: std::map::hashmap, named_types: std::map::hashmap) { fn associate(s: str, t: TypeRef) { assert (!named_types.contains_key(s)); assert (!type_names.contains_key(t)); type_names.insert(t, s); named_types.insert(s, t); } fn type_has_name(t: TypeRef) -> bool { ret type_names.contains_key(t); } fn get_name(t: TypeRef) -> str { ret type_names.get(t); } fn name_has_type(s: str) -> bool { ret named_types.contains_key(s); } fn get_type(s: str) -> TypeRef { ret named_types.get(s); } } fn mk_type_names() -> type_names { let nt = std::map::new_str_hash[TypeRef](); fn hash(t: &TypeRef) -> uint { ret t as uint; } fn eq(a: &TypeRef, b: &TypeRef) -> bool { ret a as uint == b as uint; } let hasher: std::map::hashfn = hash; let eqer: std::map::eqfn = eq; let tn = std::map::mk_hashmap[TypeRef, str](hasher, eqer); ret type_names(tn, nt); } fn type_to_str(names: type_names, ty: TypeRef) -> str { ret type_to_str_inner(names, ~[], ty); } fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> str { if names.type_has_name(ty) { ret names.get_name(ty); } let outer = outer0 + ~[ty]; let kind: int = llvm::LLVMGetTypeKind(ty); fn tys_str(names: type_names, outer: &[TypeRef], tys: &[TypeRef]) -> str { let s: str = ""; let first: bool = true; for t: TypeRef in tys { if first { first = false; } else { s += ", "; } s += type_to_str_inner(names, outer, t); } ret s; } alt kind { // FIXME: more enum-as-int constants determined from Core::h; // horrible, horrible. Complete as needed. 0 { ret "Void"; } 1 { ret "Float"; } 2 { ret "Double"; } 3 { ret "X86_FP80"; } 4 { ret "FP128"; } 5 { ret "PPC_FP128"; } 6 { ret "Label"; } 7 { ret "i" + std::int::str(llvm::LLVMGetIntTypeWidth(ty) as int); } 8 { let s = "fn("; let out_ty: TypeRef = llvm::LLVMGetReturnType(ty); let n_args: uint = llvm::LLVMCountParamTypes(ty); let args: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_args); llvm::LLVMGetParamTypes(ty, vec::to_ptr(args)); s += tys_str(names, outer, args); s += ") -> "; s += type_to_str_inner(names, outer, out_ty); ret s; } 9 { let s: str = "{"; let n_elts: uint = llvm::LLVMCountStructElementTypes(ty); let elts: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_elts); llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts)); s += tys_str(names, outer, elts); s += "}"; ret s; } 10 { let el_ty = llvm::LLVMGetElementType(ty); ret "[" + type_to_str_inner(names, outer, el_ty) + "]"; } 11 { let i: uint = 0u; for tout: TypeRef in outer0 { i += 1u; if tout as int == ty as int { let n: uint = vec::len[TypeRef](outer0) - i; ret "*\\" + std::int::str(n as int); } } ret "*" + type_to_str_inner(names, outer, llvm::LLVMGetElementType(ty)); } 12 { ret "Opaque"; } 13 { ret "Vector"; } 14 { ret "Metadata"; } _ { log_err #fmt("unknown TypeKind %d", kind as int); fail; } } } fn float_width(llt: TypeRef) -> uint { ret alt llvm::LLVMGetTypeKind(llt) { 1 { 32u } 2 { 64u } 3 { 80u } 4 | 5 { 128u } _ { fail "llvm_float_width called on a non-float type" } }; } fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] { let args = vec::init_elt(0 as TypeRef, llvm::LLVMCountParamTypes(fn_ty)); llvm::LLVMGetParamTypes(fn_ty, vec::to_ptr(args)); ret args; } /* Memory-managed interface to target data. */ resource target_data_res(TD: TargetDataRef) { llvm::LLVMDisposeTargetData(TD); } type target_data = {lltd: TargetDataRef, dtor: @target_data_res}; fn mk_target_data(string_rep: str) -> target_data { let lltd = llvm::LLVMCreateTargetData(str::buf(string_rep)); ret {lltd: lltd, dtor: @target_data_res(lltd)}; } /* Memory-managed interface to pass managers. */ resource pass_manager_res(PM: PassManagerRef) { llvm::LLVMDisposePassManager(PM); } type pass_manager = {llpm: PassManagerRef, dtor: @pass_manager_res}; fn mk_pass_manager() -> pass_manager { let llpm = llvm::LLVMCreatePassManager(); ret {llpm: llpm, dtor: @pass_manager_res(llpm)}; } /* Memory-managed interface to object files. */ resource object_file_res(ObjectFile: ObjectFileRef) { llvm::LLVMDisposeObjectFile(ObjectFile); } type object_file = {llof: ObjectFileRef, dtor: @object_file_res}; fn mk_object_file(llmb: MemoryBufferRef) -> object_file { let llof = llvm::LLVMCreateObjectFile(llmb); ret {llof: llof, dtor: @object_file_res(llof)}; } /* Memory-managed interface to section iterators. */ resource section_iter_res(SI: SectionIteratorRef) { llvm::LLVMDisposeSectionIterator(SI); } type section_iter = {llsi: SectionIteratorRef, dtor: @section_iter_res}; fn mk_section_iter(llof: ObjectFileRef) -> section_iter { let llsi = llvm::LLVMGetSections(llof); ret {llsi: llsi, dtor: @section_iter_res(llsi)}; } // // Local Variables: // mode: rust // fill-column: 78; // indent-tabs-mode: nil // c-basic-offset: 4 // buffer-file-coding-system: utf-8-unix // compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'"; // End: //