#include <CodeSection.hh>

Inheritance diagram for TPEF::CodeSection:

Collaboration diagram for TPEF::CodeSection:

Public Member Functions
virtual	~CodeSection ()

virtual void	addElement (SectionElement *element)

virtual void	setElement (Word index, SectionElement *element)

virtual SectionType	type () const

virtual InstructionElement *	element (Word index) const

void	clearInstructionCache () const

Word	instructionCount () const

InstructionElement &	instruction (Word index) const

Word	instructionToSectionIndex (Word index) const

Word	indexOfElement (const InstructionElement &elem) const

Word	indexOfInstruction (const InstructionElement &elem) const

bool	isInSection (const InstructionElement &elem) const

bool	isCodeSection () const override

Public Member Functions inherited from TPEF::Section
virtual	~Section ()

virtual bool	isChunkable () const

virtual Chunk *	chunk (SectionOffset offset) const

bool	isProgramSection () const

bool	isAuxSection () const

SectionElement *	element (Word index) const

Word	elementCount () const

void	setFlagNoBits ()

void	unsetFlagNoBits ()

bool	noBits () const

bool	vLen () const

Byte	flags () const

void	setFlags (Byte flagByte)

void	setStartingAddress (AddressImage address)

AddressImage	startingAddress () const

void	setLink (const ReferenceManager::SafePointer *aLink)

void	setLink (Section *aLink)

Section *	link () const

void	setASpace (const ReferenceManager::SafePointer *addrSpace)

void	setASpace (ASpaceElement *addrSpace)

ASpaceElement *	aSpace () const

void	setName (const ReferenceManager::SafePointer *sectionName)

void	setName (Chunk *sectionName)

Chunk *	name () const

virtual bool	isDataSection () const

Public Member Functions inherited from TPEF::SafePointable
virtual	~SafePointable ()

Protected Member Functions
	CodeSection (bool init)

virtual Section *	clone () const

Protected Member Functions inherited from TPEF::Section
	Section ()

void	setFlagVLen ()

void	unsetFlagVLen ()

Protected Member Functions inherited from TPEF::SafePointable
	SafePointable ()

Private Member Functions
void	initInstructionCache () const

Private Attributes
std::vector< Word >	instructionStartCache_
	Cache vector of element indexes of those instruction elements, which begins a new instruction. More...

std::map< const InstructionElement *, Word >	elementIndexCache_
	Cache of indexes of instruction elemenets. More...

Static Private Attributes
static CodeSection	proto_
	Prototype instance of section. More...

Additional Inherited Members
Public Types inherited from TPEF::Section
enum	SectionType { ST_NULL = 0x00, ST_STRTAB = 0x01, ST_SYMTAB = 0x02, ST_DEBUG = 0x03, ST_RELOC = 0x04, ST_LINENO = 0x05, ST_NOTE = 0x06, ST_ADDRSP = 0x07, ST_MR = 0x0A, ST_CODE = 0x81, ST_DATA = 0x82, ST_UDATA = 0x83, ST_LEDATA = 0x84, ST_DUMMY = 0xff }

enum	SectionFlag { SF_VLEN = 0x40, SF_NOBITS = 0x80 }

Static Public Member Functions inherited from TPEF::Section
static Section *	createSection (SectionType type)

static bool	isProgramSection (SectionType type)

Static Protected Member Functions inherited from TPEF::Section
static void	registerSection (const Section *section)

Detailed Description

Code section.

Definition at line 44 of file CodeSection.hh.

Constructor & Destructor Documentation

◆ ~CodeSection()

TPEF::CodeSection::~CodeSection ( )

virtual

Destructor.

Definition at line 58 of file CodeSection.cc.

58 {

59 }

◆ CodeSection()

TPEF::CodeSection::CodeSection ( bool init )

protected

Constructor.

Parameters

init	True if registeration is wanted.

Definition at line 46 of file CodeSection.cc.

                                   :
     Section() {
     if (init) {
         Section::registerSection(this);
     }
     setFlagVLen();
     unsetFlagNoBits();
 }

References TPEF::Section::registerSection(), TPEF::Section::setFlagVLen(), and TPEF::Section::unsetFlagNoBits().

Referenced by clone().

Here is the call graph for this function:

Member Function Documentation

◆ addElement()

void TPEF::CodeSection::addElement ( SectionElement * element )

virtual

Adds an element to section and clears internal caches.

Parameters

element Element that is added to section.

Reimplemented from TPEF::Section.

Definition at line 267 of file CodeSection.cc.

                                                {
     Section::addElement(element);
     clearInstructionCache();
 }

References TPEF::Section::addElement(), clearInstructionCache(), and element().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), CodeSectionCreator::finalize(), and TPEF::TPEFCodeSectionReader::readData().

Here is the call graph for this function:

◆ clearInstructionCache()

void TPEF::CodeSection::clearInstructionCache ( ) const

Clears instruction startpoint cache.

Definition at line 96 of file CodeSection.cc.

                                          {
     instructionStartCache_.clear();
     elementIndexCache_.clear();
 }

References elementIndexCache_, and instructionStartCache_.

Referenced by addElement(), and setElement().

◆ clone()

Section * TPEF::CodeSection::clone ( ) const

protectedvirtual

Creates an instance of CodeSection.

Returns: Newly created section.

Implements TPEF::Section.

Definition at line 77 of file CodeSection.cc.

                          {
     return new CodeSection(false);
 }

References CodeSection().

Here is the call graph for this function:

◆ element()

InstructionElement * TPEF::CodeSection::element ( Word index ) const

virtual

Returns requested instruction element.

Parameters

index Index of requested element.

Returns: Requested element.

Definition at line 88 of file CodeSection.cc.

                                      {
     return dynamic_cast<InstructionElement*>(Section::element(index));
 }

References TPEF::Section::element().

Referenced by addElement(), TTAProgram::TPEFProgramFactory::addProcedures(), TPEFDisassembler::createInstruction(), TPEF::AOutSymbolSectionReader::finalize(), CodeCompressorPlugin::immediateTerminal(), TPEFDisassembler::initCache(), CodeCompressorPlugin::initializeRelocations(), initInstructionCache(), instruction(), and setElement().

Here is the call graph for this function:

◆ indexOfElement()

Word TPEF::CodeSection::indexOfElement ( const InstructionElement & elem ) const

Returns index of instruction element.

If section elements are changed, cache must be cleared before calling this function.

Parameters

elem	Element whose index is returned.

Returns: index of instruction element.

Definition at line 198 of file CodeSection.cc.

                                                                 {
     initInstructionCache();
     return MapTools::valueForKey<Word>(elementIndexCache_, &elem);
  
 }

References elementIndexCache_, and initInstructionCache().

Referenced by TPEFDumper::section().

Here is the call graph for this function:

◆ indexOfInstruction()

Word TPEF::CodeSection::indexOfInstruction ( const InstructionElement & elem ) const

Returns index of instruction of requested element.

If requested element is in middle of instruction, then index of that instruction is returned.

If section elements are changed, cache must be cleared before calling this function.

Parameters

elem	Element whose instruction index is returned.

Returns: index of instruction element.

Definition at line 232 of file CodeSection.cc.

                                                                     {
     initInstructionCache();
  
     // get instruction element index
     Word elementIndex = 
         MapTools::valueForKey<Word>(elementIndexCache_, &elem);
  
     Word instrCount = instructionCount();
     int first = 0;
     int last = instrCount - 1;
     Word key = elementIndex;
  
     int middle = 0;
  
     // binary search from instructionStartCache for finding instruction index
     while (first <= last) {
         middle = (first + last) / 2;
         if (key > instructionStartCache_[middle]) {
             first = middle + 1;
         } else if (key < instructionStartCache_[middle]) {
             last = middle - 1;
         } else {
             break;
         }
     }
  
     return middle;
 }

References elementIndexCache_, initInstructionCache(), instructionCount(), and instructionStartCache_.

Referenced by TPEFDumper::section(), and ProgramImageGenerator::writeDataSection().

Here is the call graph for this function:

◆ initInstructionCache()

void TPEF::CodeSection::initInstructionCache ( ) const

private

Initializes instruction cache.

Scans through section and marks element indexes of those instruction elements that starts a new instruction.

Also sets section element index for every element.

Definition at line 110 of file CodeSection.cc.

                                         {
  
     // both caches must be initialized or uninitilized
     assert(instructionStartCache_.empty() == elementIndexCache_.empty());
  
     if (instructionStartCache_.empty()) {
         for (Word i = 0; i < elementCount(); i++) {
             InstructionElement* elem = element(i);
  
             // cache start index of instruction
             if (elem->begin()) {
                 instructionStartCache_.push_back(i);
             }
  
             // cache element index of instruction element
             elementIndexCache_[elem] = i;
  
         }
     }
  
     // there must be at least one instruction start
     assert(!instructionStartCache_.empty());
     assert(!elementIndexCache_.empty());
  
 }

References assert, TPEF::InstructionElement::begin(), element(), TPEF::Section::elementCount(), elementIndexCache_, and instructionStartCache_.

Referenced by indexOfElement(), indexOfInstruction(), instructionCount(), instructionToSectionIndex(), and isInSection().

Here is the call graph for this function:

◆ instruction()

InstructionElement & TPEF::CodeSection::instruction ( Word index ) const

Returns starting element of requested instruction.

See. instructionCount() for more information.

If section elements are changed, cache must be cleared before calling this function.

Parameters

index Index of requested instruction.

Returns: Starting element of requested instruction.

Definition at line 165 of file CodeSection.cc.

                                          {
     return *element(instructionToSectionIndex(index));
 }

References element(), and instructionToSectionIndex().

Referenced by TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createRelocSections(), LabelManager::createSymbolWithReference(), TPEF::AOutSymbolSectionReader::finalize(), LabelManager::finalize(), and LabelManager::writeProcedureSymbols().

Here is the call graph for this function:

◆ instructionCount()

Word TPEF::CodeSection::instructionCount ( ) const

Returns number of instructions stored in section.

Each instruction elements that starts new instruction are marked with begin() flag.

If section elements are changed, cache must be cleared before calling this function.

Returns: Number of instructions in code section.

Definition at line 148 of file CodeSection.cc.

                                     {
     initInstructionCache();
     return instructionStartCache_.size();
 }

References initInstructionCache(), and instructionStartCache_.

Referenced by TPEF::AOutSymbolSectionReader::finalize(), LabelManager::findRelocationDstSection(), TTAProgram::ProgramWriter::findSection(), LabelManager::findSectionByAddress(), indexOfInstruction(), and LabelManager::writeProcedureSymbols().

Here is the call graph for this function:

◆ instructionToSectionIndex()

Word TPEF::CodeSection::instructionToSectionIndex ( Word index ) const

Returns element index of starting element of requested instruction.

I.e. converts instruction index to instruction element index.

See. instructionCount() for more information.

If section elements are changed, cache must be cleared before calling this function.

Parameters

index Index of instruction

Returns: Instruction element index of requested instruction.

Definition at line 183 of file CodeSection.cc.

                                                        {
     initInstructionCache();
     return instructionStartCache_[index];
 }

References initInstructionCache(), and instructionStartCache_.

Referenced by TPEF::AOutSymbolSectionReader::finalize(), and instruction().

Here is the call graph for this function:

◆ isCodeSection()

bool TPEF::CodeSection::isCodeSection ( ) const

inlineoverridevirtual

Reimplemented from TPEF::Section.

Definition at line 66 of file CodeSection.hh.

66 { return true; }

◆ isInSection()

bool TPEF::CodeSection::isInSection ( const InstructionElement & elem ) const

Returns true if element is found from section.

If section elements are changed, cache must be cleared before calling this function.

Parameters

elem	Element to check.

Returns: True if element is found from section.

Definition at line 214 of file CodeSection.cc.

                                                              {
     initInstructionCache();
     return MapTools::containsKey(elementIndexCache_, &elem);
 }

References MapTools::containsKey(), elementIndexCache_, and initInstructionCache().

Referenced by TPEF::TPEFTools::sectionOfElement().

Here is the call graph for this function:

◆ setElement()

void TPEF::CodeSection::setElement	(	Word	index,
		SectionElement *	element
	)

virtual

Sets replaces an element with another and clears internal caches.

Parameters

index	Index of element that is replaced.
element	Element that is set to given index.

Reimplemented from TPEF::Section.

Definition at line 279 of file CodeSection.cc.

                                                            {
     Section::setElement(index, element);
     clearInstructionCache();
 }

References clearInstructionCache(), element(), and TPEF::Section::setElement().

Here is the call graph for this function:

◆ type()

Section::SectionType TPEF::CodeSection::type ( ) const

virtual

Returns section's type.

Returns: Type of section.

Implements TPEF::Section.

Definition at line 67 of file CodeSection.cc.

                         {
     return ST_CODE;
 }

References TPEF::Section::ST_CODE.

Member Data Documentation

◆ elementIndexCache_

std::map<const InstructionElement*, Word> TPEF::CodeSection::elementIndexCache_

mutableprivate

Cache of indexes of instruction elemenets.

Definition at line 81 of file CodeSection.hh.

Referenced by clearInstructionCache(), indexOfElement(), indexOfInstruction(), initInstructionCache(), and isInSection().

◆ instructionStartCache_

std::vector<Word> TPEF::CodeSection::instructionStartCache_

mutableprivate

Cache vector of element indexes of those instruction elements, which begins a new instruction.

Definition at line 78 of file CodeSection.hh.

Referenced by clearInstructionCache(), indexOfInstruction(), initInstructionCache(), instructionCount(), and instructionToSectionIndex().

◆ proto_

CodeSection TPEF::CodeSection::proto_

staticprivate

Prototype instance of section.

Definition at line 74 of file CodeSection.hh.

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~CodeSection()

◆ CodeSection()

Member Function Documentation

◆ addElement()

◆ clearInstructionCache()

◆ clone()

◆ element()

◆ indexOfElement()

◆ indexOfInstruction()

◆ initInstructionCache()

◆ instruction()

◆ instructionCount()

◆ instructionToSectionIndex()

◆ isCodeSection()

◆ isInSection()

◆ setElement()

◆ type()

Member Data Documentation

◆ elementIndexCache_

◆ instructionStartCache_

◆ proto_