#include <TPEFDumper.hh>

Collaboration diagram for TPEFDumper:

Public Member Functions
	TPEFDumper (TPEF::Binary &tpef, std::ostream &out)

virtual	~TPEFDumper ()

void	setOnlyLogical (bool flag)

bool	onlyLogical () const

void	fileHeaders ()

void	sectionHeaders ()

void	memoryInfo ()

void	relocationTables ()

void	symbolTables ()

void	section (Word sectionIndex)

Private Member Functions
void	createLogicalIndexes ()

Word	actualIndex (Word logicalIndex) const

std::string	sectionHeader ()

std::string	sectionHeader (TPEF::Section &sect, bool noIndex=false)

void	section (TPEF::Section &sect)

int	findSectionIndex (TPEF::Section &sect)

int	findElementIndex (TPEF::Section &sect, TPEF::SectionElement &elem)

std::string	sectionString (TPEF::Section &sect, bool shortForm=false)

std::string	addressSpaceString (TPEF::ASpaceElement &aSpace)

std::string	symbolString (TPEF::Section &sect, TPEF::SymbolElement &sym)

std::string	sectionTypeString (TPEF::Section::SectionType type, bool shortForm=false)

std::string	fileArchString (TPEF::Binary::FileArchitecture arch)

std::string	debugElementTypeString (TPEF::DebugElement::ElementType type)

std::string	fileTypeString (TPEF::Binary::FileType type)

std::string	symbolTypeString (TPEF::SymbolElement::SymbolType type)

std::string	symbolBindString (TPEF::SymbolElement::SymbolBinding bind)

std::string	relocTypeString (TPEF::RelocElement::RelocType type)

std::string	resourceTypeString (TPEF::ResourceElement::ResourceType type)

std::string	resourceIdString (HalfWord id, TPEF::ResourceElement::ResourceType type)

void	dumpStringSet (std::set< std::string > &aSet) const

Private Attributes
std::vector< Word >	actualIndexes_

TPEF::Binary &	tpef_

std::ostream &	out_

bool	onlyLogicalInfo_

Detailed Description

Outputs TPEF hierarchy in textual form.

Definition at line 51 of file TPEFDumper.hh.

Constructor & Destructor Documentation

◆ TPEFDumper()

TPEFDumper::TPEFDumper	(	TPEF::Binary &	tpef,
		std::ostream &	out
	)

Constructor.

Definition at line 95 of file TPEFDumper.cc.

                                                    :
    tpef_(tpef), out_(out), onlyLogicalInfo_(false) {
}

◆ ~TPEFDumper()

TPEFDumper::~TPEFDumper ( )

virtual

Destructor.

Definition at line 102 of file TPEFDumper.cc.

102 {

103}

Member Function Documentation

◆ actualIndex()

Word TPEFDumper::actualIndex ( Word origIndex ) const

private

Converts index to print sections in logical order, if onlyLogical() is set.

Parameters

Requested index of section.

Returns: Converted or same index that in parameter.

Definition at line 137 of file TPEFDumper.cc.

                                            {
    if (onlyLogical()) {
        return actualIndexes_[origIndex];
    } else {
        return origIndex;
    }
}

References actualIndexes_, and onlyLogical().

Referenced by findSectionIndex(), memoryInfo(), relocationTables(), section(), sectionHeaders(), and symbolTables().

Here is the call graph for this function:

◆ addressSpaceString()

std::string TPEFDumper::addressSpaceString ( TPEF::ASpaceElement & aSpace )

private

Returns address space element in human readable form.

Parameters

aSpace Address space to convert.

Returns: Address space string.

Definition at line 1320 of file TPEFDumper.cc.

                                                    {
 
    ASpaceSection* aSpaces = dynamic_cast<ASpaceSection*>(
        tpef_.section(Section::ST_ADDRSP,0));
 
    assert(aSpaces != NULL);
 
    StringSection* strings = dynamic_cast<StringSection*>(aSpaces->link());
    assert(strings != NULL);
 
    std::string str;
    if (aSpaces->isUndefined(&aSpace)) {
        str = "undefined";
    } else {
        // find index
        int aSpaceIndex = findElementIndex(*aSpaces, aSpace);
 
        assert(aSpaceIndex != -1);
 
        if (!onlyLogical()) {
            str = Conversion::toString(aSpaceIndex) + ":";
        }
 
        str +=
            Conversion::toString(static_cast<Word>(aSpace.MAU())) + "bit:" +
            Conversion::toString(static_cast<Word>(aSpace.align())) + ":" +
            Conversion::toString(static_cast<Word>(aSpace.wordSize()));
    }
 
    return str;
}

References TPEF::ASpaceElement::align(), assert, findElementIndex(), TPEF::ASpaceSection::isUndefined(), TPEF::Section::link(), TPEF::ASpaceElement::MAU(), onlyLogical(), TPEF::Binary::section(), Conversion::toString(), tpef_, and TPEF::ASpaceElement::wordSize().

Referenced by section(), and sectionHeader().

Here is the call graph for this function:

◆ createLogicalIndexes()

void TPEFDumper::createLogicalIndexes ( )

private

Organizes sections alphabetically and creates index table.

NOTE: method does not work if there is two sections with same header string (very rare).

Definition at line 112 of file TPEFDumper.cc.

                                 {
 
    std::map<std::string, Word> organizedSections;
 
    for (Word i = 0; i < tpef_.sectionCount(); i++) {
        Section *sect = tpef_.section(i);
        organizedSections[sectionHeader(*sect, true)] = i;
    }
 
    for (std::map<std::string, Word>::iterator
             iter = organizedSections.begin();
         iter != organizedSections.end();
         iter++) {
 
        actualIndexes_.push_back((*iter).second);
    }
}

References actualIndexes_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), sectionHeader(), and tpef_.

Referenced by setOnlyLogical().

Here is the call graph for this function:

◆ debugElementTypeString()

std::string TPEFDumper::debugElementTypeString ( TPEF::DebugElement::ElementType type )

private

Returns debug element type string in human readable form.

Parameters

type	Type id to convert.convert.

Returns: Type in string form.

Definition at line 1135 of file TPEFDumper.cc.

                                                               {
 
    std::string str;
 
    switch (type) {
    case DebugElement::DE_STAB:  str = "STAB";  break;
    default: str = "UNKNOWN";
    }
 
    return str;
}

Referenced by section().

◆ dumpStringSet()

void TPEFDumper::dumpStringSet ( std::set< std::string > & aSet ) const

private

Dumps a set of strings to output stream.

Clears dumped set.

Parameters

set	Set of strings to print.

Definition at line 1385 of file TPEFDumper.cc.

                                                       {
    typedef std::set<std::string>::iterator StrSetIter;
    for (StrSetIter iter = aSet.begin(); iter != aSet.end(); iter++) {
        out_ << *iter << std::endl;
    }
    aSet.clear();
}

References out_.

Referenced by section().

◆ fileArchString()

std::string TPEFDumper::fileArchString ( TPEF::Binary::FileArchitecture arch )

private

Returns file architecture type in human readable form.

Parameters

arch	Architecture id to convert.

Returns: Architecture id string.

Definition at line 1113 of file TPEFDumper.cc.

                                                      {
 
    std::string str;
 
    switch (arch) {
    case Binary::FA_NOARCH:  str = "NOARCH";  break;
    case Binary::FA_TTA_MOVE:str = "TTA_MOVE";break;
    case Binary::FA_TTA_TUT: str = "TTA_TUT"; break;
    case Binary::FA_TDS_TI:  str = "TDS_TI";  break;
    default: str = "UNKNOWN";
    }
 
    return str + " (" + Conversion::toHexString(arch, 2) + ")";
}

References Conversion::toHexString().

Referenced by fileHeaders().

Here is the call graph for this function:

◆ fileHeaders()

void TPEFDumper::fileHeaders ( )

Prints file headers.

Definition at line 181 of file TPEFDumper.cc.

                        {
 
    // generate string for strings() field of binary
    int strSectionIndex = findSectionIndex(*tpef_.strings());
    std::string strIndexString;
 
    if (strSectionIndex != -1) {
        strIndexString = Conversion::toString(strSectionIndex);
    } else if (tpef_.strings() == NULL) {
        strIndexString = "No strings section defined";
    } else {
        strIndexString = "INVALID TPEF: String section was not found.";
    }
 
    out_ << std::left
         << std::setw(20) << "Section count: " << tpef_.sectionCount()
         << std::endl
         << std::setw(20) << "String section: " << sectionString(*tpef_.strings(), false)
         << std::endl
         << std::setw(20) << "File architecture: "
         << fileArchString(tpef_.arch()) << std::endl
         << std::setw(20) << "File type: " << fileTypeString(tpef_.type())
         << std::endl << std::endl;
}

References TPEF::Binary::arch(), fileArchString(), fileTypeString(), findSectionIndex(), out_, TPEF::Binary::sectionCount(), sectionString(), TPEF::Binary::strings(), Conversion::toString(), tpef_, and TPEF::Binary::type().

Referenced by main().

Here is the call graph for this function:

◆ fileTypeString()

std::string TPEFDumper::fileTypeString ( TPEF::Binary::FileType type )

private

Returns file type in human readable form.

Parameters

type	File type id to convert.

Returns: File type id string.

Definition at line 1154 of file TPEFDumper.cc.

                                              {
 
    std::string str;
 
    switch (type) {
    case Binary::FT_NULL:    str = "UNDEF";   break;
    case Binary::FT_OBJSEQ:  str = "OBJSEQ";  break;
    case Binary::FT_PURESEQ: str = "PURESEQ"; break;
    case Binary::FT_LIBSEQ:  str = "LIBSEQ";  break;
    case Binary::FT_MIXED:   str = "MIXED";   break;
    case Binary::FT_PARALLEL:str = "PARALLEL";break;
    default: str = "UNKNOWN";
    }
 
    return str + " (" + Conversion::toHexString(type, 2) + ")";
}

References Conversion::toHexString().

Referenced by fileHeaders().

Here is the call graph for this function:

◆ findElementIndex()

int TPEFDumper::findElementIndex	(	TPEF::Section &	sect,
		TPEF::SectionElement &	elem
	)

private

Returns index of element.

If element is not found from section returns -1.

Parameters

sect	Section which contains the element.
elem	Element whose index is returned.

Returns: Index of element or error code.

Definition at line 1053 of file TPEFDumper.cc.

                                                                {
    int index = 0;
 
    while (static_cast<Word>(index) < sect.elementCount() &&
           sect.element(index) != &elem) {
        index++;
    }
 
    if (static_cast<Word>(index) < sect.elementCount()) {
        return index;
    } else {
        return -1;
    }
}

References TPEF::Section::element(), and TPEF::Section::elementCount().

Referenced by addressSpaceString(), and symbolString().

Here is the call graph for this function:

◆ findSectionIndex()

int TPEFDumper::findSectionIndex ( TPEF::Section & sect )

private

Returns index of section.

If section is not found from tpef returns -1.

Parameters

sect	Section whose index is returned.

Returns: Index of section or error code.

Definition at line 1023 of file TPEFDumper.cc.

                                          {
 
    int index = 0;
    while (static_cast<Word>(index) < tpef_.sectionCount() &&
           tpef_.section(index) != &sect) {
 
        index++;
    }
 
    if (static_cast<Word>(index) < tpef_.sectionCount()) {
        for (Word i = 0; i < tpef_.sectionCount(); i++) {
            if (actualIndex(i) == static_cast<Word>(index)) {
                return i;
            }
        }
    }
 
    return -1;
}

References actualIndex(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), and tpef_.

Referenced by fileHeaders(), sectionHeader(), and sectionString().

Here is the call graph for this function:

◆ memoryInfo()

void TPEFDumper::memoryInfo ( )

Prints information about needed data address space sizes for initialized and uninitialized data.

Definition at line 232 of file TPEFDumper.cc.

                       {
    
    out_ << "Minimum sizes for address spaces:" << std::endl << std::endl;
 
    // map of used address spaces
    std::map<ASpaceElement*, std::pair<int, int> > neededMAUsOfASpace;
    // map telling if CODE and/or DATA memory is used in this aspace
    std::map<ASpaceElement*, std::pair<bool, bool> > typeOfMemNeeded;
    
    for (Word i = 0; i < tpef_.sectionCount(); i++) {
        Section& currSect = *tpef_.section(actualIndex(i));
 
        if (currSect.isProgramSection()) {
            
            // init new address space limits to 0,0
            if (neededMAUsOfASpace.find(currSect.aSpace()) == 
                neededMAUsOfASpace.end()) {
                
                neededMAUsOfASpace[currSect.aSpace()] = std::pair<int,int>(0,0);
                typeOfMemNeeded[currSect.aSpace()] = std::pair<bool,bool>(false,false);
            }
            
            std::pair<int,int> currentLimits = neededMAUsOfASpace[currSect.aSpace()];
            int currMin = currSect.startingAddress();
            int currMax = currMin;
            std::pair<bool,bool> currentMemtypes = typeOfMemNeeded[currSect.aSpace()];
            
            if (currSect.type() == Section::ST_CODE) {
                
                currMax += dynamic_cast<const CodeSection*>
                    (&currSect)->instructionCount();
                currentMemtypes.first = true;
                                                              
            } else if (currSect.type() == Section::ST_DATA ||
                       currSect.type() == Section::ST_UDATA ||
                       currSect.type() == Section::ST_LEDATA) {
 
                currMax += dynamic_cast<const UDataSection*>(
                    &currSect)->lengthInMAUs();
                currentMemtypes.second = true;
                
            } else {
                assert(false && "Unknown program section type");
            }
            
            // update limits to map
            if (currMin < currentLimits.first) {
                currentLimits.first = currMin;
            }
 
            if (currMax > currentLimits.second) {
                currentLimits.second = currMax;
            }
 
            neededMAUsOfASpace[currSect.aSpace()] = currentLimits;
            typeOfMemNeeded[currSect.aSpace()] = currentMemtypes;
        }
    }
    
    // print out in ASpace order...
    Section* aSpaces = tpef_.section(Section::ST_ADDRSP, 0);
    
    for (Word i = 0; i < aSpaces->elementCount(); i++) {
        ASpaceElement* aSpace = 
            dynamic_cast<ASpaceElement*>(aSpaces->element(i));
        
        if (neededMAUsOfASpace.find(aSpace) != neededMAUsOfASpace.end()) {
            int aSpaceSize =  
                neededMAUsOfASpace[aSpace].second - 
                neededMAUsOfASpace[aSpace].first;
 
            out_ <<  i << ":";
            if (typeOfMemNeeded[aSpace].first) out_ << " CODE";
            if (typeOfMemNeeded[aSpace].second) out_ << " DATA";
            out_ << ": " <<  aSpaceSize << " MAU(s)" << std::endl;
 
        } else {
            out_ << i << ": not used for data nor instructions." 
                 << std::endl;
        }
    }
 
    out_ << std::endl;
}

References actualIndex(), TPEF::Section::aSpace(), assert, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::Section::isProgramSection(), out_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::startingAddress(), tpef_, and TPEF::Section::type().

Referenced by main().

Here is the call graph for this function:

◆ onlyLogical()

bool TPEFDumper::onlyLogical ( ) const

Returns true if dumper is set to print only logical information.

See. setOnlyLogical for more information.

Returns: True if dumper is set to print only logical information.

Definition at line 173 of file TPEFDumper.cc.

                              {
    return onlyLogicalInfo_;
}

References onlyLogicalInfo_.

Referenced by actualIndex(), addressSpaceString(), section(), and symbolString().

◆ relocationTables()

void TPEFDumper::relocationTables ( )

Prints full information of every relocation table in tpef.

Definition at line 321 of file TPEFDumper.cc.

                             {
 
    for (Word i = 0; i < tpef_.sectionCount(); i++) {
        Section& currSect = *tpef_.section(actualIndex(i));
 
        if (currSect.type() == Section::ST_RELOC) {
            section(currSect);
        }
    }
}

References actualIndex(), TPEF::Binary::section(), section(), TPEF::Binary::sectionCount(), tpef_, and TPEF::Section::type().

Referenced by main().

Here is the call graph for this function:

◆ relocTypeString()

std::string TPEFDumper::relocTypeString ( TPEF::RelocElement::RelocType type )

private

Returns srelocation type in human readable form.

Parameters

type	Relocation type id to convert.

Returns: Relocation type id string.

Definition at line 1223 of file TPEFDumper.cc.

                                                      {
 
    std::string str;
 
    switch (type) {
    case RelocElement::RT_NOREL: str = "NOREL";  break;
    case RelocElement::RT_SELF:  str = "SELF";  break;
    case RelocElement::RT_PAGE:  str = "PAGE";  break;
    case RelocElement::RT_PCREL: str = "PCREL";  break;
    default: str = "UNKNOWN";
    }
 
    return str + " (" + Conversion::toHexString(type, 2) + ")";
}

References Conversion::toHexString().

Referenced by section().

Here is the call graph for this function:

◆ resourceIdString()

std::string TPEFDumper::resourceIdString	(	HalfWord	id,
		TPEF::ResourceElement::ResourceType	type
	)

private

Returns resource id in human readable form.

Parameters

id	Resource id to convert.
type	Resource type of id. (needed for conversion)

Returns: Resource id string.

Definition at line 1269 of file TPEFDumper.cc.

                                                                          {
    std::string str;
 
    switch (type) {
 
    case ResourceElement::MRT_UNIT:
    case ResourceElement::MRT_BUS: {
        if (id == 0) {
            str = "UNIVERSAL";
        }
    } break;
 
    case ResourceElement::MRT_RF: {
        if (id == 0) {
            str = "ILLEGAL";
        } else if (id == ResourceElement::INT_RF) {
            str = "UNIV_INT";
        } else if (id == ResourceElement::BOOL_RF) {
            str = "UNIV_BOOL";
        } else if (id == ResourceElement::FP_RF) {
            str = "UNIV_FP";
        } else if ((id&ResourceElement::UNIVERSAL_RF_MASK) != 0) {
            str = "UNIV_UNKNWN";
        }
    } break;
 
    case ResourceElement::MRT_IMM: {
        if (id == ResourceElement::INLINE_IMM) {
            str = "INLINE_IMM";
        }
 
    } break;
 
    default:
        return Conversion::toHexString(id, 4);
    }
 
    if (str != "") {
        return str + " (" + Conversion::toHexString(id, 2) + ")";
    } else {
        return Conversion::toHexString(id, 4);
    }
}

References Conversion::toHexString().

Referenced by section().

Here is the call graph for this function:

◆ resourceTypeString()

std::string TPEFDumper::resourceTypeString ( TPEF::ResourceElement::ResourceType type )

private

Returns resource type in human readable form.

Parameters

type	Resource type id to convert.

Returns: Resource type id string.

Definition at line 1245 of file TPEFDumper.cc.

                                                               {
    std::string str;
    switch (type) {
    case ResourceElement::MRT_NULL:str = "NULL";break;
    case ResourceElement::MRT_BUS: str = "BUS"; break;
    case ResourceElement::MRT_UNIT:str = "UNIT";break;
    case ResourceElement::MRT_RF:  str = "RF";  break;
    case ResourceElement::MRT_OP:  str = "OP";  break;
    case ResourceElement::MRT_IMM: str = "IMM"; break;
    case ResourceElement::MRT_SR:  str = "SR";  break;
    case ResourceElement::MRT_PORT:str = "PORT";break;
    default: str = "UNKNOWN";
    }
    return str + " (" + Conversion::toHexString(type, 2) + ")";
}

References Conversion::toHexString().

Referenced by section().

Here is the call graph for this function:

◆ section() [1/2]

void TPEFDumper::section ( TPEF::Section & sect )

private

Prints all information of requested section.

Parameters

sect	Section to print.

Definition at line 468 of file TPEFDumper.cc.

                                 {
 
    std::set<std::string> organizedElements;
 
    switch (sect.type()) {
    case Section::ST_SYMTAB: {
        out_ << "Symbol table:" << std::endl << std::endl;
        out_ << sectionHeader() << std::endl;;
        out_ << sectionHeader(sect) << std::endl;
 
        out_ << std::endl << std::left;
 
        if (!onlyLogical()) {
            out_ << std::setw(6)  << "index" << std::right;
        }
 
        out_ << std::setw(17) << "type" << std::right
             << std::setw(15) << "binding"
             << std::setw(10) << "absolute"
             << std::setw(12) << "owner"
             << std::setw(15) << "value"
             << std::left << "\tname"
             << std::endl << std::endl;
 
        StringSection* strings = dynamic_cast<StringSection*>(sect.link());
 
        for (Word i = 0; i < sect.elementCount(); i++) {
            SymbolElement* sym =
                dynamic_cast<SymbolElement*>(sect.element(i));
 
            std::string isAbso = (sym->absolute()) ? ("yes") : ("no");
 
            // resolve value
            std::string symValue;
            switch (sym->type()) {
            case SymbolElement::STT_NOTYPE: {
                symValue = "NONE";
            } break;
 
            case SymbolElement::STT_SECTION: {
                symValue = Conversion::toString(
                    dynamic_cast<SectionSymElement*>(sym)->value());
            } break;
 
            case SymbolElement::STT_FILE: {
                symValue = Conversion::toString(
                    dynamic_cast<FileSymElement*>(sym)->value());
            } break;
 
            case SymbolElement::STT_DATA: {
                UDataSection* uDataSect =
                    dynamic_cast<UDataSection*>(sym->section());
                assert(uDataSect != NULL);
 
                DataSymElement* dataSym =
                    dynamic_cast<DataSymElement*>(sym);
                assert(dataSym != NULL);
 
                symValue = Conversion::toString(
                    uDataSect->chunkToMAUIndex(dataSym->reference())) +
                    " U";
 
            } break;
 
            case SymbolElement::STT_CODE:
            case SymbolElement::STT_PROCEDURE: {
                CodeSection* codeSect =
                    dynamic_cast<CodeSection*>(sym->section());
 
                assert(codeSect != NULL);
 
                CodeSymElement* codeSym =
                    dynamic_cast<CodeSymElement*>(sym);
                assert(codeSym != NULL);
 
                symValue = Conversion::toString(
                    codeSect->indexOfElement(*codeSym->reference())) +
                    " E";
            } break;
 
 
            default:
                symValue = "Unknown symbol type!";
            };
 
            std::stringstream elemStr;
            elemStr << std::left;
 
            if (!onlyLogical()) {
                elemStr << std::setw(6)
                        << Conversion::toString(i) + ":"
                        << std::right;
            }
 
            elemStr << std::setw(17) << symbolTypeString(sym->type())
                    << std::right
                    << std::setw(15)
                    << symbolBindString(sym->binding())
                    << std::setw(10) << isAbso
                    << std::setw(12)
                    << sectionString(*sym->section(), false)
                    << std::setw(15) << symValue
                    << std::left
                    << "\t" + strings->chunk2String(sym->name());
 
            if (onlyLogical()) {
                organizedElements.insert(elemStr.str());
            } else {
                out_ << elemStr.str() << std::endl;
            }
 
            elemStr.clear();
        }
 
        dumpStringSet(organizedElements);
 
        out_ << std::endl
             << "U = Minimum allocateable unit index. "
             << "E = Section element index. "
             << std::endl;
    } break;
 
    case Section::ST_RELOC: {
        RelocSection& relocSect =
            dynamic_cast<RelocSection&>(sect);
 
        out_ << "Relocation table: " << std::endl;
        out_ << "Referenced section: "
             << sectionString(*relocSect.referencedSection())
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        out_ << std::endl << std::left;
 
        if (!onlyLogical()) {
            out_ << std::setw(6)  << "index" << std::right;
        }
 
        out_ << std::setw(17) << "type"
             << std::right
             << std::setw(6) << "size"
             << std::setw(18) << "location"
             << std::setw(18) << "destination"
             << std::setw(17) << "address space"
             << std::left << "\tsymbol"
             << std::endl << std::endl;
 
        for (Word i = 0; i < sect.elementCount(); i++) {
            RelocElement* reloc =
                dynamic_cast<RelocElement*>(sect.element(i));
 
            
            std::string locationAddress;
 
            if (relocSect.referencedSection()->type() == Section::ST_DATA || 
                relocSect.referencedSection()->type() == Section::ST_LEDATA) {
                Chunk* srcChunk = dynamic_cast<Chunk*>(reloc->location());
 
                DataSection* dataSect =
                    dynamic_cast<DataSection*>(relocSect.referencedSection());
 
                assert(dataSect != NULL);
 
                locationAddress = Conversion::toString(
                    dataSect->chunkToMAUIndex(srcChunk)) + " U";
 
            } else if (relocSect.referencedSection()->type() ==
                       Section::ST_CODE) {
 
                CodeSection* codeSect =
                    dynamic_cast<CodeSection*>(relocSect.referencedSection());
 
                assert(codeSect != NULL);
 
                locationAddress = Conversion::toString(
                    codeSect->indexOfElement(
                        *dynamic_cast<InstructionElement*>(
                            reloc->location()))) + " E";
 
            } else {
                abortWithError("Section containing relocated elements must"
                               " be DATA or CODE.");
            }
            
            std::string destinationAddress;
            Word dstAddress = 0;
            
            // if relocation is resolved 
            if (reloc->destination() != NULL) {
                
                Section& dstSection =
                    TPEFTools::sectionOfElement(tpef_, *reloc->destination());
                
                if (dstSection.type() == Section::ST_CODE) {
                    CodeSection& codeSect =
                        dynamic_cast<CodeSection&>(dstSection);
                    
                    dstAddress = codeSect.indexOfInstruction(
                        *dynamic_cast<InstructionElement*>(reloc->destination()));
                    
                } else if (dstSection.type() == Section::ST_DATA ||
                           dstSection.type() == Section::ST_LEDATA ||
                           dstSection.type() == Section::ST_UDATA) {
                    
                    UDataSection& uDataSect =
                        dynamic_cast<UDataSection&>(dstSection);
                    
                    assert(uDataSect.belongsToSection(dynamic_cast<Chunk*>(reloc->destination())));
                    
                    dstAddress = uDataSect.chunkToMAUIndex(
                        dynamic_cast<Chunk*>(reloc->destination()));
                    
                } else {
                    abortWithError("Destination of relocation must be DATA, "
                                   "UDATA or CODE section.");
                }
 
                dstAddress += dstSection.startingAddress();
            }
 
            std::stringstream elemStr;
            elemStr << std::left;
 
            if (!onlyLogical()) {
                elemStr << std::setw(6)  << Conversion::toString(i) + ":"
                        << std::right;
            }
 
            elemStr << std::setw(17) << relocTypeString(reloc->type())
                    << std::right
                    << std::setw(6) << static_cast<Word>(reloc->size())
                    << std::setw(18) << locationAddress;
            
            if (reloc->destination() != NULL) {
                elemStr << std::setw(18)
                        << Conversion::toString(dstAddress) + " A";
            } else {
                elemStr << std::setw(18)
                        << "Unresolved";
            }
            
            elemStr << std::setw(17) << addressSpaceString(*reloc->aSpace())
                    << std::left
                    << "\t" + symbolString(*sect.link(), *reloc->symbol());
 
            if (onlyLogical()) {
                organizedElements.insert(elemStr.str());
            } else {
                out_ << elemStr.str() << std::endl;
            }
        }
 
        dumpStringSet(organizedElements);
 
        out_ << std::endl
             << "E = Section element index. "
             << "U = Minimum allocateable unit Index. "
             << "A = Address of the address space."
             << std::endl << std::endl;
 
    } break;
 
    case Section::ST_ADDRSP: {
        out_ << "Address space table:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
 
        out_ << std::endl << std::left;
        if (!onlyLogical()) {
            out_ << std::setw(6)  << "index" << std::right;
        }
 
        out_ << std::setw(6) << "MAU"
             << std::right
             << std::setw(10) << "alignment"
             << std::setw(10) << "word size"
             << std::left << "\tname"
             << std::endl << std::endl;
 
        StringSection* strings = dynamic_cast<StringSection*>(sect.link());
 
        for (Word i = 0; i < sect.elementCount(); i++) {
            ASpaceElement* aSpace =
                dynamic_cast<ASpaceElement*>(sect.element(i));
 
            std::stringstream elemStr;
 
            elemStr << std::left;
            if (!onlyLogical()) {
                elemStr << std::setw(6)  << Conversion::toString(i) + ":"
                        << std::right;
            }
 
            elemStr << std::setw(6) << static_cast<Word>(aSpace->MAU())
                    << std::right
                    << std::setw(10) << static_cast<Word>(aSpace->align())
                    << std::setw(10) << static_cast<Word>(aSpace->wordSize())
                    << std::left
                    << "\t" + strings->chunk2String(aSpace->name());
 
            if (onlyLogical()) {
                organizedElements.insert(elemStr.str());
            } else {
                out_ << elemStr.str() << std::endl;
            }
        }
 
        dumpStringSet(organizedElements);
 
 
    } break;
 
    case Section::ST_MR: {
        out_ << "Machine resource table:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        if (onlyLogical()) {
            out_ << std::endl << std::left
                 << std::setw(12) << "type"
                 << std::right
                 << std::setw(8) << "info"
                 << std::left << "\tname"
                 << std::endl << std::endl;
        } else {
            out_ << std::endl << std::left
                 << std::setw(6)  << "index"
                 << std::setw(12) << std::right << "type"
                 << std::setw(17) << "id"
                 << std::setw(8) << "info"
                 << std::left << "\tname"
                 << std::endl << std::endl;
        }
 
        StringSection* strings = dynamic_cast<StringSection*>(sect.link());
 
        for (Word i = 0; i < sect.elementCount(); i++) {
            ResourceElement* res =
                dynamic_cast<ResourceElement*>(sect.element(i));
 
            std::stringstream elemStr;
 
            if (onlyLogical()) {
                elemStr << std::left
                        << std::setw(12)
                        << resourceTypeString(res->type())
                        << std::right
                        << std::setw(8) << res->info()
                        << std::left
                        << "\t" + strings->chunk2String(res->name());
 
                organizedElements.insert(elemStr.str());
 
            } else {
                out_ << std::left
                     << std::setw(6)  << Conversion::toString(i) + ":"
                     << std::setw(12) << std::right
                     << resourceTypeString(res->type())
                     << std::setw(17)
                     << resourceIdString(res->id(), res->type())
                     << std::setw(8) << res->info()
                     << std::left
                     << "\t" + strings->chunk2String(res->name())
                     << std::endl;
            }
        }
 
        dumpStringSet(organizedElements);
 
 
    } break;
 
    case Section::ST_CODE: {
        out_ << "Code section:"
             << std::endl << std::endl;
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        out_ << std::endl;
 
        TPEFDisassembler disasm(tpef_);
 
        for (Word i = 0; i < disasm.instructionCount(); i++) {
 
            DisassemblyInstruction *instr = disasm.createInstruction(i);
 
            out_ << std::left << std::setw(10)
                 << Conversion::toString(
                     i + disasm.startAddress()) + ":"
                 << std::left
                 << instr->toString()
                 << std::endl;
 
            delete instr;
        }
 
    } break;
 
    case Section::ST_DATA: {
        out_ << "Data section:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        DataSection &data = dynamic_cast<DataSection&>(sect);
 
        for (Word i = 0; i < data.lengthInMAUs(); i++) {
 
            if (i%16 == 0) {
                out_ << std::endl << std::setw(9) <<
                    Conversion::toString(i + data.startingAddress()) + ":";
            }
 
            out_ << std::setw(sizeof(MinimumAddressableUnit)*2 + 3)
                 << Conversion::toHexString(data.MAU(i));
 
        }
 
        out_ << std::endl;
    } break;
 
    case Section::ST_LEDATA: {
        out_ << "Low Endian Data section:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        DataSection &data = dynamic_cast<DataSection&>(sect);
 
        for (Word i = 0; i < data.lengthInMAUs(); i++) {
 
            if (i%16 == 0) {
                out_ << std::endl << std::setw(9) <<
                    Conversion::toString(i + data.startingAddress()) + ":";
            }
 
            out_ << std::setw(sizeof(MinimumAddressableUnit)*2 + 3)
                 << Conversion::toHexString(data.MAU(i));
 
        }
 
        out_ << std::endl;
 
    } break;
 
    case Section::ST_STRTAB: {
        out_ << "String section:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        out_ << std::endl << std::left;
 
        if (!onlyLogical()) {
            out_ << std::setw(10)  << "offset";
        }
 
        out_ << std::left << "string "
             << std::endl << std::endl;
 
        StringSection &strings = dynamic_cast<StringSection&>(sect);
 
        for (Word i = 0; i < strings.length(); i++) {
            std::stringstream elemStr;
 
            if (!onlyLogical()) {
                elemStr << std::setw(10) << std::left
                        << Conversion::toString(i) + ":";
            }
 
            while  (strings.byte(i) != 0) {
                elemStr << strings.byte(i++);
            }
 
            if (onlyLogical()) {
                organizedElements.insert(elemStr.str());
            } else {
                out_ << elemStr.str() << std::endl;
            }
        }
 
        dumpStringSet(organizedElements);
 
 
    } break;
 
    case Section::ST_DEBUG: {
        out_ << "Debug section:"
             << std::endl << std::endl;
 
        out_ << sectionHeader() << std::endl;
        out_ << sectionHeader(sect) << std::endl;
 
        out_ << std::endl << std::left;
 
        out_ << std::setw(10)  << "type";
        out_ << std::left << "data "
             << std::endl << std::endl;
 
        for (Word i = 0; i < sect.elementCount(); i++) {
 
            std::stringstream elemStr;
 
            DebugElement* elem = dynamic_cast<DebugElement*>(sect.element(i));
 
            elemStr << std::setw(10) << std::left
                    << debugElementTypeString(elem->type());
 
            for (unsigned int j = 0; j < elem->length(); j++) {
                elemStr << std::hex << std::setw(3)
                        << static_cast<int>(elem->byte(j));
            }
 
            elemStr << "\t"
                    << dynamic_cast<StringSection*>(
                        sect.link())->chunk2String(elem->debugString());
 
            if (onlyLogical()) {
                organizedElements.insert(elemStr.str());
            } else {
                out_ << elemStr.str() << std::endl;
            }
        }
 
        dumpStringSet(organizedElements);
 
    } break;
 
    default:
        out_ << "Printing section type: " << sectionTypeString(sect.type())
             << " is not implemented." << std::endl;
    }
 
    out_ << std::endl;
}

References abortWithError, TPEF::SymbolElement::absolute(), addressSpaceString(), TPEF::ASpaceElement::align(), TPEF::RelocElement::aSpace(), assert, TPEF::RawSection::belongsToSection(), TPEF::SymbolElement::binding(), TPEF::DataSection::byte(), TPEF::DebugElement::byte(), TPEF::StringSection::chunk2String(), TPEF::RawSection::chunkToMAUIndex(), TPEFDisassembler::createInstruction(), debugElementTypeString(), TPEF::DebugElement::debugString(), TPEF::RelocElement::destination(), dumpStringSet(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::ResourceElement::id(), TPEF::CodeSection::indexOfElement(), TPEF::CodeSection::indexOfInstruction(), TPEF::ResourceElement::info(), TPEFDisassembler::instructionCount(), TPEF::DataSection::length(), TPEF::DebugElement::length(), TPEF::RawSection::lengthInMAUs(), TPEF::Section::link(), TPEF::RelocElement::location(), TPEF::ASpaceElement::MAU(), TPEF::DataSection::MAU(), TPEF::ASpaceElement::name(), TPEF::ResourceElement::name(), TPEF::SymbolElement::name(), onlyLogical(), out_, TPEF::CodeSymElement::reference(), TPEF::DataSymElement::reference(), TPEF::RelocSection::referencedSection(), relocTypeString(), resourceIdString(), resourceTypeString(), TPEF::SymbolElement::section(), sectionHeader(), sectionString(), sectionTypeString(), TPEF::RelocElement::size(), TPEFDisassembler::startAddress(), TPEF::Section::startingAddress(), TPEF::RelocElement::symbol(), symbolBindString(), symbolString(), symbolTypeString(), Conversion::toHexString(), DisassemblyInstruction::toString(), Conversion::toString(), tpef_, TPEF::RelocElement::type(), TPEF::ResourceElement::type(), TPEF::DebugElement::type(), TPEF::Section::type(), TPEF::SymbolElement::type(), and TPEF::ASpaceElement::wordSize().

◆ section() [2/2]

void TPEFDumper::section ( Word sectionIndex )

Prints full information of one section in tpef.

Parameters

sectionIndex Index of requested section.

Definition at line 353 of file TPEFDumper.cc.

                                     {
    if (sectionIndex < tpef_.sectionCount()) {
        section(*tpef_.section(actualIndex(sectionIndex)));
 
    } else {
        out_ << "There is no section with index: " << sectionIndex
             << std::endl << std::endl;
    }
}

References actualIndex(), out_, TPEF::Binary::section(), section(), TPEF::Binary::sectionCount(), and tpef_.

Referenced by main(), relocationTables(), section(), and symbolTables().

Here is the call graph for this function:

◆ sectionHeader() [1/2]

std::string TPEFDumper::sectionHeader ( )

private

Returns field names (first line of table) of section header table.

Returns: field names (first line of table) of section header table.

Definition at line 369 of file TPEFDumper.cc.

                          {
    std::stringstream retVal;
 
    retVal << std::setw(6) << std::left << "index"
           << std::setw(15)<< std::right << "type"
           << std::setw(12) << "address"
           << std::setw(17) << "address space"
           << std::setw(9)  << "flags"
           << std::setw(12)  << "link"
           << std::setw(15)  << "size(B/U/E)"
           << std::left << "\tname";
 
    return retVal.str();
}

Referenced by createLogicalIndexes(), section(), and sectionHeaders().

◆ sectionHeader() [2/2]

std::string TPEFDumper::sectionHeader	(	TPEF::Section &	sect,
		bool	noIndex = `false`
	)

private

Returns section header string of one section.

Parameters

sect	Section whose header is printed.

Returns: section header information of one section.

Definition at line 391 of file TPEFDumper.cc.

                                                     {
 
    std::string nameString;
    if (tpef_.strings() == NULL) {
        nameString = "No section name defined.";
    } else {
        nameString = tpef_.strings()->chunk2String(sect.name());
    }
 
    std::string elementsOrMAUs;
    if (sect.isChunkable()) {
 
        if (sect.type() == Section::ST_STRTAB) {
            elementsOrMAUs = Conversion::toString(
                dynamic_cast<UDataSection&>(sect).length()) + " B";
        } else {
            elementsOrMAUs = Conversion::toString(
                dynamic_cast<UDataSection&>(sect).lengthInMAUs()) + " U";
        }
 
    } else {
        elementsOrMAUs = Conversion::toString(sect.elementCount()) + " E";
    }
 
    int sectIndex = findSectionIndex(sect);
 
    std::stringstream retVal;
 
    retVal << std::left;
    if (!noIndex) {
        retVal << std::setw(6)
               << Conversion::toString(sectIndex) + ":"
               << std::setw(15) << std::right;
    }
 
    retVal << sectionTypeString(sect.type())
           << std::setw(12) << sect.startingAddress()
           << std::setw(17) << addressSpaceString(*sect.aSpace())
           << std::setw(9)  << Conversion::toHexString((int)sect.flags(),2)
           << std::setw(12) << sectionString(*sect.link(), false)
           << std::setw(15) << elementsOrMAUs
           << std::left << "\t" + nameString;
 
    return retVal.str();
}

References addressSpaceString(), TPEF::Section::aSpace(), TPEF::StringSection::chunk2String(), TPEF::Section::elementCount(), findSectionIndex(), TPEF::Section::flags(), TPEF::Section::isChunkable(), TPEF::Section::link(), TPEF::Section::name(), sectionString(), sectionTypeString(), TPEF::Section::startingAddress(), TPEF::Binary::strings(), Conversion::toHexString(), Conversion::toString(), tpef_, and TPEF::Section::type().

Here is the call graph for this function:

◆ sectionHeaders()

void TPEFDumper::sectionHeaders ( )

Prints one lined section header for every section.

Definition at line 210 of file TPEFDumper.cc.

                           {
 
    out_ << sectionHeader() << std::endl;
 
    for (Word i = 0; i < tpef_.sectionCount(); i++) {
        Section *sect = tpef_.section(actualIndex(i));
 
        out_ << sectionHeader(*sect) << std::endl;
    }
 
    out_ << std::endl
         << "B = Bytes. U = MAUs. E = SectionElements."
         << std::endl;
 
    out_ << std::endl;
}

References actualIndex(), out_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), sectionHeader(), and tpef_.

Referenced by main().

Here is the call graph for this function:

◆ sectionString()

std::string TPEFDumper::sectionString	(	TPEF::Section &	sect,
		bool	shortForm = `false`
	)

private

Returns section index and/or type information.

Parameters

sect	Section whose string is requested.
shortForm	If true then only index is returned.

Returns: Type and/or index of section.

Definition at line 445 of file TPEFDumper.cc.

                                                       {
    std::string str;
 
    int index = findSectionIndex(sect);
 
    if (index == -1) {
        str = "FAIL";
    } else {
        if (!shortForm) {
            str = sectionTypeString(sect.type(), true) + ":";
        }
        str += Conversion::toString(index);
    }
 
    return str;
}

References findSectionIndex(), sectionTypeString(), Conversion::toString(), and TPEF::Section::type().

Referenced by fileHeaders(), section(), and sectionHeader().

Here is the call graph for this function:

◆ sectionTypeString()

std::string TPEFDumper::sectionTypeString	(	TPEF::Section::SectionType	type,
		bool	shortForm = `false`
	)

private

Returns section type in human readable form.

Parameters

type	Type id to convert.
shortForm	If short form (only enum string) is returned.

Returns: Section type id string.

Definition at line 1076 of file TPEFDumper.cc.

                                             {
 
    std::string typeStr;
 
    switch (type) {
    case Section::ST_NULL:   typeStr = "NULL";   break;
    case Section::ST_STRTAB: typeStr = "STRTAB"; break;
    case Section::ST_SYMTAB: typeStr = "SYMTAB"; break;
    case Section::ST_DEBUG:  typeStr = "DEBUG";  break;
    case Section::ST_RELOC:  typeStr = "RELOC";  break;
    case Section::ST_LINENO: typeStr = "LINENO"; break;
    case Section::ST_NOTE:   typeStr = "NOTE";   break;
    case Section::ST_ADDRSP: typeStr = "ADDRSP"; break;
    case Section::ST_MR:     typeStr = "MR";     break;
    case Section::ST_CODE:   typeStr = "CODE";   break;
    case Section::ST_DATA:   typeStr = "DATA";   break;
    case Section::ST_UDATA:  typeStr = "UDATA";  break;
    case Section::ST_LEDATA: typeStr = "LEDATA";   break;
    case Section::ST_DUMMY:  typeStr = "DUMMY";  break;
    default: typeStr = "UNKNOWN";
    }
 
    if (!shortForm) {
        typeStr += " (" + Conversion::toHexString(type, 2) + ")";
    }
 
    return typeStr;
}

References Conversion::toHexString().

Referenced by section(), sectionHeader(), and sectionString().

Here is the call graph for this function:

◆ setOnlyLogical()

void TPEFDumper::setOnlyLogical ( bool flag )

Sets if dumper is wanted to print out only logical information of TPEF.

If flag is set then no element or section indexes are dumped, only information that is independent to that how TPEF hierarchy is physically constructed is dumped. With this option user can check for example if two different TPEF files actually contains same program, relocations, symbols etc.

Parameters

flag	If true, then logical printing is set on.

Definition at line 157 of file TPEFDumper.cc.

                                    {
    if (flag) {
        createLogicalIndexes();
    }
 
    onlyLogicalInfo_ = flag;
}

References createLogicalIndexes(), and onlyLogicalInfo_.

Referenced by main().

Here is the call graph for this function:

◆ symbolBindString()

std::string TPEFDumper::symbolBindString ( TPEF::SymbolElement::SymbolBinding bind )

private

Returns symbol binding type in human readable form.

Parameters

bind	Symbol binding type id to convert.

Returns: Symbol binding id string.

Definition at line 1202 of file TPEFDumper.cc.

                                                            {
 
    std::string str;
 
    switch (bind) {
    case SymbolElement::STB_LOCAL:  str = "LOCAL";  break;
    case SymbolElement::STB_GLOBAL: str = "GLOBAL"; break;
    case SymbolElement::STB_WEAK:   str = "WEAK";   break;
    default: str = "UNKNOWN";
    }
 
    return str + " (" + Conversion::toHexString(bind, 2) + ")";
}

References Conversion::toHexString().

Referenced by section().

Here is the call graph for this function:

◆ symbolString()

std::string TPEFDumper::symbolString	(	TPEF::Section &	sect,
		TPEF::SymbolElement &	sym
	)

private

Returns symbol in human readable form.

Parameters

sect	Section containing requested symbol.
sym	Symbol to convert.

Returns: Symbol string.

Definition at line 1360 of file TPEFDumper.cc.

                                                          {
 
    std::string str;
    int index = findElementIndex(sect, sym);
 
    StringSection* strings = dynamic_cast<StringSection*>(sect.link());
    assert(strings != NULL);
 
    if (!onlyLogical()) {
        str = Conversion::toString(index) + ":";
    }
 
    str += strings->chunk2String(sym.name());
 
    return str;
}

References assert, TPEF::StringSection::chunk2String(), findElementIndex(), TPEF::Section::link(), TPEF::SymbolElement::name(), onlyLogical(), and Conversion::toString().

Referenced by section().

Here is the call graph for this function:

◆ symbolTables()

void TPEFDumper::symbolTables ( )

Prints full information of every symbol table in tpef.

Definition at line 336 of file TPEFDumper.cc.

                         {
 
    for (Word i = 0; i < tpef_.sectionCount(); i++) {
        Section& currSect = *tpef_.section(actualIndex(i));
 
        if (currSect.type() == Section::ST_SYMTAB) {
            section(currSect);
        }
    }
}

References actualIndex(), TPEF::Binary::section(), section(), TPEF::Binary::sectionCount(), tpef_, and TPEF::Section::type().

Referenced by main().

Here is the call graph for this function:

◆ symbolTypeString()

std::string TPEFDumper::symbolTypeString ( TPEF::SymbolElement::SymbolType type )

private

Returns symbol type in human readable form.

Parameters

type	Symbol type id to convert.

Returns: Symbol type id string.

Definition at line 1178 of file TPEFDumper.cc.

                                                         {
 
    std::string str;
 
    switch (type) {
    case SymbolElement::STT_NOTYPE:    str = "NOTYPE";    break;
    case SymbolElement::STT_CODE:      str = "CODE";      break;
    case SymbolElement::STT_DATA:      str = "DATA";      break;
    case SymbolElement::STT_FILE:      str = "FILE";      break;
    case SymbolElement::STT_SECTION:   str = "SECTION";   break;
    case SymbolElement::STT_PROCEDURE: str = "PROCEDURE"; break;
    default: str = "UNKNOWN";
    }
 
    return str + " (" + Conversion::toHexString(type, 2) + ")";
}

References Conversion::toHexString().

Referenced by section().

Here is the call graph for this function:

Member Data Documentation

◆ actualIndexes_

std::vector<Word> TPEFDumper::actualIndexes_

private

Definition at line 104 of file TPEFDumper.hh.

Referenced by actualIndex(), and createLogicalIndexes().

◆ onlyLogicalInfo_

bool TPEFDumper::onlyLogicalInfo_

private

Definition at line 109 of file TPEFDumper.hh.

Referenced by onlyLogical(), and setOnlyLogical().

◆ out_

std::ostream& TPEFDumper::out_

private

Definition at line 107 of file TPEFDumper.hh.

Referenced by dumpStringSet(), fileHeaders(), memoryInfo(), section(), section(), and sectionHeaders().

◆ tpef_

TPEF::Binary& TPEFDumper::tpef_

private

Definition at line 106 of file TPEFDumper.hh.

Referenced by addressSpaceString(), createLogicalIndexes(), fileHeaders(), findSectionIndex(), memoryInfo(), relocationTables(), section(), section(), sectionHeader(), sectionHeaders(), and symbolTables().

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TPEFDumper()

◆ ~TPEFDumper()

Member Function Documentation

◆ actualIndex()

◆ addressSpaceString()

◆ createLogicalIndexes()

◆ debugElementTypeString()

◆ dumpStringSet()

◆ fileArchString()

◆ fileHeaders()

◆ fileTypeString()

◆ findElementIndex()

◆ findSectionIndex()

◆ memoryInfo()

◆ onlyLogical()

◆ relocationTables()

◆ relocTypeString()

◆ resourceIdString()

◆ resourceTypeString()

◆ section() [1/2]

◆ section() [2/2]

◆ sectionHeader() [1/2]

◆ sectionHeader() [2/2]

◆ sectionHeaders()

◆ sectionString()

◆ sectionTypeString()

◆ setOnlyLogical()

◆ symbolBindString()

◆ symbolString()

◆ symbolTables()

◆ symbolTypeString()

Member Data Documentation

◆ actualIndexes_

◆ onlyLogicalInfo_

◆ out_

◆ tpef_