/// <summary>
/// For loop for array which will invoke Amplifier code.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="compiler">The compiler.</param>
/// <param name="kernelName">Name of the kernel.</param>
/// <param name="args">The arguments.</param>
public static void AmplifyFor(this Array x, BaseCompiler compiler, string kernelName, params object[] args)
{
var arguments = args.ToList();
arguments.Insert(0, x);
compiler.Execute(kernelName, arguments.ToArray());
}
/// <summary>
/// Initializes a new instance of the <see cref="AotMethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The compiler.</param>
/// <param name="method">The method.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public AotMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
: base(compiler, method, basicBlocks, threadID)
{
var compilerOptions = compiler.CompilerOptions;
// Populate the pipeline
Pipeline.Add(new IMethodCompilerStage[] {
new CILDecodingStage(),
new ExceptionPrologueStage(),
new OperandAssignmentStage(),
new StackSetupStage(),
new CILProtectedRegionStage(),
new ExceptionStage(),
new StaticAllocationResolutionStage(),
new CILTransformationStage(),
new UnboxValueTypeStage(),
(compilerOptions.EnableInlinedMethods) ? new InlineStage() : null,
(compilerOptions.EnableSSA) ? new EdgeSplitStage() : null,
(compilerOptions.EnableSSA) ? new EnterSSAStage() : null,
(compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null,
(compilerOptions.EnableIROptimizations) ? new IROptimizationStage() : null,
new LowerIRStage(),
(compilerOptions.IRLongExpansion && compiler.Architecture.NativePointerSize == 4) ? new IRLongExpansionStage() : null,
(compilerOptions.TwoPassOptimizations && compilerOptions.EnableIROptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null,
(compilerOptions.TwoPassOptimizations && compilerOptions.EnableIROptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new IROptimizationStage() : null,
(compilerOptions.EnableSSA) ? new LeaveSSAStage() : null,
new IRCleanupStage(),
(compilerOptions.EnableInlinedMethods) ? new InlineEvaluationStage() : null,
new DevirtualizeCallStage(),
new CallStage(),
new PlatformStubStage(),
new PlatformEdgeSplitStage(),
new VirtualRegisterRenameStage(),
new GreedyRegisterAllocatorStage(),
new StackLayoutStage(),
new EmptyBlockRemovalStage(),
new BlockOrderingStage(),
new CodeGenerationStage(),
new PreciseGCStage(),
new ProtectedRegionLayoutStage(),
});
}
/// <summary>
/// Initializes a new instance of the <see cref="AotMethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The compiler.</param>
/// <param name="method">The method.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public AotMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
: base(compiler, method, basicBlocks, threadID)
{
var compilerOptions = compiler.CompilerOptions;
// Populate the pipeline
Pipeline.Add(new IMethodCompilerStage[] {
new CILDecodingStage(),
new ExceptionPrologueStage(),
new OperandAssignmentStage(),
new StackSetupStage(),
new CILProtectedRegionStage(),
new ExceptionStage(),
new StaticAllocationResolutionStage(),
new CILTransformationStage(),
new ConvertCompoundStage(),
new UnboxValueTypeStage(),
(compilerOptions.EnableInlinedMethods) ? new InlineStage() : null,
(compilerOptions.EnableVariablePromotion) ? new PromoteTempVariablesStage() : null,
(compilerOptions.EnableSSA) ? new EdgeSplitStage() : null,
(compilerOptions.EnableSSA) ? new PhiPlacementStage() : null,
(compilerOptions.EnableSSA) ? new EnterSSAStage() : null,
(compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null,
(compilerOptions.EnableOptimizations) ? new IROptimizationStage() : null,
(compilerOptions.TwoPassOptimizationStages && compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null,
(compilerOptions.TwoPassOptimizationStages && compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new IROptimizationStage() : null,
(compilerOptions.EnableSSA) ? new LeaveSSA() : null,
new IRCleanupStage(),
(compilerOptions.EnableInlinedMethods) ? new InlineEvaluationStage() : null,
new PlatformStubStage(),
new PlatformEdgeSplitStage(),
new VirtualRegisterRenameStage(),
new GreedyRegisterAllocatorStage(),
new StackLayoutStage(),
new EmptyBlockRemovalStage(),
new BlockOrderingStage(),
new CodeGenerationStage(),
new ProtectedRegionLayoutStage(),
});
}
Assembly GetAssemblyFromSource(string vpath)
{
vpath = UrlUtils.Combine(BaseVirtualDir, vpath);
string realPath = MapPath(vpath, false);
if (!File.Exists(realPath))
{
ThrowParseException("File " + vpath + " not found");
}
AddSourceDependency(vpath);
CompilerResults result;
string tmp;
CompilerParameters parameters;
CodeDomProvider provider = BaseCompiler.CreateProvider(HttpContext.Current, language, out parameters, out tmp);
if (provider == null)
{
throw new HttpException("Cannot find provider for language '" + language + "'.");
}
AssemblyBuilder abuilder = new AssemblyBuilder(provider);
abuilder.CompilerOptions = parameters;
abuilder.AddAssemblyReference(BuildManager.GetReferencedAssemblies() as List <Assembly>);
abuilder.AddCodeFile(realPath);
result = abuilder.BuildAssembly(new VirtualPath(vpath));
if (result.NativeCompilerReturnValue != 0)
{
using (StreamReader reader = new StreamReader(realPath)) {
throw new CompilationException(realPath, result.Errors, reader.ReadToEnd());
}
}
AddAssembly(result.CompiledAssembly, true);
return(result.CompiledAssembly);
}
void ICompilerStage.Setup(BaseCompiler compiler)
{
base.Setup(compiler);
this.linker = RetrieveLinkerFromCompiler();
}
static void Main(string[] args)
{
CompilerType compilerType = ReadCompilerType();
ICompiler compiler = BaseCompiler.CreateCompiler(compilerType);
Console.WriteLine("Enter file path.");
string sourceFilePath = Console.ReadLine();
string source = File.ReadAllText(sourceFilePath);
string fileName = Path.GetRandomFileName();
if (compilerType == CompilerType.Java)
{
fileName = GetClassName(source);
}
string workingDirectory = Environment.CurrentDirectory + "\\" + Guid.NewGuid().ToString();
Directory.CreateDirectory(workingDirectory);
WriteSourceToFile(source, compilerType, workingDirectory, fileName);
CompileResult compileResult = compiler.Compile(new CompilerArguments(fileName, workingDirectory, new List <string> {
source
}));
if (!compileResult.IsSuccessfull)
{
Console.WriteLine($"Compile time error: {compileResult.Errors}");
return;
}
IExecutor executor = BaseExecutor.CreateExecutor(compilerType);
string compiledFileName = Path.GetFileName(compileResult.CompiledFilePath);
string compiledFileDirectory = Path.GetDirectoryName(compileResult.CompiledFilePath);
Console.WriteLine("Enter inputs to test the program. If you want to stop enter 'stop'!");
string input = string.Empty;
while ((input = Console.ReadLine()) != "stop")
{
ProcessExecutionResult processExecutionResult = executor.Execute(input, compiledFileName, compiledFileDirectory).GetAwaiter().GetResult();
if (processExecutionResult.IsSuccesfull && processExecutionResult.Type == ProcessExecutionResultType.Success)
{
Console.WriteLine("The application was run seccessfully!");
Console.WriteLine(processExecutionResult.ReceivedOutput);
}
else
{
Console.WriteLine("Some errors occured!");
Console.WriteLine(processExecutionResult.ErrorOutput);
}
Console.WriteLine("Process statistics");
Console.WriteLine($"Exit code: {processExecutionResult.ExitCode}");
Console.WriteLine($"Memory Used: {processExecutionResult.MemoryUsed}");
Console.WriteLine($"Processor time used: {processExecutionResult.TotalProcessorTime}");
Console.WriteLine($"Working time: {processExecutionResult.TimeWorked}");
Console.WriteLine($"Execution Type: {processExecutionResult.Type}");
Console.WriteLine(new string('-', 50));
}
DeleteWorkingDirectory(workingDirectory);
}
/// <summary>
/// Call RemoteHost.ExtractInfoFromCompiler() instead.
/// Requires these utilities on the remote system: pwd, echo, which, touch, sort, pushd, popd, zip
/// </summary>
/// <param name="remote">Remote host where compiler installed</param>
public void ExtractAdditionalInfo(RemoteHost remote)
{
String remoteTempFile = String.Format(Compiler.RemoteTempFile, BaseCompiler.ShortName, instanceGuid.ToString());
if (remote.Execute("pwd || echo $PWD", out String pwd) != RemoteHost.Success)
{
throw new ApplicationException("could not get current directory name");
}
pwd = pwd.TrimEnd(RemoteHost.LineEndingChars);
if (remote.Execute($"which {BaseCompiler.ExePath}", out String absExePath) != RemoteHost.Success)
{
throw new ApplicationException("could not get absolute compiler path");
}
absExePath = absExePath.TrimEnd(RemoteHost.LineEndingChars);
if (remote.Execute($"{BaseCompiler.ExePath} -dumpversion", out String version) != RemoteHost.Success)
{
throw new ApplicationException("could not extract version from compiler");
}
Version = version.TrimEnd(RemoteHost.LineEndingChars);
// create temporary .c file for auto-distinguishment between C and C++
if (remote.Execute($"touch {remoteTempFile} || echo > {remoteTempFile}", out String _) != RemoteHost.Success)
{
throw new ApplicationException("could not create temporary file");
}
if (remote.Execute($"{BaseCompiler.ExePath} {this} -E -dM {remoteTempFile} | sort", out String defines) != RemoteHost.Success)
{
throw new ApplicationException("could not extract defines from compiler");
}
if (remote.Execute($"{BaseCompiler.ExePath} {this} -E -Wp,-v {remoteTempFile} 2>&1 1> /dev/null", out String includeDirs) != RemoteHost.Success)
{
throw new ApplicationException("could not extract include dirs from compiler");
}
AbsoluteCrosspath xpwd = AbsoluteCrosspath.FromString(pwd);
AbsoluteCrosspath xcompiler = AbsoluteCrosspath.FromString(absExePath);
if (!xcompiler.ToString().Equals(BaseCompiler.ExePath.ToString()))
{
AbsoluteCrosspath compilerLocatedIn = new AbsoluteCrosspath(xcompiler);
((RelativeCrosspath)BaseCompiler.ExePath).SetWorkingDirectory(xcompiler.ToContainingDirectory());
Logger.WriteLine(LogLevel.Info, $"compiler '{BaseCompiler.ExePath}' actually located at '{xcompiler}'");
}
Defines.Clear();
Platform fallbackPlatform = Platform.x64;
foreach (String macro in defines.Split(RemoteHost.LineEndings, StringSplitOptions.RemoveEmptyEntries))
{
// assuming standard format '#define MACRO some thing probably with spaces'
String[] defArray = macro.Split(new[] { ' ' }, 3);
// try to auto-detect the platform
if (VSPlatform == Platform.Unknown)
{
switch (defArray[1])
{
case "__x86_64__": VSPlatform = Platform.x64; break;
case "__i386__": VSPlatform = Platform.x86; break;
case "__arm__": VSPlatform = Platform.ARM; break;
case "__aarch64__": VSPlatform = Platform.ARM64; break;
case "__mips__": VSPlatform = Platform.MIPS; break;
case "__WORDSIZE__": /* this seems to be standard */
case "__INTPTR_WIDTH__": /* this not, but use as fallback */
if (Int32.Parse(defArray[2]) == 32)
{
fallbackPlatform = Platform.x86;
}
break;
}
}
Defines.Add(new Define(defArray[1], defArray[2]));
}
if (VSPlatform == Platform.Unknown)
{
VSPlatform = fallbackPlatform;
}
IncludeDirectories.Clear();
IncludeDirectoryType incDirType = IncludeDirectoryType.Null;
foreach (String cppLine in includeDirs.Split(RemoteHost.LineEndings, StringSplitOptions.RemoveEmptyEntries))
{
// sample output:
/*
* ignoring nonexistent directory "/opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/arm-v5te-linux-gnueabi/include"
#include "..." search starts here:
#include <...> search starts here:
* /opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/bin/../lib/gcc/arm-v5te-linux-gnueabi/4.1.2/include
* /opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/bin/../sysroot-arm-v5te-linux-gnueabi/usr/include
* End of search list.
*/
// regarding priority:
// -iquote has the highest priority affecting #include "..." not only #include <...>
// -I has lower priority than -iquote
// -isystem has lower priority but yet higher priority than system-wide headers
// then follows the priority of system-wide-headers
// -idirafter has the lowest priority possible
// example (gcc 9):
/*
* $ gcc -x c -c -Wp,-v -iquote /proc/1 -I /proc/10 -isystem /proc/12 -I /proc/14 -idirafter /proc/1204 - < /dev/null
* ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
* ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
* ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
* /proc/1
#include <...> search starts here:
* /proc/10
* /proc/14
* /proc/12
* /usr/lib/gcc/x86_64-linux-gnu/9/include
* /usr/local/include
* /usr/include/x86_64-linux-gnu
* /usr/include
* /proc/1204
* End of search list.
*/
// usually gcc does not have any include directories in the #include "..." section.
// so the reason for parsing this section is when using some compiler wrapper that puts some paths to -iquote.
if (cppLine == "#include \"...\" search starts here:")
{
incDirType = IncludeDirectoryType.Quote;
continue;
}
if (cppLine == "#include <...> search starts here:")
{
incDirType = IncludeDirectoryType.System;
continue;
}
if (cppLine.Length > 0 && cppLine[0] == ' ')
{
Crosspath xpath = Crosspath.FromString(cppLine.Substring(1));
if (xpath is RelativeCrosspath relPath)
{
relPath.SetWorkingDirectory(xpwd);
xpath = relPath.Absolutized();
}
IncludeDirectory incDir = new IncludeDirectory(xpath as AbsoluteCrosspath, incDirType);
IncludeDirectory incDirCached = BaseCompiler.TrackIncludeDir(incDir);
if (incDirCached != null)
{
incDir = incDirCached;
}
IncludeDirectories.Add(incDir);
continue;
}
if (cppLine == "End of search list.")
{
break;
}
}
HaveAdditionalInfo = true;
Logger.WriteLine(LogLevel.Info, $"{absExePath} {this} is {VSPlatform} compiler");
}
void ICompilerStage.Setup(BaseCompiler compiler)
{
base.Setup(compiler);
plugTypeAttribute = typeSystem.GetType("Mosa.Internal.Plug", "Mosa.Internal.Plug", "PlugTypeAttribute");
plugMethodAttribute = typeSystem.GetType("Mosa.Internal.Plug", "Mosa.Internal.Plug", "PlugMethodAttribute");
}
private static List<RuntimeMethod> RecompileMethods(BaseCompiler compiler, List<Token> types, RuntimeMethod method)
{
throw new NotImplementedException();
}
private static List<Token> GetTokenTypesForMethod(BaseCompiler compiler, RuntimeType type, RuntimeMethod method)
{
throw new NotImplementedException();
}
