SageBuilderAsm.h

#ifndef ROSE_SageBuilderAsm_H
#define ROSE_SageBuilderAsm_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <AssemblerX86Init.h>                           // for X86InstructionKind
 
#include <SgAsmRiscOperation.h>
#include <SgAsmOperandList.h>
 
#include <Sawyer/BitVector.h>
 
namespace Rose {
 
namespace SageBuilderAsm {
 
// Build files
 
SgBinaryComposite* buildBinaryComposite(const std::string &fileName);
 
 
 
// Build data types
//
// These data type builders always return the same IR node and are thread-safe.
 
// Generic data types
SgAsmIntegerType* buildTypeU(size_t nBits);             
SgAsmIntegerType* buildTypeI(size_t nBits);             
SgAsmIntegerType* buildTypeU1();                        
SgAsmIntegerType* buildTypeU4();                        
SgAsmIntegerType* buildTypeU8();                        
SgAsmIntegerType* buildTypeU16();                       
SgAsmIntegerType* buildTypeU32();                       
SgAsmIntegerType* buildTypeU64();                       
SgAsmIntegerType* buildTypeI8();                        
SgAsmIntegerType* buildTypeI16();                       
SgAsmIntegerType* buildTypeI32();                       
SgAsmIntegerType* buildTypeI64();                       
SgAsmFloatType* buildIeee754Binary16();                 
SgAsmFloatType* buildIeee754Binary32();                 
SgAsmFloatType* buildIeee754Binary64();                 
SgAsmFloatType* buildIeee754Binary80();                 
SgAsmFloatType* buildIeee754Binary128();                
SgAsmVectorType* buildTypeVector(size_t, SgAsmType*);   
// Architecture-specific data types
SgAsmIntegerType *buildTypeX86Byte();                   
SgAsmIntegerType *buildTypeX86Word();                   
SgAsmIntegerType *buildTypeX86DoubleWord();             
SgAsmIntegerType *buildTypeX86QuadWord();               
SgAsmFloatType *buildTypeX86Float32();                  
SgAsmFloatType *buildTypeX86Float64();                  
SgAsmFloatType *buildTypeX86Float80();                  
SgAsmVectorType *buildTypeX86DoubleQuadWord();          
SgAsmFloatType *buildTypeM68kFloat96();                 
SgAsmFloatType *buildTypeM68kFloat80();                 
// Generic value builders
SgAsmIntegerValueExpression* buildValueInteger(uint64_t value, SgAsmType*);
SgAsmIntegerValueExpression* buildValueInteger(const Sawyer::Container::BitVector&, SgAsmType*);
SgAsmFloatValueExpression* buildValueFloat(double value, SgAsmType*);
SgAsmFloatValueExpression* buildValueFloat(const Sawyer::Container::BitVector&, SgAsmType*);
 
// Building integer or FP values.
 
// Build integer or FP values generically (one of these per buildType function above)
SgAsmIntegerValueExpression* buildValueU1(bool);
SgAsmIntegerValueExpression* buildValueU8(uint8_t);
SgAsmIntegerValueExpression* buildValueU16(uint16_t);
SgAsmIntegerValueExpression* buildValueU32(uint32_t);
SgAsmIntegerValueExpression* buildValueU64(uint64_t);
SgAsmIntegerValueExpression* buildValueI8(int8_t);
SgAsmIntegerValueExpression* buildValueI16(int16_t);
SgAsmIntegerValueExpression* buildValueI32(int32_t);
SgAsmIntegerValueExpression* buildValueI64(int64_t);
SgAsmFloatValueExpression* buildValueIeee754Binary32(double);
SgAsmFloatValueExpression* buildValueIeee754Binary64(double);
 
// Template specializations for building integer values
template <class T>
SgAsmIntegerValueExpression* buildValue(T);
 
// Building integer or FP values with x86-specific type names
SgAsmIntegerValueExpression* buildValueX86Byte(uint8_t);
SgAsmIntegerValueExpression* buildValueX86Word(uint16_t);
SgAsmIntegerValueExpression* buildValueX86DWord(uint32_t);
SgAsmIntegerValueExpression* buildValueX86QWord(uint64_t);
SgAsmFloatValueExpression* buildValueX86Float32(double);
SgAsmFloatValueExpression* buildValueX86Float64(double);
SgAsmFloatValueExpression* buildValueX86Float80(double);
 
// Operators
SgAsmBinaryAdd* buildAddExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinarySubtract* buildSubtractExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryMultiply* buildMultiplyExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryPreupdate* buildPreupdateExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryPostupdate* buildPostupdateExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryMsl* buildMslExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryLsl* buildLslExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryLsr* buildLsrExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryAsr* buildAsrExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmBinaryRor* buildRorExpression(SgAsmExpression *lhs, SgAsmExpression *rhs, SgAsmType *type=NULL);
SgAsmUnaryRrx* buildRrxExpression(SgAsmExpression *lhs, SgAsmType *type=NULL);
SgAsmUnaryTruncate* buildTruncateExpression(SgAsmExpression*, SgAsmType*);
SgAsmBinaryConcat* buildConcatExpression(SgAsmExpression *moreSignificant, SgAsmExpression *lessSignificant);
SgAsmUnarySignedExtend* buildSignedExtendExpression(SgAsmExpression*, SgAsmType*);
SgAsmUnaryUnsignedExtend* buildUnsignedExtendExpression(SgAsmExpression*, SgAsmType*);
SgAsmExprListExp* buildExprListExpression();
void appendExpression(SgAsmExprListExp*, SgAsmExpression*);
SgAsmMemoryReferenceExpression* buildMemoryReferenceExpression(SgAsmExpression *addr, SgAsmExpression *segment=NULL,
                                                               SgAsmType *type=NULL);
SgAsmRiscOperation* buildRiscOperation(SgAsmRiscOperation::RiscOperator);
SgAsmRiscOperation* buildRiscOperation(SgAsmRiscOperation::RiscOperator, SgAsmExpression*);
SgAsmRiscOperation* buildRiscOperation(SgAsmRiscOperation::RiscOperator, SgAsmExpression*, SgAsmExpression*);
SgAsmRiscOperation* buildRiscOperation(SgAsmRiscOperation::RiscOperator, SgAsmExpression*, SgAsmExpression*, SgAsmExpression*);
SgAsmRiscOperation* buildRiscOperation(SgAsmRiscOperation::RiscOperator, SgAsmExpression*, SgAsmExpression*, SgAsmExpression*,
                                       SgAsmExpression*);
 
 
template <typename Insn>
inline Insn* appendOperand(Insn* insn, SgAsmExpression* op) {
    SgAsmOperandList* operands = insn->get_operandList();
    operands->get_operands().push_back(op);
    op->set_parent(operands);
    return insn; // For chaining this operation
}
 
// Build instruction
SgAsmX86Instruction *buildX86MultibyteNopInstruction(size_t nBytes);
 
// Build basic blocks
SgAsmBlock* buildBasicBlock(const std::vector<SgAsmInstruction*>&);
SgAsmFunction* buildFunction(rose_addr_t entryVa, const std::vector<SgAsmBlock*>&);
 
// Build data blocks
SgAsmStaticData* buildStaticData(rose_addr_t startVa, const SgUnsignedCharList &rawData);
SgAsmBlock* buildDataBlock(SgAsmStaticData*);
 
 
} // namespace
} // namespace
 
#endif
#endif