public static String Tostring(TypeRef type)
{
string ret = type.TypeKind.ToString();
if (type.TypeKind == LLVMTypeKind.PointerTypeKind)
ret += " to " + Native.GetTypeKind(type.PointedType).ToString();
return ret;
}
/// <summary>
/// Create a function with arguments and a return type.
/// </summary>
/// <param name="module"></param>
/// <param name="name"></param>
/// <param name="returnType"></param>
/// <param name="paramTypes"></param>
public Function(Module module, string name, TypeRef returnType, TypeRef[] paramTypes)
{
m_name = name;
m_returnType = returnType;
m_paramTypes = paramTypes;
IntPtr[] paramArray = LLVMHelper.MarshallPointerArray(paramTypes);
m_funcType = Native.FunctionType(returnType.Handle, paramArray, (uint)paramArray.Length, 0);
m_handle = Native.AddFunction(module.Handle, name, m_funcType);
}
public Function(string name, LLVMValueRef* handle)
{
m_name = name;
m_handle = handle;
m_funcType = Native.GetElementType(Native.TypeOf(handle));
m_returnType = new TypeRef(Native.GetReturnType(m_funcType));
uint paramCount = Native.CountParamTypes(m_funcType);
m_paramTypes = new TypeRef[paramCount];
if(paramCount > 0)
{
IntPtr[] types = new IntPtr[paramCount];
Native.GetParamTypes(m_funcType, types);
for(int i = 0; i < paramCount; ++i)
{
m_paramTypes[i] = new TypeRef((LLVMTypeRef*)types[i]);
}
}
}
public static TypeRef CreatePointer(TypeRef target)
{
Guard.ArgumentNull(target, "target");
return new TypeRef(Native.PointerType(target.Handle, 0), target.Handle);
}
public Value BuildPhi(TypeRef type, string name, PhiIncoming incoming)
{
IntPtr[] valPointers = incoming.GetValuePointers();
IntPtr[] blockPointers = incoming.GetBlockPointers();
LLVMValueRef* phi = Native.BuildPhi(m_builder, type.Handle, name);
Native.AddIncoming(phi, valPointers, blockPointers, (uint)valPointers.Length);
return new Value(phi);
}
public Value BuildEntryBlockAlloca(Function function, TypeRef type, string varName = tmpvarname)
{
LLVMBasicBlockRef* block = Native.GetInsertBlock(m_builder);
LLVMBasicBlockRef* entry = Native.GetEntryBasicBlock(function.Handle);
Native.PositionBuilderAtEnd(m_builder, entry);
LLVMValueRef* alloca = Native.BuildAlloca(m_builder, type.Handle, varName);
Native.PositionBuilderAtEnd(m_builder, block);
return new Value(alloca);
}
public Value BuildAlloca(TypeRef arg, string name = tmpvarname)
{
return new Value(Native.BuildAlloca(m_builder, arg.Handle, name));
}
public Value AddGlobal(Module module, TypeRef type, String name)
{
return new Value(Native.AddGlobal(module.Handle, type.Handle, name));
}
public Value BuildIntToPtr(Value arg, TypeRef ptrType, string name = tmpvarname)
{
return new Value(Native.BuildIntToPtr(m_builder, arg.Handle, ptrType.Handle, name));
}
public Value BuildFCmpAndPromote(Value lhs, LLVMRealPredicate predicate, Value rhs, TypeRef promoteType)
{
lhs = BuildFCmp(lhs, predicate, rhs);
return new Value(Native.BuildUIToFP(m_builder, lhs.Handle, promoteType.Handle, "promotetmp"));
}
public static Value CreateConstInt(TypeRef type, long value)
{
return new Value(Native.ConstInt(type.Handle, (ulong)value, 1));
}
public static Value CreateConstReal(TypeRef type, double value)
{
return new Value(Native.ConstReal(type.Handle, value));
}
public static Value CreateConstUInt(TypeRef type, ulong value)
{
return new Value(Native.ConstInt(type.Handle, value, 0));
}
/// <summary>
/// Create a function that takes no arguments
/// </summary>
/// <param name="module"></param>
/// <param name="name"></param>
/// <param name="returnType"></param>
public Function(Module module, string name, TypeRef returnType)
: this(module, name, returnType, new TypeRef[0])
{
}
