Example #1
0
        /// <summary>
        /// Constructs a new method.
        /// </summary>
        /// <param name="unit">The target unit.</param>
        /// <param name="methodBase">The target method.</param>
        internal Method(CompileUnit unit, MethodBase methodBase)
        {
            if ((methodBase.MethodImplementationFlags & MethodImplAttributes.InternalCall) == MethodImplAttributes.InternalCall)
            {
                throw unit.CompilationContext.GetNotSupportedException(
                          ErrorMessages.RuntimeInternalMethodNotSupported, methodBase);
            }
            if ((methodBase.MethodImplementationFlags & MethodImplAttributes.Native) == MethodImplAttributes.Native)
            {
                throw unit.CompilationContext.GetNotSupportedException(
                          ErrorMessages.NativeMethodNotSupported, methodBase);
            }
            CompileUnit = unit;
            Name        = unit.GetLLVMName(methodBase);
            MethodBase  = methodBase;
            if (methodBase is MethodInfo)
            {
                var genericArgs = methodBase.GetGenericArguments();
                for (int i = 0, e = genericArgs.Length; i < e; ++i)
                {
                    if (genericArgs[i].IsGenericParameter)
                    {
                        throw unit.CompilationContext.GetNotSupportedException(
                                  ErrorMessages.NotSupportedGenericMethod, methodBase);
                    }
                }
            }
            var functionType = unit.GetType(methodBase);

            LLVMFunction = AddFunction(unit.LLVMModule, Name, functionType);
            AddFunctionAttr(LLVMFunction, LLVMAttribute.LLVMAlwaysInlineAttribute);
            SetLinkage(LLVMFunction, LLVMLinkage.LLVMInternalLinkage);
        }
Example #2
0
        internal void Decompile(CompileUnit unit)
        {
            Debug.Assert(unit != null, "Invalid unit");

            Disassemble(unit.CompilationContext);
            using (var decompiler = new CodeGenerator(unit, this, DisassembledMethod))
            {
                decompiler.GenerateCode();
            }

            // Perform a simple pass over the method
            RunFunctionPassManager(unit.CodeGenFunctionPassManager, LLVMFunction);
        }
Example #3
0
 /// <summary>
 /// Visits all call instructions and invokes the call handler for each
 /// called method.
 /// </summary>
 /// <param name="callHandler">The handler to handle called methods.</param>
 /// <param name="recursive">True, iff this method should be invoked on each called method recursively.</param>
 public void VisitCalls(
     Action <ILInstruction, Method> callHandler,
     bool recursive)
 {
     foreach (var call in DisassembledMethod.DirectCallInstructions)
     {
         var m = CompileUnit.GetMethod(call.GetArgumentAs <MethodBase>(), false);
         if (m == null)
         {
             continue;
         }
         callHandler(call, m);
         if (recursive)
         {
             m.VisitCalls(callHandler);
         }
     }
 }
Example #4
0
        /// <summary>
        /// Constructs a new compilation context.
        /// </summary>
        /// <param name="compileUnit">The associated compile unit.</param>
        public CompilationContext(CompileUnit compileUnit)
        {
            Debug.Assert(compileUnit != null, "Invalid compile unit");
            CompileUnit = compileUnit;
            NotSupportedILInstructionHandler = (sender, opCode) =>
            {
                switch (opCode)
                {
                case ILOpCode.Ldftn:
                    throw GetNotSupportedException(
                              ErrorMessages.NotSupportedILInstructionPossibleLambda,
                              opCode.ToString());

                default:
                    throw GetNotSupportedException(
                              ErrorMessages.NotSupportedILInstruction,
                              opCode.ToString());
                }
            };
        }