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; }