public Compiler(MosaCompiler mosaCompiler)
{
TypeSystem = mosaCompiler.TypeSystem;
TypeLayout = mosaCompiler.TypeLayout;
CompilerOptions = mosaCompiler.CompilerOptions;
Linker = mosaCompiler.Linker;
CompilerTrace = mosaCompiler.CompilerTrace;
Architecture = CompilerOptions.Architecture;
PostCompilerTraceEvent(CompilerEvent.CompilerStart);
CompilerExtensions.AddRange(mosaCompiler.CompilerExtensions);
MethodStagePipelines = new Pipeline <BaseMethodCompilerStage> [mosaCompiler.MaxThreads + 1];
MethodScheduler = new MethodScheduler(this);
MethodScanner = new MethodScanner(this);
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (!type.IsClass)
{
continue;
}
foreach (var method in type.GetRuntimeMethods())
{
// Now get all the IntrinsicMethodAttribute attributes
var attributes = (IntrinsicMethodAttribute[])method.GetCustomAttributes(typeof(IntrinsicMethodAttribute), true);
for (int i = 0; i < attributes.Length; i++)
{
var d = (InstrinsicMethodDelegate)Delegate.CreateDelegate(typeof(InstrinsicMethodDelegate), method);
// Finally add the dictionary entry mapping the target name and the delegate
InternalIntrinsicMethods.Add(attributes[i].Target, d);
}
}
}
PlugSystem = new PlugSystem(TypeSystem);
PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
InternalRuntimeType = GeInternalRuntimeType();
// Build the default compiler pipeline
CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerOptions));
foreach (var extension in CompilerExtensions)
{
extension.ExtendCompilerPipeline(CompilerPipeline);
}
Architecture.ExtendCompilerPipeline(CompilerPipeline, CompilerOptions);
IsStopped = false;
WorkCount = 0;
}
public void Initialize(MosaCompiler compiler)
{
if (compiler == null)
{
throw new ArgumentNullException(@"compiler");
}
Compiler = compiler;
Architecture = Compiler.CompilerOptions.Architecture;
TypeSystem = Compiler.TypeSystem;
TypeLayout = Compiler.TypeLayout;
CompilerTrace = Compiler.CompilerTrace;
CompilerOptions = Compiler.CompilerOptions;
CompilationScheduler = Compiler.CompilationScheduler;
Linker = compiler.Linker;
PreCompilePipeline = new CompilerPipeline();
PostCompilePipeline = new CompilerPipeline();
Counters = new Counters();
PlugSystem = new PlugSystem();
CompilerData = new CompilerData(this);
// 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();
// Extended Setup
ExtendCompilerSetup();
// Build the default pre-compiler pipeline
Architecture.ExtendPreCompilerPipeline(this.PreCompilePipeline);
// Build the default post-compiler pipeline
Architecture.ExtendPostCompilerPipeline(this.PostCompilePipeline);
}
public void Initialize(MosaCompiler compiler)
{
if (compiler == null)
{
throw new ArgumentNullException(@"compiler");
}
Compiler = compiler;
Architecture = Compiler.CompilerOptions.Architecture;
TypeSystem = Compiler.TypeSystem;
TypeLayout = Compiler.TypeLayout;
CompilerTrace = Compiler.CompilerTrace;
CompilerOptions = Compiler.CompilerOptions;
CompilationScheduler = Compiler.CompilationScheduler;
Linker = compiler.Linker;
PreCompilePipeline = new CompilerPipeline();
PostCompilePipeline = new CompilerPipeline();
GlobalCounters = new Counters();
PlugSystem = new PlugSystem();
CompilerData = new CompilerData();
// Create new dictionary
IntrinsicTypes = new Dictionary <string, Type>();
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type))
{
// Now get all the ReplacementTarget attributes
var attributes = (ReplacementTargetAttribute[])type.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, type);
}
}
}
PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
InternalRuntimeType = GeInternalRuntimeType();
// Extended Setup
ExtendCompilerSetup();
// Build the default pre-compiler pipeline
Architecture.ExtendPreCompilerPipeline(PreCompilePipeline);
// Build the default post-compiler pipeline
Architecture.ExtendPostCompilerPipeline(PostCompilePipeline);
}
public Compiler(MosaCompiler mosaCompiler)
{
Architecture = mosaCompiler.CompilerOptions.Architecture;
TypeSystem = mosaCompiler.TypeSystem;
TypeLayout = mosaCompiler.TypeLayout;
CompilerTrace = mosaCompiler.CompilerTrace;
CompilerOptions = mosaCompiler.CompilerOptions;
CompilationScheduler = mosaCompiler.CompilationScheduler;
Linker = mosaCompiler.Linker;
CompilerExtensions.AddRange(mosaCompiler.CompilerExtensions);
methodStagePipelines = new Pipeline <BaseMethodCompilerStage> [mosaCompiler.MaxThreads];
// Create new dictionary
IntrinsicTypes = new Dictionary <string, Type>();
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type))
{
// Now get all the ReplacementTarget attributes
var attributes = (ReplacementTargetAttribute[])type.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, type);
}
}
}
PlugSystem = new PlugSystem(TypeSystem);
PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
InternalRuntimeType = GeInternalRuntimeType();
// Build the default compiler pipeline
CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerOptions));
foreach (var extension in CompilerExtensions)
{
extension.ExtendCompilerPipeline(CompilerPipeline);
}
Architecture.ExtendCompilerPipeline(CompilerPipeline);
IsStopped = false;
}
/// <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);
}
}
public void Initialize(MosaCompiler compiler)
{
if (compiler == null)
throw new ArgumentNullException(@"compiler");
Compiler = compiler;
Architecture = Compiler.CompilerOptions.Architecture;
TypeSystem = Compiler.TypeSystem;
TypeLayout = Compiler.TypeLayout;
CompilerTrace = Compiler.CompilerTrace;
CompilerOptions = Compiler.CompilerOptions;
CompilationScheduler = Compiler.CompilationScheduler;
Linker = compiler.Linker;
PreCompilePipeline = new CompilerPipeline();
PostCompilePipeline = new CompilerPipeline();
GlobalCounters = new Counters();
PlugSystem = new PlugSystem();
CompilerData = new CompilerData();
// Create new dictionary
IntrinsicTypes = new Dictionary<string, Type>();
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type))
{
// Now get all the ReplacementTarget attributes
var attributes = (ReplacementTargetAttribute[])type.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, type);
}
}
}
PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
InternalRuntimeType = GeInternalRuntimeType();
// Extended Setup
ExtendCompilerSetup();
// Build the default pre-compiler pipeline
Architecture.ExtendPreCompilerPipeline(PreCompilePipeline);
// Build the default post-compiler pipeline
Architecture.ExtendPostCompilerPipeline(PostCompilePipeline);
}
public void Initialize(MosaCompiler compiler)
{
if (compiler == null)
throw new ArgumentNullException(@"compiler");
Compiler = compiler;
Architecture = Compiler.CompilerOptions.Architecture;
TypeSystem = Compiler.TypeSystem;
TypeLayout = Compiler.TypeLayout;
CompilerTrace = Compiler.CompilerTrace;
CompilerOptions = Compiler.CompilerOptions;
CompilationScheduler = Compiler.CompilationScheduler;
Linker = compiler.Linker;
PreCompilePipeline = new CompilerPipeline();
PostCompilePipeline = new CompilerPipeline();
Counters = new Counters();
PlugSystem = new PlugSystem();
CompilerData = new CompilerData(this);
// 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();
// Extended Setup
ExtendCompilerSetup();
// Build the default pre-compiler pipeline
Architecture.ExtendPreCompilerPipeline(this.PreCompilePipeline);
// Build the default post-compiler pipeline
Architecture.ExtendPostCompilerPipeline(this.PostCompilePipeline);
}
/// <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(IArchitecture architecture, ITypeSystem typeSystem, ITypeLayout typeLayout, ICompilationScheduler compilationScheduler, 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);
this.counters = new Counters();
this.compilationScheduler = compilationScheduler;
this.linker = compilerOptions.Linker;
this.plugSystem = new PlugSystem();
}
public Compiler(MosaCompiler mosaCompiler)
{
TypeSystem = mosaCompiler.TypeSystem;
TypeLayout = mosaCompiler.TypeLayout;
CompilerSettings = mosaCompiler.CompilerSettings;
Architecture = mosaCompiler.Platform;
CompilerHooks = mosaCompiler.CompilerHooks;
TraceLevel = CompilerSettings.TraceLevel;
Statistics = CompilerSettings.Statistics;
Linker = new MosaLinker(this);
ObjectHeaderSize = Architecture.NativePointerSize + 4 + 4; // Hash Value (32-bit) + Lock & Status (32-bit) + Method Table
StackFrame = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister);
StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister);
LinkRegister = Architecture.LinkRegister == null ? null : Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.LinkRegister);
ProgramCounter = Architecture.ProgramCounter == null ? null : Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.ProgramCounter);
ExceptionRegister = Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.ExceptionRegister);
LeaveTargetRegister = Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.LeaveTargetRegister);
PostEvent(CompilerEvent.CompileStart);
MethodStagePipelines = new Pipeline <BaseMethodCompilerStage> [MaxThreads];
MethodScheduler = new MethodScheduler(this);
MethodScanner = new MethodScanner(this);
foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (!type.IsClass)
{
continue;
}
foreach (var method in type.GetRuntimeMethods())
{
// Now get all the IntrinsicMethodAttribute attributes
var intrinsicMethodAttributes = (IntrinsicMethodAttribute[])method.GetCustomAttributes(typeof(IntrinsicMethodAttribute), true);
for (int i = 0; i < intrinsicMethodAttributes.Length; i++)
{
var d = (IntrinsicMethodDelegate)System.Delegate.CreateDelegate(typeof(IntrinsicMethodDelegate), method);
// Finally add the dictionary entry mapping the target name and the delegate
InternalIntrinsicMethods.Add(intrinsicMethodAttributes[i].Target, d);
}
// Now get all the StubMethodAttribute attributes
var stubMethodAttributes = (StubMethodAttribute[])method.GetCustomAttributes(typeof(StubMethodAttribute), true);
for (int i = 0; i < stubMethodAttributes.Length; i++)
{
var d = (StubMethodDelegate)System.Delegate.CreateDelegate(typeof(StubMethodDelegate), method);
// Finally add the dictionary entry mapping the target name and the delegate
InternalStubMethods.Add(stubMethodAttributes[i].Target, d);
}
}
}
PlugSystem = new PlugSystem(TypeSystem);
PlatformInternalRuntimeType = GetPlatformInternalRuntimeType();
InternalRuntimeType = GeInternalRuntimeType();
// Build the default compiler pipeline
CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerSettings, Architecture.Is64BitPlatform));
// Call hook to allow for the extension of the pipeline
CompilerHooks.ExtendCompilerPipeline?.Invoke(CompilerPipeline);
Architecture.ExtendCompilerPipeline(CompilerPipeline, CompilerSettings);
IsStopped = false;
}