public string EmitRegisters(IProcessorArchitecture arch, string caption, BitSet regs) { StringWriter sw = new StringWriter(); EmitRegisters(arch, caption, regs, sw); return(sw.ToString()); }
public bool TerminatesProcess; // True if entering this block means the process/thread will be terminated. #endregion Fields #region Constructors public BlockFlow(Block block, BitSet dataOut, SymbolicEvaluationContext ctx) { this.Block = block; this.DataOut = dataOut; this.StackVarsOut = new Dictionary<Storage,int>(); this.SymbolicIn = ctx; }
public bool TerminatesProcess; // True if entering this block means the process/thread will be terminated. public BlockFlow(Block block, BitSet dataOut, SymbolicEvaluationContext ctx) { this.Block = block; this.DataOut = dataOut; this.StackVarsOut = new Dictionary <Storage, int>(); this.SymbolicIn = ctx; }
/// <summary> /// Creates a signature for this procedure, and ensures that all registers accessed by the procedure are in the procedure /// Frame. /// </summary> public void EnsureSignature(Procedure proc, ProcedureFlow flow) { if (proc.Signature != null && proc.Signature.ParametersValid) { return; } SignatureBuilder sb = new SignatureBuilder(proc, Program.Architecture); Frame frame = proc.Frame; if (flow.grfLiveOut != 0) { sb.AddFlagGroupReturnValue(flow.grfLiveOut, frame); } var implicitRegs = Program.Platform.CreateImplicitArgumentRegisters(); BitSet mayUse = flow.MayUse - implicitRegs; foreach (int r in mayUse) { if (!IsSubRegisterOfRegisters(r, mayUse)) { sb.AddRegisterArgument(r); } } foreach (KeyValuePair <int, Identifier> de in GetSortedStackArguments(proc.Frame)) { AddStackArgument(de.Key, de.Value, flow, sb); } foreach (KeyValuePair <int, Identifier> de in GetSortedFpuStackArguments(proc.Frame, 0)) { sb.AddFpuStackArgument(de.Key, de.Value); } BitSet liveOut = flow.LiveOut - implicitRegs; foreach (int r in liveOut) { if (!IsSubRegisterOfRegisters(r, liveOut)) { sb.AddArgument(frame.EnsureRegister(Program.Architecture.GetRegister(r)), true); } } foreach (KeyValuePair <int, Identifier> de in GetSortedFpuStackArguments(proc.Frame, -proc.Signature.FpuStackDelta)) { int i = de.Key; if (i <= proc.Signature.FpuStackOutArgumentMax) { sb.AddArgument(frame.EnsureFpuStackVariable(i, de.Value.DataType), true); } } var sig = sb.BuildSignature(); flow.Signature = sig; proc.Signature = sig; }
public bool VisitRegisterStorage(RegisterStorage reg) { //$REFACTOR: make SetAliases be a bitset of Register. BitSet b = new BitSet(liveState.BitSet.Count); reg.SetAliases(b, true); return(!(liveState.BitSet & b).IsEmpty); }
private void Dump(bool enable, string s, BitSet a) { if (enable) { StringWriter sw = new StringWriter(); sw.Write("{0}: ", s); ProcedureFlow.EmitRegisters(prog.Architecture, "", a, sw); Debug.WriteLine(sw.ToString()); } }
/// <summary> /// Returns true if the register is a strict subregister of one of the registers in the bitset. /// </summary> /// <param name="r"></param> /// <param name="regs"></param> /// <returns></returns> private bool IsSubRegisterOfRegisters(int r, BitSet regs) { var rr = Program.Architecture.GetRegister(r); if (rr == null) { return(false); } foreach (int r2 in regs) { if (rr.IsSubRegisterOf(Program.Architecture.GetRegister(r2))) { return(true); } } return(false); }
/// <summary> /// Propagates the live-out from a call instruction to /// the exit block of the function the call statement invokes. /// </summary> /// <param name="stm"></param> private void PropagateToCalleeExitBlocks(Statement stm) { BitSet liveOrig = new BitSet(varLive.BitSet); uint grfOrig = varLive.Grf; var stackOrig = new Dictionary <Storage, int>(varLive.LiveStorages); foreach (Procedure p in prog.CallGraph.Callees(stm)) { var flow = mpprocData[p]; varLive.BitSet = liveOrig - flow.PreservedRegisters; varLive.LiveStorages = new Dictionary <Storage, int>(); MergeBlockInfo(p.ExitBlock); varLive.BitSet = new BitSet(liveOrig); varLive.Grf = grfOrig; varLive.LiveStorages = new Dictionary <Storage, int>(stackOrig); } }
private static void EmitRegistersCore(IProcessorArchitecture arch, BitSet regs, TextWriter sb) { if (regs != null && !regs.IsEmpty) { for (int i = 0; i < regs.Count; ++i) { if (regs[i]) { var r = arch.GetRegister(i); if (r != null && r.IsAluRegister) { sb.Write(" "); sb.Write(r.Name); } } } } }
private string DumpRegisters(BitSet arr) { var sb = new StringBuilder(); var arch = prog.Architecture; for (int i = 0; i < arr.Count; ++i) { if (arr[i]) { var reg = arch.GetRegister(i); if (reg != null && reg.IsAluRegister) { sb.Append(reg.Name); sb.Append(" "); } } } return(sb.ToString()); }
public static void EmitRegisters(IProcessorArchitecture arch, string caption, BitSet regs, TextWriter sb) { sb.Write(caption); EmitRegistersCore(arch, regs, sb); }
public static void EmitRegisters(IProcessorArchitecture arch, string caption, uint grfFlags, BitSet regs, TextWriter sb) { sb.Write(caption); if (grfFlags != 0) { sb.Write(" {0}", arch.GrfToString(grfFlags)); } EmitRegistersCore(arch, regs, sb); }
/// <summary> /// Returns true if the register is a strict subregister of one of the registers in the bitset. /// </summary> /// <param name="r"></param> /// <param name="regs"></param> /// <returns></returns> private bool IsSubRegisterOfRegisters(int r, BitSet regs) { var rr = Program.Architecture.GetRegister(r); if (rr == null) return false; foreach (int r2 in regs) { if (rr.IsSubRegisterOf(Program.Architecture.GetRegister(r2))) return true; } return false; }
public void RegisterBitset() { BitSet regs = arch.CreateRegisterBitset(); Assert.IsTrue(regs.Count >= (int)Registers.Max); }