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 void AddGlobalMapping(LLVMValueRef @Global, IntPtr @Addr)
{
LLVM.AddGlobalMapping(this.instance, @Global, @Addr);
}
public Int32CompilerResult(LLVMValueRef reference)
{
this.reference = reference;
}
public void FreeMachineCodeForFunction(LLVMValueRef @F)
{
LLVM.FreeMachineCodeForFunction(this.instance, @F);
}
internal AtomicCmpXchgInst(LLVMValueRef handle) : base(handle.IsAAtomicCmpXchgInst)
{
}
