/// <summary>
        /// Initializes a new instance of the <see cref="BaseMethodCompiler" /> class.
        /// </summary>
        /// <param name="compiler">The assembly compiler.</param>
        /// <param name="method">The method to compile by this instance.</param>
        /// <param name="basicBlocks">The basic blocks.</param>
        /// <param name="threadID">The thread identifier.</param>
        protected BaseMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
        {
            Compiler = compiler;
            Method = method;
            Type = method.DeclaringType;
            Scheduler = compiler.CompilationScheduler;
            Architecture = compiler.Architecture;
            TypeSystem = compiler.TypeSystem;
            TypeLayout = compiler.TypeLayout;
            Trace = compiler.CompilerTrace;
            Linker = compiler.Linker;
            BasicBlocks = basicBlocks ?? new BasicBlocks();
            Pipeline = new CompilerPipeline();
            StackLayout = new StackLayout(Architecture, method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0));
            VirtualRegisters = new VirtualRegisters(Architecture);
            LocalVariables = emptyOperandList;
            ThreadID = threadID;
            DominanceAnalysis = new Dominance(Compiler.CompilerOptions.DominanceAnalysisFactory, BasicBlocks);
            PluggedMethod = compiler.PlugSystem.GetPlugMethod(Method);
            stop = false;

            MethodData = compiler.CompilerData.GetCompilerMethodData(Method);
            MethodData.Counters.Clear();

            EvaluateParameterOperands();
        }

        /// <summary>
        /// Initializes a new compiler instance.
        /// </summary>
        /// <param name="architecture">The compiler target architecture.</param>
        /// <param name="typeSystem">The type system.</param>
        protected AssemblyCompiler(IArchitecture architecture, ITypeSystem typeSystem)
        {
            if (architecture == null)
                throw new ArgumentNullException(@"architecture");

            this.architecture = architecture;
            this.pipeline = new CompilerPipeline();
            this.typeSystem = typeSystem;
        }

        /// <summary>
        /// Initializes a new compiler instance.
        /// </summary>
        /// <param name="architecture">The compiler target architecture.</param>
        /// <param name="assembly">The assembly of this compiler.</param>
        /// <exception cref="System.ArgumentNullException">Either <paramref name="architecture"/> or <paramref name="assembly"/> is null.</exception>
        protected AssemblyCompiler(IArchitecture architecture, IMetadataModule assembly)
        {
            if (architecture == null)
                throw new ArgumentNullException(@"architecture");

            _architecture = architecture;
            _assembly = assembly;
            _pipeline = new CompilerPipeline();
        }

        /// <summary>
        /// Initializes a new compiler instance.
        /// </summary>
        /// <param name="architecture">The compiler target architecture.</param>
        /// <param name="typeSystem">The type system.</param>
        protected AssemblyCompiler(IArchitecture architecture, ITypeSystem typeSystem, ITypeLayout typeLayout, IInternalTrace internalTrace, CompilerOptions compilerOptions)
        {
            if (architecture == null)
                throw new ArgumentNullException(@"architecture");

            this.pipeline = new CompilerPipeline();
            this.architecture = architecture;
            this.typeSystem = typeSystem;
            this.typeLayout = typeLayout;
            this.internalTrace = internalTrace;
            this.compilerOptions = compilerOptions;
            this.genericTypePatcher = new GenericTypePatcher(typeSystem);
        }

        /// <summary>
        /// Initializes a new compiler instance.
        /// </summary>
        /// <param name="architecture">The compiler target architecture.</param>
        /// <param name="typeSystem">The type system.</param>
        /// <param name="typeLayout">The type layout.</param>
        /// <param name="compilationScheduler">The compilation scheduler.</param>
        /// <param name="compilerTrace">The compiler trace.</param>
        /// <param name="linker">The linker.</param>
        /// <param name="compilerOptions">The compiler options.</param>
        /// <exception cref="System.ArgumentNullException">@Architecture</exception>
        protected BaseCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ICompilationScheduler compilationScheduler, CompilerTrace compilerTrace, BaseLinker linker, CompilerOptions compilerOptions)
        {
            if (architecture == null)
                throw new ArgumentNullException(@"Architecture");

            Pipeline = new CompilerPipeline();
            Architecture = architecture;
            TypeSystem = typeSystem;
            TypeLayout = typeLayout;
            CompilerTrace = compilerTrace;
            CompilerOptions = compilerOptions;
            Counters = new Counters();
            CompilationScheduler = compilationScheduler;
            PlugSystem = new PlugSystem();
            Linker = linker;

            if (Linker == null)
            {
                Linker = compilerOptions.LinkerFactory();
                Linker.Initialize(compilerOptions.BaseAddress, architecture.Endianness, architecture.ElfMachineType);
            }

            // Create new dictionary
            IntrinsicTypes = new Dictionary<string, Type>();

            // Get all the classes that implement the IIntrinsicInternalMethod interface
            IEnumerable<Type> types = AppDomain.CurrentDomain.GetAssemblies()
                .SelectMany(s => s.GetTypes())
                .Where(p => typeof(IIntrinsicInternalMethod).IsAssignableFrom(p) && p.IsClass);

            // Iterate through all the found types
            foreach (var t in types)
            {
                // Now get all the ReplacementTarget attributes
                var attributes = (ReplacementTargetAttribute[])t.GetCustomAttributes(typeof(ReplacementTargetAttribute), true);
                for (int i = 0; i < attributes.Length; i++)
                {
                    // Finally add the dictionary entry mapping the target string and the type
                    IntrinsicTypes.Add(attributes[i].Target, t);
                }
            }

            PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
        }

        /// <summary>
        /// Initializes a new compiler instance.
        /// </summary>
        /// <param name="architecture">The compiler target architecture.</param>
        /// <param name="typeSystem">The type system.</param>
        /// <param name="typeLayout">The type layout.</param>
        /// <param name="compilationScheduler">The compilation scheduler.</param>
        /// <param name="internalTrace">The internal trace.</param>
        /// <param name="compilerOptions">The compiler options.</param>
        protected BaseCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ICompilationScheduler compilationScheduler, IInternalTrace internalTrace, ILinker linker, CompilerOptions compilerOptions)
        {
            if (architecture == null)
                throw new ArgumentNullException(@"Architecture");

            Pipeline = new CompilerPipeline();
            Architecture = architecture;
            TypeSystem = typeSystem;
            TypeLayout = typeLayout;
            InternalTrace = internalTrace;
            CompilerOptions = compilerOptions;
            Counters = new Counters();
            CompilationScheduler = compilationScheduler;
            PlugSystem = new PlugSystem();
            Linker = linker;

            if (Linker == null)
            {
                Linker = compilerOptions.LinkerFactory();
                Linker.Initialize(compilerOptions.OutputFile, architecture.Endianness, architecture.ElfMachineType);
            }
        }

 /// <summary>
 /// Extends the method compiler pipeline with ARM specific stages.
 /// </summary>
 /// <param name="methodCompilerPipeline">The method compiler pipeline to extend.</param>
 public override void ExtendMethodCompilerPipeline(CompilerPipeline methodCompilerPipeline)
 {
 }

        /// <summary>
        /// Extends the method compiler pipeline with x86 specific stages.
        /// </summary>
        /// <param name="methodCompilerPipeline">The method compiler pipeline to extend.</param>
        public override void ExtendMethodCompilerPipeline(CompilerPipeline methodCompilerPipeline)
        {
            // FIXME: Create a specific code generator instance using requested feature flags.
            // FIXME: Add some more optimization passes, which take advantage of advanced x86 instructions
            // and packed operations available with MMX/SSE extensions
            methodCompilerPipeline.InsertAfter<PlatformStubStage>(
                new IMethodCompilerStage[]
                {
                    //InstructionLogger.Instance,
                    new LongOperandTransformationStage(),
                    //InstructionLogger.Instance,
                    new AddressModeConversionStage(),
                    //InstructionLogger.Instance,
                    new IRTransformationStage(),
                    //InstructionLogger.Instance,
                    new TweakTransformationStage(),
                    //InstructionLogger.Instance,
                    new MemToMemConversionStage(),
                    //InstructionLogger.Instance,
                    new ExceptionHeaderPreprocessingStage(),
                });

            methodCompilerPipeline.InsertAfter<IBlockOrderStage>(
                new IMethodCompilerStage[]
                {
                    new SimplePeepholeOptimizationStage(),
                    //InstructionLogger.Instance,
                });

            //FlowGraphVisualizationStage.Instance,
        }

        /// <summary>
        /// Extends the assembly compiler pipeline with ARM specific stages.
        /// </summary>
        /// <param name="assemblyCompilerPipeline">The assembly compiler pipeline to extend.</param>
        public override void ExtendAssemblyCompilerPipeline(CompilerPipeline assemblyCompilerPipeline)
        {
            //assemblyCompilerPipeline.InsertAfterFirst<IAssemblyCompilerStage>(
            //    new InterruptVectorStage()
            //);

            //assemblyCompilerPipeline.InsertAfterFirst<InterruptVectorStage>(
            //    new ExceptionVectorStage()
            //);

            //assemblyCompilerPipeline.InsertAfterLast<TypeLayoutStage>(
            //    new MethodTableBuilderStage()
            //);
        }

 /// <summary>
 /// Extends the assembly compiler pipeline with architecture specific assembly compiler stages.
 /// </summary>
 /// <param name="assemblyPipeline">The pipeline to extend.</param>
 public abstract void ExtendAssemblyCompilerPipeline(CompilerPipeline assemblyPipeline);

 /// <summary>
 /// Initializes a new instance of.
 /// </summary>
 protected CompilerBase()
 {
     _pipeline = new CompilerPipeline();
 }

        /// <summary>
        /// Extends the pre-compiler pipeline with x86 compiler stages.
        /// </summary>
        /// <param name="compilerPipeline">The pipeline to extend.</param>
        public override void ExtendPreCompilerPipeline(CompilerPipeline compilerPipeline)
        {
            compilerPipeline.InsertAfterFirst<ICompilerStage>(
                new InterruptVectorStage()
            );

            compilerPipeline.InsertAfterLast<ICompilerStage>(
                new SSESetupStage()
            );
        }

        /// <summary>
        /// Extends the compiler pipeline with x86 specific stages.
        /// </summary>
        /// <param name="compilerPipeline">The pipeline to extend.</param>
        public override void ExtendCompilerPipeline(CompilerPipeline compilerPipeline)
        {
            compilerPipeline.InsertAfterFirst<ICompilerStage>(
                new InterruptVectorStage()
            );

            compilerPipeline.InsertAfterFirst<InterruptVectorStage>(
                new ExceptionVectorStage()
            );

            compilerPipeline.InsertAfterLast<TypeLayoutStage>(
                new MethodTableBuilderStage()
            );
        }

        /// <summary>
        /// Extends the pre-compiler pipeline with x86 compiler stages.
        /// </summary>
        /// <param name="compilerPipeline">The pipeline to extend.</param>
        public override void ExtendCompilerPipeline(CompilerPipeline compilerPipeline)
        {
            compilerPipeline.Add(
                new StartUpStage()
            );

            compilerPipeline.Add(
                new InterruptVectorStage()
            );

            compilerPipeline.Add(
                new SSEInitStage()
            );
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseMethodCompiler"/> class.
        /// </summary>
        /// <param name="compiler">The assembly compiler.</param>
        /// <param name="method">The method to compile by this instance.</param>
        /// <param name="instructionSet">The instruction set.</param>
        protected BaseMethodCompiler(BaseCompiler compiler, RuntimeMethod method, InstructionSet instructionSet)
        {
            this.compiler = compiler;
            this.method = method;
            this.type = method.DeclaringType;
            this.compilationScheduler = compiler.Scheduler;
            this.moduleTypeSystem = method.Module;
            this.architecture = compiler.Architecture;
            this.typeSystem = compiler.TypeSystem;
            this.typeLayout = Compiler.TypeLayout;
            this.internalTrace = Compiler.InternalTrace;
            this.linker = compiler.Linker;

            this.basicBlocks = new BasicBlocks();

            this.instructionSet = instructionSet ?? new InstructionSet(256);

            this.pipeline = new CompilerPipeline();

            this.stackLayout = new StackLayout(architecture, method.Parameters.Count + (method.Signature.HasThis || method.Signature.HasExplicitThis ? 1 : 0));

            this.virtualRegisterLayout = new VirtualRegisterLayout(architecture, stackLayout);

            EvaluateParameterOperands();

            this.stopMethodCompiler = false;
        }

 /// <summary>
 /// Extends the method compiler pipeline with x86 specific stages.
 /// </summary>
 /// <param name="methodCompilerPipeline">The method compiler pipeline to extend.</param>
 public override void ExtendMethodCompilerPipeline(CompilerPipeline methodCompilerPipeline)
 {
     // FIXME: Create a specific code generator instance using requested feature flags.
     // FIXME: Add some more optimization passes, which take advantage of advanced x86 instructions
     // and packed operations available with MMX/SSE extensions
     methodCompilerPipeline.AddRange (new IMethodCompilerStage[] {
         new LongOperandTransformationStage (),
         new InstructionLogger (typeof(LongOperandTransformationStage)),
         new AddressModeConversionStage (),
         new InstructionLogger (typeof(AddressModeConversionStage)),
         new CILTransformationStage (),
         new InstructionLogger (typeof(CILTransformationStage)),
         new IRTransformationStage (),
         new InstructionLogger (typeof(IRTransformationStage)),
         new TweakTransformationStage (),
         new InstructionLogger (typeof(TweakTransformationStage)),
         new MemToMemConversionStage (),
         new InstructionLogger (typeof(MemToMemConversionStage)),
         new SimplePeepholeOptimizationStage (),
         new InstructionLogger (typeof(SimplePeepholeOptimizationStage))
         //FlowGraphVisualizationStage.Instance,
     });
 }

        /// <summary>
        /// Extends the method compiler pipeline with ARMv6 specific stages.
        /// </summary>
        /// <param name="methodCompilerPipeline">The method compiler pipeline to extend.</param>
        public override void ExtendMethodCompilerPipeline(CompilerPipeline methodCompilerPipeline)
        {
            methodCompilerPipeline.InsertAfterLast<PlatformStubStage>(
                new IMethodCompilerStage[]
                {
                    //new LongOperandTransformationStage(),
                    new IRTransformationStage(),
                });

            //methodCompilerPipeline.InsertAfterLast<CodeGenerationStage>(
            //    new ExceptionLayoutStage()
            //);

            methodCompilerPipeline.InsertBefore<GreedyRegisterAllocatorStage>(
                new StopStage()
            );
        }

 /// <summary>
 /// Extends the assembly compiler pipeline with ARMv6 specific stages.
 /// </summary>
 /// <param name="compilerPipeline">The pipeline to extend.</param>
 public override void ExtendCompilerPipeline(CompilerPipeline compilerPipeline)
 {
     // TODO
 }

        /// <summary>
        /// Extends the method compiler pipeline with x86 specific stages.
        /// </summary>
        /// <param name="methodCompilerPipeline">The method compiler pipeline to extend.</param>
        public override void ExtendMethodCompilerPipeline(CompilerPipeline methodCompilerPipeline)
        {
            methodCompilerPipeline.InsertAfterLast<PlatformStubStage>(
                new IMethodCompilerStage[]
                {
                    //new CheckOperandCountStage(),
                    new PlatformIntrinsicStage(),
                    new LongOperandTransformationStage(),

                    //new StopStage(),

                    new IRTransformationStage(),
                    new TweakTransformationStage(),

                    new FixedRegisterAssignmentStage(),
                    new SimpleDeadCodeRemovalStage(),
                    new AddressModeConversionStage(),
                    new FloatingPointStage(),
                });

            methodCompilerPipeline.InsertAfterLast<StackLayoutStage>(
                new BuildStackStage()
            );

            methodCompilerPipeline.InsertBefore<CodeGenerationStage>(
                new FinalTweakTransformationStage()
            );

            methodCompilerPipeline.InsertBefore<CodeGenerationStage>(
                new JumpOptimizationStage()
            );
        }

 /// <summary>
 /// Extends the post-compiler pipeline with x86 compiler stages.
 /// </summary>
 /// <param name="compilerPipeline">The pipeline to extend.</param>
 public override void ExtendPostCompilerPipeline(CompilerPipeline compilerPipeline)
 {
 }