private void doInvoke(string id, BasicBlock<MilocInstruction> b, List<int> regLocs)
{
var fun = CSC431.Program.Stable.Value.getType(id);
for (int i = 0; i < regLocs.Count; i++)
{
var t = fun.getArgs()[i];
b.Add(new StoreoutargumentInstruction(regLocs[i], i) { Type = t });
}
b.Add(new CallInstruction(id));
}
public override BasicBlock<MilocInstruction> Load(int target)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new LoadaiVarInstruction(name, target) { ArgIndex = ArgIndex });
b.Reg = target;
return b;
}
public override BasicBlock<MilocInstruction> Load(int target)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new MovInstruction(this.reg, target) { ArgIndex = ArgIndex, ArgReg = reg });
b.Reg = target;
return b;
}
public override BasicBlock<MilocInstruction> Load(int target)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new LoadaiFieldInstruction(addressReg, name, target) { ContainingType = containingType, FieldIndex = fieldIndex, FieldType = this.Type });
b.Reg = target;
return b;
}
public override BasicBlock<MilocInstruction> Load(int target)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new LoadglobalInstruction(name, target) { Type = this.Type });
b.Reg = target;
return b;
}
private void AddOperation(Operation operation)
{
if (_needsNewBlock)
{
NewNextBlock();
}
_irBlock.Add(operation);
}
private void AddDataflowAstNode(IDataflowAstNode dataflowAstNode, BasicBlock <TupleSequence> tupleBasicBlock, bool preventMappingEmission)
{
_astToBasicBlockMapping[dataflowAstNode] = tupleBasicBlock;
var tupleProvider = _tupleProviderManager[dataflowAstNode];
var singleMappedInputTupleProvider = tupleProvider as SingleMappedInputTupleProvider;
if (singleMappedInputTupleProvider != null)
{
singleMappedInputTupleProvider.PreventMappedInputTupleEmission = preventMappingEmission;
}
// TODO: Do I have to account for inserts here or can we canonicalize on add-to-the-end?
tupleBasicBlock.Add(tupleProvider.InlineTupleSequence);
_prologueBasicBlock.Add(tupleProvider.PrologueTupleSequence);
_epilogueBasicBlock.Add(tupleProvider.EpilogueTupleSequence);
}
/// <summary>
/// Swaps the successors of a given block.
/// </summary>
/// <param name="currentBlock">Current block.</param>
/// <param name="oldSuccessor">Old successor.</param>
/// <param name="newSuccessor">New successor.</param>
///
void swapSuccessors(BasicBlock <Instruction> currentBlock, BasicBlock <Instruction> oldSuccessor,
BasicBlock <Instruction> newSuccessor)
{
if ((newSuccessor.Last.OpCode.FlowControl != FlowControl.Branch) ||
(newSuccessor.Last.OpCode.FlowControl != FlowControl.Cond_Branch))
{
Instruction br = Instruction.Create(OpCodes.Br, newSuccessor.Last.Next);
br.Next = newSuccessor.Last.Next;
newSuccessor.Last.Next = br;
newSuccessor.Add(br);
}
BasicBlock <Instruction> block = currentBlock.Successors.Find(x => x.Name == oldSuccessor.Name);
currentBlock.Successors.Remove(block);
block.Predecessors.Remove(currentBlock);
currentBlock.Successors.Add(newSuccessor);
newSuccessor.Predecessors.Add(currentBlock);
}
public override BasicBlock<MilocInstruction> Store(int source)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new StoreaiVarInstruction(source, name) { ArgIndex = ArgIndex });
return b;
}
public override BasicBlock<MilocInstruction> Store(int source)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new MovInstruction(source, this.reg) { ArgIndex = ArgIndex, ArgReg = reg });
return b;
}
public override BasicBlock<MilocInstruction> Store(int source)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new StoreaiFieldInstruction(source, addressReg, name) { ContainingType = containingType, FieldIndex = fieldIndex, FieldType = this.Type });
return b;
}
public override BasicBlock<MilocInstruction> Store(int source)
{
var b = new BasicBlock<MilocInstruction>();
b.Add(new StoreglobalInstruction(source, name) { Type = this.Type });
return b;
}
