ROSE 0.11.145.250
StackDelta.h
1#ifndef ROSE_BinaryAnalysis_StackDelta_H
2#define ROSE_BinaryAnalysis_StackDelta_H
3#include <featureTests.h>
4#ifdef ROSE_ENABLE_BINARY_ANALYSIS
5
6#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
7#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
8#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
9#include <Sawyer/Map.h>
10
11#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
12#include <boost/serialization/access.hpp>
13#include <boost/serialization/split_member.hpp>
14#endif
15
16namespace Rose {
17namespace BinaryAnalysis {
18
19// Forwards
20namespace Partitioner2 {
21 namespace DataFlow {
23 }
24}
25
29namespace StackDelta {
30
35
40
44void initNamespace();
45
61class Analysis {
62public:
67
68private:
70 Sawyer::Optional<Address> initialConcreteStackPointer_; // where to start
71
72 bool hasResults_; // Are the following data members initialized?
73 bool didConverge_; // Are the following data membeers valid (else only approximations)?
74
75 SValuePair functionStackPtrs_; // Initial and final stack pointers
76 InstructionSemantics::BaseSemantics::SValuePtr functionDelta_; // Stack delta for entire function
77
78 SValuePairPerAddress bblockStackPtrs_; // Per-basic block initial and final stack pointers
79 DeltasPerAddress bblockDeltas_; // Stack delta per basic block (net effect of BB on stack ptr)
80
81 SValuePairPerAddress insnStackPtrs_; // Per-instruction initial and final stack pointers
82 SValuePairPerAddress insnFramePtrs_; // Per-instruction initial and final frame pointers if known
83 DeltasPerAddress insnSpDeltas_; // Stack delta per instruction (net effect of insn on stack ptr)
84 bool hasConsistentFramePointer_ = false; // Arch has FP register that's used as a frame pointer for this function
85
86#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
87private:
88 friend class boost::serialization::access;
89
90 template<class S>
91 void serializeCommon(S &s, const unsigned version) {
92 if (version < 1)
93 s & BOOST_SERIALIZATION_NVP(cpu_);
94 s & BOOST_SERIALIZATION_NVP(initialConcreteStackPointer_);
95 s & BOOST_SERIALIZATION_NVP(hasResults_);
96 s & BOOST_SERIALIZATION_NVP(didConverge_);
97 s & BOOST_SERIALIZATION_NVP(functionStackPtrs_);
98 s & BOOST_SERIALIZATION_NVP(functionDelta_);
99 s & BOOST_SERIALIZATION_NVP(bblockStackPtrs_);
100 s & BOOST_SERIALIZATION_NVP(bblockDeltas_);
101 s & BOOST_SERIALIZATION_NVP(insnStackPtrs_);
102 s & BOOST_SERIALIZATION_NVP(insnSpDeltas_);
103 if (version >= 2) {
104 s & BOOST_SERIALIZATION_NVP(insnFramePtrs_);
105 s & BOOST_SERIALIZATION_NVP(hasConsistentFramePointer_);
106 }
107 }
108
109 template<class S>
110 void save(S &s, const unsigned version) const {
111 const_cast<Analysis*>(this)->serializeCommon(s, version);
112 if (version >= 1) {
113 std::string archName;
115 if (cpu_) {
116 archName = Architecture::name(cpu_->architecture());
117 ops = cpu_->operators();
118 }
119 s & BOOST_SERIALIZATION_NVP(archName);
120 s & BOOST_SERIALIZATION_NVP(ops);
121 }
122 }
123
124 template<class S>
125 void load(S &s, const unsigned version) {
126 serializeCommon(s, version);
127 if (version >= 1) {
128 std::string archName;
130 s & BOOST_SERIALIZATION_NVP(archName);
131 s & BOOST_SERIALIZATION_NVP(ops);
132 if (!archName.empty())
133 cpu_ = Architecture::newInstructionDispatcher(archName, ops);
134 }
135 }
136
137 BOOST_SERIALIZATION_SPLIT_MEMBER();
138#endif
139
140public:
147 : hasResults_(false), didConverge_(false) {}
148
153 : hasResults_(false), didConverge_(false) {
154 init(d);
155 }
156
165 : cpu_(cpu), hasResults_(false), didConverge_(false) {}
166
174 Sawyer::Optional<Address> initialConcreteStackPointer() const { return initialConcreteStackPointer_; }
175 void initialConcreteStackPointer(const Sawyer::Optional<Address> &val) { initialConcreteStackPointer_ = val; }
183 void
186
191 bool hasResults() const { return hasResults_; }
192
197 bool didConverge() const { return didConverge_; }
198
204
209
212
217
223
228 SValuePair functionStackPointers() const { return functionStackPtrs_; }
229
235
241
246 SValuePair basicBlockStackPointers(Address basicBlockAddress) const;
247
253
268 int64_t basicBlockStackDeltaConcrete(Address basicBlockAddress) const;
269
275
282
308
315
320
326
332
337
339 void print(std::ostream&) const;
340
341public:
342 // Used internally. Do not document with doxygen.
343 void adjustInstruction(SgAsmInstruction*,
344 const InstructionSemantics::BaseSemantics::SValuePtr &spIn, // SP before execution
345 const InstructionSemantics::BaseSemantics::SValuePtr &spOut, // SP after execution
346 const InstructionSemantics::BaseSemantics::SValuePtr &spDelta, // spOut - spIn
347 const InstructionSemantics::BaseSemantics::SValuePtr &fpIn, // FP before execution
348 const InstructionSemantics::BaseSemantics::SValuePtr &fpOut); // FP after execution
349
350private:
351 void init(const Disassembler::BasePtr&);
352};
353
354std::ostream& operator<<(std::ostream&, const Analysis&);
355
356} // namespace
357} // namespace
358} // namespace
359
360// Class versions must be at global scope
361#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
362BOOST_CLASS_VERSION(Rose::BinaryAnalysis::StackDelta::Analysis, 2);
363#endif
364
365#endif
366#endif
Various tools for data-flow analysis.
Definition DataFlow.h:72
Predicate that decides when to use inter-procedural data-flow.
InstructionSemantics::BaseSemantics::SValuePtr basicBlockOutputStackDeltaWrtFunction(Address basicBlockAddress) const
Stack delta for block w.r.t.
InstructionSemantics::BaseSemantics::SValuePtr instructionInputStackDeltaWrtFunction(SgAsmInstruction *) const
Stack delta for instruction w.r.t.
InstructionSemantics::BaseSemantics::SValuePtr basicBlockInputStackDeltaWrtFunction(Address basicBlockAddress) const
Stack delta for block w.r.t.
SValuePair instructionStackPointers(SgAsmInstruction *) const
Initial and final stack ponters for an analyzed instruction.
void analyzeFunction(const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &, Partitioner2::DataFlow::InterproceduralPredicate &)
Analyze one function.
static Sawyer::Optional< int64_t > toInt(const InstructionSemantics::BaseSemantics::SValuePtr &)
Convert a symbolic value to an integer.
void clearStackDeltas()
Clear stack deltas, not pointers.
InstructionSemantics::BaseSemantics::SValuePtr instructionStackDelta(SgAsmInstruction *) const
Stack delta for an instruction.
void clearFramePointers()
Clear the frame pointers.
SValuePair functionStackPointers() const
Initial and final stack pointers for an analyzed function.
Definition StackDelta.h:228
int64_t instructionStackDeltaConcrete(SgAsmInstruction *) const
Concrete stack delta for an instruction.
void print(std::ostream &) const
Print multi-line value to specified stream.
void saveAnalysisResults(SgAsmFunction *) const
Update AST with analysis results.
static void clearAstStackDeltas(SgNode *)
Clear AST stack deltas.
Sawyer::Optional< Address > initialConcreteStackPointer() const
Property: Initial value to use for stack pointers.
Definition StackDelta.h:174
InstructionSemantics::BaseSemantics::SValuePtr functionStackDelta() const
Stack delta for an analyzed function.
Definition StackDelta.h:234
int64_t functionStackDeltaConcrete() const
Concrete stack delta for an analyzed function.
int64_t basicBlockStackDeltaConcrete(Address basicBlockAddress) const
Concrete stack delta for an analyzed basic block.
SValuePair basicBlockStackPointers(Address basicBlockAddress) const
Initial and final stack pointers for a basic block.
InstructionSemantics::BaseSemantics::SValuePtr instructionOutputStackDeltaWrtFunction(SgAsmInstruction *) const
Stack delta for instruction w.r.t.
InstructionSemantics::BaseSemantics::SValuePtr basicBlockStackDelta(Address basicBlockAddress) const
Stack delta for an analyzed basic block.
void initialConcreteStackPointer(const Sawyer::Optional< Address > &val)
Property: Initial value to use for stack pointers.
Definition StackDelta.h:175
void clearNonResults()
Clears everything but results.
bool hasConsistentFramePointer() const
True if the function appears to have a frame pointer.
InstructionSemantics::BaseSemantics::SValuePtr instructionInputFrameDelta(SgAsmInstruction *) const
Frame delta for an instruction.
Analysis(const InstructionSemantics::BaseSemantics::DispatcherPtr &cpu)
Construct an analysis using a specified dispatcher.
Definition StackDelta.h:164
void clearStackPointers()
Clear stack pointers, not deltas.
InstructionSemantics::BaseSemantics::DispatcherPtr cpu() const
Virtual CPU used for analysis.
Definition StackDelta.h:325
bool hasResults() const
Whether a function has been analyzed.
Definition StackDelta.h:191
InstructionSemantics::BaseSemantics::SValuePtr instructionOutputFrameDelta(SgAsmInstruction *) const
Frame delta for an instruction.
void clearResults()
Clear analysis results.
Analysis(const Disassembler::BasePtr &d)
Construct an analyzer using a specified disassembler.
Definition StackDelta.h:152
bool didConverge() const
Whether the analysis results are valid.
Definition StackDelta.h:197
Container associating values with keys.
Definition Sawyer/Map.h:72
Collection of streams.
Definition Message.h:1606
Holds a value or nothing.
Definition Optional.h:56
Represents a synthesized function.
Base class for machine instructions.
This class represents the base class for all IR nodes within Sage III.
InstructionSemantics::BaseSemantics::DispatcherPtr newInstructionDispatcher(const std::string &name, const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &)
Create a new instruction dispatcher by name.
const std::string & name(const BaseConstPtr &)
Architecture name free function.
boost::shared_ptr< Dispatcher > DispatcherPtr
Shared-ownership pointer to a semantics instruction dispatcher.
Sawyer::SharedPointer< SValue > SValuePtr
Shared-ownership pointer to a semantic value in any domain.
Sawyer::Message::Facility mlog
Facility for diagnostic output.
void initDiagnostics()
Initialize diagnostics.
void initNamespace()
Initialize this namespace.
std::uint64_t Address
Address.
Definition Address.h:11
The ROSE library.