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/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>
16 #include <ByteOrder.h>
18 #include <Sawyer/BitVector.h>
20 #include <boost/filesystem.hpp>
23 namespace BinaryAnalysis {
30 using Ptr = ArchitecturePtr;
41 TestCaseId testCaseId_;
42 TestCasePtr testCase_;
44 Debugger::BasePtr debugger_;
45 ExecutionLocation currentLocation_;
46 SystemCallMap systemCalls_;
47 SharedMemoryMap sharedMemory_;
48 InputVariablesPtr inputVariables_;
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;
109 virtual Ptr instanceFromFactory(
const DatabasePtr&, TestCaseId,
const Yaml::Node &config)
const = 0;
116 bool isFactory()
const;
128 const std::string& name()
const;
129 void name(
const std::string&);
136 DatabasePtr database()
const;
142 TestCaseId testCaseId()
const;
148 TestCasePtr testCase()
const;
161 Debugger::BasePtr debugger()
const;
162 void debugger(
const Debugger::BasePtr&);
187 ExecutionLocation currentLocation()
const;
188 void currentLocation(
const ExecutionLocation&);
200 const SystemCallMap& systemCalls()
const;
214 const SharedMemoryMap& sharedMemory()
const;
222 InputVariablesPtr inputVariables()
const;
223 void inputVariables(
const InputVariablesPtr&);
236 virtual void configureSystemCalls() = 0;
243 virtual void configureSharedMemory(
const Yaml::Node &config);
252 void sharedMemory(
const SharedMemoryCallbackPtr&);
253 void sharedMemory(
const SharedMemoryCallbackPtr&,
const AddressInterval&);
257 void systemCalls(
size_t syscallId,
const SyscallCallbackPtr&);
268 virtual void load(
const boost::filesystem::path &tempDirectory) = 0;
274 virtual bool isTerminated();
288 virtual std::vector<ExecutionEventPtr> createMemoryRestoreEvents() = 0;
289 std::vector<ExecutionEventPtr> createMemoryRestoreEvents(
const MemoryMapPtr&);
295 virtual std::vector<ExecutionEventPtr> createMemoryHashEvents() = 0;
302 virtual std::vector<ExecutionEventPtr> createMemoryAdjustEvents(
const MemoryMap::Ptr&, rose_addr_t insnVa) = 0;
308 virtual std::vector<ExecutionEventPtr> createRegisterRestoreEvents();
314 void saveEvents(
const std::vector<ExecutionEventPtr>&, When);
333 virtual bool playEvent(
const ExecutionEventPtr&);
343 uint64_t readMemoryUnsigned(rose_addr_t va,
size_t nBytes);
350 virtual std::string readCString(rose_addr_t va,
size_t maxBytes =
UNLIMITED);
359 virtual ByteOrder::Endianness memoryByteOrder() = 0;
364 virtual rose_addr_t ip();
365 virtual void ip(rose_addr_t);
372 virtual void mapMemory(
const AddressInterval &where,
unsigned permissions);
382 virtual size_t writeMemory(rose_addr_t startVa,
const std::vector<uint8_t> &bytes);
388 virtual std::vector<uint8_t> readMemory(rose_addr_t startVa,
size_t nBytes);
396 virtual void writeRegister(RegisterDescriptor, uint64_t value);
428 const ExecutionLocation& nextInstructionLocation();
436 const ExecutionLocation& nextEventLocation(When);
443 std::vector<ExecutionEventPtr> getRelatedEvents(
const ExecutionEventPtr&)
const;
502 virtual std::pair<ExecutionEventPtr, SymbolicExpressionPtr>
504 rose_addr_t memVa,
size_t nBytes);
514 virtual void runSharedMemoryPostCallbacks(
const ExecutionEventPtr &sharedMemoryEvent,
const Emulation::RiscOperatorsPtr&);
543 void fixupSharedMemoryEvents(
const ExecutionEventPtr &sharedMemoryEvent,
const Emulation::RiscOperatorsPtr&);
546 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...
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.