ROSE_HTML_Reference/SageBuilderAsm_8h_source.html

 #ifndef ROSE_SageBuilderAsm_H

 #define ROSE_SageBuilderAsm_H

 #include <featureTests.h>

 #ifdef ROSE_ENABLE_BINARY_ANALYSIS


 #include <AssemblerX86Init.h>                           // for X86InstructionKind


 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* buildX86Instruction(Rose::BinaryAnalysis::X86InstructionKind);

 SgAsmX86Instruction* buildX86Instruction(Rose::BinaryAnalysis::X86InstructionKind, SgAsmExpression *operand);

 SgAsmX86Instruction* buildX86Instruction(Rose::BinaryAnalysis::X86InstructionKind, SgAsmExpression *lhs, SgAsmExpression *rhs);

 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

SgAsmBinaryAdd
Expression that adds two operands.
Definition: binaryInstruction.C:37882

SgAsmBinaryRor
Expression that performs a right rotate.
Definition: binaryInstruction.C:37269

SgAsmBlock
Instruction basic block.
Definition: binaryInstruction.C:36871

Rose::SageBuilderAsm::buildTypeU16
SgAsmIntegerType * buildTypeU16()
16-bit unsigned.

SgAsmBinaryPostupdate
Expression that represents an update to a storage location.
Definition: binaryInstruction.C:37385

Rose::SageBuilderAsm::buildIeee754Binary32
SgAsmFloatType * buildIeee754Binary32()
32-bit IEEE-754 floating-point.

Rose::SageBuilderAsm::buildTypeI64
SgAsmIntegerType * buildTypeI64()
64-bit signed.

SgAsmRiscOperation::RiscOperator
RiscOperator
One enum per RISC operator.
Definition: binaryInstruction.C:1475

Rose::SageBuilderAsm::buildTypeU1
SgAsmIntegerType * buildTypeU1()
1-bit unsigned (Boolean).

SgAsmExprListExp
List of expression nodes.
Definition: binaryInstruction.C:15308

Rose::SageBuilderAsm::buildTypeU64
SgAsmIntegerType * buildTypeU64()
64-bit unsigned.

SgAsmBinaryAsr
Expression that performs an arithmetic, sign-bit preserving right shift.
Definition: binaryInstruction.C:37827

SgNode::set_parent
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.

SgAsmBinaryLsr
Expression that performs a logical, sign-bit non-preserving right shift.
Definition: binaryInstruction.C:37607

Rose::SageBuilderAsm::buildTypeM68kFloat96
SgAsmFloatType * buildTypeM68kFloat96()
Motorola M68k 96-bit float (16-bits are always zero).

SgAsmUnaryTruncate
Expression representing truncation.
Definition: binaryInstruction.C:543

SgAsmFunction
Represents a synthesized function.
Definition: binaryInstruction.C:14231

Rose::SageBuilderAsm::buildTypeU8
SgAsmIntegerType * buildTypeU8()
8-bit unsigned.

Rose::SageBuilderAsm::buildTypeU4
SgAsmIntegerType * buildTypeU4()
4-bit unsigned.

SgAsmUnaryRrx
Definition: binaryInstruction.C:659

Rose
Main namespace for the ROSE library.
Definition: BinaryTutorial.dox:3

Rose::SageBuilderAsm::buildTypeI32
SgAsmIntegerType * buildTypeI32()
32-bit signed.

Rose::SageBuilderAsm::buildTypeX86Byte
SgAsmIntegerType * buildTypeX86Byte()
8-bit unsigned.

Rose::SageBuilderAsm::buildTypeI16
SgAsmIntegerType * buildTypeI16()
16-bit signed.

Rose::SageBuilderAsm::buildIeee754Binary128
SgAsmFloatType * buildIeee754Binary128()
128-bit IEEE-754 floating-point.

SgAsmMemoryReferenceExpression
Reference to memory locations.
Definition: binaryInstruction.C:6705

Rose::SageBuilderAsm::buildTypeX86Float32
SgAsmFloatType * buildTypeX86Float32()
32-bit IEEE-754 floating-point.

SgAsmIntegerValueExpression
Base class for integer values.
Definition: binaryInstruction.C:12636

SgAsmOperandList
List of operands for an instruction.
Definition: binaryInstruction.C:4886

Rose::SageBuilderAsm::buildBinaryComposite
SgBinaryComposite * buildBinaryComposite(const std::string &fileName)
Build a new binary composite object.

Rose::SageBuilderAsm::buildTypeX86DoubleWord
SgAsmIntegerType * buildTypeX86DoubleWord()
32-bit unsigned.

SgBinaryComposite
Definition: Cxx_Grammar.h:28776

Rose::SageBuilderAsm::buildTypeU32
SgAsmIntegerType * buildTypeU32()
32-bit unsigned.

Rose::SageBuilderAsm::buildTypeX86QuadWord
SgAsmIntegerType * buildTypeX86QuadWord()
64-bit unsigned.

SgAsmStaticData
Represents static data in an executable.
Definition: binaryInstruction.C:1279

SgAsmX86Instruction
Represents one Intel x86 machine instruction.
Definition: binaryInstruction.C:112

Rose::SageBuilderAsm::buildIeee754Binary16
SgAsmFloatType * buildIeee754Binary16()
16-bit IEEE-754 floating-point.

SgAsmUnarySignedExtend
Expression representing sign extending.
Definition: binaryInstruction.C:601

SgAsmExpression
Base class for expressions.
Definition: binaryInstruction.C:40157

Sawyer::Container::BitVector
Bit vectors.
Definition: BitVector.h:64

SgAsmBinaryLsl
Expression that performs a logical left shift operation.
Definition: binaryInstruction.C:37662

SgAsmBinaryMultiply
Expression that multiplies two operands.
Definition: binaryInstruction.C:37440

SgAsmBinaryMsl
Expression that performs a logical left shift operation filling low-order bits with one...
Definition: binaryInstruction.C:37497

SgAsmUnaryUnsignedExtend
Expression representing unsigned extending.
Definition: binaryInstruction.C:485

SgAsmType
Base class for binary types.
Definition: binaryInstruction.C:15212

Rose::SageBuilderAsm::buildTypeI8
SgAsmIntegerType * buildTypeI8()
8-bit signed.

Rose::SageBuilderAsm::buildTypeM68kFloat80
SgAsmFloatType * buildTypeM68kFloat80()
Motorola M68k 96-bit float w/out 16-bit constant zero field.

SgAsmFloatValueExpression
Floating-point value.
Definition: binaryInstruction.C:14782

Rose::SageBuilderAsm::buildTypeU
SgAsmIntegerType * buildTypeU(size_t nBits)
Unsigned type of specified size.

SgAsmBinarySubtract
Expression that subtracts the second operand from the first.
Definition: binaryInstruction.C:37214

Rose::SageBuilderAsm::buildTypeX86Word
SgAsmIntegerType * buildTypeX86Word()
16-bit unsigned.

SgAsmBinaryPreupdate
Expression that represents an update to a storage location.
Definition: binaryInstruction.C:37327

Rose::SageBuilderAsm::buildIeee754Binary80
SgAsmFloatType * buildIeee754Binary80()
80-bit IEEE-754 floating-point (as in x86).

SgAsmBinaryConcat
Expression that concatenates two values to form a wider value.
Definition: binaryInstruction.C:37772

SgAsmOperandList::get_operands
SgAsmExpressionPtrList const & get_operands() const
Property: Ordered list of instruction operands.

Rose::BinaryAnalysis::X86InstructionKind
X86InstructionKind
List of all x86 instructions known to the ROSE disassembler/assembler.
Definition: AssemblerX86Init.h:27

Rose::SageBuilderAsm::buildIeee754Binary64
SgAsmFloatType * buildIeee754Binary64()
64-bit IEEE-754 floating-point.

SgAsmIntegerType
Integer types.
Definition: binaryInstruction.C:12793

Rose::SageBuilderAsm::buildTypeX86Float80
SgAsmFloatType * buildTypeX86Float80()
80-bit IEEE-754 floating-point.

Rose::SageBuilderAsm::buildTypeI
SgAsmIntegerType * buildTypeI(size_t nBits)
Signed type of specified size.

SgAsmFloatType
Floating point types.
Definition: binaryInstruction.C:14892

Rose::SageBuilderAsm::buildTypeVector
SgAsmVectorType * buildTypeVector(size_t, SgAsmType *)
Fixed-size, packed array.

SgAsmVectorType
Base class for vector types.
Definition: binaryInstruction.C:392

SgAsmRiscOperation
Static representation of instruction semantics.
Definition: binaryInstruction.C:1434

Rose::SageBuilderAsm::buildTypeX86Float64
SgAsmFloatType * buildTypeX86Float64()
64-bit IEEE-754 floating-point.

Rose::SageBuilderAsm::buildTypeX86DoubleQuadWord
SgAsmVectorType * buildTypeX86DoubleQuadWord()
Vector of two 64-bit unsigned integers.