ROSE  0.11.145.0
Unparser/Base.h
1 #ifndef ROSE_BinaryAnalysis_Unparser_Base_H
2 #define ROSE_BinaryAnalysis_Unparser_Base_H
3 
4 #include <featureTests.h>
5 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6 
7 #include <Rose/BinaryAnalysis/BasicTypes.h>
8 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
9 #include <Rose/BinaryAnalysis/Partitioner2/ControlFlowGraph.h>
10 #include <Rose/BinaryAnalysis/Partitioner2/FunctionCallGraph.h>
11 #include <Rose/BinaryAnalysis/Reachability.h>
12 #include <Rose/BinaryAnalysis/RegisterNames.h>
13 #include <Rose/BinaryAnalysis/Unparser/EdgeArrows.h>
14 #include <Rose/BinaryAnalysis/Unparser/Settings.h>
15 #include <Rose/BitFlags.h>
16 #include <Rose/Progress.h>
17 
18 #include <Sawyer/Map.h>
19 #include <Sawyer/Message.h>
20 #include <Sawyer/SharedObject.h>
21 
22 namespace Rose {
23 namespace BinaryAnalysis {
24 
25 namespace Unparser {
26 
28 typedef std::map<uint64_t, std::string> LabelMap;
29 
31 extern Sawyer::Message::Facility mlog;
32 
33 // used internally to initialize mlog
34 void initDiagnostics();
35 
37 // Supporting functions
39 
43 std::string invalidRegister(SgAsmInstruction*, RegisterDescriptor, const RegisterDictionaryPtr&);
44 
46 // Margins containing arrows
48 
50 class ArrowMargin {
51 public:
53  enum Flags {
58  POINTABLE_ENTITY_START = 0x00000001,
59 
63  POINTABLE_ENTITY_END = 0x00000002,
64 
66  POINTABLE_ENTITY_INSIDE = 0x00000004,
67 
70  ALWAYS_RENDER = 0x00000008
71  };
72 
73  EdgeArrows arrows;
74  BitFlags<Flags> flags;
75  Sawyer::Optional<EdgeArrows::VertexId> latestEntity;
80  void reset() {
81  arrows.reset();
82  flags = 0;
83  latestEntity = Sawyer::Nothing();
84  }
85 
91  std::string render(Sawyer::Optional<EdgeArrows::VertexId> currentEntity);
92 };
93 
95 // Output style
97 
99 class StyleStack {
100  std::vector<Style> stack_;
101  Style current_;
102  Color::Colorization colorization_;
103 
104 public:
105  StyleStack() {}
106 
110  Color::Colorization colorization() const { return colorization_; }
111  void colorization(const Color::Colorization c) { colorization_ = c; }
117  size_t push(const Style&);
118 
122  void pop();
123 
125  void popTo(size_t);
126 
128  void reset();
129 
131  size_t size() const;
132 
138  const Style& current() const;
139 
140 private:
141  void merge(const Style &style); // merge style into current_
142  void mergeAll(); // recalculate current_ based on stack_
143 };
144 
146 class StyleGuard {
147  StyleStack &stack_;
148  size_t n_;
149  Style current_;
150  Style previous_;
151 public:
156  StyleGuard(StyleStack &stack, const Style &style)
157  : stack_(stack) {
158  previous_ = stack_.current();
159  n_ = stack_.push(style);
160  current_ = stack_.current();
161  }
162 
163  StyleGuard(StyleStack &stack, const Style &first, const Style &second)
164  : stack_(stack) {
165  previous_ = stack_.current();
166  n_ = stack_.push(first);
167  stack_.push(second);
168  current_ = stack_.current();
169  }
170 
171  ~StyleGuard() {
172  stack_.popTo(n_);
173  }
174 
176  std::string render() const;
177 
179  std::string restore() const;
180 
182  const Style& current() const {
183  return current_;
184  }
185 
187  const Style& previous() const {
188  return previous_;
189  }
190 };
191 
193 // State of the unparser (the unparser itself is const during unparsing)
195 
200 class State {
201 public:
202  typedef Sawyer::Container::Map<rose_addr_t, std::string> AddrString;
204 private:
205  Partitioner2::PartitionerConstPtr partitioner_;
206  Partitioner2::FunctionCallGraph cg_;
207  Partitioner2::FunctionPtr currentFunction_;
208  Partitioner2::BasicBlockPtr currentBasicBlock_;
209  Sawyer::Optional<EdgeArrows::VertexId> currentPredSuccId_;
210  std::string nextInsnLabel_;
211  AddrString basicBlockLabels_;
212  RegisterNames registerNames_;
213  const Base &frontUnparser_;
214  std::vector<Reachability::ReasonFlags> cfgVertexReachability_;
215  Sawyer::Container::Map<Reachability::ReasonFlags::Vector, std::string> reachabilityNames_; // map reachability value to name
216  ArrowMargin intraFunctionCfgArrows_; // arrows for the intra-function control flow graphs
217  ArrowMargin intraFunctionBlockArrows_; // user-defined intra-function arrows to/from blocks
218  ArrowMargin globalBlockArrows_; // user-defined global arrows to/from blocks
219  bool cfgArrowsPointToInsns_; // arrows point to insns? else predecessor/successor lines
220  StyleStack styleStack_; // styles
221 
222 public:
223  State(const Partitioner2::PartitionerConstPtr&, const Settings&, const Base &frontUnparser);
224  State(const Partitioner2::PartitionerConstPtr&, const RegisterDictionaryPtr&, const Settings&, const Base &frontUnparser);
225  virtual ~State();
226 
227  Partitioner2::PartitionerConstPtr partitioner() const;
228 
229  const Partitioner2::FunctionCallGraph& cg() const;
230 
237  const std::vector<Reachability::ReasonFlags> cfgVertexReachability() const;
238  void cfgVertexReachability(const std::vector<Reachability::ReasonFlags>&);
245  Reachability::ReasonFlags isCfgVertexReachable(size_t vertexId) const;
246 
259  const ArrowMargin& intraFunctionCfgArrows() const { return intraFunctionCfgArrows_; }
260  ArrowMargin& intraFunctionCfgArrows() { return intraFunctionCfgArrows_; }
276  const ArrowMargin& intraFunctionBlockArrows() const { return intraFunctionBlockArrows_; }
277  ArrowMargin& intraFunctionBlockArrows() { return intraFunctionBlockArrows_; }
288  const ArrowMargin& globalBlockArrows() const { return globalBlockArrows_; }
289  ArrowMargin& globalBlockArrows() { return globalBlockArrows_; }
293  void thisIsBasicBlockFirstInstruction();
294 
296  void thisIsBasicBlockLastInstruction();
297 
305  Sawyer::Optional<EdgeArrows::VertexId> currentPredSuccId() const { return currentPredSuccId_; }
306  void currentPredSuccId(Sawyer::Optional<EdgeArrows::VertexId> id) { currentPredSuccId_ = id; }
316  bool cfgArrowsPointToInsns() const { return cfgArrowsPointToInsns_; }
317  void cfgArrowsPointToInsns(bool b) { cfgArrowsPointToInsns_ = b; }
323  const StyleStack& styleStack() const { return styleStack_; }
324  StyleStack& styleStack() { return styleStack_; }
341  void reachabilityName(Reachability::Reason value, const std::string &name);
342  std::string reachabilityName(Reachability::ReasonFlags value) const;
345  Partitioner2::FunctionPtr currentFunction() const;
346  void currentFunction(const Partitioner2::FunctionPtr&);
347 
348  Partitioner2::BasicBlockPtr currentBasicBlock() const;
349  void currentBasicBlock(const Partitioner2::BasicBlockPtr&);
350 
351  const std::string& nextInsnLabel() const;
352  void nextInsnLabel(const std::string&);
353 
354  const RegisterNames& registerNames() const;
355  void registerNames(const RegisterNames &r);
356 
357  const AddrString& basicBlockLabels() const;
358  AddrString& basicBlockLabels();
359 
360  const Base& frontUnparser() const;
361 };
362 
364 // Base unparser
366 
413 class Base: public Sawyer::SharedObject {
414 public:
415  typedef Sawyer::SharedPointer<Base> Ptr;
416 
417 private:
418  Ptr nextUnparser_;
419 
420 protected:
421  Base();
422  explicit Base(const Ptr &nextUnparser);
423 
424 public:
425  virtual Ptr copy() const = 0;
426  virtual ~Base();
427 
437  virtual const Settings& settings() const = 0;
438  virtual Settings& settings() = 0;
439  void settings(const Settings &s) {
440  settings() = s;
441  }
451  Ptr nextUnparser() const { return nextUnparser_; }
452  void nextUnparser(Ptr next) { nextUnparser_ = next; }
462  void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&) const /*final*/;
463  void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
464  void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
465  void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
466  void operator()(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
474  std::string operator()(const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
475  std::string operator()(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
476  std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
477  std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
478  std::string operator()(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
481 public:
487  void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
488  void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
489  void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
490  void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
491  void unparse(std::ostream&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
492 
493  std::string unparse(const Partitioner2::PartitionerConstPtr&, const Progress::Ptr& = Progress::Ptr()) const /*final*/;
494  std::string unparse(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*) const /*final*/;
495  std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&) const /*final*/;
496  std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::DataBlockPtr&) const /*final*/;
497  std::string unparse(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const /*final*/;
500 public:
523  virtual void emitFunction(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
524  virtual void emitFunctionPrologue(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
525  virtual void emitFunctionBody(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
526  virtual void emitFunctionEpilogue(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
527 
528  virtual void emitFunctionSourceLocation(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
529  virtual void emitFunctionReasons(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
530  virtual void emitFunctionCallers(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
531  virtual void emitFunctionCallees(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
532  virtual void emitFunctionComment(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
533  virtual void emitFunctionStackDelta(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
534  virtual void emitFunctionCallingConvention(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
535  virtual void emitFunctionNoopAnalysis(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
536  virtual void emitFunctionMayReturn(std::ostream&, const Partitioner2::FunctionPtr&, State&) const;
537 
538  virtual void emitDataBlockSourceLocation(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
539  virtual void emitDataBlock(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
540  virtual void emitDataBlockPrologue(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
541  virtual void emitDataBlockBody(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
542  virtual void emitDataBlockEpilogue(std::ostream&, const Partitioner2::DataBlockPtr&, State&) const;
543 
544  virtual void emitBasicBlock(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
545  virtual void emitBasicBlockPrologue(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
546  virtual void emitBasicBlockBody(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
547  virtual void emitBasicBlockEpilogue(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
548 
549  virtual void emitBasicBlockSourceLocation(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
550  virtual void emitBasicBlockComment(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
551  virtual void emitBasicBlockSharing(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
552  virtual void emitBasicBlockPredecessors(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
553  virtual void emitBasicBlockSuccessors(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
554  virtual void emitBasicBlockReachability(std::ostream&, const Partitioner2::BasicBlockPtr&, State&) const;
555 
556  virtual void emitInstruction(std::ostream&, SgAsmInstruction*, State&) const;
557  virtual void emitInstructionPrologue(std::ostream&, SgAsmInstruction*, State&) const;
558  virtual void emitInstructionBody(std::ostream&, SgAsmInstruction*, State&) const;
559  virtual void emitInstructionEpilogue(std::ostream&, SgAsmInstruction*, State&) const;
560 
561  virtual void emitInstructionAddress(std::ostream&, SgAsmInstruction*, State&) const;
562  virtual void emitInstructionBytes(std::ostream&, SgAsmInstruction*, State&) const;
563  virtual void emitInstructionStackDelta(std::ostream&, SgAsmInstruction*, State&) const;
564  virtual void emitInstructionMnemonic(std::ostream&, SgAsmInstruction*, State&) const;
565  virtual void emitInstructionOperands(std::ostream&, SgAsmInstruction*, State&) const;
566  virtual void emitInstructionComment(std::ostream&, SgAsmInstruction*, State&) const;
567 
568  virtual void emitInstructionSemantics(std::ostream&, SgAsmInstruction*, State&) const;
569 
570  virtual void emitOperand(std::ostream&, SgAsmExpression*, State&) const;
571  virtual void emitOperandPrologue(std::ostream&, SgAsmExpression*, State&) const;
572  virtual void emitOperandBody(std::ostream&, SgAsmExpression*, State&) const;
573  virtual void emitOperandEpilogue(std::ostream&, SgAsmExpression*, State&) const;
574 
575  virtual void emitRegister(std::ostream&, RegisterDescriptor, State&) const;
576  virtual std::vector<std::string> emitUnsignedInteger(std::ostream&, const Sawyer::Container::BitVector&, State&) const;
577  virtual std::vector<std::string> emitSignedInteger(std::ostream&, const Sawyer::Container::BitVector&, State&) const;
578  virtual std::vector<std::string> emitInteger(std::ostream&, const Sawyer::Container::BitVector&, State&,
579  bool isSigned) const;
580  virtual bool emitAddress(std::ostream&, rose_addr_t, State&, bool always=true) const;
581  virtual bool emitAddress(std::ostream&, const Sawyer::Container::BitVector&, State&, bool always=true) const;
582  virtual void emitCommentBlock(std::ostream&, const std::string&, State&, const std::string &prefix = ";;; ") const;
583  virtual void emitTypeName(std::ostream&, SgAsmType*, State&) const;
584 
585  virtual void emitLinePrefix(std::ostream&, State&) const;
588  //----- Other overrridable things -----
589 public:
595  virtual void initializeState(State&) const;
596 
602  virtual void updateIntraFunctionArrows(State&) const;
603 
604  //----- Utility functions -----
605 public:
607  static std::string leftJustify(const std::string&, size_t nchars);
608 
614  static std::string juxtaposeColumns(const std::vector<std::string> &content, const std::vector<size_t> &minWidths,
615  const std::vector<std::pair<std::string, std::string> > &colorEscapes,
616  const std::string &columnSeparator = " ");
617 
623  static bool ascendingSourceAddress(Partitioner2::ControlFlowGraph::ConstEdgeIterator a,
624  Partitioner2::ControlFlowGraph::ConstEdgeIterator b);
625 
631  static bool ascendingTargetAddress(Partitioner2::ControlFlowGraph::ConstEdgeIterator a,
632  Partitioner2::ControlFlowGraph::ConstEdgeIterator b);
633 
638  static std::vector<Partitioner2::ControlFlowGraph::ConstEdgeIterator>
639  orderedBlockPredecessors(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&);
640 
645  static std::vector<Partitioner2::ControlFlowGraph::ConstEdgeIterator>
646  orderedBlockSuccessors(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&);
647 };
648 
649 
651 // Python API wrappers and functions
653 
654 #ifdef ROSE_ENABLE_PYTHON_API
655 class PythonBase {
656  Base::Ptr base_;
657 
658 public:
659  PythonBase() {}
660 
661  explicit PythonBase(const Base::Ptr &base)
662  : base_(base) {
663  ASSERT_not_null(base);
664  }
665 
666  std::string unparse(const Partitioner2::PartitionerConstPtr &p) const {
667  return base_->unparse(p);
668  }
669 
670  void print(const Partitioner2::PartitionerConstPtr &p) const {
671  base_->unparse(std::cout, p);
672  }
673 };
674 #endif
675 
676 } // namespace
677 } // namespace
678 } // namespace
679 
680 #endif
681 #endif
Sawyer::Container::BitVectorSupport::copy
void copy(const Word *src, const BitRange &srcRange, Word *dst, const BitRange &dstRange)
Copy some bits.
Definition: BitVectorSupport.h:448
SgAsmInstruction
Base class for machine instructions.
Definition: binaryInstruction.C:39392
Sawyer::Message::Facility
Collection of streams.
Definition: Message.h:1606
Rose::Diagnostics::mlog
ROSE_DLL_API Sawyer::Message::Facility mlog
Diagnostic facility for the ROSE library as a whole.
std
STL namespace.
Sawyer::Optional
Holds a value or nothing.
Definition: Optional.h:49
Sawyer::Optional::reset
void reset()
Reset as if default-constructed.
Definition: Optional.h:181
Rose::BinaryAnalysis::RegisterDictionaryPtr
Sawyer::SharedPointer< RegisterDictionary > RegisterDictionaryPtr
Reference counting pointer.
Definition: BinaryAnalysis/BasicTypes.h:49
Rosebud::settings
Settings settings
Command-line settings for the rosebud tool.
Rose
Main namespace for the ROSE library.
Definition: BinaryTutorial.dox:3
Rose::BinaryAnalysis::Reachability::Reason
Reason
Predefined bit flags for why something is reachable.
Definition: Reachability.h:25
Sawyer
Name space for the entire library.
Definition: FeasiblePath.h:767
Rose::BinaryAnalysis::Partitioner2::FunctionPtr
Sawyer::SharedPointer< Function > FunctionPtr
Shared-ownership pointer for Function.
Definition: BinaryAnalysis/Partitioner2/BasicTypes.h:815
Rose::BinaryAnalysis::Partitioner2::BasicBlockPtr
Sawyer::SharedPointer< BasicBlock > BasicBlockPtr
Shared-ownersip pointer for BasicBlock.
Definition: BinaryAnalysis/Partitioner2/BasicTypes.h:778
Rose::AST::IO::merge
ROSE_DLL_API void merge(SgProject *project)
Performs sharing of AST nodes followed by linking accross translation units.
Rose::BinaryAnalysis::Variables::print
void print(const StackVariables &, const Partitioner2::PartitionerConstPtr &, std::ostream &out, const std::string &prefix="")
Print info about multiple local variables.
Rose::BinaryAnalysis::Reachability::ReasonFlags
BitFlags< Reason, uint32_t > ReasonFlags
Bit flags for reachability.
Definition: Reachability.h:56
Rose::BinaryAnalysis::Partitioner2::PartitionerConstPtr
Sawyer::SharedPointer< const Partitioner > PartitionerConstPtr
Shared-ownership pointer for Partitioner.
Definition: BinaryAnalysis/Partitioner2/BasicTypes.h:833
SgAsmExpression
Base class for expressions.
Definition: binaryInstruction.C:40157
Rose::BinaryAnalysis::JvmInstructionKind::pop
0x57: "Pop the top operand stack value"
SgAsmType
Base class for binary types.
Definition: binaryInstruction.C:15212
Sawyer::SharedObject
Base class for reference counted objects.
Definition: SharedObject.h:64
Rose::BinaryAnalysis::CallingConvention::initDiagnostics
void initDiagnostics()
Initialize diagnostics.
Rose::BinaryAnalysis::SymbolicExpression::Ptr
Sawyer::SharedPointer< Node > Ptr
Reference counting pointer.
Definition: BinaryAnalysis/BasicTypes.h:118
Sawyer::Nothing
Represents no value.
Definition: Optional.h:32
Rose::BinaryAnalysis::Strings::State
State
Decoder state.
Definition: String.h:198
stringify::Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags
const char * Flags(int64_t)
Convert Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags enum constant to a string.
Generated on Mon Oct 23 2023 01:05:45 for ROSE by   doxygen 1.8.10