TPEF::TPEFTools Class Reference

#include <TPEFTools.hh>

Collaboration diagram for TPEF::TPEFTools:

Public Member Functions
	TPEFTools (const Binary &aTpef)
void	clearCache () const
Section &	sectionOfElement (const SectionElement &element)
std::string	resourceName (ResourceElement::ResourceType type, HalfWord resourceId) const
std::string	addressSpaceName (const ASpaceElement &aSpace) const
bool	hasRelocation (const SectionElement &element) const
const RelocElement &	relocation (const SectionElement &element) const

Static Public Member Functions
static Section &	sectionOfElement (const Binary &bin, const SectionElement &element)
static std::string	resourceName (const Binary &bin, ResourceElement::ResourceType type, HalfWord resourceId)
static std::string	addressSpaceName (const Binary &bin, const ASpaceElement &aSpace)
static bool	hasRelocation (const Binary &bin, const SectionElement &element)
static const RelocElement &	relocation (const Binary &bin, const SectionElement &element)

Private Member Functions
void	initRelocationCache () const

Private Attributes
const Binary &	tpef_
	TPEF whose resources are accessed.
std::map< const SectionElement *, const RelocElement * >	relocationCache_
	Cache of Chunks and immediates, which are relocated.

Detailed Description

Contains many helper functions that makes TPEF handling a bit easier.

These are kind of functions that doesn't fit to any Sections' or SectionElements' interfaces.

Class can be used stright through static interface, or client may create instance of TPEFTools, which enables caching functionality. Basically, if TPEFTools is highly utilized it should be used as a object.

Definition at line 62 of file TPEFTools.hh.

Constructor & Destructor Documentation

TPEFTools()

TPEF::TPEFTools::TPEFTools

(

const Binary &

aTpef

)

Constructor.

Parameters

aTpef

TPEF that is accessed with toolkit.

Definition at line 54 of file TPEFTools.cc.

                                        : tpef_(aTpef) {
}

Member Function Documentation

addressSpaceName() [1/2]

std::string TPEF::TPEFTools::addressSpaceName

(

const ASpaceElement &

aSpace

)

const

Finds name string of an address space element.

Parameters

aSpace

Element whose name is needed.

Returns

Name of the requested address space.

Definition at line 96 of file TPEFTools.cc.

                                                             {
    return addressSpaceName(tpef_, aSpace);
}

References addressSpaceName(), and tpef_.

Referenced by addressSpaceName(), and TTAProgram::TPEFProgramFactory::findAddressSpace().

Here is the call graph for this function:

addressSpaceName() [2/2]

std::string TPEF::TPEFTools::addressSpaceName ( const Binary &  bin, const ASpaceElement &  aSpace  )

static

Finds name string of an address space element.

Parameters

bin	TPEF which is checked.
aSpace	Element whose name is needed.

Returns

Name of the requested address space.

Definition at line 246 of file TPEFTools.cc.

                                                                          {
 
    assert(bin.sectionCount(Section::ST_ADDRSP) == 1);
 
    Section *aSpaceSection = bin.section(Section::ST_ADDRSP, 0);
 
    StringSection *strings = dynamic_cast<StringSection*>(
        aSpaceSection->link());
 
    assert(strings != NULL);
 
    return strings->chunk2String(aSpace.name());
}

References assert, TPEF::StringSection::chunk2String(), TPEF::Section::link(), TPEF::ASpaceElement::name(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), and TPEF::Section::ST_ADDRSP.

Here is the call graph for this function:

clearCache()

void TPEF::TPEFTools::clearCache

(

)

const

Clears cache of object.

Definition at line 61 of file TPEFTools.cc.

                            {
    relocationCache_.clear();
}

References relocationCache_.

hasRelocation() [1/2]

bool TPEF::TPEFTools::hasRelocation ( const Binary &  bin, const SectionElement &  element  )

static

Checks if the requested immediate or chunk is relocated.

Parameters

bin	TPEF which is checked.
element	Element whose name is needed.

Returns

True if the requested element has corresponding relocation element.

Definition at line 268 of file TPEFTools.cc.

                                                                         {
 
    for (Word i = 0; i < bin.sectionCount(Section::ST_RELOC); i++) {
        Section *relocSect = bin.section(Section::ST_RELOC, i);
 
        for (Word j = 0; j < relocSect->elementCount(); j++) {
            RelocElement *reloc =
                dynamic_cast<RelocElement*>(relocSect->element(j));
 
            assert(reloc != NULL);
 
            if (reloc->location() == &element) {
                return true;
            }
        }
    }
 
    return false;
}

References assert, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::RelocElement::location(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), and TPEF::Section::ST_RELOC.

Here is the call graph for this function:

hasRelocation() [2/2]

bool TPEF::TPEFTools::hasRelocation

(

const SectionElement &

element

)

const

Checks if the requested immediate or chunk is relocated.

Parameters

element

Element whose name is needed.

Returns

True if the requested element has corresponding relocation element.

Definition at line 107 of file TPEFTools.cc.

                                                            {
    initRelocationCache();
    return MapTools::containsKey(relocationCache_, &element);
}

References MapTools::containsKey(), initRelocationCache(), and relocationCache_.

Referenced by TTAProgram::TPEFProgramFactory::createInstruction(), and TTAProgram::TPEFProgramFactory::createTerminal().

Here is the call graph for this function:

initRelocationCache()

void TPEF::TPEFTools::initRelocationCache ( ) const

private

Inits cache for hasRelocation and relocation methods.

Definition at line 323 of file TPEFTools.cc.

                                     {
 
    if (relocationCache_.empty()) {
        for (Word i = 0; i < tpef_.sectionCount(Section::ST_RELOC); i++) {
            Section *relocSect = tpef_.section(Section::ST_RELOC, i);
 
            for (Word j = 0; j < relocSect->elementCount(); j++) {
                RelocElement *reloc =
                    dynamic_cast<RelocElement*>(relocSect->element(j));
 
                assert(reloc != NULL);
 
                relocationCache_[reloc->location()] = reloc;
            }
        }
    }
}

References assert, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::RelocElement::location(), relocationCache_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::ST_RELOC, and tpef_.

Referenced by hasRelocation(), and relocation().

Here is the call graph for this function:

relocation() [1/2]

const RelocElement & TPEF::TPEFTools::relocation ( const Binary &  bin, const SectionElement &  element  )

static

Retrieves the relocation element requested immediate or chunk is relocated.

Parameters

bin	TPEF which is checked.
element	Element relocations are checked.

Returns

Relocation element for the element given in parameter.

Definition at line 296 of file TPEFTools.cc.

                                                                      {
 
    for (Word i = 0; i < bin.sectionCount(Section::ST_RELOC); i++) {
        Section *relocSect = bin.section(Section::ST_RELOC, i);
 
        for (Word j = 0; j < relocSect->elementCount(); j++) {
            RelocElement *reloc =
                dynamic_cast<RelocElement*>(relocSect->element(j));
 
            assert(reloc != NULL);
 
            if (reloc->location() == &element) {
                return *reloc;
            }
        }
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "There is no relocation for requested element.");
}

References __func__, assert, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::RelocElement::location(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), and TPEF::Section::ST_RELOC.

Here is the call graph for this function:

relocation() [2/2]

const RelocElement & TPEF::TPEFTools::relocation

(

const SectionElement &

element

)

const

Retrieves the relocation element requested immediate or chunk is relocated.

Parameters

element

Element relocations are checked.

Returns

Relocation element for the element given in parameter.

Definition at line 119 of file TPEFTools.cc.

                                                         {
    initRelocationCache();
    return *MapTools::valueForKey<const RelocElement*>(
        relocationCache_, &element);
}

References initRelocationCache(), MapTools::keyForValue(), and relocationCache_.

Referenced by TTAProgram::TPEFProgramFactory::createInstruction(), and TTAProgram::TPEFProgramFactory::createTerminal().

Here is the call graph for this function:

resourceName() [1/2]

std::string TPEF::TPEFTools::resourceName ( const Binary &  bin, ResourceElement::ResourceType  type, HalfWord  resourceId  )

static

Finds name string of a resource.

Parameters

bin	TPEF which is checked.
type	Type of the resource.
resourceId	Id of the resource.

Returns

Name of the requested resource.

Definition at line 208 of file TPEFTools.cc.

                         {
 
    for (Word i = 0; i < bin.sectionCount(Section::ST_MR); i++) {
        ResourceSection* resources =
            dynamic_cast<ResourceSection*>(bin.section(Section::ST_MR, i));
 
        assert(resources != NULL);
 
        if (resources->hasResource(type, resourceId)) {
 
            ResourceElement& resource =
                dynamic_cast<ResourceElement&>(
                    resources->findResource(type, resourceId));
 
            StringSection *strings =
                dynamic_cast<StringSection*>(resources->link());
 
            assert(strings != NULL);
 
            return strings->chunk2String(resource.name());
        }
    }
    
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "Resource wasn't found id:" + Conversion::toString(resourceId));
}

References __func__, assert, TPEF::StringSection::chunk2String(), TPEF::ResourceSection::findResource(), TPEF::ResourceSection::hasResource(), TPEF::Section::link(), TPEF::ResourceElement::name(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::ST_MR, and Conversion::toString().

Here is the call graph for this function:

resourceName() [2/2]

std::string TPEF::TPEFTools::resourceName	(	ResourceElement::ResourceType	type,
		HalfWord	resourceId
	)		const

Finds name string of a resource.

Parameters

type	Type of the resource.
resourceId	Id of the resource.

Returns

Name of the requested resource.

Definition at line 84 of file TPEFTools.cc.

                                                   {
    return resourceName(tpef_, type, resourceId);
}

References resourceName(), and tpef_.

Referenced by CodeCompressorPlugin::immediateTerminal(), CodeCompressorPlugin::programImmediate(), and resourceName().

Here is the call graph for this function:

sectionOfElement() [1/2]

Section & TPEF::TPEFTools::sectionOfElement ( const Binary &  bin, const SectionElement &  element  )

static

Return section of the requested element.

NOTE: method does not work for LineNumElements (line number section element desing is wrong).

Parameters

bin	TPEF which is checked.
element	Element whose section is needed.

Returns

Section of the requested element.

Definition at line 136 of file TPEFTools.cc.

                                   {
 
    // check if chunkable element
    const Chunk* chunk = dynamic_cast<const Chunk*>(&element);
 
    if (chunk != NULL) {
        for (Word i = 0; i < bin.sectionCount(); i++) {
            RawSection* currSect =
                dynamic_cast<RawSection*>(bin.section(i));
 
            if (currSect == NULL) {
                continue;
            }
 
            if (chunk->offset() < currSect->length() &&
                currSect->chunk(chunk->offset()) == chunk) {
                return *currSect;
            }
        }
 
    } else {
        for (Word i = 0; i < bin.sectionCount(); i++) {
            Section* currSect = bin.section(i);
 
            if (currSect->isChunkable()) {
                continue;
            }
 
            // optimization for code section
            if (currSect->isCodeSection()) {
                CodeSection* codeSect =
                    dynamic_cast<CodeSection*>(currSect);
 
                const InstructionElement* instr =
                    dynamic_cast<const InstructionElement*>(&element);
 
                if (instr == NULL) {
                    continue;
                }
 
                if (codeSect->isInSection(*instr)) {
                    return *currSect;
                } else {
                    continue;
                }
            }
 
            // other sections a bit slower
            for (Word j = 0; j < currSect->elementCount(); j++) {
                if (&element == currSect->element(j)) {
                    return *currSect;
                }
            }
        }
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "Requested element is not found from any section of binary.");
}

References __func__, TPEF::RawSection::chunk(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::Section::isChunkable(), TPEF::Section::isCodeSection(), TPEF::CodeSection::isInSection(), TPEF::RawSection::length(), TPEF::Chunk::offset(), TPEF::Binary::section(), and TPEF::Binary::sectionCount().

Here is the call graph for this function:

sectionOfElement() [2/2]

Section & TPEF::TPEFTools::sectionOfElement

(

const SectionElement &

element

)

Return section of the requested element.

Parameters

element

Element whose section is needed.

Returns

Section of the requested element.

Definition at line 72 of file TPEFTools.cc.

                                                         {
    return sectionOfElement(tpef_, element);
}

References sectionOfElement(), and tpef_.

Referenced by sectionOfElement().

Here is the call graph for this function:

Member Data Documentation

relocationCache_

std::map< const SectionElement*, const RelocElement*> TPEF::TPEFTools::relocationCache_

mutableprivate

Cache of Chunks and immediates, which are relocated.

Definition at line 110 of file TPEFTools.hh.

Referenced by clearCache(), hasRelocation(), initRelocationCache(), and relocation().

tpef_

const Binary& TPEF::TPEFTools::tpef_

private

TPEF whose resources are accessed.

Definition at line 106 of file TPEFTools.hh.

Referenced by addressSpaceName(), initRelocationCache(), resourceName(), and sectionOfElement().

---

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

• TPEFTools.hh
• TPEFTools.cc