ROSE  0.11.123.0
Architecture.h
1 #ifndef ROSE_BinaryAnalysis_Concolic_Architecture_H
2 #define ROSE_BinaryAnalysis_Concolic_Architecture_H
3 #include <featureTests.h>
4 #ifdef ROSE_ENABLE_CONCOLIC_TESTING
5 
6 #include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
7 #include <Rose/BinaryAnalysis/Concolic/ExecutionLocation.h>
8 #include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
9 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
10 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
11 #include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
12 #include <Rose/BinaryAnalysis/RegisterDescriptor.h>
13 #include <Rose/BinaryAnalysis/SmtSolver.h>
14 #include <Rose/Yaml.h>
15 
16 #include <ByteOrder.h>
17 
18 #include <Sawyer/BitVector.h>
19 
20 #include <boost/filesystem.hpp>
21 
22 namespace Rose {
23 namespace BinaryAnalysis {
24 namespace Concolic {
25 
27 class Architecture: public Sawyer::SharedObject, public Sawyer::SharedFromThis<Architecture> {
28 public:
30  using Ptr = ArchitecturePtr;
31 
33  using SystemCallMap = Sawyer::Container::Map<int /*syscall*/, SyscallCallbacks>;
34 
37 
38 private:
39  std::string name_; // architecture name for factory matching
40  DatabasePtr db_;
41  TestCaseId testCaseId_;
42  TestCasePtr testCase_;
44  Debugger::BasePtr debugger_;
45  ExecutionLocation currentLocation_; // incremented when the instruction begins execution
46  SystemCallMap systemCalls_; // callbacks for syscalls
47  SharedMemoryMap sharedMemory_; // callbacks for shared memory
48  InputVariablesPtr inputVariables_; // info about variables for events and inputs
49  Sawyer::Optional<rose_addr_t> scratchVa_; // scratch page for internal use in subordinate address space
50 
51 protected:
52  // See "instance" methods in subclasses
53  explicit Architecture(const std::string&); // for factories
54  Architecture(const DatabasePtr&, TestCaseId); // for non-factories
55 public:
56  virtual ~Architecture();
57 
59  // Factory
61 public:
70  static void registerFactory(const Ptr &factory);
71 
78  static bool deregisterFactory(const Ptr &factory);
79 
86  static std::vector<Ptr> registeredFactories();
87 
98  static Ptr forge(const DatabasePtr&, TestCaseId, const Yaml::Node &config);
99  static Ptr forge(const DatabasePtr&, const TestCasePtr&, const Yaml::Node &config);
103  virtual bool matchFactory(const Yaml::Node &config) const = 0;
104 
109  virtual Ptr instanceFromFactory(const DatabasePtr&, TestCaseId, const Yaml::Node &config) const = 0;
110 
116  bool isFactory() const;
117 
119  // Properties
121 public:
128  const std::string& name() const;
129  void name(const std::string&);
136  DatabasePtr database() const;
137 
142  TestCaseId testCaseId() const;
143 
148  TestCasePtr testCase() const;
149 
153  Partitioner2::PartitionerConstPtr partitioner() const;
154  void partitioner(const Partitioner2::PartitionerConstPtr&);
155 
161  Debugger::BasePtr debugger() const;
162  void debugger(const Debugger::BasePtr&);
171  Sawyer::Optional<rose_addr_t> scratchVa() const;
172  void scratchVa(const Sawyer::Optional<rose_addr_t>&);
187  ExecutionLocation currentLocation() const;
188  void currentLocation(const ExecutionLocation&);
200  const SystemCallMap& systemCalls() const;
201 
214  const SharedMemoryMap& sharedMemory() const;
215 
222  InputVariablesPtr inputVariables() const;
223  void inputVariables(const InputVariablesPtr&);
226  // Functions that can be called before execution starts.
229 public:
231  virtual Partitioner2::PartitionerPtr partition(Partitioner2::Engine*, const std::string &specimenName) = 0;
232 
236  virtual void configureSystemCalls() = 0;
237 
243  virtual void configureSharedMemory(const Yaml::Node &config);
244 
252  void sharedMemory(const SharedMemoryCallbackPtr&);
253  void sharedMemory(const SharedMemoryCallbackPtr&, const AddressInterval&);
257  void systemCalls(size_t syscallId, const SyscallCallbackPtr&);
258 
268  virtual void load(const boost::filesystem::path &tempDirectory) = 0;
269 
274  virtual bool isTerminated();
275 
279 
281  // Functions that create execution events. These query the concrete state but do not modify it.
283 public:
288  virtual std::vector<ExecutionEventPtr> createMemoryRestoreEvents() = 0;
289  std::vector<ExecutionEventPtr> createMemoryRestoreEvents(const MemoryMapPtr&);
290 
295  virtual std::vector<ExecutionEventPtr> createMemoryHashEvents() = 0;
296 
302  virtual std::vector<ExecutionEventPtr> createMemoryAdjustEvents(const MemoryMap::Ptr&, rose_addr_t insnVa) = 0;
303 
308  virtual std::vector<ExecutionEventPtr> createRegisterRestoreEvents();
309 
314  void saveEvents(const std::vector<ExecutionEventPtr>&, When);
315 
317  // High-level functions controlling concrete execution.
319 public:
325  size_t playAllEvents(const Partitioner2::PartitionerConstPtr&);
326 
333  virtual bool playEvent(const ExecutionEventPtr&);
334 
338  virtual void runToEvent(const ExecutionEventPtr&, const Partitioner2::PartitionerConstPtr&);
339 
343  uint64_t readMemoryUnsigned(rose_addr_t va, size_t nBytes);
344 
350  virtual std::string readCString(rose_addr_t va, size_t maxBytes = UNLIMITED);
351 
353  // Low-level functions controlling concrete execution.
355 public:
359  virtual ByteOrder::Endianness memoryByteOrder() = 0;
360 
364  virtual rose_addr_t ip();
365  virtual void ip(rose_addr_t);
372  virtual void mapMemory(const AddressInterval &where, unsigned permissions);
373 
377  virtual void unmapMemory(const AddressInterval &where);
378 
382  virtual size_t writeMemory(rose_addr_t startVa, const std::vector<uint8_t> &bytes);
383 
388  virtual std::vector<uint8_t> readMemory(rose_addr_t startVa, size_t nBytes);
389 
396  virtual void writeRegister(RegisterDescriptor, uint64_t value);
397  virtual void writeRegister(RegisterDescriptor, const Sawyer::Container::BitVector&);
401  virtual Sawyer::Container::BitVector readRegister(RegisterDescriptor);
402 
407  virtual void checkInstruction(SgAsmInstruction*);
408 
413  virtual void advanceExecution(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);
414 
420  virtual void executeInstruction(const Partitioner2::PartitionerConstPtr&);
421  virtual void executeInstruction(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, SgAsmInstruction*);
428  const ExecutionLocation& nextInstructionLocation();
429 
436  const ExecutionLocation& nextEventLocation(When);
443  std::vector<ExecutionEventPtr> getRelatedEvents(const ExecutionEventPtr&) const;
444 
446  // Functions related to symbolic states.
448 public:
456  virtual void createInputVariables(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
457  const SmtSolver::Ptr&) = 0;
458 
476  virtual void restoreInputVariables(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
477  const SmtSolver::Ptr&);
478 
480  // Functions related to operating system emulation
482 public:
487  virtual void systemCall(const Partitioner2::PartitionerConstPtr&,
489 
502  virtual std::pair<ExecutionEventPtr, SymbolicExpressionPtr>
503  sharedMemoryRead(const SharedMemoryCallbacks&, const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
504  rose_addr_t memVa, size_t nBytes);
505  virtual bool
506  sharedMemoryWrite(const SharedMemoryCallbacks&, const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
507  rose_addr_t memVa, const InstructionSemantics::BaseSemantics::SValuePtr&);
514  virtual void runSharedMemoryPostCallbacks(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);
515 
543  void fixupSharedMemoryEvents(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);
544 
546  void printSharedMemoryEvents(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);
547 
549  virtual void sharedMemoryAccessPost(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&);
550 };
551 
552 } // namespace
553 } // namespace
554 } // namespace
555 
556 #endif
557 #endif
SmtSolverPtr Ptr
Reference counting pointer for SMT solvers.
Definition: SmtSolver.h:45
An associative container whose keys are non-overlapping intervals.
Definition: IntervalMap.h:171
boost::shared_ptr< RiscOperators > RiscOperatorsPtr
Shared-ownership pointer to a RISC operators object.
Base class for machine instructions.
Main namespace for the ROSE library.
const size_t UNLIMITED(static_cast< size_t >(-1))
Effictively unlimited size.
Sawyer::SharedPointer< MemoryMap > MemoryMapPtr
Reference counting pointer.
boost::shared_ptr< Dispatcher > DispatcherPtr
Shared-ownership pointer to a semantics instruction dispatcher.
std::vector< BasePtr > registeredFactories()
Returns all registered disassembler factories.
MemoryMapPtr Ptr
Reference counting pointer.
Definition: MemoryMap.h:115
Sawyer::SharedPointer< Partitioner > PartitionerPtr
Shared-ownership pointer for Partitioner.
Creates SharedPointer from this.
ROSE_DLL_API void load(SgProject *project, std::list< std::string > const &filepaths)
Load ASTs that have been saved to files.
Sawyer::SharedPointer< const Partitioner > PartitionerConstPtr
Shared-ownership pointer for Partitioner.
const char * Architecture(int64_t)
Convert Rose::BinaryAnalysis::Disassembler::Mips::Decoder::Architecture enum constant to a string...
bool deregisterFactory(const BasePtr &)
Remove a disassembler factory from the registry.
Sawyer::SharedPointer< SValue > SValuePtr
Shared-ownership pointer to a semantic value in any domain.
Base class for reference counted objects.
Definition: SharedObject.h:64
Range of values delimited by endpoints.
Definition: Interval.h:33
Sawyer::SharedPointer< Node > Ptr
Reference counting pointer.
void registerFactory(const BasePtr &)
Append a disassembler factory to the registry.
Container associating values with keys.
Definition: Sawyer/Map.h:66