TPEFDisassembler Class Reference

#include <TPEFDisassembler.hh>

Collaboration diagram for TPEFDisassembler:

Public Member Functions
	TPEFDisassembler (const TPEF::Binary &aTpef)
virtual	~TPEFDisassembler ()
virtual DisassemblyInstruction *	createInstruction (Word instructionIndex) const
virtual Word	startAddress () const
virtual Word	instructionCount () const
void	clearCache () const

Protected Types
typedef std::pair< Word, Word >	ImmediateKey
typedef std::map< ImmediateKey, TPEF::ImmediateElement * >	ImmediateMap

Protected Member Functions
void	initCache () const
DisassemblyElement *	createDisassemblyElement (TPEF::MoveElement::FieldType type, Word unit, Word index, ImmediateMap &immediateMap) const

Private Attributes
const TPEF::Binary *	tpef_
	Binary where data for disassembler is retrieved.
std::vector< Word >	instructionStartCache_
	Cache of starting elements of instructions.

Detailed Description

TPEF Disassembler.

Retrievs data from TPEF and builds Disassembler instructions out of TPEF hierarchy.

Contains internal cache to speedup instruction fetching, so if instruction ordering of TPEF is changed cache will not be valid anymore and must be cleared.

NOTE: Class disassembles only the first of code sections in binary.

Definition at line 58 of file TPEFDisassembler.hh.

Member Typedef Documentation

ImmediateKey

typedef std::pair<Word,Word> TPEFDisassembler::ImmediateKey

protected

Definition at line 72 of file TPEFDisassembler.hh.

ImmediateMap

typedef std::map<ImmediateKey, TPEF::ImmediateElement*> TPEFDisassembler::ImmediateMap

protected

Definition at line 73 of file TPEFDisassembler.hh.

Constructor & Destructor Documentation

TPEFDisassembler()

TPEFDisassembler::TPEFDisassembler

(

const TPEF::Binary &

aTpef

)

Constructor.

Parameters

aTpef

TPEF hierarchy whose code sections are disassembled.

Definition at line 70 of file TPEFDisassembler.cc.

                                                      :
    tpef_(&aTpef) {
}

~TPEFDisassembler()

TPEFDisassembler::~TPEFDisassembler ( )

virtual

Destructor.

Definition at line 77 of file TPEFDisassembler.cc.

                                    {
}

Member Function Documentation

clearCache()

void TPEFDisassembler::clearCache

(

)

const

Clears internal cache of instruction start indexes in TPEF code section.

If you modify order or begin flags of instruction elements in TPEF, chache should be cleared, because instruction start indexes might be changed.

Definition at line 296 of file TPEFDisassembler.cc.

                                   {
    instructionStartCache_.clear();
}

References instructionStartCache_.

createDisassemblyElement()

DisassemblyElement * TPEFDisassembler::createDisassemblyElement ( TPEF::MoveElement::FieldType  type, Word  unit, Word  index, ImmediateMap &  immediateMap  ) const

protected

Creates DisassemblyElement out of given paramters.

Finds needed strings and stuff from TPEF hierarchy.

Parameters

type	Type of elemet to create.
unit	Unit id of referred resource.
index	Index part of referred resource.
immediateMap	All immediate values found in instruction.

Returns

Dynamically allocated fully contructed DisassemblerElement.

Definition at line 334 of file TPEFDisassembler.cc.

                                      {
 
    ResourceSection *resources =
        dynamic_cast<ResourceSection*>(tpef_->section(Section::ST_MR,0));
 
    assert(resources != NULL);
 
    StringSection *strings =
        dynamic_cast<StringSection*>(resources->link());
 
    switch (type) {
 
    case MoveElement::MF_RF: {
        if (unit & ResourceElement::UNIVERSAL_RF_MASK) {
            switch (unit) {
            case ResourceElement::INT_RF:
                return  new DisassemblyIntRegister(index);
            case ResourceElement::BOOL_RF:
                // only one boolean register for now
                assert(index == 0);
                return  new DisassemblyBoolRegister();
            case ResourceElement::FP_RF:
                return  new DisassemblyFPRegister(index);
            default:
                // Error: not universal unit
                assert(false);
            }
        } else {
            // real resources from real machines
            ResourceElement &rfUnit =
                resources->findResource(ResourceElement::MRT_RF,unit);
 
            std::string rfName = strings->chunk2String(rfUnit.name());
 
            return new DisassemblyRegister(rfName, index);
        }
 
    } break;
 
    case MoveElement::MF_IMM: {
        ImmediateKey  immKey(unit, index);
 
        if (MapTools::containsKey(immediateMap, immKey)) {
 
            ImmediateElement *imm =
                MapTools::valueForKey<ImmediateElement*>(immediateMap, immKey);
 
            assert(imm->isInline());
 
            SimValue immValue(64);
            immValue = imm->sLongWord();
            return new DisassemblyImmediate(immValue, false);
 
        } else {
            // register reference to immediate register.
 
            // get that immediate unit
            ResourceElement &immUnit =
                resources->findResource(ResourceElement::MRT_IMM, unit);
 
            std::string immUnitName = strings->chunk2String(immUnit.name());
 
            return new DisassemblyImmediateRegister(immUnitName, index);
        }
 
    } break;
 
    case MoveElement::MF_UNIT: {
 
        if (unit == ResourceElement::UNIVERSAL_FU) {
 
            // TODO refactor
 
            if (resources->hasResource(
                    ResourceElement::MRT_OP, index)) {
 
                ResourceElement resource =
                    resources->findResource(
                        ResourceElement::MRT_OP, index);
 
                std::string opString  =
                    strings->chunk2String(resource.name());
 
                std::string::size_type dotIndex = opString.rfind('.');
                std::string opName = opString.substr(0,dotIndex);
 
                // move dotIndex to start of regnumber part of operation
                dotIndex++;
 
                std::string opIndexStr = opString.substr(
                    dotIndex, opString.length() - dotIndex);
 
                Word opIndex = Conversion::toInt(opIndexStr);
 
                return new DisassemblyOperand(opName, opIndex);
 
            } else if (resources->hasResource(
                           ResourceElement::MRT_SR, index)) {
 
                ResourceElement &resource =
                    resources->findResource(
                        ResourceElement::MRT_SR, index);
 
                std::string regName = strings->chunk2String(resource.name());
 
                if (regName == ResourceElement::RETURN_ADDRESS_NAME) {
                    return new DisassemblyReturnAddressRegister();
 
                } else {
                    abortWithError("Unknown special register");
                }
 
            } else {
                abortWithError(
            "Can't find universal operand or special register "
            "resource by index:" + Conversion::toString(index));
            }
 
        } else {
            // terminal types fuName.portName or fuName.opName.index
        // not universal FU, which has no fuName field
 
            // get FU name
            ResourceElement &fuResource =
                resources->findResource(ResourceElement::MRT_UNIT, unit);
 
            std::string fuName = strings->chunk2String(fuResource.name());
 
            // TODO refactor
            if (resources->hasResource(
                    ResourceElement::MRT_PORT, index)) {
 
                ResourceElement &fuPort =
                    resources->findResource(ResourceElement::MRT_PORT, index);
 
                std::string fuPortName =
                    strings->chunk2String(fuPort.name());
 
                return new DisassemblyFUPort(fuName, fuPortName);
 
            } else if (resources->hasResource(
                           ResourceElement::MRT_OP, index)) {
 
                ResourceElement &fuOperationOperand =
                    resources->findResource(ResourceElement::MRT_OP, index);
 
                std::string operandString =
                    strings->chunk2String(fuOperationOperand.name());
 
                std::string::size_type dotPos = operandString.rfind(".");
 
                assert(dotPos != std::string::npos);
 
                std::string opName = operandString.substr(0, dotPos);
 
                std::string operandIndexString =
                    operandString.substr(
                        dotPos+1, operandString.length() - dotPos - 1);
 
                Word operandIndex =
            Conversion::toUnsignedInt(operandIndexString);
 
                return new DisassemblyFUOperand(fuName, opName, operandIndex);
 
            } else if (resources->hasResource(
                           ResourceElement::MRT_SR, index)) {
 
                ResourceElement &fuSpecialRegister =
                    resources->findResource(ResourceElement::MRT_SR, index);
 
                std::string srName =
                    strings->chunk2String(fuSpecialRegister.name());
 
                return new DisassemblyFUPort(fuName, srName);
 
            } else {
                abortWithError(
            "Can't find real port, operation or special register by "
            "index: " + Conversion::toString(index));
            }
        }
 
    } break;
 
    default:
        abortWithError("Unknown type: " + Conversion::toString((int)type));
    }
 
    assert(false);
    return NULL;
}

References abortWithError, assert, TPEF::ResourceElement::BOOL_RF, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TPEF::ResourceSection::findResource(), TPEF::ResourceElement::FP_RF, TPEF::ResourceSection::hasResource(), TPEF::ResourceElement::INT_RF, TPEF::ImmediateElement::isInline(), MapTools::keyForValue(), TPEF::Section::link(), TPEF::MoveElement::MF_IMM, TPEF::MoveElement::MF_RF, TPEF::MoveElement::MF_UNIT, TPEF::ResourceElement::MRT_IMM, TPEF::ResourceElement::MRT_OP, TPEF::ResourceElement::MRT_PORT, TPEF::ResourceElement::MRT_RF, TPEF::ResourceElement::MRT_SR, TPEF::ResourceElement::MRT_UNIT, TPEF::ResourceElement::name(), TPEF::ResourceElement::RETURN_ADDRESS_NAME, TPEF::Binary::section(), TPEF::ImmediateElement::sLongWord(), TPEF::Section::ST_MR, Conversion::toInt(), Conversion::toString(), Conversion::toUnsignedInt(), tpef_, TPEF::ResourceElement::UNIVERSAL_FU, and TPEF::ResourceElement::UNIVERSAL_RF_MASK.

Referenced by createInstruction().

Here is the call graph for this function:

createInstruction()

DisassemblyInstruction * TPEFDisassembler::createInstruction ( Word  instructionIndex ) const

virtual

Creates dynamically allocated disassembler instruction.

Parameters

instructionIndex

Number of instruction to return.

Returns

Dynamically allocated disassembler instruction.

Definition at line 87 of file TPEFDisassembler.cc.

                                                               {
 
    CodeSection *theCodeSection =
        dynamic_cast<CodeSection*>(tpef_->section(Section::ST_CODE,0));
 
    assert(theCodeSection != NULL);
 
    if (instructionStartCache_.empty()) {
        initCache();
    }
 
    Word currIndex = instructionStartCache_[instructionIndex];
 
    InstructionElement *currElement =
        dynamic_cast<InstructionElement*>(
            theCodeSection->element(currIndex));
 
    DisassemblyInstruction *newInstruction = new DisassemblyInstruction();
 
    // scan all elements in first pass, because we want to have also
    // immediates when we build instructions
    ImmediateMap immediates;
    std::vector<MoveElement*> moves;
 
    do {
        if (currElement->isMove()) {
            MoveElement *move = dynamic_cast<MoveElement*>(currElement);
            assert (move != NULL);
            moves.push_back(move);
 
        } else if (currElement->isImmediate()) {
            ImmediateElement *imm =
                dynamic_cast<ImmediateElement*>(currElement);
 
            assert (imm != NULL);
 
            if (imm->isInline()) {
                ImmediateKey
                    immKey(imm->destinationUnit(), imm->destinationIndex());
 
                immediates[immKey] = imm;
 
            } else {
                // this is long immediate
                DisassemblyElement* dest =
                    createDisassemblyElement(MoveElement::MF_IMM,
                                             imm->destinationUnit(),
                                             imm->destinationIndex(),
                                             immediates);
                
                SimValue immValue(64);
                immValue = imm->longWord();
 
                // do not know if unit is signed or not without adf
                DisassemblyImmediateAssignment* immAssign = 
                    new DisassemblyImmediateAssignment(immValue, false, dest);
                               
                // add annotationes for the move
                for (Word j = 0; j < imm->annotationCount(); j++) {
                    InstructionAnnotation& ann = *(imm->annotation(j));
                    immAssign->addAnnotation(
                        new DisassemblyAnnotation(ann.id(), ann.payload()));
                }
                
                newInstruction->addLongImmediate(immAssign);
            }
 
        } else {
            assert(false);
        }
 
        currIndex++;
 
        // if we reached end of section
        if (currIndex == theCodeSection->elementCount()) {
            break;
        }
 
        currElement = dynamic_cast<InstructionElement*>(
            theCodeSection->element(currIndex));
 
    } while (!currElement->begin());
 
    // find out how many busses tpef have.
    ResourceSection* resources = dynamic_cast<ResourceSection*>(
        tpef_->section(Section::ST_MR, 0));
 
    assert(resources != NULL);
 
    std::vector<DisassemblyInstructionSlot*> organizedInstr;
 
    for (Word i = 0; i < resources->elementCount(); i++) {
        ResourceElement* resource =
            dynamic_cast<ResourceElement*>(resources->element(i));
 
        if (resource->type() == ResourceElement::MRT_BUS &&
            resource->id() != ResourceElement::UNIVERSAL_BUS) {
 
            organizedInstr.push_back(NULL);
        }
    }
 
    for (unsigned int i = 0; i < moves.size(); i++) {
        MoveElement *currMove = moves[i];
 
        if (!currMove->isEmpty()) {
            DisassemblyElement *source =
                createDisassemblyElement(currMove->sourceType(),
                                         currMove->sourceUnit(),
                                         currMove->sourceIndex(),
                                         immediates);
 
            DisassemblyElement *destination =
                createDisassemblyElement(currMove->destinationType(),
                                         currMove->destinationUnit(),
                                         currMove->destinationIndex(),
                                         immediates);
 
            DisassemblyGuard *guard = NULL;
 
            if (currMove->isGuarded()) {
                DisassemblyElement *guardElement =
                    createDisassemblyElement(currMove->guardType(),
                                             currMove->guardUnit(),
                                             currMove->guardIndex(),
                                             immediates);
 
                guard = new DisassemblyGuard(
                    guardElement, currMove->isGuardInverted());
            }
 
            DisassemblyMove *newMove =
                new DisassemblyMove(source, destination, guard);
 
            // add annotationes for the move
            for (Word j = 0; j < currMove->annotationCount(); j++) {
                InstructionAnnotation& ann = *(currMove->annotation(j));
                newMove->addAnnotation(
                    new DisassemblyAnnotation(ann.id(), ann.payload()));
            }
 
            // add unassigned moves to end of instruction
            if (currMove->bus() > 0) {
                organizedInstr[currMove->bus() - 1] = newMove;
            } else {
                organizedInstr.push_back(newMove);
            }
        } else {
            // empty move element. NOP?
            // add annotationes for the move
            for (Word j = 0; j < currMove->annotationCount(); j++) {
                InstructionAnnotation& ann = *(currMove->annotation(j));
                newInstruction->addAnnotation(
                    new DisassemblyAnnotation(ann.id(), ann.payload()));
            }
        }
    }
 
    // create all moves and add them to disassembler instruction
    for (Word i = 0; i < organizedInstr.size(); i++) {
 
        if (organizedInstr[i] != NULL) {
            newInstruction->addMove(organizedInstr[i]);
 
        } else {
            DisassemblyNOP *newNOP = new DisassemblyNOP();
            newInstruction->addMove(newNOP);
        }
    }
 
    return newInstruction;
}

References DisassemblyInstruction::addAnnotation(), DisassemblyInstructionSlot::addAnnotation(), DisassemblyInstruction::addLongImmediate(), DisassemblyInstruction::addMove(), TPEF::InstructionElement::annotation(), TPEF::InstructionElement::annotationCount(), assert, TPEF::InstructionElement::begin(), TPEF::MoveElement::bus(), createDisassemblyElement(), TPEF::ImmediateElement::destinationIndex(), TPEF::MoveElement::destinationIndex(), TPEF::MoveElement::destinationType(), TPEF::ImmediateElement::destinationUnit(), TPEF::MoveElement::destinationUnit(), TPEF::CodeSection::element(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::MoveElement::guardIndex(), TPEF::MoveElement::guardType(), TPEF::MoveElement::guardUnit(), TPEF::InstructionAnnotation::id(), TPEF::ResourceElement::id(), initCache(), instructionStartCache_, TPEF::MoveElement::isEmpty(), TPEF::MoveElement::isGuarded(), TPEF::MoveElement::isGuardInverted(), TPEF::InstructionElement::isImmediate(), TPEF::ImmediateElement::isInline(), TPEF::InstructionElement::isMove(), TPEF::ImmediateElement::longWord(), TPEF::MoveElement::MF_IMM, TPEF::ResourceElement::MRT_BUS, TPEF::InstructionAnnotation::payload(), TPEF::Binary::section(), TPEF::MoveElement::sourceIndex(), TPEF::MoveElement::sourceType(), TPEF::MoveElement::sourceUnit(), TPEF::Section::ST_CODE, TPEF::Section::ST_MR, tpef_, TPEF::ResourceElement::type(), and TPEF::ResourceElement::UNIVERSAL_BUS.

Referenced by TPEFDumper::section().

Here is the call graph for this function:

initCache()

void TPEFDisassembler::initCache ( ) const

protected

Initilises instruction start indexes in code section to vector.

After cache init we have vector of all instruction start indexes of the section.

Definition at line 307 of file TPEFDisassembler.cc.

                                  {
    CodeSection *theCodeSection =
    dynamic_cast<CodeSection*>(tpef_->section(Section::ST_CODE,0));
 
    assert(theCodeSection != NULL);
 
    for (Word i = 0; i < theCodeSection->elementCount(); i++) {
        if (dynamic_cast<InstructionElement*>(
                theCodeSection->element(i))->begin()) {
            // if i is begin of instruction push it to instruction start vector
            instructionStartCache_.push_back(i);
        }
    }
}

References assert, TPEF::InstructionElement::begin(), TPEF::CodeSection::element(), TPEF::Section::elementCount(), instructionStartCache_, TPEF::Binary::section(), TPEF::Section::ST_CODE, and tpef_.

Referenced by createInstruction(), and instructionCount().

Here is the call graph for this function:

instructionCount()

Word TPEFDisassembler::instructionCount ( ) const

virtual

Number of instructions available in first code section of TPEF.

Returns

Number of instruction available.

Definition at line 280 of file TPEFDisassembler.cc.

                                         {
    if (instructionStartCache_.empty()) {
    initCache();
    }
    return instructionStartCache_.size();
}

References initCache(), and instructionStartCache_.

Referenced by TPEFDumper::section().

Here is the call graph for this function:

startAddress()

Word TPEFDisassembler::startAddress ( ) const

virtual

Address of first instruction.

Returns

Address of first instruction.

Definition at line 266 of file TPEFDisassembler.cc.

                                     {
    CodeSection *theCodeSection =
    dynamic_cast<CodeSection*>(tpef_->section(Section::ST_CODE,0));
 
    assert(theCodeSection != NULL);
    return theCodeSection->startingAddress();
}

References assert, TPEF::Binary::section(), TPEF::Section::ST_CODE, TPEF::Section::startingAddress(), and tpef_.

Referenced by TPEFDumper::section().

Here is the call graph for this function:

Member Data Documentation

instructionStartCache_

std::vector<Word> TPEFDisassembler::instructionStartCache_

mutableprivate

Cache of starting elements of instructions.

Definition at line 86 of file TPEFDisassembler.hh.

Referenced by clearCache(), createInstruction(), initCache(), and instructionCount().

tpef_

const TPEF::Binary* TPEFDisassembler::tpef_

private

Binary where data for disassembler is retrieved.

Definition at line 83 of file TPEFDisassembler.hh.

Referenced by createDisassemblyElement(), createInstruction(), initCache(), and startAddress().

---

The documentation for this class was generated from the following files:

• TPEFDisassembler.hh
• TPEFDisassembler.cc