public static void AddIncoming(LLVMValueRef PhiNode, LLVMValueRef[] IncomingValues, LLVMBasicBlockRef[] IncomingBlocks, uint Count) { if (Count == 0) { return; } AddIncoming(PhiNode, out IncomingValues[0], out IncomingBlocks[0], Count); }
public FnCompiler(DetailLogger log, SymbolTableWalker walker, LLVMContextRef context, LLVMModuleRef module, LLVMBuilderRef builder, LLVMValueRef self) { this.log = log; this.walker = walker; this.context = context; this.module = module; this.builder = builder; this.self = self; }
public static LLVMValueRef BuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, LLVMValueRef[] Indices, string Name) { if (Indices.Length == 0) { LLVMValueRef dummy; return BuildInBoundsGEP(B, Pointer, out dummy, 0, Name); } return BuildInBoundsGEP(B, Pointer, out Indices[0], (uint)Indices.Length, Name); }
public static LLVMValueRef ConstArray(LLVMTypeRef ElementTy, LLVMValueRef[] ConstantVals) { if (ConstantVals.Length == 0) { LLVMValueRef dummy; return ConstArray(ElementTy, out dummy, 0); } return ConstArray(ElementTy, out ConstantVals[0], (uint)ConstantVals.Length); }
public static LLVMValueRef BuildInvoke(LLVMBuilderRef param0, LLVMValueRef Fn, LLVMValueRef[] Args, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, string Name) { if (Args.Length == 0) { LLVMValueRef dummy; return BuildInvoke(param0, Fn, out dummy, 0, Then, Catch, Name); } return BuildInvoke(param0, Fn, out Args[0], (uint)Args.Length, Then, Catch, Name); }
public static LLVMValueRef ConstExtractValue(LLVMValueRef AggConstant, uint[] IdxList) { if (IdxList.Length == 0) { uint dummy; return ConstExtractValue(AggConstant, out dummy, 0); } return ConstExtractValue(AggConstant, out IdxList[0], (uint)IdxList.Length); }
public void SetLLVMRegister(string variableName, ClepsType variableType, LLVMValueRef llvmValueRef) { var localVariablesBlockWithVar = LocalVariableBlocks.Where(b => b.ContainsKey(variableName)).LastOrDefault(); Debug.Assert(localVariablesBlockWithVar != null); LLVMRegister ret = localVariablesBlockWithVar[variableName]; Debug.Assert(ret.VariableType == variableType); localVariablesBlockWithVar[variableName] = new LLVMRegister(variableType, llvmValueRef); }
public static LLVMValueRef BuildCall(LLVMBuilderRef param0, LLVMValueRef Fn, LLVMValueRef[] Args, string Name) { if (Args.Length == 0) { LLVMValueRef dummy; return BuildCall(param0, Fn, out dummy, 0, Name); } return BuildCall(param0, Fn, out Args[0], (uint)Args.Length, Name); }
public static LLVMValueRef MDNode(LLVMValueRef[] Vals) { if (Vals.Length == 0) { LLVMValueRef dummy; return MDNode(out dummy, 0); } return MDNode(out Vals[0], (uint)Vals.Length); }
public static LLVMValueRef[] GetMDNodeOperands(LLVMValueRef V) { uint count = GetMDNodeNumOperands(V); var buffer = new LLVMValueRef[count]; if (count > 0) { GetMDNodeOperands(V, out buffer[0]); } return buffer; }
public static LLVMValueRef[] GetParams(LLVMValueRef Fn) { uint count = CountParams(Fn); var buffer = new LLVMValueRef[count]; if (count > 0) { GetParams(Fn, out buffer[0]); } return buffer; }
internal ReturnInst(LLVMValueRef handle) : base(handle.IsAReturnInst) { }
public LLVMGenericValueRef RunFunction(LLVMValueRef @F, LLVMGenericValueRef[] @Args) { return(LLVM.RunFunction(this.instance, @F, @Args)); }
public LLVMBasicBlockRef AppendBasicBlockInContext(LLVMValueRef @Fn, string @Name) { return LLVM.AppendBasicBlockInContext(this, @Fn, @Name); }
public int RunFunctionAsMain(LLVMValueRef @F, uint @ArgC, string[] @ArgV, string[] @EnvP) { return LLVM.RunFunctionAsMain(this.instance, @F, @ArgC, @ArgV, @EnvP); }
public static extern LLVMValueRef DIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef @D, LLVMValueRef @Storage, LLVMMetadataRef @VarInfo, LLVMMetadataRef @Expr, LLVMBasicBlockRef @Block);
public static extern LLVMValueRef DIBuilderInsertValueAtEnd(LLVMDIBuilderRef @D, LLVMValueRef @Val, ulong @Offset, LLVMMetadataRef @VarInfo, LLVMMetadataRef @Expr, LLVMBasicBlockRef @Block);
private protected UnaryInstruction(LLVMValueRef handle) : base(handle.IsAUnaryInstruction) { }
internal BitCastInst(LLVMValueRef handle) : base(handle.IsABitCastInst) { }
internal static new UnaryInstruction Create(LLVMValueRef handle) => handle switch {
public bool FindFunction(string @Name, out LLVMValueRef @OutFn) { return(LLVM.FindFunction(this.instance, @Name, out @OutFn)); }
public void FreeMachineCodeForFunction(LLVMValueRef @F) { LLVM.FreeMachineCodeForFunction(this.instance, @F); }
public IntPtr GetPointerToGlobal(LLVMValueRef @Global) { return(LLVM.GetPointerToGlobal(this.instance, @Global)); }
public static extern ulong GetFunctionAttr2(LLVMValueRef @Fn);
internal FenceInst(LLVMValueRef handle) : base(handle.IsAFenceInst) { }
public static extern void RemoveFunctionAttr2(LLVMValueRef @Fn, ulong @PA);
public IntPtr RecompileAndRelinkFunction(LLVMValueRef @Fn) { return LLVM.RecompileAndRelinkFunction(this.instance, @Fn); }
public static LLVMValueRef ConstNamedStruct(LLVMTypeRef StructTy, LLVMValueRef[] ConstantVals) { if (ConstantVals.Length == 0) { LLVMValueRef dummy; return ConstNamedStruct(StructTy, out dummy, 0); } return ConstNamedStruct(StructTy, out ConstantVals[0], (uint)ConstantVals.Length); }
public bool FindFunction(string @Name, out LLVMValueRef @OutFn) { return LLVM.FindFunction(this.instance, @Name, out @OutFn); }
public static LLVMValueRef ConstVector(LLVMValueRef[] ScalarConstantVars) { if (ScalarConstantVars.Length == 0) { LLVMValueRef dummy; return ConstVector(out dummy, 0); } return ConstVector(out ScalarConstantVars[0], (uint)ScalarConstantVars.Length); }
public static extern LLVMMetadataRef ConstantAsMetadata(LLVMValueRef @Val);
public int RunFunctionAsMain(LLVMValueRef @F, uint @ArgC, string[] @ArgV, string[] @EnvP) { return(LLVM.RunFunctionAsMain(this.instance, @F, @ArgC, @ArgV, @EnvP)); }
public static LLVMValueRef ConstStructInContext(LLVMContextRef C, LLVMValueRef[] ConstantVals, bool Packed) { if (ConstantVals.Length == 0) { LLVMValueRef dummy; return ConstStructInContext(C, out dummy, 0, Packed); } return ConstStructInContext(C, out ConstantVals[0], (uint)ConstantVals.Length, Packed); }
public static extern void SetMetadata2(LLVMValueRef @Inst, uint @KindID, LLVMMetadataRef @MD);
public static LLVMValueRef BuildAggregateRet(LLVMBuilderRef param0, LLVMValueRef[] RetVals) { return BuildAggregateRet(param0, out RetVals[0], (uint)RetVals.Length); }
public static extern LLVMMetadataRef DIBuilderCreateFunction(LLVMDIBuilderRef @D, LLVMMetadataRef @Scope, [MarshalAs(UnmanagedType.LPStr)] string @Name, [MarshalAs(UnmanagedType.LPStr)] string @LinkageName, LLVMMetadataRef @File, uint @Line, LLVMMetadataRef @CompositeType, int @IsLocalToUnit, int @IsDefinition, uint @ScopeLine, uint @Flags, int @IsOptimized, LLVMValueRef @Function);
public static LLVMValueRef[] GetNamedMetadataOperands(LLVMModuleRef M, string name) { uint count = GetNamedMetadataNumOperands(M, name); var buffer = new LLVMValueRef[count]; if (count > 0) { GetNamedMetadataOperands(M, name, out buffer[0]); } return buffer; }
internal static new CmpInst Create(LLVMValueRef handle) => handle switch {
public static LLVMGenericValueRef RunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, LLVMGenericValueRef[] Args) { if (Args.Length == 0) { LLVMGenericValueRef dummy; return RunFunction(EE, F, 0, out dummy); } return RunFunction(EE, F, (uint)Args.Length, out Args[0]); }
public IntPtr RecompileAndRelinkFunction(LLVMValueRef @Fn) { return(LLVM.RecompileAndRelinkFunction(this.instance, @Fn)); }
public static LLVMValueRef MDNodeInContext(LLVMContextRef C, LLVMValueRef[] Vals) { if (Vals.Length == 0) { LLVMValueRef dummy; return MDNodeInContext(C, out dummy, 0); } return MDNodeInContext(C, out Vals[0], (uint)Vals.Length); }
public void AddGlobalMapping(LLVMValueRef @Global, IntPtr @Addr) { LLVM.AddGlobalMapping(this.instance, @Global, @Addr); }
private protected CmpInst(LLVMValueRef handle) : base(handle.IsACmpInst) { }
internal ConstantInt(LLVMValueRef handle) : base(handle.IsAConstantInt, LLVMValueKind.LLVMConstantIntValueKind) { }
public static LLVMValueRef ConstGEP(LLVMValueRef ConstantVal, LLVMValueRef[] ConstantIndices) { if (ConstantIndices.Length == 0) { LLVMValueRef dummy; return ConstGEP(ConstantVal, out dummy, 0); } return ConstGEP(ConstantVal, out ConstantIndices[0], (uint)ConstantIndices.Length); }
public LLVMValueRef MDNodeInContext(LLVMValueRef[] @Vals) { return LLVM.MDNodeInContext(this, @Vals); }
internal LoadInst(LLVMValueRef handle) : base(handle.IsALoadInst) { }
internal GlobalIFunc(LLVMValueRef handle) : base(handle.IsAGlobalIFunc, LLVMValueKind.LLVMGlobalIFuncValueKind) { }
public ScoreVal(Span span, TyRef ty, LLVMValueRef value) { this.ty = ty; this.value = value; }
internal Function(LLVMValueRef handle) : base(handle.IsAFunction, LLVMValueKind.LLVMFunctionValueKind) { }
public LLVMValueRef ConstStructInContext(LLVMValueRef[] @ConstantVals, bool @Packed) { return LLVM.ConstStructInContext(this, @ConstantVals, @Packed); }
internal BlockAddress(LLVMValueRef handle) : base(handle.IsABlockAddress, LLVMValueKind.LLVMBlockAddressValueKind) { }
public IntPtr GetPointerToGlobal(LLVMValueRef @Global) { return LLVM.GetPointerToGlobal(this.instance, @Global); }
internal InsertElementInst(LLVMValueRef handle) : base(handle.IsAInsertElementInst) { }
public LLVMGenericValueRef RunFunction(LLVMValueRef @F, LLVMGenericValueRef[] @Args) { return LLVM.RunFunction(this.instance, @F, @Args); }
internal ConstantDataArray(LLVMValueRef handle) : base(handle.IsAConstantDataArray, LLVMValueKind.LLVMConstantDataArrayValueKind) { }
public Int32CompilerResult(LLVMValueRef reference) { this.reference = reference; }
internal AtomicCmpXchgInst(LLVMValueRef handle) : base(handle.IsAAtomicCmpXchgInst) { }