Expressions.C

Go to the documentation of this file.

/* This source file contains anything related to SgAsm*Expression nodes. */
#include "sage3basic.h"
#include "stringify.h"          /* used in error messages */
#include "integerOps.h"

using namespace rose;

//                                      Documentation for ROSETTA-generated things.





//                                      SgAsmIntegerValueExpression


uint64_t
SgAsmIntegerValueExpression::virtual_address(SgNode *node)
{
    if (!node)
        return 0;
    if (isSgAsmFunction(node))
        return isSgAsmFunction(node)->get_entry_va();
    if (isSgAsmStatement(node)) // instructions, block, function, staticdata, ...
        return isSgAsmStatement(node)->get_address();
    if (isSgAsmGenericSymbol(node))
        return isSgAsmGenericSymbol(node)->get_value();
    if (isSgAsmPEImportItem(node))
        return isSgAsmPEImportItem(node)->get_bound_rva().get_va();
    if (isSgAsmPERVASizePair(node))
        return isSgAsmPERVASizePair(node)->get_e_rva().get_va();
    if (isSgAsmGenericSection(node)) {
        SgAsmGenericSection *section = isSgAsmGenericSection(node);
        if (section->is_mapped())
            return section->get_mapped_actual_va();
        return 0;
    }

    std::cerr <<"SgAsmIntegerValueExpression::virtual_address: non-addressable node type: "
              <<stringifyVariantT(node->variantT(), "V_") <<std::endl;
    assert(!"need addressable node type"); // to get location info in error messsage
    abort(); // if asserts are disabled
}

std::string
SgAsmIntegerValueExpression::get_label(bool quiet/*=false*/) const
{
    SgNode *node = get_base_node();
    if (!node)
        return "";

    // Get the name of the base object if possible.
    std::string retval;
    std::string refkind;
    if (isSgAsmFunction(node)) {
        retval = isSgAsmFunction(node)->get_name();
        refkind = "Func";
    } else if (isSgAsmGenericSymbol(node)) {
        retval = isSgAsmGenericSymbol(node)->get_name()->get_string();
        refkind = "Sym";
    } else if (isSgAsmPEImportItem(node)) {
        retval = isSgAsmPEImportItem(node)->get_name()->get_string();
        refkind = "Import";
    } else if (isSgAsmGenericSection(node)) {
        retval = isSgAsmGenericSection(node)->get_short_name();
        refkind = "Section";
    } else if (isSgAsmInstruction(node)) {
        refkind = "Insn";
    } else if (isSgAsmStaticData(node)) {
        SgAsmBlock *blk = SageInterface::getEnclosingNode<SgAsmBlock>(node);
        if (blk && 0!=(blk->get_reason() & SgAsmBlock::BLK_JUMPTABLE)) {
            refkind = "JumpTable";
        } else {
            refkind = "StaticData";
        }
    } else if (isSgAsmBlock(node)) {
        refkind = "BBlock";
    } else if (isSgAsmPERVASizePair(node)) {
        refkind = "Rva/Size";
    } else {
        refkind = "Reference";
    }

    // If it has no name, then use something fairly generic.  That way we can at least indicate that the value is relative.
    int64_t offset = (int64_t)get_relative_value();
    if (retval.empty()) {
        retval = "<" + refkind; // extra level of brackets to indicate that it's not a real name
        if (offset)
            retval += "@" + StringUtility::addrToString(virtual_address(node), 32);
        retval += ">";
    }

    // Append the offset, but consider it to be signed.  Disregard the number of significant bits in the absolute value and use
    // a smaller bit width if possible.  But don't use the minimum bit width since this makes it hard to tell how many bits
    // there are at a glance (use only 8, 16, 32, or 64).
    size_t nbits = 0;
    if (offset > 0xffffffffll) {
        nbits = 64;
        retval += "+";
    } else if (offset > 0xffffll) {
        nbits = 32;
        retval += "+";
    } else if (offset > 0xffll) {
        nbits = 16;
        retval += "+";
    } else if (offset > 9) {
        nbits = 8;
        retval += "+";
    } else if (offset > 0) {
        char buf[64];
        snprintf(buf, sizeof buf, "+%"PRId64, offset);
        retval += buf;
    } else if (offset==0) {
        /*void*/
    } else if (-offset > 0xffffffffll) {
        nbits = 64;
        offset = -offset;
        retval += "-";
    } else if (-offset > 0xffffll) {
        nbits = 32;
        offset = -offset;
        retval += "-";
    } else if (-offset > 0xffll) {
        nbits = 16;
        offset = -offset;
        retval += "-";
    } else if (-offset > 9) {
        nbits = 8;
        offset = -offset;
        retval += "-";
    } else {
        char buf[64];
        snprintf(buf, sizeof buf, "%"PRId64, offset);
        retval += buf;
    }
    if (nbits!=0)
        retval += StringUtility::addrToString(offset, nbits);

    return retval;
}

void
SgAsmIntegerValueExpression::set_significant_bits(size_t nbits)
{
    assert(nbits>0 && nbits<=64); // usual values are 8, 16, 32, and 64
    p_significant_bits = nbits;
}

size_t
SgAsmIntegerValueExpression::get_significant_bits() const
{
    return p_significant_bits;
}

void
SgAsmIntegerValueExpression::make_relative_to(SgNode *base_node)
{
    uint64_t cur_value = get_absolute_value();
    uint64_t base_va = virtual_address(base_node);
    set_base_node(base_node);
    set_relative_value(cur_value - base_va);    // mod 2^64
}

uint64_t
SgAsmIntegerValueExpression::get_base_address() const
{
    return virtual_address(get_base_node());
}

uint64_t
SgAsmIntegerValueExpression::get_absolute_value(size_t nbits) const
{
    if (0==nbits)
        nbits = get_significant_bits();
    uint64_t retval = get_base_address() + get_relative_value();
    uint64_t mask = IntegerOps::genMask<uint64_t>(nbits);
    return retval & mask; // clear high-order bits
}

int64_t
SgAsmIntegerValueExpression::get_signed_value() const
{
    size_t nbits = get_significant_bits();
    uint64_t u = (get_base_address() + get_relative_value()) & IntegerOps::genMask<uint64_t>(nbits);
    uint64_t retval = IntegerOps::signExtend2(u, nbits, 64);
    return (int64_t)retval;
}

void
SgAsmIntegerValueExpression::set_absolute_value(uint64_t v)
{
    uint64_t new_offset = v - get_base_address(); // mod 2^64
    set_relative_value(new_offset);
}