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]) { }