Rose/BinaryAnalysis/Architecture/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_Architecture_BasicTypes_H
#define ROSE_BinaryAnalysis_Architecture_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Architecture/Exception.h> // needed for Result<T,NotFound>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
 
class SgAsmGenericHeader;
class SgAsmInterpretation;
 
#include <Sawyer/Message.h>
#include <Sawyer/Result.h>
#include <boost/filesystem.hpp>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
// Basic types needed by almost all architectures
 
namespace Rose {
namespace BinaryAnalysis {
namespace Architecture {
 
// Forward class declarations for built-in architectures and their reference-counting pointers.
 
class Amd64;
using Amd64Ptr = std::shared_ptr<Amd64>;                
class ArmAarch32;
using ArmAarch32Ptr = std::shared_ptr<ArmAarch32>;      
class ArmAarch64;
using ArmAarch64Ptr = std::shared_ptr<ArmAarch64>;      
class Base;
using BasePtr = std::shared_ptr<Base>;                  
using BaseConstPtr = std::shared_ptr<const Base>;       
class Cil;
using CilPtr = std::shared_ptr<Cil>;                    
class Intel80286;
using Intel80286Ptr = std::shared_ptr<Intel80286>;      
class Intel8086;
using Intel8086Ptr = std::shared_ptr<Intel8086>;        
class Intel8088;
using Intel8088Ptr = std::shared_ptr<Intel8088>;        
class IntelI386;
using IntelI386Ptr = std::shared_ptr<IntelI386>;        
class IntelI486;
using IntelI486Ptr = std::shared_ptr<IntelI486>;        
class IntelPentium;
using IntelPentiumPtr = std::shared_ptr<IntelPentium>;  
class IntelPentiumii;
using IntelPentiumiiPtr = std::shared_ptr<IntelPentiumii>; 
class IntelPentiumiii;
using IntelPentiumiiiPtr = std::shared_ptr<IntelPentiumiii>; 
class IntelPentium4;
using IntelPentium4Ptr = std::shared_ptr<IntelPentium4>; 
class Jvm;
using JvmPtr = std::shared_ptr<Jvm>;                    
class Mips32;
using Mips32Ptr = std::shared_ptr<Mips32>;              
class Motorola;
using MotorolaPtr = std::shared_ptr<Motorola>;          
class Motorola68040;
using Motorola68040Ptr = std::shared_ptr<Motorola68040>; 
class NxpColdfire;
using NxpColdfirePtr = std::shared_ptr<NxpColdfire>;    
class Powerpc;
using PowerpcPtr = std::shared_ptr<Powerpc>;            
class Powerpc32;
using Powerpc32Ptr = std::shared_ptr<Powerpc32>;        
class Powerpc64;
using Powerpc64Ptr = std::shared_ptr<Powerpc64>;        
class X86;
using X86Ptr = std::shared_ptr<X86>;                    
// Diagnostics
 
extern Sawyer::Message::Facility mlog;
 
void initDiagnostics();
 
// Subclass registration functions
 
size_t registerDefinition(const BasePtr&);
 
void registerDefinition(const std::string&);
 
template<class Iterator>
void registerDefinitions(Iterator begin, Iterator end) {
    for (/*void*/; begin != end; ++begin)
        registerDefinition(*begin);
}
 
bool deregisterDefinition(const BasePtr&);
 
std::vector<BasePtr> registeredDefinitions();
 
std::set<std::string> registeredNames();
 
// Searching for suitable architectures
 
Sawyer::Result<BasePtr, NotFound> findByName(const std::string&);
 
Sawyer::Result<BasePtr, NotFound> findById(size_t);
 
Sawyer::Result<BasePtr, NotFound> findByHeader(SgAsmGenericHeader*);
 
Sawyer::Result<BasePtr, NotFound> findByInterpretation(SgAsmInterpretation*);
 
std::pair<BasePtr, size_t> findBestByInterpretation(SgAsmInterpretation*);
 
// Helper functions
 
const std::string& name(const BaseConstPtr&);
const std::string& name(size_t registrationId);
InstructionSemantics::BaseSemantics::DispatcherPtr
newInstructionDispatcher(const std::string &name, const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif