Exemple #1
0
        public CodeGenerator(DynamicRuntimeState globalState, TargetMachine machine, bool disableOptimization = false)
            : base(null)
        {
            globalState.ValidateNotNull(nameof(globalState));
            machine.ValidateNotNull(nameof(machine));

            if (globalState.LanguageLevel > LanguageLevel.MutableVariables)
            {
                throw new ArgumentException("Language features not supported by this generator", nameof(globalState));
            }

            RuntimeState         = globalState;
            Context              = new Context( );
            TargetMachine        = machine;
            DisableOptimizations = disableOptimization;
            InstructionBuilder   = new InstructionBuilder(Context);
            Module = Context.CreateBitcodeModule( );
            Module.TargetTriple = machine.Triple;
            Module.Layout       = TargetMachine.TargetData;
            FunctionPassManager = new FunctionPassManager(Module);
            FunctionPassManager.AddPromoteMemoryToRegisterPass( );

            if (!DisableOptimizations)
            {
                FunctionPassManager.AddInstructionCombiningPass( )
                .AddReassociatePass( )
                .AddGVNPass( )
                .AddCFGSimplificationPass( );
            }

            FunctionPassManager.Initialize( );
        }
Exemple #2
0
        /// <summary>Initializes a new instance of the <see cref="OrcJit"/> class for a given target machine.</summary>
        /// <param name="machine">Target machine for the JIT</param>
        public OrcJit(TargetMachine machine)
        {
            machine.ValidateNotNull(nameof(machine));

            JitStackHandle = LLVMOrcCreateInstance(machine.TargetMachineHandle).ThrowIfInvalid();
            TargetMachine  = machine;
        }
Exemple #3
0
        public static void Main(string[] args)
        {
            Utilities.WaitForDebugger( );

            using (StaticState.InitializeLLVM( ))
            {
                StaticState.RegisterNative( );
                using (var machine = TargetMachine.FromTriple(Triple.HostTriple))
                    using (var generator = new CodeGenerator(LanguageLevel.MutableVariables, machine))
                    {
                        RunReplLoop(generator);
                        generator.Module.DIBuilder.Finish( );
                        if (!generator.Module.Verify(out string errMsg))
                        {
                            Console.Error.WriteLine(errMsg);
                        }
                        else
                        {
                            machine.EmitToFile(generator.Module, "kls.o", CodeGenFileType.ObjectFile);
                            Console.WriteLine(generator.Module.WriteToString( ));
                            Console.WriteLine("Wrote module to kls.o");
                        }
                    }
            }
        }
Exemple #4
0
 private void CheckIfValidMachine()
 {
     if (TargetMachine != null && !TargetMachine.PositionIsValid())
     {
         TargetMachine.Machinist = null;
         TargetMachine           = null;
     }
 }
Exemple #5
0
 public CodeGenerator(LanguageLevel level, TargetMachine machine)
 {
     Context            = new Context( );
     TargetMachine      = machine;
     InstructionBuilder = new InstructionBuilder(Context);
     NamedValues        = new Dictionary <string, Alloca>( );
     FunctionPrototypes = new PrototypeCollection( );
     ParserStack        = new ReplParserStack(level);
 }
 public CodeGenVisitor(bool disableOptimizations, Session session, TargetMachine machine)
 {
     this._disableOptimizations = disableOptimizations;
     this._ctx     = new Context( );
     this._machine = machine;
     this.InitializeModuleAndPassManager( );
     this._instructionBuilder = new InstructionBuilder(this._ctx);
     this._session            = session;
 }
Exemple #7
0
        public static int Main(string[] args)
        {
            (string sourceFilePath, int exitCode) = ProcessArgs(args);
            if (exitCode != 0)
            {
                return(exitCode);
            }

            string objFilePath = Path.ChangeExtension(sourceFilePath, ".o");
            string irFilePath  = Path.ChangeExtension(sourceFilePath, ".ll");
            string asmPath     = Path.ChangeExtension(sourceFilePath, ".s");

            using var rdr     = File.OpenText(sourceFilePath);
            using var libLLVM = InitializeLLVM( );
            libLLVM.RegisterTarget(CodeGenTarget.Native);

            var machine = new TargetMachine(Triple.HostTriple);
            var parser  = new Parser(LanguageLevel.MutableVariables);

            using var generator = new CodeGenerator(parser.GlobalState, machine);
            Console.WriteLine("Ubiquity.NET.Llvm Kaleidoscope Compiler - {0}", parser.LanguageLevel);
            Console.WriteLine("Compiling {0}", sourceFilePath);

            IParseErrorLogger errorLogger = new ColoredConsoleParseErrorLogger( );

            // time the parse and code generation
            var timer = System.Diagnostics.Stopwatch.StartNew( );
            var ast   = parser.Parse(rdr);

            if (!errorLogger.CheckAndShowParseErrors(ast))
            {
                (bool hasValue, BitcodeModule? module) = generator.Generate(ast);
                if (!hasValue)
                {
                    Console.Error.WriteLine("No module generated");
                }
                else if (!module !.Verify(out string errMsg))
                {
                    Console.Error.WriteLine(errMsg);
                }
                else
                {
                    machine.EmitToFile(module, objFilePath, CodeGenFileType.ObjectFile);
                    timer.Stop( );

                    Console.WriteLine("Wrote {0}", objFilePath);
                    if (!module.WriteToTextFile(irFilePath, out string msg))
                    {
                        Console.Error.WriteLine(msg);
                        return(-1);
                    }

                    machine.EmitToFile(module, asmPath, CodeGenFileType.AssemblySource);
                    Console.WriteLine("Compilation Time: {0}", timer.Elapsed);
                }
            }
Exemple #8
0
        public override void Initialize()
        {
            _context ??= new Context();

            if (_targetTriple.Length == 0)
            {
                _targetTriple = Target.DefaultTargetTriple;
            }
            _targetTriple = Target.NormalizeTargetTriple(_targetTriple);

            _optBuilder ??= _O0 || _O1 || _O2 || _Os || _Oz || _O3 ? new PassManagerBuilder() : null;
            _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelNone;
            if (_optBuilder != null)
            {
                if (_O0)
                {
                    _optBuilder.SetOptLevels(0, 0);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelNone;
                }
                else if (_O1)
                {
                    _optBuilder.SetOptLevels(1, 0);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelLess;
                }
                else if (_O2)
                {
                    _optBuilder.SetOptLevels(2, 0);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
                }
                else if (_Os)
                {
                    _optBuilder.SetOptLevels(2, 1);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
                }
                else if (_Oz)
                {
                    _optBuilder.SetOptLevels(2, 2);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
                }
                else if (_O3)
                {
                    _optBuilder.SetOptLevels(3, 0);
                    _optLevel = LLVMCodeGenOptLevel.LLVMCodeGenLevelAggressive;
                }
            }

            Target.InitializeAllTargets();

            if (_native)
            {
                _target       = Target.FromTriple(_targetTriple);
                TargetMachine = _target.CreateTargetMachine(_targetTriple, "", "", _optLevel,
                                                            LLVMRelocMode.LLVMRelocDefault, LLVMCodeModel.LLVMCodeModelDefault);
                TargetMachine.SetAsmVerbosity(true);
            }
        }
Exemple #9
0
        public void TargetMachineConstructorWithInvalidIPAddressTest()
        {
            // Random IP address (Invalid)
            string inputValue = "121.242.121.242";

            // User WWTMockRequest in WWTManager so that all calls to WWT API will succeed.
            Globals_Accessor.wwtManager = new WWTManager(new WWTMockRequest());

            TargetMachine target = new TargetMachine(inputValue);

            Assert.Fail("TargetMachine object initialized with invalid IP Address!");
        }
Exemple #10
0
        public void TargetMachineConstructorWithInvalidParameterTest()
        {
            // Invalid parameter
            string inputValue = "InvalidParameter";

            // User WWTMockRequest in WWTManager so that all calls to WWT API will succeed.
            Globals_Accessor.wwtManager = new WWTManager(new WWTMockRequest());

            TargetMachine target = new TargetMachine(inputValue);

            Assert.Fail("TargetMachine object initialized with invalid parameter!");
        }
Exemple #11
0
 //private TargetMachineState state = TargetMachineState.IDLE;
 void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
     else if (instance != this)
     {
         Debug.Log("Instance already exists, destroying object!");
         Destroy(this);
     }
 }
Exemple #12
0
        private static BitcodeModule CreateModule(Context ctx, TargetMachine machine, int magicNumber, string modulename = "test", string functionname = "main")
        {
            var module = ctx.CreateBitcodeModule(modulename);

            module.Layout = machine.TargetData;
            IrFunction main       = module.CreateFunction(functionname, ctx.GetFunctionType(ctx.Int32Type));
            BasicBlock entryBlock = main.AppendBasicBlock("entry");
            var        bldr       = new InstructionBuilder(entryBlock);

            bldr.Return(ctx.CreateConstant(magicNumber));
            return(module);
        }
Exemple #13
0
        /// <summary>C# version of the LLVM Kaleidoscope language tutorial</summary>
        /// <param name="args">Command line arguments to the application</param>
        /// <returns>0 on success; non-zero on error</returns>
        /// <remarks>
        /// The command line options at present are 'WaitForDebugger' and the source file name
        ///
        /// Specifying 'WaitForDebugger' will trigger a wait loop in Main() to wait
        /// for an attached debugger if one is not yet attached. This is useful
        /// for mixed mode native+managed debugging as the SDK project system does
        /// not support that on launch.
        /// </remarks>
        public static int Main(string[] args)
        {
            (string sourceFilePath, int exitCode) = ProcessArgs(args);
            if (exitCode != 0)
            {
                return(exitCode);
            }

            string objFilePath = Path.ChangeExtension(sourceFilePath, ".o");
            string irFilePath  = Path.ChangeExtension(sourceFilePath, ".ll");
            string asmPath     = Path.ChangeExtension(sourceFilePath, ".s");

            using (TextReader rdr = File.OpenText(sourceFilePath))
                using (InitializeLLVM( ))
                {
                    RegisterNative( );

                    var machine = new TargetMachine(Triple.HostTriple);
                    var parser  = new Parser(LanguageLevel.MutableVariables);
                    using (var generator = new CodeGenerator(parser.GlobalState, machine, sourceFilePath, true))
                    {
                        Console.WriteLine("Llvm.NET Kaleidoscope Compiler - {0}", parser.LanguageLevel);
                        Console.WriteLine("Compiling {0}", sourceFilePath);

                        // time the parse and code generation
                        var      timer = System.Diagnostics.Stopwatch.StartNew( );
                        IAstNode ast   = parser.Parse(rdr);
                        generator.Generate(ast, null);
                        if (!generator.Module.Verify(out string errMsg))
                        {
                            Console.Error.WriteLine(errMsg);
                        }
                        else
                        {
                            machine.EmitToFile(generator.Module, objFilePath, CodeGenFileType.ObjectFile);
                            timer.Stop( );

                            Console.WriteLine("Wrote {0}", objFilePath);
                            if (!generator.Module.WriteToTextFile(irFilePath, out string msg))
                            {
                                Console.Error.WriteLine(msg);
                                return(-1);
                            }

                            machine.EmitToFile(generator.Module, asmPath, CodeGenFileType.AssemblySource);
                            Console.WriteLine("Compilation Time: {0}", timer.Elapsed);
                        }
                    }
                }

            return(0);
        }
Exemple #14
0
        public void TargetMachineConstructorDefaultTest()
        {
            TargetMachine target = new TargetMachine();

            // Make sure target is not null.
            Assert.IsNotNull(target);

            // Make sure MachineIP is not null.
            Assert.IsNotNull(target.MachineIP);

            // Make sure DisplayValue is not null.
            Assert.IsNotNull(target.DisplayValue);
        }
        public CodeGenerator(DynamicRuntimeState globalState, TargetMachine machine, string sourcePath, bool disableOptimization = false)
            : base(null)
        {
            if (globalState.LanguageLevel > LanguageLevel.MutableVariables)
            {
                throw new ArgumentException("Language features not supported by this generator", nameof(globalState));
            }

            RuntimeState         = globalState;
            Context              = new Context( );
            TargetMachine        = machine;
            DisableOptimizations = disableOptimization;
            InitializeModuleAndPassManager(sourcePath);
            InstructionBuilder = new InstructionBuilder(Context);
        }
Exemple #16
0
 public CodeGenerator(LanguageLevel level, TargetMachine machine)
 {
     LexicalBlocks      = new Stack <DIScope>( );
     Context            = new Context( );
     TargetMachine      = machine;
     InstructionBuilder = new InstructionBuilder(Context);
     NamedValues        = new Dictionary <string, Alloca>( );
     FunctionPrototypes = new PrototypeCollection( );
     ParserStack        = new ReplParserStack(level);
     Module             = new BitcodeModule(Context, "Kaleidoscope", SourceLanguage.C, "fib.ks", "Kaleidoscope Compiler")
     {
         TargetTriple = machine.Triple,
         Layout       = machine.TargetData
     };
     DoubleType = new DebugBasicType(Context.DoubleType, Module, "double", DiTypeKind.Float);
 }
Exemple #17
0
        public static void Initialize(TestContext ctx)
        {
            _ = ctx; // unused
            using var llvmContext = new Context( );
            using var module      = llvmContext.CreateBitcodeModule("test", SourceLanguage.C, TestSrcFileName, "unit tests");
            var tm = TargetMachine.FromTriple(Triple.HostTriple);

            module.TargetTriple = tm.Triple;
            module.Layout       = tm.TargetData;

            var doubleType = new DebugBasicType(llvmContext.DoubleType, module, "double", DiTypeKind.Float);
            var voidType   = DebugType.Create <ITypeRef, DIType>(module.Context.VoidType, null);

            var printDecl = module.CreateFunction(PrintFuncName, false, voidType, doubleType);

            var bldr = CreateFunctionAndGetBuilder(module, doubleType, AddFuncName, AddSectionName, 0);

            bldr.CurrentDebugLocation = new DILocation(llvmContext, 2, 1, bldr.InsertFunction !.DISubProgram !);
            var result = bldr.FAdd(bldr.InsertFunction.Parameters[0], bldr.InsertFunction.Parameters[1]);

            _ = bldr.Call(printDecl, result);
            bldr.Return(result);

            bldr = CreateFunctionAndGetBuilder(module, doubleType, SubFuncName, SubSectionName, 5);
            bldr.CurrentDebugLocation = new DILocation(llvmContext, 7, 1, bldr.InsertFunction !.DISubProgram !);
            result = bldr.FSub(bldr.InsertFunction.Parameters[0], bldr.InsertFunction.Parameters[1]);
            _      = bldr.Call(printDecl, result);
            bldr.Return(result);

            bldr = CreateFunctionAndGetBuilder(module, doubleType, MulFuncName, MulSectionName, 10);
            bldr.CurrentDebugLocation = new DILocation(llvmContext, 12, 1, bldr.InsertFunction !.DISubProgram !);
            result = bldr.FMul(bldr.InsertFunction.Parameters[0], bldr.InsertFunction.Parameters[1]);
            _      = bldr.Call(printDecl, result);
            bldr.Return(result);

            bldr = CreateFunctionAndGetBuilder(module, doubleType, DivFuncName, DivSectionName, 15);
            bldr.CurrentDebugLocation = new DILocation(llvmContext, 17, 1, bldr.InsertFunction !.DISubProgram !);
            result = bldr.FDiv(bldr.InsertFunction.Parameters[0], bldr.InsertFunction.Parameters[1]);
            _      = bldr.Call(printDecl, result);
            bldr.Return(result);

            Debug.WriteLine(module.WriteToString( ));
            tm.EmitToFile(module, TestObjFileName, CodeGenFileType.ObjectFile);
        }
Exemple #18
0
        public CodeGenerator(DynamicRuntimeState globalState, TargetMachine machine, string sourcePath, bool disableOptimization = false)
            : base(null)
        {
            globalState.ValidateNotNull(nameof(globalState));
            machine.ValidateNotNull(nameof(machine));
            if (globalState.LanguageLevel > LanguageLevel.MutableVariables)
            {
                throw new ArgumentException("Language features not supported by this generator", nameof(globalState));
            }

            RuntimeState         = globalState;
            Context              = new Context( );
            TargetMachine        = machine;
            DisableOptimizations = disableOptimization;
            InstructionBuilder   = new InstructionBuilder(Context);

            #region InitializeModuleAndPassManager
            Module = Context.CreateBitcodeModule(Path.GetFileName(sourcePath), SourceLanguage.C, sourcePath, "Kaleidoscope Compiler");
            Debug.Assert(Module.DICompileUnit != null, "Expected non null compile unit");
            Debug.Assert(Module.DICompileUnit.File != null, "Expected non-null file for compile unit");

            Module.TargetTriple = machine.Triple;
            Module.Layout       = TargetMachine.TargetData;
            DoubleType          = new DebugBasicType(Context.DoubleType, Module, "double", DiTypeKind.Float);

            FunctionPassManager = new FunctionPassManager(Module);
            FunctionPassManager.AddPromoteMemoryToRegisterPass( );

            if (!DisableOptimizations)
            {
                FunctionPassManager.AddInstructionCombiningPass( )
                .AddReassociatePass( )
                .AddGVNPass( )
                .AddCFGSimplificationPass( );
            }

            FunctionPassManager.Initialize( );
            #endregion
        }
        public PowerShellScriptProjectInfo(
      string name, 
      string artifactsRepositoryName, 
      IEnumerable<string> allowedEnvironmentNames, 
      string artifactsRepositoryDirName, 
      bool artifactsAreNotEnvironmentSpecific,
      TargetMachine targetMachine,
      string scriptName,
      bool isRemote,
      List<string> dependendProjectNames = null)
            : base(name, 
        artifactsRepositoryName, 
        allowedEnvironmentNames, 
        dependendProjectNames, 
        artifactsRepositoryDirName, 
        artifactsAreNotEnvironmentSpecific)
        {
            Guard.NotNullNorEmpty(scriptName, "scriptName");

              TargetMachine = targetMachine;
              ScriptName = scriptName;
              IsRemote = isRemote;
        }
Exemple #20
0
            public override void Execute(object parameter)
            {
                if (this.parent != null && parameter != null)
                {
                    string machineName = parameter as string;
                    try
                    {
                        ThisAddIn.ExcelApplication.Cursor = XlMousePointer.xlWait;
                        var machine = new TargetMachine(machineName.Trim());
                        Common.Globals.TargetMachine      = machine;
                        ThisAddIn.ExcelApplication.Cursor = XlMousePointer.xlDefault;
                    }
                    catch (CustomException ex)
                    {
                        ThisAddIn.ExcelApplication.Cursor = XlMousePointer.xlDefault;
                        Ribbon.ShowError(ex.HasCustomMessage ? ex.Message : Resources.DefaultErrorMessage);
                        return;
                    }

                    // This is OK button click. So request window close
                    this.parent.OnRequestClose();
                }
            }
Exemple #21
0
        public PowerShellScriptProjectInfo(
            string name,
            string artifactsRepositoryName,
            IEnumerable <string> allowedEnvironmentNames,
            string artifactsRepositoryDirName,
            bool artifactsAreNotEnvironmentSpecific,
            TargetMachine targetMachine,
            string scriptName,
            bool isRemote,
            List <string> dependendProjectNames = null)
            : base(
                name,
                artifactsRepositoryName,
                allowedEnvironmentNames,
                dependendProjectNames,
                artifactsRepositoryDirName,
                artifactsAreNotEnvironmentSpecific)
        {
            Guard.NotNullNorEmpty(scriptName, "scriptName");

            TargetMachine = targetMachine;
            ScriptName    = scriptName;
            IsRemote      = isRemote;
        }
Exemple #22
0
        public void ToVcxprojProperties(XmlWriter writer)
        {
            WriteStringArray(writer, "AdditionalDependencies", AreAdditionalDependenciesSpecified ? AdditionalDependencies : new string[0]);
            WriteStringArray(writer, "AdditionalLibraryDirectories", AreAdditionalLibraryDirectoriesSpecified ? AdditionalLibraryDirectories : new string[0]);
            WriteStringArray(writer, "AdditionalManifestDependencies", AreAdditionalManifestDependenciesSpecified ? AdditionalManifestDependencies : new string[0]);
            WriteStringArray(writer, "AdditionalOptions", AreAdditionalOptionsSpecified ? AdditionalOptions : new string[0]);
            WriteStringArray(writer, "AddModuleNamesToAssembly", IsAddModuleNamesToAssemblySpecified ? AddModuleNamesToAssembly : new string[0]);
            if (IsAllowIsolationSpecified && AllowIsolation)
            {
                writer.WriteElementString("AllowIsolation", XmlConvert.ToString(AllowIsolation));
            }
            writer.WriteElementString("AssemblyDebug", XmlConvert.ToString(IsAssemblyDebugSpecified ? AssemblyDebug : suite.ActiveGoal.Has(Suite.DebugGoal.Name)));
            if (IsBaseAddressSpecified)
            {
                writer.WriteElementString("BaseAddress", BaseAddress);
            }
            if (IsCLRImageTypeSpecified && CLRImageType != CLRImageType.Default)
            {
                writer.WriteElementString("CLRImageType", CLRImageType.ToString());
            }
            if (IsCLRSupportLastErrorSpecified && CLRSupportLastError != CLRSupportLastError.Disabled)
            {
                writer.WriteElementString("CLRSupportLastError", CLRSupportLastError.ToString());
            }
            else
            {
                writer.WriteElementString("CLRSupportLastError", Model.CLRSupportLastError.Enabled.ToString());
            }
            if (IsCLRThreadAttributeSpecified && CLRThreadAttribute != ApartmentState.Unknown)
            {
                writer.WriteElementString("CLRThreadAttribute", CLRThreadAttribute.ToString());
            }
            writer.WriteElementString("CLRUnmanagedCodeCheck", XmlConvert.ToString(!IsCLRUnmanagedCodeCheckSpecified || CLRUnmanagedCodeCheck));
            if (IsCreateHotPatchableImageSpecified && CreateHotPatchableImage != LinkerHotPatchingOption.Disabled)
            {
                writer.WriteElementString("CreateHotPatchableImage", CreateHotPatchableImage.ToString());
            }
            writer.WriteElementString("DataExecutionPrevention", XmlConvert.ToString(!IsDataExecutionPreventionSpecified || DataExecutionPrevention));
            WriteStringArray(writer, "DelayLoadDLLs", AreDelayLoadDLLsSpecified ? DelayLoadDLLs : new string[0]);
            writer.WriteElementString("DelaySign", XmlConvert.ToString(IsDelaySignSpecified && DelaySign));
            if (IsDriverSpecified && Driver != LinkerDriverOption.NotSet)
            {
                writer.WriteElementString("Driver", Driver.ToString());
            }
            writer.WriteElementString("EnableCOMDATFolding", XmlConvert.ToString(IsEnableCOMDATFoldingSpecified && EnableCOMDATFolding));
            writer.WriteElementString("EnableUAC", XmlConvert.ToString(!IsEnableUACSpecified || EnableUAC));
            if (IsEntryPointSymbolSpecified)
            {
                writer.WriteElementString("EntryPointSymbol", EntryPointSymbol);
            }
            writer.WriteElementString("FixedBaseAddress", XmlConvert.ToString(IsFixedBaseAddressSpecified && FixedBaseAddress));
            if (IsForceFileOutputSpecified && ForceFileOutput != LinkerForceOption.Disabled)
            {
                writer.WriteElementString("ForceFileOutput", ForceFileOutput.ToString());
            }
            WriteStringArray(writer, "ForceSymbolReferences", AreForceSymbolReferencesSpecified ? ForceSymbolReferences : new string[0]);
            if (IsFunctionOrderSpecified)
            {
                writer.WriteElementString("FunctionOrder", FunctionOrder);
            }
            writer.WriteElementString("GenerateDebugInformation",
                                      XmlConvert.ToString(IsGenerateDebugInformationSpecified
                    ? GenerateDebugInformation
                    : suite.ActiveGoal.Has(Suite.DebugGoal.Name)));
            writer.WriteElementString("GenerateManifest", XmlConvert.ToString(IsGenerateManifestSpecified && GenerateManifest));
            writer.WriteElementString("GenerateMapFile", XmlConvert.ToString(IsGenerateMapFileSpecified && GenerateMapFile));
            if (HeapCommitSize.HasValue)
            {
                writer.WriteElementString("HeapCommitSize", XmlConvert.ToString(HeapCommitSize.Value));
            }
            if (HeapReserveSize.HasValue)
            {
                writer.WriteElementString("HeapReserveSize", XmlConvert.ToString(HeapReserveSize.Value));
            }
            writer.WriteElementString("IgnoreAllDefaultLibraries", XmlConvert.ToString(IsIgnoreAllDefaultLibrariesSpecified && IgnoreAllDefaultLibraries));
            writer.WriteElementString("IgnoreEmbeddedIDL", XmlConvert.ToString(IsIgnoreEmbeddedIDLSpecified && IgnoreEmbeddedIDL));
            writer.WriteElementString("IgnoreImportLibrary", XmlConvert.ToString(IsIgnoreImportLibrarySpecified && IgnoreImportLibrary));
            WriteStringArray(writer, "IgnoreSpecificDefaultLibraries", IsIgnoreSpecificDefaultLibrariesSpecified ? IgnoreSpecificDefaultLibraries : new string[0]);
            writer.WriteElementString("ImageHasSafeExceptionHandlers", XmlConvert.ToString(IsImageHasSafeExceptionHandlersSpecified ? ImageHasSafeExceptionHandlers : suite.ActiveGoal.Has("x86")));
            if (IsImportLibrarySpecified)
            {
                writer.WriteElementString("ImportLibrary", ImportLibrary);
            }
            if (IsKeyContainerSpecified)
            {
                writer.WriteElementString("KeyContainer", KeyContainer);
            }
            if (IsKeyFileSpecified)
            {
                writer.WriteElementString("KeyFile", KeyFile);
            }
            writer.WriteElementString("LargeAddressAware", XmlConvert.ToString(!IsLargeAddressAwareSpecified || LargeAddressAware));
            writer.WriteElementString("LinkDLL", XmlConvert.ToString(IsLinkDLLSpecified && LinkDLL));
            writer.WriteElementString("MapExports", XmlConvert.ToString(IsMapExportsSpecified && MapExports));
            if (IsMapFileNameSpecified)
            {
                writer.WriteElementString("MapFileName", MapFileName);
            }
            if (IsMergedIDLBaseFileNameSpecified)
            {
                writer.WriteElementString("MergedIDLBaseFileName", MergedIDLBaseFileName);
            }
            if (IsMergeSectionsSpecified && MergeSections.Count > 0)
            {
                string merges = string.Join(";", MergeSections.Select(pair => pair.Key + "=" + pair.Value));
                writer.WriteElementString("MergeSections", merges);
            }
            if (MinimumRequiredVersion.HasValue)
            {
                writer.WriteElementString("MinimumRequiredVersion", XmlConvert.ToString(MinimumRequiredVersion.Value));
            }
            writer.WriteElementString("NoEntryPoint", XmlConvert.ToString(IsNoEntryPointSpecified && NoEntryPoint));
            writer.WriteElementString("OptimizeReferences", XmlConvert.ToString(!IsOptimizeReferencesSpecified || OptimizeReferences));
            writer.WriteElementString("PreventDllBinding", XmlConvert.ToString(IsPreventDllBindingSpecified && PreventDllBinding));
            writer.WriteElementString("RandomizedBaseAddress", XmlConvert.ToString(!IsRandomizedBaseAddressSpecified || RandomizedBaseAddress));
            if (SectionAlignment.HasValue)
            {
                writer.WriteElementString("SectionAlignment", XmlConvert.ToString(SectionAlignment.Value));
            }
            writer.WriteElementString("SetChecksum", XmlConvert.ToString(IsSetChecksumSpecified && SetChecksum));
            if (StackCommitSize.HasValue)
            {
                writer.WriteElementString("StackCommitSize", XmlConvert.ToString(StackCommitSize.Value));
            }
            if (StackReserveSize.HasValue)
            {
                writer.WriteElementString("StackReserveSize", XmlConvert.ToString(StackReserveSize.Value));
            }
            if (IsSubSystemSpecified && SubSystem != LinkerSubSystemOption.NotSet)
            {
                writer.WriteElementString("SubSystem", SubSystem.ToString());
            }
            else
            {
                writer.WriteElementString("SubSystem", LinkerSubSystemOption.Windows.ToString());
            }
            writer.WriteElementString("SupportNobindOfDelayLoadedDLL", XmlConvert.ToString(IsSupportNobindOfDelayLoadedDLLSpecified && SupportNobindOfDelayLoadedDLL));
            writer.WriteElementString("SupportUnloadOfDelayLoadedDLL", XmlConvert.ToString(IsSupportUnloadOfDelayLoadedDLLSpecified && SupportUnloadOfDelayLoadedDLL));
            writer.WriteElementString("SwapRunFromCD", XmlConvert.ToString(IsSwapRunFromCDSpecified && SwapRunFromCD));
            writer.WriteElementString("SwapRunFromNet", XmlConvert.ToString(IsSwapRunFromNetSpecified && SwapRunFromNet));
            if (IsTargetMachineSpecified && TargetMachine != LinkerTargetMachine.NotSet)
            {
                writer.WriteElementString("TargetMachine", TargetMachine.ToString());
            }
            else
            {
                writer.WriteElementString("TargetMachine",
                                          (suite.ActiveGoal.Has("x64") ? LinkerTargetMachine.MachineX64 : LinkerTargetMachine.MachineX86).ToString());
            }
            writer.WriteElementString("TerminalServerAware", XmlConvert.ToString(IsTerminalServerAwareSpecified && TerminalServerAware));
            writer.WriteElementString("TreatLinkerWarningAsErrors", XmlConvert.ToString(IsTreatLinkerWarningAsErrorsSpecified && TreatLinkerWarningAsErrors));
            writer.WriteElementString("TurnOffAssemblyGeneration", XmlConvert.ToString(IsTurnOffAssemblyGenerationSpecified && TurnOffAssemblyGeneration));
            if (TypeLibraryResourceID.HasValue)
            {
                writer.WriteElementString("TypeLibraryResourceID", XmlConvert.ToString(TypeLibraryResourceID.Value));
            }

            if (IsTypeLibraryFileSpecified)
            {
                writer.WriteElementString("TypeLibraryFile", TypeLibraryFile);
            }

            writer.WriteElementString("UACExecutionLevel", (IsUACExecutionLevelSpecified ? UACExecutionLevel : UACExecutionLevel.AsInvoker).ToString());
            writer.WriteElementString("UACUIAccess", XmlConvert.ToString(IsUACUIAccessSpecified && UACUIAccess));
        }
        public void DebugUnionTypeTest2( )
        {
            var testTriple    = new Triple("thumbv7m-none--eabi");
            var targetMachine = new TargetMachine(testTriple);

            using var ctx    = new Context( );
            using var module = ctx.CreateBitcodeModule("testModule");
            const string nativeUnionName = "union.testUnion";
            const string unionSymbolName = "testUnion";

            module.Layout = targetMachine.TargetData;
            var diFile        = module.DIBuilder.CreateFile("test.cs");
            var diCompileUnit = module.DIBuilder.CreateCompileUnit(SourceLanguage.CSharp, "test.cs", "unit-test", false, string.Empty, 0);

            // Create basic types used in this compilation
            var i32 = new DebugBasicType(module.Context.Int32Type, module, "int", DiTypeKind.Signed);
            var i16 = new DebugBasicType(module.Context.Int16Type, module, "short", DiTypeKind.Signed);
            var f32 = new DebugBasicType(module.Context.FloatType, module, "float", DiTypeKind.Float);

            var members = new[]
            { new DebugMemberInfo(0, "a", diFile, 3, i32)
              , new DebugMemberInfo(1, "b", diFile, 4, i16)
              , new DebugMemberInfo(2, "c", diFile, 5, f32) };

            var llvmType = module.Context.CreateStructType(nativeUnionName);
            var union    = new DebugUnionType(llvmType, module, diCompileUnit, unionSymbolName, diFile, 0, DebugInfoFlags.None, members);

            Assert.IsNotNull(union);
            Assert.IsNotNull(union !.DIType);
            Assert.IsNotNull(union.NativeType);
            Assert.AreEqual(Tag.UnionType, union.DIType !.Tag);
            Assert.AreEqual(nativeUnionName, union.Name);
            Assert.AreEqual(nativeUnionName, union.NativeType !.Name);
            Assert.AreEqual(unionSymbolName, union.DIType.Name);
            Assert.IsNull(union.DIType.Scope);
            Assert.AreEqual(diFile, union.DIType.File);
            Assert.AreEqual(0U, union.DIType.Line);

            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Private));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Protected));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Public));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.ForwardDeclaration));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.AppleBlock));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Virtual));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Artificial));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.ObjectPointer));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.ObjcClassComplete));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.Vector));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.StaticMember));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.LValueReference));
            Assert.IsFalse(union.DIType.DebugInfoFlags.HasFlag(DebugInfoFlags.RValueReference));

            // test the wrapped native type created correctly
            Assert.IsTrue(union.NativeType.IsSized);
            Assert.IsTrue(union.NativeType.IsStruct);
            Assert.AreEqual(TypeKind.Struct, union.NativeType.Kind);
            Assert.IsFalse(union.NativeType.IsInteger);
            Assert.IsFalse(union.NativeType.IsFloat);
            Assert.IsFalse(union.NativeType.IsDouble);
            Assert.IsFalse(union.NativeType.IsVoid);
            Assert.IsFalse(union.NativeType.IsPointer);
            Assert.IsFalse(union.NativeType.IsSequence);
            Assert.IsFalse(union.NativeType.IsFloatingPoint);
            Assert.IsFalse(union.NativeType.IsPointerPointer);
            Assert.AreEqual(0U, union.NativeType.IntegerBitWidth);

            // test the wrapping interface reflects the wrapped native type
            Assert.IsTrue(union.IsSized);
            Assert.IsTrue(union.IsStruct);
            Assert.AreEqual(TypeKind.Struct, union.Kind);
            Assert.IsFalse(union.IsInteger);
            Assert.IsFalse(union.IsFloat);
            Assert.IsFalse(union.IsDouble);
            Assert.IsFalse(union.IsVoid);
            Assert.IsFalse(union.IsPointer);
            Assert.IsFalse(union.IsSequence);
            Assert.IsFalse(union.IsFloatingPoint);
            Assert.IsFalse(union.IsPointerPointer);
            Assert.AreEqual(0U, union.IntegerBitWidth);

            Assert.AreEqual(1, union.NativeType.Members.Count);
            Assert.AreSame(ctx.Int32Type, union.NativeType.Members[0]);

            Assert.IsNotNull(union.DIType.Elements);
            Assert.AreEqual(members.Length, union.DIType.Elements.Count);
            for (int i = 0; i < members.Length; ++i)
            {
                var memberType = union.DIType.Elements[i] as DIDerivedType;
                Assert.IsNotNull(memberType);
                Assert.AreEqual(Tag.Member, memberType !.Tag);
                Assert.AreEqual(members[i].Name, memberType.Name);
                Assert.AreEqual(members[i].DebugType.DIType, memberType.BaseType);
            }
        }
Exemple #24
0
        public void ToVcxprojProperties(XmlWriter writer)
        {
            WriteStringArray(writer, "AdditionalDependencies", AdditionalDependencies);
            WriteStringArray(writer, "AdditionalLibraryDirectories", AdditionalLibraryDirectories);
            WriteStringArray(writer, "AdditionalManifestDependencies", AdditionalManifestDependencies);
            WriteStringArray(writer, "AdditionalOptions", AdditionalOptions);
            WriteStringArray(writer, "AddModuleNamesToAssembly", AddModuleNamesToAssembly);
            if (AllowIsolation)
            {
                writer.WriteElementString("AllowIsolation", XmlConvert.ToString(AllowIsolation));
            }
            writer.WriteElementString("AssemblyDebug", XmlConvert.ToString(AssemblyDebug));
            if (!string.IsNullOrWhiteSpace(BaseAddress))
            {
                writer.WriteElementString("BaseAddress", BaseAddress);
            }
            if (CLRImageType != CLRImageType.Default)
            {
                writer.WriteElementString("CLRImageType", CLRImageType.ToString());
            }
            if (CLRSupportLastError != CLRSupportLastError.Disabled)
            {
                writer.WriteElementString("CLRSupportLastError", CLRSupportLastError.ToString());
            }
            if (CLRThreadAttribute != ApartmentState.Unknown)
            {
                writer.WriteElementString("CLRThreadAttribute", CLRThreadAttribute.ToString());
            }
            writer.WriteElementString("CLRUnmanagedCodeCheck", XmlConvert.ToString(CLRUnmanagedCodeCheck));
            if (CreateHotPatchableImage != LinkerHotPatchingOption.Disabled)
            {
                writer.WriteElementString("CreateHotPatchableImage", CreateHotPatchableImage.ToString());
            }
            writer.WriteElementString("DataExecutionPrevention", XmlConvert.ToString(DataExecutionPrevention));
            WriteStringArray(writer, "DelayLoadDLLs", DelayLoadDLLs);
            writer.WriteElementString("DelaySign", XmlConvert.ToString(DelaySign));
            if (Driver != LinkerDriverOption.NotSet)
            {
                writer.WriteElementString("Driver", Driver.ToString());
            }
            writer.WriteElementString("EnableCOMDATFolding", XmlConvert.ToString(EnableCOMDATFolding));
            writer.WriteElementString("EnableUAC", XmlConvert.ToString(EnableUAC));
            if (!string.IsNullOrWhiteSpace(EntryPointSymbol))
            {
                writer.WriteElementString("EntryPointSymbol", EntryPointSymbol);
            }
            writer.WriteElementString("FixedBaseAddress", XmlConvert.ToString(FixedBaseAddress));
            if (ForceFileOutput != LinkerForceOption.Disabled)
            {
                writer.WriteElementString("ForceFileOutput", ForceFileOutput.ToString());
            }
            WriteStringArray(writer, "ForceSymbolReferences", ForceSymbolReferences);
            if (!string.IsNullOrWhiteSpace(FunctionOrder))
            {
                writer.WriteElementString("FunctionOrder", FunctionOrder);
            }
            writer.WriteElementString("GenerateDebugInformation", XmlConvert.ToString(GenerateDebugInformation));
            writer.WriteElementString("GenerateManifest", XmlConvert.ToString(GenerateManifest));
            writer.WriteElementString("GenerateMapFile", XmlConvert.ToString(GenerateMapFile));
            if (HeapCommitSize.HasValue)
            {
                writer.WriteElementString("HeapCommitSize", XmlConvert.ToString(HeapCommitSize.Value));
            }
            if (HeapReserveSize.HasValue)
            {
                writer.WriteElementString("HeapReserveSize", XmlConvert.ToString(HeapReserveSize.Value));
            }
            writer.WriteElementString("IgnoreAllDefaultLibraries", XmlConvert.ToString(IgnoreAllDefaultLibraries));
            writer.WriteElementString("IgnoreEmbeddedIDL", XmlConvert.ToString(IgnoreEmbeddedIDL));
            writer.WriteElementString("IgnoreImportLibrary", XmlConvert.ToString(IgnoreImportLibrary));
            WriteStringArray(writer, "IgnoreSpecificDefaultLibraries", IgnoreSpecificDefaultLibraries);
            writer.WriteElementString("ImageHasSafeExceptionHandlers", XmlConvert.ToString(ImageHasSafeExceptionHandlers));
            if (!string.IsNullOrWhiteSpace(ImportLibrary))
            {
                writer.WriteElementString("ImportLibrary", ImportLibrary);
            }
            if (!string.IsNullOrWhiteSpace(KeyContainer))
            {
                writer.WriteElementString("KeyContainer", KeyContainer);
            }
            if (!string.IsNullOrWhiteSpace(KeyFile))
            {
                writer.WriteElementString("KeyFile", KeyFile);
            }
            writer.WriteElementString("LargeAddressAware", XmlConvert.ToString(LargeAddressAware));
            writer.WriteElementString("LinkDLL", XmlConvert.ToString(LinkDLL));
            writer.WriteElementString("LinkIncremental", XmlConvert.ToString(LinkIncremental));
            writer.WriteElementString("MapExports", XmlConvert.ToString(MapExports));
            if (!string.IsNullOrWhiteSpace(MapFileName))
            {
                writer.WriteElementString("MapFileName", MapFileName);
            }
            if (!string.IsNullOrWhiteSpace(MergedIDLBaseFileName))
            {
                writer.WriteElementString("MergedIDLBaseFileName", MergedIDLBaseFileName);
            }
            if (MergeSections != null && MergeSections.Count > 0)
            {
                string merges = string.Join(";", MergeSections.Select(pair => pair.Key + "=" + pair.Value));
                writer.WriteElementString("MergeSections", merges);
            }
            if (MinimumRequiredVersion.HasValue)
            {
                writer.WriteElementString("MinimumRequiredVersion", XmlConvert.ToString(MinimumRequiredVersion.Value));
            }
            writer.WriteElementString("NoEntryPoint", XmlConvert.ToString(NoEntryPoint));
            writer.WriteElementString("OptimizeReferences", XmlConvert.ToString(OptimizeReferences));
            writer.WriteElementString("PreventDllBinding", XmlConvert.ToString(PreventDllBinding));
            writer.WriteElementString("RandomizedBaseAddress", XmlConvert.ToString(RandomizedBaseAddress));
            if (SectionAlignment.HasValue)
            {
                writer.WriteElementString("SectionAlignment", XmlConvert.ToString(SectionAlignment.Value));
            }
            writer.WriteElementString("SetChecksum", XmlConvert.ToString(SetChecksum));
            if (StackCommitSize.HasValue)
            {
                writer.WriteElementString("StackCommitSize", XmlConvert.ToString(StackCommitSize.Value));
            }
            if (StackReserveSize.HasValue)
            {
                writer.WriteElementString("StackReserveSize", XmlConvert.ToString(StackReserveSize.Value));
            }
            if (SubSystem != LinkerSubSystemOption.NotSet)
            {
                writer.WriteElementString("SubSystem", SubSystem.ToString());
            }
            writer.WriteElementString("SupportNobindOfDelayLoadedDLL", XmlConvert.ToString(SupportNobindOfDelayLoadedDLL));
            writer.WriteElementString("SupportUnloadOfDelayLoadedDLL", XmlConvert.ToString(SupportUnloadOfDelayLoadedDLL));
            writer.WriteElementString("SwapRunFromCD", XmlConvert.ToString(SwapRunFromCD));
            writer.WriteElementString("SwapRunFromNet", XmlConvert.ToString(SwapRunFromNet));
            if (TargetMachine != LinkerTargetMachine.NotSet)
            {
                writer.WriteElementString("TargetMachine", TargetMachine.ToString());
            }
            writer.WriteElementString("TerminalServerAware", XmlConvert.ToString(TerminalServerAware));
            writer.WriteElementString("TreatLinkerWarningAsErrors", XmlConvert.ToString(TreatLinkerWarningAsErrors));
            writer.WriteElementString("TurnOffAssemblyGeneration", XmlConvert.ToString(TurnOffAssemblyGeneration));
            if (TypeLibraryResourceID.HasValue)
            {
                writer.WriteElementString("TypeLibraryResourceID", XmlConvert.ToString(TypeLibraryResourceID.Value));
            }

            if (!String.IsNullOrWhiteSpace(TypeLibraryFile))
            {
                writer.WriteElementString("TypeLibraryFile", TypeLibraryFile);
            }

            writer.WriteElementString("UACExecutionLevel", UACExecutionLevel.ToString());
            writer.WriteElementString("UACUIAccess", XmlConvert.ToString(UACUIAccess));
        }
Exemple #25
0
 /// <summary>Initializes a new instance of the <see cref="OrcJit"/> class for a given target machine.</summary>
 /// <param name="machine">Target machine for the JIT</param>
 public OrcJit(TargetMachine machine)
 {
     JitStackHandle = LLVMOrcCreateInstance(machine.TargetMachineHandle);
 }
Exemple #26
0
 public bool isMonoposto()
 {
     if (DataSource == null || TargetMachine != null && DataSource.ToLower().StartsWith(TargetMachine.ToLower()))
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
        public void TargetMachineConstructorDefaultTest()
        {
            TargetMachine target = new TargetMachine();

            // Make sure target is not null.
            Assert.IsNotNull(target);

            // Make sure MachineIP is not null.
            Assert.IsNotNull(target.MachineIP);

            // Make sure DisplayValue is not null.
            Assert.IsNotNull(target.DisplayValue);
        }
        public void TargetMachineConstructorWithInvalidIPAddressTest()
        {
            // Random IP address (Invalid)
            string inputValue = "121.242.121.242";

            // User WWTMockRequest in WWTManager so that all calls to WWT API will succeed.
            Globals_Accessor.wwtManager = new WWTManager(new WWTMockRequest());

            TargetMachine target = new TargetMachine(inputValue);
            Assert.Fail("TargetMachine object initialized with invalid IP Address!");
        }
        public void TargetMachineConstructorWithInvalidParameterTest()
        {
            // Invalid parameter
            string inputValue = "InvalidParameter";

            // User WWTMockRequest in WWTManager so that all calls to WWT API will succeed.
            Globals_Accessor.wwtManager = new WWTManager(new WWTMockRequest());

            TargetMachine target = new TargetMachine(inputValue);
            Assert.Fail("TargetMachine object initialized with invalid parameter!");
        }