Inheritance: IDisposable, IPointerWrapper
Exemple #1
0
        static void Main(string[] args)
        {
            var context = new LLVMContext();
            var module = new Module("NoName", context);
            var builder = new IRBuilder(context);
            var t = builder.getInt32Ty();
            var funcType = FunctionType.get(t, false);
            var main = Function.Create(funcType, GlobalValue.LinkageTypes.ExternalLinkage, "main", module);
            var entry = BasicBlock.Create(context, "entrypoint", main);
            builder.SetInsertPoint(entry);

            var hello = builder.CreateGlobalStringPtr("Hello, World!");

            var putsType = FunctionType.get(builder.getInt32Ty(),
                new[] { builder.getInt8Ty().getPointerTo(0) }, false);
            var putsFunc = module.getOrInsertFunction("puts", putsType);

            builder.CreateCall(putsFunc, hello);

            var variable = builder.CreateAlloca(t);
            var val = ConstantInt.get(t, 127);
            builder.CreateStore(val, variable);

            builder.CreateRetVoid();

            var pm = new PassManager();
            var os = new raw_fd_ostream("code.ll");
            pm.add(Passes.createPrintModulePass(os));
            pm.run(module);
            os.close();

            Console.ReadKey();
        }
Exemple #2
0
    static void Main()
    {
        LLVM.Module module = new LLVM.Module("test_type");

        module.AddTypeName("int1", LLVM.Type.GetInt1());
        module.AddTypeName("int8", LLVM.Type.GetInt8());
        module.AddTypeName("int16", LLVM.Type.GetInt16());
        module.AddTypeName("int32", LLVM.Type.GetInt32());
        module.AddTypeName("int64", LLVM.Type.GetInt64());
        module.AddTypeName("int24", LLVM.Type.GetIntN(24));
        module.AddTypeName("int48", LLVM.IntegerType.Get(48));

        LLVM.Type[] arr = new LLVM.Type[] {LLVM.Type.GetInt8(), LLVM.Type.GetInt8(), LLVM.Type.GetInt32()};
        module.AddTypeName("structtype", LLVM.StructType.Get(arr));

        module.AddTypeName("arraytype", LLVM.ArrayType.Get(LLVM.Type.GetInt8(), 10));

        module.AddTypeName("pointertype", LLVM.PointerType.Get(LLVM.Type.GetInt8(), 0));

        module.AddTypeName("opaquetype", LLVM.OpaqueType.Get());

        LLVM.OpaqueType o  = LLVM.OpaqueType.Get();
        LLVM.TypeHandle th = new LLVM.TypeHandle(o);
        LLVM.StructType st = LLVM.StructType.Get(new LLVM.Type[] {LLVM.Type.GetInt32(), o});
        o.RefineAbstractTypeTo(st);
        module.AddTypeName("refinedtype", th.Resolve());

        module.Dump();
    }
Exemple #3
0
    static void Main()
    {
        LLVM.Module module = new LLVM.Module("test_type");

        module.AddTypeName("int1", LLVM.Type.GetInt1());
        module.AddTypeName("int8", LLVM.Type.GetInt8());
        module.AddTypeName("int16", LLVM.Type.GetInt16());
        module.AddTypeName("int32", LLVM.Type.GetInt32());
        module.AddTypeName("int64", LLVM.Type.GetInt64());
        module.AddTypeName("int24", LLVM.Type.GetIntN(24));
        module.AddTypeName("int48", LLVM.IntegerType.Get(48));

        LLVM.Type[] arr = new LLVM.Type[] { LLVM.Type.GetInt8(), LLVM.Type.GetInt8(), LLVM.Type.GetInt32() };
        module.AddTypeName("structtype", LLVM.StructType.Get(arr));

        module.AddTypeName("arraytype", LLVM.ArrayType.Get(LLVM.Type.GetInt8(), 10));

        module.AddTypeName("pointertype", LLVM.PointerType.Get(LLVM.Type.GetInt8(), 0));

        module.AddTypeName("opaquetype", LLVM.OpaqueType.Get());

        LLVM.OpaqueType o  = LLVM.OpaqueType.Get();
        LLVM.TypeHandle th = new LLVM.TypeHandle(o);
        LLVM.StructType st = LLVM.StructType.Get(new LLVM.Type[] { LLVM.Type.GetInt32(), o });
        o.RefineAbstractTypeTo(st);
        module.AddTypeName("refinedtype", th.Resolve());

        module.Dump();
    }
Exemple #4
0
        private static Function EmitFunction(Module module, MethodBase method)
        {
            var methodInfo = method as MethodInfo;
            var methodConstructor = method as ConstructorInfo;
            var declaringType = method.DeclaringType;
            if (methodInfo == null && methodConstructor == null)
                throw new CudaSharpException("Unknown MethodBase type " + method.GetType().FullName);
            if (declaringType == null)
                throw new CudaSharpException("Could not find the declaring type of " + method.Name.StripNameToValidPtx());

            var parameters = method.GetParameters().Select(p => p.ParameterType);
            if (methodConstructor != null)
                parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
            if (methodInfo != null && methodInfo.IsStatic == false)
            {
                if (declaringType.IsValueType == false)
                    throw new CudaSharpException("Cannot compile object instance methods (did you forget to mark the method as static?)");
                parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
            }
            var llvmParameters =
                parameters.Select(t => ConvertType(module, t)).ToArray();
            var funcType = new FunctionType(ConvertType(module, methodInfo == null ? typeof(void) : methodInfo.ReturnType), llvmParameters);

            var intrinsic = method.GetCustomAttribute<Gpu.BuiltinAttribute>();
            if (intrinsic != null)
            {
                var name = intrinsic.Intrinsic;
                var preExisting = module.GetFunction(name);
                if (preExisting != null)
                    return preExisting;
                return module.CreateFunction(name, funcType);
            }

            var function = module.CreateFunction(methodConstructor == null ? method.Name.StripNameToValidPtx() : declaringType.Name.StripNameToValidPtx() + "_ctor", funcType);

            var block = new Block("entry", module.Context, function);
            var writer = new InstructionBuilder(module.Context, block);

            var opcodes = method.Disassemble().ToList();
            FindBranchTargets(opcodes, module.Context, function);

            var body = method.GetMethodBody();
            var efo = new EmitFuncObj(module, function, body, writer, null, new Stack<Value>(),
                body == null ? null : new Value[body.LocalVariables.Count], new Value[llvmParameters.Length]);

            PrintHeader(efo);
            foreach (var opcode in opcodes)
            {
                if (EmitFunctions.ContainsKey(opcode.Opcode) == false)
                    throw new CudaSharpException("Unsupported CIL instruction " + opcode.Opcode);
                var func = EmitFunctions[opcode.Opcode];
                efo.Argument = opcode.Parameter;
                func(efo);
            }

            return function;
        }
Exemple #5
0
        public static StructType GetTypeByName(this Module module, string name)
        {
            var intPtr = LLVMGetTypeByName(module, name);

            if (intPtr == IntPtr.Zero)
            {
                return(null);
            }
            return((StructType)StructTypeConstructor.Invoke(new object[] { intPtr }));
        }
Exemple #6
0
        /// <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);
        }
Exemple #7
0
 public EmitFuncObj(Module module, Function function, MethodBody cilMethod, InstructionBuilder instructionBuilder, object argument, Stack <Value> stack, Value[] locals, Value[] parameters)
 {
     Module     = module;
     Function   = function;
     CilMethod  = cilMethod;
     Builder    = instructionBuilder;
     Argument   = argument;
     Stack      = stack;
     Locals     = locals;
     Parameters = parameters;
 }
Exemple #8
0
        private static void Translate(Module module, MethodBase method)
        {
            var function = EmitFunction(module, method);
            if (method.IsStatic == false)
                throw new CudaSharpException("Cannot translate instance methods to GPU code");

            var metadataArgs = new[]
            {
                function, PInvoke.LLVMMDStringInContext(module.Context, "kernel"),
                IntegerType.GetInt32(module.Context).Constant(1, true)
            };
            var metadata = module.Context.MetadataNodeInContext(metadataArgs);
            module.AddNamedMetadataOperand("nvvm.annotations", metadata);
        }
Exemple #9
0
        private static void Translate(Module module, MethodBase method)
        {
            var function = EmitFunction(module, method);

            if (method.IsStatic == false)
            {
                throw new CudaSharpException("Cannot translate instance methods to GPU code");
            }

            var metadataArgs = new[]
            {
                function, PInvoke.LLVMMDStringInContext(module.Context, "kernel"),
                IntegerType.GetInt32(module.Context).Constant(1, true)
            };
            var metadata = module.Context.MetadataNodeInContext(metadataArgs);

            module.AddNamedMetadataOperand("nvvm.annotations", metadata);
        }
        public static Module Translate(Context context, params MethodInfo[] methods)
        {
            var module = new Module("Module", context);

            if (Environment.Is64BitOperatingSystem)
            {
                PInvoke.LLVMSetTarget(module, "nvptx64-nvidia-cuda");
                PInvoke.LLVMSetDataLayout(module, "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64");
            }
            else
            {
                PInvoke.LLVMSetTarget(module, "nvptx-nvidia-cuda");
                PInvoke.LLVMSetDataLayout(module, "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64");
            }

            foreach (var method in methods)
                Translate(context, module, method);
            return module;
        }
Exemple #11
0
        public static byte[] EmitInMemory(Module module, string targetCpu)
        {
            if (!_initialized)
            {
                _initialized = true;
                PInvoke.LLVMInitializeNVPTXTarget();
                PInvoke.LLVMInitializeNVPTXTargetMC();
                PInvoke.LLVMInitializeNVPTXTargetInfo();
                PInvoke.LLVMInitializeNVPTXAsmPrinter();
            }
            var    triple = Marshal.PtrToStringAnsi(PInvoke.LLVMGetTarget(module));
            IntPtr errorMessage;
            IntPtr target;

            if (PInvoke.LLVMGetTargetFromTriple(triple, out target, out errorMessage))
            {
                throw new CudaSharpException(Marshal.PtrToStringAnsi(errorMessage));
            }
            var targetMachine = PInvoke.LLVMCreateTargetMachine(target, triple, targetCpu, "",
                                                                PInvoke.LlvmCodeGenOptLevel.LlvmCodeGenLevelDefault, PInvoke.LlvmRelocMode.LlvmRelocDefault,
                                                                PInvoke.LlvmCodeModel.LlvmCodeModelDefault);

            IntPtr memoryBuffer;

            PInvoke.LLVMTargetMachineEmitToMemoryBuffer(targetMachine, module, PInvoke.LlvmCodeGenFileType.LlvmAssemblyFile, out errorMessage, out memoryBuffer);

            if (errorMessage != IntPtr.Zero)
            {
                var errorMessageStr = Marshal.PtrToStringAnsi(errorMessage);
                if (string.IsNullOrWhiteSpace(errorMessageStr) == false)
                {
                    throw new CudaSharpException(errorMessageStr);
                }
            }
            var bufferStart  = PInvoke.LLVMGetBufferStart(memoryBuffer);
            var bufferLength = PInvoke.LLVMGetBufferSize(memoryBuffer);
            var buffer       = new byte[bufferLength.ToInt32()];

            Marshal.Copy(bufferStart, buffer, 0, buffer.Length);
            PInvoke.LLVMDisposeMemoryBuffer(memoryBuffer);
            return(buffer);
        }
Exemple #12
0
        private static Function EmitFunction(Module module, MethodBase method)
        {
            var methodInfo        = method as MethodInfo;
            var methodConstructor = method as ConstructorInfo;
            var declaringType     = method.DeclaringType;

            if (methodInfo == null && methodConstructor == null)
            {
                throw new CudaSharpException("Unknown MethodBase type " + method.GetType().FullName);
            }
            if (declaringType == null)
            {
                throw new CudaSharpException("Could not find the declaring type of " + method.Name.StripNameToValidPtx());
            }

            var parameters = method.GetParameters().Select(p => p.ParameterType);

            if (methodConstructor != null)
            {
                parameters = new[] { declaringType.MakeByRefType() }
            }
Exemple #13
0
        public static Module Translate(Context context, params MethodInfo[] methods)
        {
            var module = new Module("Module", context);

            if (Environment.Is64BitOperatingSystem)
            {
                module.SetTarget("nvptx64-nvidia-cuda");
                module.SetDataLayout("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64");
            }
            else
            {
                module.SetTarget("nvptx-nvidia-cuda");
                module.SetDataLayout("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64");
            }

            foreach (var method in methods)
            {
                Translate(module, method);
            }

            return(module);
        }
Exemple #14
0
 /// <summary>
 /// Create a void function that takes no arguments
 /// </summary>
 /// <param name="module"></param>
 /// <param name="name"></param>
 /// <param name="returnType"></param>
 public Function(Module module, string name)
     : this(module, name, TypeRef.CreateVoid(), new TypeRef[0])
 {
 }
Exemple #15
0
        public static byte[] EmitInMemory(Module module, string targetCpu)
        {
            if (!_initialized)
            {
                _initialized = true;
                PInvoke.LLVMInitializeNVPTXTarget();
                PInvoke.LLVMInitializeNVPTXTargetMC();
                PInvoke.LLVMInitializeNVPTXTargetInfo();
                PInvoke.LLVMInitializeNVPTXAsmPrinter();
            }
            var triple = Marshal.PtrToStringAnsi(PInvoke.LLVMGetTarget(module));
            IntPtr errorMessage;
            IntPtr target;
            if (PInvoke.LLVMGetTargetFromTriple(triple, out target, out errorMessage))
                throw new CudaSharpException(Marshal.PtrToStringAnsi(errorMessage));
            var targetMachine = PInvoke.LLVMCreateTargetMachine(target, triple, targetCpu, "",
                PInvoke.LlvmCodeGenOptLevel.LlvmCodeGenLevelDefault, PInvoke.LlvmRelocMode.LlvmRelocDefault,
                PInvoke.LlvmCodeModel.LlvmCodeModelDefault);

            IntPtr memoryBuffer;
            PInvoke.LLVMTargetMachineEmitToMemoryBuffer(targetMachine, module, PInvoke.LlvmCodeGenFileType.LlvmAssemblyFile, out errorMessage, out memoryBuffer);

            if (errorMessage != IntPtr.Zero)
            {
                var errorMessageStr = Marshal.PtrToStringAnsi(errorMessage);
                if (string.IsNullOrWhiteSpace(errorMessageStr) == false)
                    throw new CudaSharpException(errorMessageStr);
            }
            var bufferStart = PInvoke.LLVMGetBufferStart(memoryBuffer);
            var bufferLength = PInvoke.LLVMGetBufferSize(memoryBuffer);
            var buffer = new byte[bufferLength.ToInt32()];
            Marshal.Copy(bufferStart, buffer, 0, buffer.Length);
            PInvoke.LLVMDisposeMemoryBuffer(memoryBuffer);
            return buffer;
        }
Exemple #16
0
 public Value AddGlobal(Module module, TypeRef type, String name)
 {
     return new Value(Native.AddGlobal(module.Handle, type.Handle, name));
 }
Exemple #17
0
 public static void SetDataLayout(this Module module, string triple)
 {
     LLVMSetDataLayout(module, triple);
 }
Exemple #18
0
 public static void SetTarget(this Module module, string triple)
 {
     LLVMSetTarget(module, triple);
 }
 public ExecutionEngine(Module module)
 {
     StringBuilder sb = new StringBuilder(1024);
     if(Native.CreateExecutionEngineForModule(ref m_handle, module.Handle, ref sb) == 0)
         Console.Error.WriteLine(sb.ToString());
 }
Exemple #20
0
 public Function(Module mod, string name, FunctionType fnTy)
     : base(LLVM.AddFunction(mod, name, fnTy))
 {
     _type = fnTy;
 }
        public static void Translate(Context context, Module module, MethodInfo method)
        {
            var function = EmitFunction(context, module, method);

            var metadataArgs = new[]
            {
                function, PInvoke.LLVMMDStringInContext(context, method.Name),
                IntegerType.GetInt32(context).Constant(1, true)
            };
            var metadata = PInvoke.LLVMMDNodeInContext(context, metadataArgs);
            PInvoke.LLVMAddNamedMetadataOperand(module, "nvvm.annotations", metadata);
        }
Exemple #22
0
 public static void AddNamedMetadataOperand(this Module module, string name, IntPtr value)
 {
     LLVMAddNamedMetadataOperand(module, name, value);
 }
Exemple #23
0
 public PassManager(Module module)
 {
     Guard.ArgumentNull(module, "module");
     m_handle = Native.CreateFunctionPassManagerForModule(module.Handle);
     m_module = module.Handle;
 }
        private static Function EmitFunction(Context context, Module module, MethodInfo method)
        {
            var funcType = new FunctionType(ConvertType(context, method.ReturnType), AnalyzeArguments(context, method.GetParameters()));

            var intrinsic = method.GetCustomAttribute<Gpu.BuiltinAttribute>();
            if (intrinsic != null)
            {
                var name = intrinsic.Intrinsic;
                var preExisting = module.GetFunction(name);
                if (preExisting != null)
                    return preExisting;
                return module.CreateFunction(name, funcType);
            }

            var function = module.CreateFunction(method.Name, funcType);

            var block = new Block("entry", context, function);
            var writer = new InstructionBuilder(context, block);

            var opcodes = method.Decompile().ToList();
            FindBranchTargets(opcodes, context, function);

            var body = method.GetMethodBody();
            var efo = new EmitFuncObj(context, module, function, writer, null, new Stack<Value>(),
                body == null ? null : new Value[body.LocalVariables.Count], new Value[method.GetParameters().Length]);

            foreach (var opcode in opcodes)
            {
                if (EmitFunctions.ContainsKey(opcode.Opcode) == false)
                    throw new Exception("Unsupported CIL instruction " + opcode.Opcode);
                var func = EmitFunctions[opcode.Opcode];
                efo.Argument = opcode.Parameter;
                func(efo);
            }

            return function;
        }
Exemple #25
0
 static void Main()
 {
     LLVM.Module module = new LLVM.Module("test_module");
     module.Dump();
 }
Exemple #26
0
        private static Type ConvertType(Module module, System.Type type)
        {
            if (type == typeof(void))
                return Type.GetVoid(module.Context);
            if (type == typeof(bool))
                return IntegerType.Get(module.Context, 1);
            if (type == typeof(byte))
                return IntegerType.Get(module.Context, 8);
            if (type == typeof(short))
                return IntegerType.Get(module.Context, 16);
            if (type == typeof(int))
                return IntegerType.GetInt32(module.Context);
            if (type == typeof(long))
                return IntegerType.Get(module.Context, 64);
            if (type == typeof(float))
                return FloatType.Get(module.Context, 32);
            if (type == typeof(double))
                return FloatType.Get(module.Context, 64);
            if (type.IsArray)
                return PointerType.Get(ConvertType(module, type.GetElementType()), 1);
            if (type.IsByRef)
                return PointerType.Get(ConvertType(module, type.GetElementType()));
            if (type.IsValueType)
            {
                var name = type.Name.StripNameToValidPtx();
                var preExisting = module.GetTypeByName(name);
                if (preExisting != null)
                    return preExisting;
                return new StructType(module.Context, name, AllFields(type).Select(t => ConvertType(module, t.FieldType)));
            }

            throw new CudaSharpException("Type cannot be translated to CUDA: " + type.FullName);
        }
Exemple #27
0
 public EmitFuncObj(Module module, Function function, MethodBody cilMethod, InstructionBuilder instructionBuilder, object argument, Stack<Value> stack, Value[] locals, Value[] parameters)
 {
     Module = module;
     Function = function;
     CilMethod = cilMethod;
     Builder = instructionBuilder;
     Argument = argument;
     Stack = stack;
     Locals = locals;
     Parameters = parameters;
 }
Exemple #28
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])
 {
 }
 public EmitFuncObj(Context context, Module module, Function function, InstructionBuilder instructionBuilder, object argument, Stack<Value> stack, Value[] locals, Value[] parameters)
 {
     Context = context;
     Module = module;
     Function = function;
     Builder = instructionBuilder;
     Argument = argument;
     Stack = stack;
     Locals = locals;
     Parameters = parameters;
 }
Exemple #30
0
    public static void Initialize(LLVM.Module module)
    {
        TargetData tgt = new TargetData("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32");

        // TargetData tgt = new TargetData(module.DataLayout);

        Void = LLVM.Type.GetVoid();
        //module.AddTypeName("type System.Void", Void);
        Bool = LLVM.Type.GetInt8();
        //module.AddTypeName("type System.Bool", Bool);
        Char = LLVM.Type.GetInt8();
        //module.AddTypeName("type System.Char", Char);
        Int8 = LLVM.Type.GetInt8();
        //module.AddTypeName("type System.Int8", Int8);
        Int16 = LLVM.Type.GetInt16();
        //module.AddTypeName("type System.Int16", Int16);
        Int32 = LLVM.Type.GetInt32();
        //module.AddTypeName("type System.Int32", Int32);
        Int64 = LLVM.Type.GetInt64();
        //module.AddTypeName("type System.Int64", Int64);

        Native = tgt.GetIntPtrType();
        //module.AddTypeName("type System.Native", Native);

        Ptr = Native.GetPointerTo(0);
        //module.AddTypeName("type System.Ptr", Ptr);

        Object = LLVM.StructType.Get(module.Context, "type System.Object", new LLVM.Type[2] {
            Int32, Int32
        }, false);
        //module.AddTypeName("type System.Object", Object);

        String = LLVM.Type.GetInt8();   // FIXME, TODO
        //module.AddTypeName("type System.String", String);

        // Initialize constants
        //
        Const_0  = GetConstant(0);
        Const_1  = GetConstant(1);
        Const_2  = GetConstant(2);
        Const_3  = GetConstant(3);
        Const_4  = GetConstant(4);
        Const_5  = GetConstant(5);
        Const_6  = GetConstant(6);
        Const_7  = GetConstant(7);
        Const_8  = GetConstant(8);
        Const_m1 = GetConstant(-1);

        LLVM.FunctionType ft = LLVM.FunctionType.Get(Object.GetPointerTo(0),
                                                     new LLVM.Type[1] {
            Native
        }, false);
        Newobj = new LLVM.Function(module, "newobj", ft);

        ft = LLVM.FunctionType.Get(String.GetPointerTo(0),
                                   new LLVM.Type[1] {
            Int8.GetPointerTo(0)
        }, false);
        Newstr = new LLVM.Function(module, "newstring", ft);

        ft = LLVM.FunctionType.Get(Object.GetPointerTo(0),
                                   new LLVM.Type[2] {
            Native, Native
        }, false);
        Newarr = new LLVM.Function(module, "newarr", ft);
    }
Exemple #31
0
 static void Main()
 {
     LLVM.Module module = new LLVM.Module("test_module");
     module.Dump();
 }
Exemple #32
0
        /// <summary>
        /// Generates the BrainF runtime environment.
        /// </summary>
        private void GenerateHeader()
        {
            this.module = new Module(this.context, "BrainF");

            // === Function prototypes =========================================
            Function memsetFunction = Intrinsic.GetDecleration(this.module, IntrinsicType.memset,
                Type.GetInteger8PointerType(this.context), Type.GetInteger32Type(this.context));

            // declare i32 @getchar()
            this.getcharFunction = (Function)this.module.GetOrInsertFunction("getchar",
                new FunctionType(Type.GetInteger32Type(this.context)));

            // declare i32 @putchar(i32)
            this.putcharFunction = (Function)this.module.GetOrInsertFunction("putchar",
                new FunctionType(Type.GetInteger32Type(this.context), Type.GetInteger32Type(this.context)));

            // === Function header =============================================

            // define void @brainf()
            this.brainfFunction = (Function)this.module.GetOrInsertFunction("brainf",
                new FunctionType(Type.GetVoidType(this.context)));

            this.builder = new IRBuilder(new BasicBlock(
                this.context, this.brainfFunction, "brainf"));

            // %arr = malloc i8, i32 %d
            Constant valMemory = new Constant(this.context, 32, this.totalMemory);
            BasicBlock bb = this.builder.GetInsertBlock();
            Type intType = Type.GetInteger32Type(this.context);
            Type byteType = Type.GetInteger8Type(this.context);
            Constant allocsize = new Constant(byteType);
            allocsize.TruncOrBitCast(intType);
            Instruction pointerArray = CallInstruction.CreateMalloc(bb, intType, byteType, allocsize, valMemory, "arr");
            bb.PushBack(pointerArray);

            // call void @llvm.memset.
            CallInstruction memsetCall = this.builder.CreateCall(
                memsetFunction,
                pointerArray,
                new Constant(this.context, 8, 0),
                valMemory,
                new Constant(this.context, 32, 1),
                new Constant(this.context, 1, 0));
            memsetCall.TailCall = false;

            //
            this.currentHead = this.builder.CreateGEP(
                pointerArray, new Constant(this.context, 32, this.totalMemory / 2), "head");

            // Footer
            this.endBlock = new BasicBlock(this.context, this.brainfFunction, "brainf");
            this.endBlock.PushBack(CallInstruction.CreateFree(pointerArray, this.endBlock));

            ReturnInstruction.Create(this.context, this.endBlock);
        }
Exemple #33
0
 public GlobalVariable(Module mod, Type ty, string name)
     : base(LLVM.AddGlobal(mod, ty, name))
 {
 }