protected override void Run()
{
// Unable to optimize SSA w/ exceptions or finally handlers present
if (BasicBlocks.HeadBlocks.Count != 1)
return;
trace = CreateTrace();
foreach (var local in MethodCompiler.LocalVariables)
{
if (local.IsVirtualRegister)
continue;
if (local.Uses.Count == 0)
continue;
if (local.Definitions.Count != 1)
continue;
if (!local.IsReferenceType && !local.IsInteger && !local.IsR && !local.IsChar && !local.IsBoolean && !local.IsPointer)
continue;
if (ContainsAddressOf(local))
continue;
Promote(local);
}
}
public static void Compile(CompilerOptions compilerOptions, List<FileInfo> inputFiles, CompilerTrace compilerTrace)
{
var moduleLoader = new MosaModuleLoader();
moduleLoader.AddPrivatePath(GetInputFileNames(inputFiles));
foreach (string file in GetInputFileNames(inputFiles))
{
moduleLoader.LoadModuleFromFile(file);
}
var typeSystem = TypeSystem.Load(moduleLoader.CreateMetadata());
MosaTypeLayout typeLayout = new MosaTypeLayout(typeSystem, compilerOptions.Architecture.NativePointerSize, compilerOptions.Architecture.NativeAlignment);
AotCompiler aot = new AotCompiler(compilerOptions.Architecture, typeSystem, typeLayout, compilerTrace, compilerOptions);
var bootStage = compilerOptions.BootStageFactory != null ? compilerOptions.BootStageFactory() : null;
aot.Pipeline.Add(new ICompilerStage[] {
bootStage,
compilerOptions.MethodPipelineExportDirectory != null ? new MethodPipelineExportStage(): null,
new PlugStage(),
new MethodCompilerSchedulerStage(),
new TypeInitializerSchedulerStage(),
bootStage,
new MethodLookupTableStage(),
new MethodExceptionLookupTableStage(),
new MetadataStage(),
new LinkerFinalizationStage(),
compilerOptions.MapFile != null ? new MapFileGenerationStage() : null
});
aot.Run();
}
/// <summary>
/// Compiles the specified type system.
/// </summary>
/// <param name="typeSystem">The type system.</param>
/// <param name="typeLayout">The type layout.</param>
/// <param name="compilerTrace">The compiler trace.</param>
/// <param name="compilerOptions">The compiler options.</param>
/// <param name="architecture">The architecture.</param>
/// <param name="simAdapter">The sim adapter.</param>
/// <param name="linker">The linker.</param>
/// <returns></returns>
public static SimCompiler Compile(TypeSystem typeSystem, MosaTypeLayout typeLayout, CompilerTrace compilerTrace, CompilerOptions compilerOptions, BaseArchitecture architecture, ISimAdapter simAdapter, BaseLinker linker)
{
var compiler = new SimCompiler(architecture, typeSystem, typeLayout, linker, compilerOptions, compilerTrace, simAdapter);
compiler.Compile();
return compiler;
}
public CompilerTrace(CompilerTrace trace, string section)
: this(trace.internalTrace)
{
this.Method = trace.Method;
this.Stage = trace.Stage;
this.Section = section;
this.Active = internalTrace.TraceFilter.IsMatch(this.Method, this.Stage);
}
public GreedyRegisterAllocator(BasicBlocks basicBlocks, VirtualRegisters compilerVirtualRegisters, InstructionSet instructionSet, StackLayout stackLayout, BaseArchitecture architecture, CompilerTrace trace)
{
this.trace = trace;
this.basicBlocks = basicBlocks;
this.instructionSet = instructionSet;
this.stackLayout = stackLayout;
this.architecture = architecture;
this.virtualRegisterCount = compilerVirtualRegisters.Count;
this.physicalRegisterCount = architecture.RegisterSet.Length;
this.registerCount = virtualRegisterCount + physicalRegisterCount;
this.liveIntervalTracks = new List<LiveIntervalTrack>(physicalRegisterCount);
this.virtualRegisters = new List<VirtualRegister>(registerCount);
this.extendedBlocks = new List<ExtendedBlock>(basicBlocks.Count);
stackFrameRegister = architecture.StackFrameRegister;
stackPointerRegister = architecture.StackPointerRegister;
programCounter = architecture.ProgramCounter;
// Setup extended physical registers
foreach (var physicalRegister in architecture.RegisterSet)
{
Debug.Assert(physicalRegister.Index == virtualRegisters.Count);
Debug.Assert(physicalRegister.Index == liveIntervalTracks.Count);
bool reserved = (physicalRegister == stackFrameRegister
|| physicalRegister == stackPointerRegister
|| (programCounter != null && physicalRegister == programCounter));
this.virtualRegisters.Add(new VirtualRegister(physicalRegister, reserved));
this.liveIntervalTracks.Add(new LiveIntervalTrack(physicalRegister, reserved));
}
// Setup extended virtual registers
foreach (var virtualRegister in compilerVirtualRegisters)
{
Debug.Assert(virtualRegister.Index == virtualRegisters.Count - physicalRegisterCount + 1);
this.virtualRegisters.Add(new VirtualRegister(virtualRegister));
}
priorityQueue = new SimpleKeyPriorityQueue<LiveInterval>();
spilledIntervals = new List<LiveInterval>();
callSlots = new List<SlotIndex>();
moveHints = new Dictionary<SlotIndex, MoveHint>();
Start();
}
protected override void Run()
{
trace = CreateTrace();
var blockOrderAnalysis = MethodCompiler.Compiler.CompilerOptions.BlockOrderAnalysisFactory();
blockOrderAnalysis.PerformAnalysis(BasicBlocks);
BasicBlocks.ReorderBlocks(blockOrderAnalysis.NewBlockOrder);
if (trace.Active)
{
DumpTrace(blockOrderAnalysis);
}
}
/// <summary>
/// Compiles the specified type system.
/// </summary>
/// <param name="typeSystem">The type system.</param>
/// <param name="typeLayout">The type layout.</param>
/// <param name="compilerTrace">The compiler trace.</param>
/// <param name="platform">The platform.</param>
/// <param name="enabledSSA">if set to <c>true</c> [enabled ssa].</param>
/// <param name="enableOptimizations">if set to <c>true</c> [enable ssa optimizations].</param>
/// <param name="emitBinary">if set to <c>true</c> [emit binary].</param>
public static void Compile(TypeSystem typeSystem, MosaTypeLayout typeLayout, CompilerTrace compilerTrace, string platform, CompilerOptions compilerOptions, bool emitBinary)
{
BaseArchitecture architecture;
switch (platform.ToLower())
{
case "x86": architecture = Mosa.Platform.x86.Architecture.CreateArchitecture(Mosa.Platform.x86.ArchitectureFeatureFlags.AutoDetect); break;
case "armv6": architecture = Mosa.Platform.ARMv6.Architecture.CreateArchitecture(Mosa.Platform.ARMv6.ArchitectureFeatureFlags.AutoDetect); break;
//case "avr32": architecture = Mosa.Platform.AVR32.Architecture.CreateArchitecture(Mosa.Platform.AVR32.ArchitectureFeatureFlags.AutoDetect); break;
default:
architecture = Mosa.Platform.x86.Architecture.CreateArchitecture(Mosa.Platform.x86.ArchitectureFeatureFlags.AutoDetect); break;
}
var compiler = new ExplorerCompiler(architecture, typeSystem, typeLayout, compilerTrace, compilerOptions, emitBinary);
compiler.Compile();
}
/// <summary>
/// Prevents a default instance of the <see cref="ExplorerCompiler" /> class from being created.
/// </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="compilerTrace">The internal trace.</param>
/// <param name="compilerOptions">The compiler options.</param>
public ExplorerCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, CompilerTrace compilerTrace, CompilerOptions compilerOptions, bool emitBinary)
: base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), compilerTrace, new ExplorerLinker(), compilerOptions)
{
this.emitBinary = emitBinary;
// Build the assembly compiler pipeline
Pipeline.Add(new ICompilerStage[] {
new PlugStage(),
new MethodCompilerSchedulerStage(),
new TypeInitializerSchedulerStage(),
new MethodLookupTableStage(),
new MethodExceptionLookupTableStage(),
new MetadataStage(),
});
architecture.ExtendCompilerPipeline(Pipeline);
}
/// <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();
}
private void RemoveBlock(BasicBlock block, CompilerTrace trace)
{
Debug.Assert(block.NextBlocks.Count == 1);
BasicBlock target = block.NextBlocks[0];
if (trace.Active)
{
trace.Log("====== Removing: " + block.ToString() + " # " + block.Sequence);
trace.Log(" New Target: " + target.ToString());
foreach (var from in block.PreviousBlocks)
{
trace.Log("Previous Blocks: " + from.ToString());
}
}
target.PreviousBlocks.Remove(block);
foreach (var from in block.PreviousBlocks)
{
from.NextBlocks.Remove(block);
from.NextBlocks.AddIfNew(target);
if (trace.Active)
{
trace.Log(" Add target to NextBlock of " + from.ToString());
}
target.PreviousBlocks.AddIfNew(from);
if (trace.Active)
{
trace.Log(" Add " + from.ToString() + " to PreviousBlock of " + target.ToString());
}
ReplaceBranchTargets(from, block, target);
}
block.NextBlocks.Clear();
block.PreviousBlocks.Clear();
EmptyBlockOfAllInstructions(block);
}
/// <summary>
/// Prevents a default instance of the <see cref="SimCompiler" /> class from being created.
/// </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="linker">The linker.</param>
/// <param name="compilerOptions">The compiler options.</param>
/// <param name="compilerTrace">The internal trace.</param>
/// <param name="simAdapter">The sim adapter.</param>
public SimCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, BaseLinker linker, CompilerOptions compilerOptions, CompilerTrace compilerTrace, ISimAdapter simAdapter)
: base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), compilerTrace, linker, compilerOptions)
{
this.simAdapter = simAdapter;
// Build the assembly compiler pipeline
Pipeline.Add(new ICompilerStage[] {
new PlugStage(),
new MethodCompilerSchedulerStage(),
new TypeInitializerSchedulerStage(),
new SimPowerUpStage(),
new MethodLookupTableStage(),
new MethodExceptionLookupTableStage(),
new MetadataStage(),
new SimLinkerFinalizationStage(simAdapter.SimCPU),
});
architecture.ExtendCompilerPipeline(Pipeline);
}
private void ResolveDataFlow()
{
var resolverTrace = new CompilerTrace(trace, "ResolveDataFlow");
MoveResolver[,] moveResolvers = new MoveResolver[2, basicBlocks.Count];
foreach (var from in extendedBlocks)
{
foreach (var nextBlock in from.BasicBlock.NextBlocks)
{
var to = extendedBlocks[nextBlock.Sequence];
// determine where to insert resolving moves
bool fromAnchorFlag = (from.BasicBlock.NextBlocks.Count == 1);
ExtendedBlock anchor = fromAnchorFlag ? from : to;
MoveResolver moveResolver = moveResolvers[fromAnchorFlag ? 0 : 1, anchor.Sequence];
if (moveResolver == null)
{
moveResolver = new MoveResolver(anchor.BasicBlock, from.BasicBlock, to.BasicBlock);
moveResolvers[fromAnchorFlag ? 0 : 1, anchor.Sequence] = moveResolver;
}
foreach (var virtualRegister in GetVirtualRegisters(to.LiveIn))
{
//if (virtualRegister.IsPhysicalRegister)
//continue;
var fromLiveInterval = virtualRegister.GetIntervalAtOrEndsAt(from.End);
var toLiveInterval = virtualRegister.GetIntervalAt(to.Start);
Debug.Assert(fromLiveInterval != null);
Debug.Assert(toLiveInterval != null);
if (fromLiveInterval.AssignedPhysicalRegister != toLiveInterval.AssignedPhysicalRegister)
{
if (resolverTrace.Active)
{
resolverTrace.Log("REGISTER: " + fromLiveInterval.VirtualRegister.ToString());
resolverTrace.Log(" FROM: " + from.ToString().PadRight(7) + " " + fromLiveInterval.AssignedOperand.ToString());
resolverTrace.Log(" TO: " + to.ToString().PadRight(7) + " " + toLiveInterval.AssignedOperand.ToString());
resolverTrace.Log(" INSERT: " + (fromAnchorFlag ? "FROM (bottom)" : "TO (top)") + ((toLiveInterval.AssignedPhysicalOperand == null) ? " ****SKIPPED***" : string.Empty));
resolverTrace.Log("");
}
// interval was spilled (spill moves are inserted elsewhere)
if (toLiveInterval.AssignedPhysicalOperand == null)
continue;
Debug.Assert(from.BasicBlock.NextBlocks.Count == 1 || to.BasicBlock.PreviousBlocks.Count == 1);
moveResolver.AddMove(fromLiveInterval.AssignedOperand, toLiveInterval.AssignedOperand);
}
}
}
}
for (int b = 0; b < basicBlocks.Count; b++)
{
for (int fromTag = 0; fromTag < 2; fromTag++)
{
MoveResolver moveResolver = moveResolvers[fromTag, b];
if (moveResolver == null)
continue;
moveResolver.InsertResolvingMoves(architecture, instructionSet);
}
}
}
private void InsertRegisterMoves()
{
var insertTrace = new CompilerTrace(trace, "InsertRegisterMoves");
// collect edge slot indexes
Dictionary<SlotIndex, ExtendedBlock> blockEdges = new Dictionary<SlotIndex, ExtendedBlock>();
foreach (var block in extendedBlocks)
{
blockEdges.Add(block.Start, block);
blockEdges.Add(block.End, block);
}
foreach (var virtualRegister in virtualRegisters)
{
if (virtualRegister.IsPhysicalRegister)
continue;
if (virtualRegister.LiveIntervals.Count <= 1)
continue;
foreach (var currentInterval in virtualRegister.LiveIntervals)
{
if (blockEdges.ContainsKey(currentInterval.End))
continue;
// List is not sorted, so scan thru each one
foreach (var nextInterval in virtualRegister.LiveIntervals)
{
if (nextInterval.Start == currentInterval.End)
{
// next interval is stack - stores to stack are done elsewhere
if (nextInterval.AssignedPhysicalOperand == null)
break;
// check if source and destination operands of the move are the same
if (nextInterval.AssignedOperand == currentInterval.AssignedOperand ||
nextInterval.AssignedOperand.Register == currentInterval.AssignedOperand.Register)
break;
Context context = new Context(instructionSet, currentInterval.End.Index);
context.GotoPrevious();
while (context.IsEmpty || context.Instruction.FlowControl == FlowControl.UnconditionalBranch || context.Instruction.FlowControl == FlowControl.ConditionalBranch || context.Instruction.FlowControl == FlowControl.Return)
{
context.GotoPrevious();
}
architecture.InsertMoveInstruction(context,
nextInterval.AssignedOperand,
currentInterval.AssignedOperand
);
context.Marked = true;
if (insertTrace.Active)
{
insertTrace.Log("REGISTER: " + virtualRegister.ToString());
insertTrace.Log("POSITION: " + currentInterval.End.ToString());
insertTrace.Log(" FROM: " + currentInterval.AssignedOperand.ToString());
insertTrace.Log(" TO: " + nextInterval.AssignedOperand.ToString());
insertTrace.Log("");
}
break;
}
}
}
}
}
private void NumberInstructions()
{
var number = new CompilerTrace(trace, "InstructionNumber");
int index = SlotIncrement;
foreach (BasicBlock block in basicBlocks)
{
for (Context context = new Context(instructionSet, block); ; context.GotoNext())
{
if (!context.IsEmpty)
{
context.SlotNumber = index;
index = index + SlotIncrement;
if (number.Active)
{
if (context.IsBlockStartInstruction)
{
number.Log(context.SlotNumber.ToString() + " = " + context.ToString() + " # " + block.ToString());
}
else
{
number.Log(context.SlotNumber.ToString() + " = " + context.ToString());
}
}
}
if (context.IsBlockEndInstruction)
break;
}
SlotIndex start = new SlotIndex(instructionSet, block.StartIndex);
SlotIndex end = new SlotIndex(instructionSet, block.EndIndex);
extendedBlocks[block.Sequence].Interval = new Interval(start, end);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AotCompiler" /> class.
/// </summary>
/// <param name="architecture">The architecture.</param>
/// <param name="typeSystem">The type system.</param>
/// <param name="typeLayout">The type layout.</param>
/// <param name="compilerTrace">The internal trace.</param>
/// <param name="compilerOptions">The compiler options.</param>
public AotCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, CompilerTrace compilerTrace, CompilerOptions compilerOptions)
: base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), compilerTrace, null, compilerOptions)
{
}
private void ComputeLocalLiveSets()
{
var liveSetTrace = new CompilerTrace(trace, "ComputeLocalLiveSets");
foreach (var block in extendedBlocks)
{
if (liveSetTrace.Active)
liveSetTrace.Log("Block # " + block.BasicBlock.Sequence.ToString());
BitArray liveGen = new BitArray(registerCount, false);
BitArray liveKill = new BitArray(registerCount, false);
liveGen.Set(stackFrameRegister.Index, true);
liveGen.Set(stackPointerRegister.Index, true);
if (programCounter != null)
liveGen.Set(programCounter.Index, true);
for (Context context = new Context(instructionSet, block.BasicBlock); !context.IsBlockEndInstruction; context.GotoNext())
{
if (context.IsEmpty)
continue;
if (liveSetTrace.Active)
liveSetTrace.Log(context.ToString());
OperandVisitor visitor = new OperandVisitor(context);
foreach (var ops in visitor.Input)
{
if (liveSetTrace.Active)
liveSetTrace.Log("INPUT: " + ops.ToString());
int index = GetIndex(ops);
if (!liveKill.Get(index))
{
liveGen.Set(index, true);
if (liveSetTrace.Active)
liveSetTrace.Log("GEN: " + index.ToString() + " " + ops.ToString());
}
}
if (context.Instruction.FlowControl == FlowControl.Call)
{
for (int s = 0; s < physicalRegisterCount; s++)
{
liveKill.Set(s, true);
}
if (liveSetTrace.Active)
liveSetTrace.Log("KILL ALL PHYSICAL");
}
foreach (var ops in visitor.Output)
{
if (liveSetTrace.Active)
liveSetTrace.Log("OUTPUT: " + ops.ToString());
int index = GetIndex(ops);
liveKill.Set(index, true);
if (liveSetTrace.Active)
liveSetTrace.Log("KILL: " + index.ToString() + " " + ops.ToString());
}
}
block.LiveGen = liveGen;
block.LiveKill = liveKill;
block.LiveKillNot = ((BitArray)liveKill.Clone()).Not();
if (liveSetTrace.Active)
{
liveSetTrace.Log("GEN: " + ToString(block.LiveGen));
liveSetTrace.Log("KILL: " + ToString(block.LiveKill));
liveSetTrace.Log("KILLNOT: " + ToString(block.LiveKillNot));
liveSetTrace.Log(string.Empty);
}
}
}
private void BuildLiveIntervals()
{
var intervalTrace = new CompilerTrace(trace, "BuildLiveIntervals");
for (int b = basicBlocks.Count - 1; b >= 0; b--)
{
var block = extendedBlocks[b];
for (int r = 0; r < registerCount; r++)
{
if (!block.LiveOut.Get(r))
continue;
var register = virtualRegisters[r];
if (b + 1 != basicBlocks.Count && extendedBlocks[b + 1].LiveIn.Get(r))
{
if (intervalTrace.Active) intervalTrace.Log("Add (LiveOut) " + register.ToString() + " : " + block.Start + " to " + extendedBlocks[b + 1].Start);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.AddLiveInterval(block.Start, extendedBlocks[b + 1].Start);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
else
{
if (intervalTrace.Active) intervalTrace.Log("Add (!LiveOut) " + register.ToString() + " : " + block.Interval.Start + " to " + block.Interval.End);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.AddLiveInterval(block.Interval);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
}
Context context = new Context(instructionSet, block.BasicBlock, block.BasicBlock.EndIndex);
while (!context.IsBlockStartInstruction)
{
if (!context.IsEmpty)
{
SlotIndex slotIndex = new SlotIndex(context);
OperandVisitor visitor = new OperandVisitor(context);
if (context.Instruction.FlowControl == FlowControl.Call)
{
SlotIndex nextSlotIndex = slotIndex.Next;
for (int s = 0; s < physicalRegisterCount; s++)
{
var register = virtualRegisters[s];
if (intervalTrace.Active) intervalTrace.Log("Add (Call) " + register.ToString() + " : " + slotIndex + " to " + nextSlotIndex);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.AddLiveInterval(slotIndex, nextSlotIndex);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
callSlots.Add(slotIndex);
}
foreach (var result in visitor.Output)
{
var register = virtualRegisters[GetIndex(result)];
if (register.IsReserved)
continue;
var first = register.FirstRange;
if (!register.IsPhysicalRegister)
{
register.AddDefPosition(slotIndex);
}
if (first != null)
{
if (intervalTrace.Active) intervalTrace.Log("Replace First " + register.ToString() + " : " + slotIndex + " to " + first.End);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.FirstRange = new LiveInterval(register, slotIndex, first.End);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
else
{
// This is necesary to handled a result that is never used!
// Common with instructions which more than one result
if (intervalTrace.Active) intervalTrace.Log("Add (Unused) " + register.ToString() + " : " + slotIndex + " to " + slotIndex.Next);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.AddLiveInterval(slotIndex, slotIndex.Next);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
}
foreach (var result in visitor.Input)
{
var register = virtualRegisters[GetIndex(result)];
if (register.IsReserved)
continue;
if (!register.IsPhysicalRegister)
{
register.AddUsePosition(slotIndex);
}
if (intervalTrace.Active) intervalTrace.Log("Add (normal) " + register.ToString() + " : " + block.Start + " to " + slotIndex.Next);
if (intervalTrace.Active) intervalTrace.Log(" Before: " + LiveIntervalsToString(register.LiveIntervals));
register.AddLiveInterval(block.Start, slotIndex.Next);
if (intervalTrace.Active) intervalTrace.Log(" After: " + LiveIntervalsToString(register.LiveIntervals));
}
}
context.GotoPrevious();
}
}
}
private void TraceMoveHints()
{
if (!trace.Active)
return;
var moveHintTrace = new CompilerTrace(trace, "Move Hints");
foreach (var moveHint in moveHints)
{
moveHintTrace.Log(moveHint.Value.ToString());
}
}
private void TraceLiveIntervals(string stage, bool operand)
{
if (!trace.Active)
return;
var registerTrace = new CompilerTrace(trace, stage);
foreach (var virtualRegister in virtualRegisters)
{
if (virtualRegister.IsPhysicalRegister)
{
registerTrace.Log("Physical Register # " + virtualRegister.PhysicalRegister.ToString());
}
else
{
registerTrace.Log("Virtual Register # " + virtualRegister.VirtualRegisterOperand.Index.ToString());
}
registerTrace.Log("Live Intervals (" + virtualRegister.LiveIntervals.Count.ToString() + "): " + LiveIntervalsToString(virtualRegister.LiveIntervals, operand));
registerTrace.Log("Def Positions (" + virtualRegister.DefPositions.Count.ToString() + "): " + SlotsToString(virtualRegister.DefPositions));
registerTrace.Log("Use Positions (" + virtualRegister.UsePositions.Count.ToString() + "): " + SlotsToString(virtualRegister.UsePositions));
}
}
private void TraceBlocks()
{
if (!trace.Active)
return;
var sectionTrace = new CompilerTrace(trace, "Extended Blocks");
foreach (var block in extendedBlocks)
{
sectionTrace.Log("Block # " + block.BasicBlock.Sequence.ToString() + " (" + block.Start + " to " + block.End + ")");
sectionTrace.Log(" LiveIn: " + ToString(block.LiveIn));
sectionTrace.Log(" LiveGen: " + ToString(block.LiveGen));
sectionTrace.Log(" LiveKill: " + ToString(block.LiveKill));
sectionTrace.Log(" LiveOut: " + ToString(block.LiveOut));
}
}
private void Do(Context context)
{
if (context.IsEmpty)
return;
trace = CreateTrace();
//if (trace.IsLogging) trace.Log("@REVIEW:\t" + context.ToString());
SimplifyExtendedMove(context);
SimplifySubtraction(context);
StrengthReductionMultiplication(context);
StrengthReductionDivision(context);
StrengthReductionIntegerAdditionAndSubstraction(context);
StrengthReductionLogicalOperators(context);
ConstantFoldingIntegerOperations(context);
SimpleConstantPropagation(context);
SimpleCopyPropagation(context);
DeadCodeElimination(context);
ConstantFoldingIntegerCompare(context);
FoldIntegerCompareBranch(context);
}