Пример #1
0
        public string CoreRunPath(CompilerIndex index, bool isFramework)
        {
            string coreRunPath = Path.Combine(CoreRootOutputPath(index, isFramework), "CoreRun.exe");

            if (!File.Exists(coreRunPath))
            {
                Console.Error.WriteLine("CoreRun.exe not found in CORE_ROOT, explicit exe launches won't work");
            }
            return(coreRunPath);
        }
Пример #2
0
        public string CoreRunPath(CompilerIndex index, bool isFramework)
        {
            string coreRunDir  = CoreRootOutputPath(index, isFramework);
            string coreRunExe  = "corerun".OSExeSuffix();
            string coreRunPath = Path.Combine(coreRunDir, coreRunExe);

            if (!File.Exists(coreRunPath))
            {
                Console.Error.WriteLine($@"{coreRunExe} not found in {coreRunDir}, explicit exe launches won't work");
            }
            return(coreRunPath);
        }
Пример #3
0
        /// <summary>
        /// Construct CoreRoot native path for a given compiler runner.
        /// </summary>
        /// <param name="index">Compiler runner index</param>
        /// <returns></returns>
        public string CoreRootOutputPath(CompilerIndex index, bool isFramework)
        {
            if (CoreRootDirectory == null)
            {
                return(null);
            }

            string outputPath = CoreRootDirectory.FullName;

            if (!isFramework && (Framework || UseFramework))
            {
                outputPath = Path.Combine(outputPath, index.ToString() + ConfigurationSuffix);
            }
            return(outputPath);
        }
Пример #4
0
        public static bool Exclude(string simpleName, CompilerIndex index, out string reason)
        {
            FrameworkExclusion exclusion = Find(simpleName);

            if (exclusion != null &&
                (exclusion.ExclusionType == ExclusionType.Ignore ||
                 exclusion.ExclusionType == ExclusionType.DontCrossgen2 && index == CompilerIndex.CPAOT))
            {
                reason = exclusion.Reason;
                return(true);
            }
            else
            {
                reason = null;
                return(false);
            }
        }
Пример #5
0
        public static bool Exclude(string simpleName, CompilerIndex index, out string reason)
        {
            FrameworkExclusion exclusion = Find(simpleName);

            if (exclusion != null &&
                (exclusion.ExclusionType == ExclusionType.Ignore ||
                 exclusion.ExclusionType == ExclusionType.DontCrossgen2 && index == CompilerIndex.CPAOT))
            {
                reason = exclusion.Reason;
                return(true);
            }

            if (simpleName.StartsWith("xunit.", StringComparison.OrdinalIgnoreCase))
            {
                reason = "XUnit";
                return(true);
            }

            reason = null;
            return(false);
        }
Пример #6
0
        public void AddModuleToJittedMethodsMapping(Dictionary <string, HashSet <string> > moduleToJittedMethods, int executionIndex, CompilerIndex compilerIndex)
        {
            ProcessInfo executionProcess = _executions[executionIndex][(int)compilerIndex];

            if (executionProcess != null && executionProcess.JittedMethods != null)
            {
                foreach (KeyValuePair <string, HashSet <string> > moduleMethodKvp in executionProcess.JittedMethods)
                {
                    HashSet <string> jittedMethodsPerModule;
                    if (!moduleToJittedMethods.TryGetValue(moduleMethodKvp.Key, out jittedMethodsPerModule))
                    {
                        jittedMethodsPerModule = new HashSet <string>();
                        moduleToJittedMethods.Add(moduleMethodKvp.Key, jittedMethodsPerModule);
                    }
                    jittedMethodsPerModule.UnionWith(moduleMethodKvp.Value);
                }
            }
        }