1 #ifndef ROSE_BinaryAnalysis_Concolic_Architecture_H
2 #define ROSE_BinaryAnalysis_Concolic_Architecture_H
3 #include <featureTests.h>
4 #ifdef ROSE_ENABLE_CONCOLIC_TESTING
6 #include <Rose/BinaryAnalysis/ByteOrder.h>
7 #include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
8 #include <Rose/BinaryAnalysis/Concolic/ExecutionLocation.h>
9 #include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
10 #include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
11 #include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
12 #include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
13 #include <Rose/BinaryAnalysis/RegisterDescriptor.h>
14 #include <Rose/BinaryAnalysis/SmtSolver.h>
15 #include <Rose/Yaml.h>
17 #include <Sawyer/BitVector.h>
19 #include <boost/filesystem.hpp>
22 namespace BinaryAnalysis {
29 using Ptr = ArchitecturePtr;
40 TestCaseId testCaseId_;
41 TestCasePtr testCase_;
43 Debugger::BasePtr debugger_;
44 ExecutionLocation currentLocation_;
45 SystemCallMap systemCalls_;
46 SharedMemoryMap sharedMemory_;
47 InputVariablesPtr inputVariables_;
97 static Ptr forge(
const DatabasePtr&, TestCaseId,
const Yaml::Node &config);
98 static Ptr forge(
const DatabasePtr&,
const TestCasePtr&,
const Yaml::Node &config);
102 virtual bool matchFactory(
const Yaml::Node &config)
const = 0;
108 virtual Ptr instanceFromFactory(
const DatabasePtr&, TestCaseId,
const Yaml::Node &config)
const = 0;
115 bool isFactory()
const;
127 const std::string& name()
const;
128 void name(
const std::string&);
135 DatabasePtr database()
const;
141 TestCaseId testCaseId()
const;
147 TestCasePtr testCase()
const;
160 Debugger::BasePtr debugger()
const;
161 void debugger(
const Debugger::BasePtr&);
186 ExecutionLocation currentLocation()
const;
187 void currentLocation(
const ExecutionLocation&);
199 const SystemCallMap& systemCalls()
const;
213 const SharedMemoryMap& sharedMemory()
const;
221 InputVariablesPtr inputVariables()
const;
222 void inputVariables(
const InputVariablesPtr&);
235 virtual void configureSystemCalls() = 0;
242 virtual void configureSharedMemory(
const Yaml::Node &config);
251 void sharedMemory(
const SharedMemoryCallbackPtr&);
252 void sharedMemory(
const SharedMemoryCallbackPtr&,
const AddressInterval&);
256 void systemCalls(
size_t syscallId,
const SyscallCallbackPtr&);
267 virtual void load(
const boost::filesystem::path &tempDirectory) = 0;
273 virtual bool isTerminated();
287 virtual std::vector<ExecutionEventPtr> createMemoryRestoreEvents() = 0;
288 std::vector<ExecutionEventPtr> createMemoryRestoreEvents(
const MemoryMapPtr&);
294 virtual std::vector<ExecutionEventPtr> createMemoryHashEvents() = 0;
301 virtual std::vector<ExecutionEventPtr> createMemoryAdjustEvents(
const MemoryMap::Ptr&, rose_addr_t insnVa) = 0;
307 virtual std::vector<ExecutionEventPtr> createRegisterRestoreEvents();
313 void saveEvents(
const std::vector<ExecutionEventPtr>&, When);
332 virtual bool playEvent(
const ExecutionEventPtr&);
342 uint64_t readMemoryUnsigned(rose_addr_t va,
size_t nBytes);
349 virtual std::string readCString(rose_addr_t va,
size_t maxBytes =
UNLIMITED);
358 virtual ByteOrder::Endianness memoryByteOrder() = 0;
363 virtual rose_addr_t ip();
364 virtual void ip(rose_addr_t);
371 virtual void mapMemory(
const AddressInterval &where,
unsigned permissions);
381 virtual size_t writeMemory(rose_addr_t startVa,
const std::vector<uint8_t> &bytes);
387 virtual std::vector<uint8_t> readMemory(rose_addr_t startVa,
size_t nBytes);
395 virtual void writeRegister(RegisterDescriptor, uint64_t value);
427 const ExecutionLocation& nextInstructionLocation();
435 const ExecutionLocation& nextEventLocation(When);
442 std::vector<ExecutionEventPtr> getRelatedEvents(
const ExecutionEventPtr&)
const;
501 virtual std::pair<ExecutionEventPtr, SymbolicExpressionPtr>
503 rose_addr_t memVa,
size_t nBytes);
513 virtual void runSharedMemoryPostCallbacks(
const ExecutionEventPtr &sharedMemoryEvent,
const Emulation::RiscOperatorsPtr&);
542 void fixupSharedMemoryEvents(
const ExecutionEventPtr &sharedMemoryEvent,
const Emulation::RiscOperatorsPtr&);
545 void printSharedMemoryEvents(
const ExecutionEventPtr &sharedMemoryEvent,
const Emulation::RiscOperatorsPtr&);
SmtSolverPtr Ptr
Reference counting pointer for SMT solvers.
An associative container whose keys are non-overlapping intervals.
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.
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...
Sawyer::SharedPointer< Engine > EnginePtr
Shared-ownership pointer for Engine.
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.
Range of values delimited by endpoints.
Sawyer::SharedPointer< Node > Ptr
Reference counting pointer.
void registerFactory(const BasePtr &)
Append a disassembler factory to the registry.
Container associating values with keys.