SgAsmInstruction.C

Go to the documentation of this file.

/* SgAsmInstruction member definitions.  Do not move them to src/ROSETTA/Grammar/BinaryInstruction.code (or any *.code file)
 * because then they won't get indexed/formatted/etc. by C-aware tools. */

#include "sage3basic.h"

std::set<rose_addr_t>
SgAsmInstruction::get_successors(bool *complete) {
    abort();
    // tps (12/9/2009) : MSC requires a return value
    std::set<rose_addr_t> t;
    return t;
}

std::set<rose_addr_t>
SgAsmInstruction::get_successors(const std::vector<SgAsmInstruction*>& basic_block, bool *complete/*out*/,
                                 MemoryMap *initial_memory/*=NULL*/)
{
    if (basic_block.size()==0) {
        if (complete) *complete = true;
        return std::set<rose_addr_t>();
    }
    return basic_block.back()->get_successors(complete);
}

bool
SgAsmInstruction::terminates_basic_block()
{
    abort();
    // tps (12/9/2009) : MSC requires a return value
    return false;
}

bool
SgAsmInstruction::is_function_call(const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *return_va)
{
    return false;
}

bool
SgAsmInstruction::is_function_return(const std::vector<SgAsmInstruction*>&)
{
    return false;
}

bool
SgAsmInstruction::is_first_in_block()
{
    SgAsmBlock *bb = SageInterface::getEnclosingNode<SgAsmBlock>(this);
    if (bb) {
        const SgAsmStatementPtrList &stmts = bb->get_statementList();
        for (size_t i=0; i<stmts.size(); ++i) {
            if (SgAsmInstruction *insn = isSgAsmInstruction(stmts[i]))
                return insn==this;
        }
    }
    return false;
}

bool
SgAsmInstruction::is_last_in_block()
{
    SgAsmBlock *bb = SageInterface::getEnclosingNode<SgAsmBlock>(this);
    if (bb) {
        const SgAsmStatementPtrList &stmts = bb->get_statementList();
        for (size_t i=stmts.size(); i>0; --i) {
            if (SgAsmInstruction *insn = isSgAsmInstruction(stmts[i-1]))
                return insn==this;
        }
    }
    return false;
}

bool
SgAsmInstruction::get_branch_target(rose_addr_t *target/*out*/) {
    return false;
}

bool
SgAsmInstruction::has_effect()
{
    return true;
}

bool
SgAsmInstruction::has_effect(const std::vector<SgAsmInstruction*>&, bool allow_branch/*false*/,
                             bool relax_stack_semantics/*false*/)
{
    return true;
}

std::vector<std::pair<size_t,size_t> >
SgAsmInstruction::find_noop_subsequences(const std::vector<SgAsmInstruction*>& insns, bool allow_branch/*false*/, 
                                         bool relax_stack_semantics/*false*/)
{
    std::vector<std::pair<size_t, size_t> > retval;
    return retval;
}

size_t
SgAsmInstruction::get_size() const
{
    return p_raw_bytes.size();
}

bool
SgAsmInstruction::is_unknown() const
{
    abort(); // too bad ROSETTA doesn't allow virtual base classes
    return false;
}