#include <LabelManager.hh>

Collaboration diagram for LabelManager:

Classes
struct	InternalLabel

struct	InternalRelocation

Public Member Functions
	LabelManager (TPEF::Binary &bin, MachineResourceManager &resources, AssemblyParserDiagnostic *parent)

	~LabelManager ()

UValue	value (std::string &name)

TPEF::ASpaceElement &	aSpaceElement (std::string &labelName)

std::string	aSpaceName (std::string &labelName)

void	addLabel (TPEF::ASpaceElement &aSpace, std::string &name, UValue value)

void	removeLabel (std::string &name)

void	addProcedure (std::string &name, UValue value)

void	setGlobal (std::string &labelName)

void	addRelocation (TPEF::Section &locationSect, TPEF::SectionElement &location, TPEF::ASpaceElement &dstASpace, UValue destination, UValue bitWidth)

void	clearLastRelocations ()

void	commitLastRelocations ()

void	finalize ()

void	cleanup ()

UValue	resolveExpressionValue (UValue asmLineNumber, LiteralOrExpression &litOrExpr)

Private Types
typedef std::map< std::string, InternalLabel * >	SymbolMap

Private Member Functions
TPEF::Section *	findSectionByAddress (InternalLabel *currLabel)

TPEF::SymbolElement *	createSymbolWithReference (InternalLabel currLabel, TPEF::Section ownerSection)

void	writeProcedureSymbols (TPEF::CodeSection codeSect, TPEF::SymbolSection symbolSect, TPEF::StringSection *strings)

TPEF::RelocSection *	findOrCreateRelocationSection (InternalRelocation currReloc, TPEF::SymbolSection symbolSect)

TPEF::Section *	findRelocationDstSection (InternalRelocation *currReloc)

Private Attributes
SymbolMap	labels_
	Contains stored symbols by their name.

std::set< InternalRelocation * >	relocs_
	Added relocations.

std::set< InternalRelocation * >	uncommittedRelocs_
	Uncommitted relocations.

std::set< std::string >	globals_
	Names of global symbols.

std::map< std::string, UValue >	procedures_
	Names and addresses of procedure starts.

TPEF::Binary &	bin_
	For finding sections containing relocated elements.

MachineResourceManager &	resources_
	Common resources of TPEF.

Detailed Description

Keeps track of labels, symbols and relocations.

After all label and relocation information if added, class knows how to write SymbolSection and RelocationSectios to TPEF.

Definition at line 64 of file LabelManager.hh.

Member Typedef Documentation

◆ SymbolMap

typedef std::map<std::string, InternalLabel*> LabelManager::SymbolMap

private

Definition at line 148 of file LabelManager.hh.

Constructor & Destructor Documentation

◆ LabelManager()

LabelManager::LabelManager	(	TPEF::Binary &	bin,
		MachineResourceManager &	resources,
		AssemblyParserDiagnostic *	parent
	)

Constructor.

Parameters

bin	Binary containing data and code sections of relocations.
resources	Resource manager for getting TPEF resources.
parent	Assembler root class.

Definition at line 83 of file LabelManager.cc.

                                 :
    bin_(bin), resources_(resources) {
}

◆ ~LabelManager()

LabelManager::~LabelManager ( )

Destructor.

Definition at line 93 of file LabelManager.cc.

                            {
    MapTools::deleteAllValues(labels_);
 
    while (!relocs_.empty()) {
        delete *relocs_.begin();
        relocs_.erase(relocs_.begin());
    }
}

References MapTools::deleteAllValues(), labels_, and relocs_.

Here is the call graph for this function:

Member Function Documentation

◆ addLabel()

void LabelManager::addLabel	(	TPEF::ASpaceElement &	aSpace,
		std::string &	name,
		UValue	value
	)

Adds a label to manager.

Parameters

aSpace	Address space of the label to add.
name	Name of the label.
value	Value for the label.

Exceptions

ObjectAlreadyExists Label by the same name already exists.

Definition at line 160 of file LabelManager.cc.

                                                                           {
    if(MapTools::containsKey(labels_, name)) {
        throw ObjectAlreadyExists(
            __FILE__, __LINE__, __func__,
            "Multiply defined lablel: " + name);
    }
 
    InternalLabel *newElem = new InternalLabel();
 
    newElem->name = name;
    newElem->aSpace = &aSpace;
    newElem->value = value;
 
    labels_[name] = newElem;
}

References __func__, LabelManager::InternalLabel::aSpace, MapTools::containsKey(), labels_, LabelManager::InternalLabel::name, value(), and LabelManager::InternalLabel::value.

Referenced by AddLabelActor::operator()(), and DataSectionCreator::resolveDataAreaSizesAndLabelAddresses().

Here is the call graph for this function:

◆ addProcedure()

void LabelManager::addProcedure	(	std::string &	name,
		UValue	address
	)

Adds a procedure to manager.

Parameters

name	Name of the procedure
address	Start address of the procedure.

Exceptions

ObjectAlreadyExists Procedure with a same name is already added.

Definition at line 201 of file LabelManager.cc.

                                                          {
    if(MapTools::containsKey(procedures_, name)) {
        throw ObjectAlreadyExists(
            __FILE__, __LINE__, __func__,
            "Multiply defined procedure: " + name);
    }
 
    procedures_[name] = address;
}

References __func__, MapTools::containsKey(), and procedures_.

Referenced by AddProcedureActor::operator()().

Here is the call graph for this function:

◆ addRelocation()

void LabelManager::addRelocation	(	TPEF::Section &	locationSect,
		TPEF::SectionElement &	location,
		TPEF::ASpaceElement &	dstASpace,
		UValue	destination,
		UValue	bitWidth
	)

Adds relocated immediate or data chunk.

Parameters

locationSect	Section where relocated element is stored.
location	Immediate or Chunk containing value to relocate.
dstASpace	Destination address space of relocation.
destination	Destination address of relocation.
bitWidth	Size of the relocated field.

Definition at line 231 of file LabelManager.cc.

                     {
    
    InternalRelocation *newElem = new InternalRelocation();
    
    newElem->locationSect = &locationSect;
    newElem->location = &location;
    newElem->dstASpace = &dstASpace;
    newElem->destination = destination;
    newElem->bitWidth = bitWidth;
 
    uncommittedRelocs_.insert(newElem);
}

References LabelManager::InternalRelocation::bitWidth, LabelManager::InternalRelocation::destination, LabelManager::InternalRelocation::dstASpace, LabelManager::InternalRelocation::location, LabelManager::InternalRelocation::locationSect, and uncommittedRelocs_.

Referenced by CodeSectionCreator::finalize(), and DataSectionCreator::writeDataLineToTPEF().

◆ aSpaceElement()

ASpaceElement & LabelManager::aSpaceElement ( std::string & labelName )

Returns a TPEF address space element for a label by name.

Parameters

labelName Name of the requested label.

Returns: Address space of the label.

Exceptions

SymbolNotFound If there is not symbol for requested name.

Definition at line 129 of file LabelManager.cc.

                                                {
    if(!MapTools::containsKey(labels_, labelName)) {
        throw SymbolNotFound(
            __FILE__, __LINE__, __func__,
            "Can't find address address space for label: " + labelName);
    }
 
    return *labels_[labelName]->aSpace;
}

References __func__, MapTools::containsKey(), and labels_.

Referenced by aSpaceName(), CodeSectionCreator::finalize(), and DataSectionCreator::writeDataLineToTPEF().

Here is the call graph for this function:

◆ aSpaceName()

std::string LabelManager::aSpaceName ( std::string & labelName )

Returns the name of the address space for a label.

Parameters

labelName Name of the requested label.

Returns: Name of the address space the label belongs in.

Exceptions

SymbolNotFound If there is not symbol for requested name.

Definition at line 147 of file LabelManager.cc.

                                             {
    return TPEFTools::addressSpaceName(bin_, aSpaceElement(labelName));
}

References aSpaceElement(), and bin_.

Referenced by CodeSectionCreator::finalize().

Here is the call graph for this function:

◆ cleanup()

void LabelManager::cleanup ( )

Frees all internally allocated data.

Definition at line 263 of file LabelManager.cc.

                      {
    SequenceTools::deleteAllItems(relocs_);
    SequenceTools::deleteAllItems(uncommittedRelocs_);
    MapTools::deleteAllValues(labels_);
    globals_.clear();
    procedures_.clear();
}

References SequenceTools::deleteAllItems(), MapTools::deleteAllValues(), globals_, labels_, procedures_, relocs_, and uncommittedRelocs_.

Referenced by AssemblerParser::cleanup(), and finalize().

Here is the call graph for this function:

◆ clearLastRelocations()

void LabelManager::clearLastRelocations ( )

Removes relocations that are added but not committed to manager.

Used for cleaning up in error cases.

Definition at line 255 of file LabelManager.cc.

                                   {
    SequenceTools::deleteAllItems(uncommittedRelocs_);
}

References SequenceTools::deleteAllItems(), and uncommittedRelocs_.

Referenced by CodeSectionCreator::finalize(), and DataSectionCreator::finalize().

Here is the call graph for this function:

◆ commitLastRelocations()

void LabelManager::commitLastRelocations ( )

Adds permanently relocations that are added but not yet committed to manager.

Definition at line 276 of file LabelManager.cc.

                                    {
 
    // add last relocations for writing down
    for (std::set<InternalRelocation*>::iterator iter =
             uncommittedRelocs_.begin();
         iter != uncommittedRelocs_.end(); iter++) {
 
        relocs_.insert(*iter);
    }
 
    uncommittedRelocs_.clear();
}

References relocs_, and uncommittedRelocs_.

Referenced by CodeSectionCreator::finalize(), and DataSectionCreator::finalize().

◆ createSymbolWithReference()

SymbolElement * LabelManager::createSymbolWithReference	(	InternalLabel *	currLabel,
		TPEF::Section *	ownerSection
	)

private

Creates new TPEF SymbolElement and sets reference field of symbol.

Parameters

currLabel	Label which for symbol element is created.
ownerSection	Section who contains element referred by label.

Returns: Dynamically allocated TPEF symbol with reference field set.

Definition at line 507 of file LabelManager.cc.

                           {
 
    SymbolElement *symbol = NULL;
 
    if (ownerSection->isCodeSection()) {
        CodeSymElement *codeSym = new CodeSymElement();
        symbol = codeSym;
 
        CodeSection *codeSection =
            dynamic_cast<CodeSection*>(ownerSection);
 
        codeSym->setReference(
            &codeSection->instruction(currLabel->value));
 
    } else {
        DataSymElement *dataSym = new DataSymElement();
        symbol = dataSym;
 
        UDataSection *uDataSection =
            dynamic_cast<UDataSection*>(ownerSection);
 
        dataSym->setReference(
            uDataSection->chunk(
                uDataSection->MAUsToBytes(
                    currLabel->value - ownerSection->startingAddress())));
    }
 
    return symbol;
}

References TPEF::RawSection::chunk(), TPEF::CodeSection::instruction(), TPEF::Section::isCodeSection(), TPEF::RawSection::MAUsToBytes(), TPEF::DataSymElement::setReference(), TPEF::CodeSymElement::setReference(), TPEF::Section::startingAddress(), and LabelManager::InternalLabel::value.

Referenced by finalize().

Here is the call graph for this function:

◆ finalize()

void LabelManager::finalize ( )

Creates symbol and relocation tables corresponding to input information.

All destinations must exist in TPEF before this method can be executed, otherwise finalize will throw exception. If exception is thrown finalize method will not do any changes to TPEF. When error that caused the exception is fixed, method can be re-executed and it continues from the same phase until the end.

Exceptions

CompileError There was problems during the resolving.

Definition at line 301 of file LabelManager.cc.

                       {
    SymbolSection* symbolSect = NULL;
 
    // write labels
    StringSection* strings = resources_.stringSection();
    NoTypeSymElement* undefSymbol = NULL;
 
    // create always symbol section with undefined symbol
    symbolSect = dynamic_cast<SymbolSection*>(
        Section::createSection(Section::ST_SYMTAB));
 
    try {
        symbolSect->setASpace(resources_.undefinedAddressSpace());
 
        symbolSect->setLink(strings);
 
        undefSymbol = new NoTypeSymElement();
        undefSymbol->setName(strings->string2Chunk(""));
        symbolSect->addElement(undefSymbol);
 
        // write code and data labels
        for (SymbolMap::iterator iter = labels_.begin();
             iter != labels_.end(); iter++) {
 
            InternalLabel *currLabel = (*iter).second;
 
            Section *ownerSection = findSectionByAddress(currLabel);
            assert(ownerSection != NULL);
 
            SymbolElement *symbol =
                createSymbolWithReference(currLabel, ownerSection);
            assert(symbol != NULL);
 
            symbol->setSection(ownerSection);
            symbol->setName(strings->string2Chunk(currLabel->name));
            symbol->setAbsolute(false);
 
            // check if global
            if (ContainerTools::containsValue(globals_, currLabel->name)) {
                symbol->setBinding(SymbolElement::STB_GLOBAL);
                globals_.erase(currLabel->name);
            } else {
                symbol->setBinding(SymbolElement::STB_LOCAL);
            }
 
            symbolSect->addElement(symbol);
        }
 
        // if there is global definition without corresponding label
        if (!globals_.empty()) {
            throw CompileError(
                __FILE__, __LINE__, __func__,
                "Can't set label to be global. " +
                *(globals_.begin()) + " is undefined.");
        }
 
        // write procedure symbols
        if (bin_.sectionCount(Section::ST_CODE) != 0) {
 
            CodeSection *codeSect =
                dynamic_cast<CodeSection*>(
                    bin_.section(Section::ST_CODE, 0));
 
            assert(codeSect != NULL);
            writeProcedureSymbols(codeSect, symbolSect, strings);
 
        } else if (procedures_.size() != 0) {
            throw CompileError(
                __FILE__, __LINE__, __func__,
                "Invalid procedure declaration: " +
                (*procedures_.begin()).first);
        }
 
        // write relocations
        for (std::set<InternalRelocation*>::iterator iter = relocs_.begin();
             iter != relocs_.end(); iter++) {
 
            InternalRelocation *currReloc = *iter;
            
            // find relocation section for corresponding location section
            RelocSection* relocSect =
                findOrCreateRelocationSection(currReloc, symbolSect);
            assert(relocSect != NULL);
 
            // find destination section
            Section* dstSect = findRelocationDstSection(currReloc);
            
            if (dstSect == NULL) {
                throw CompileError(
                    __FILE__, __LINE__, __func__,
                    "Can't find destination section for address: "
                    + Conversion::toString(currReloc->destination) +
                    " of adress space: " +
                    TPEFTools::addressSpaceName(bin_, *currReloc->dstASpace));
            }
            
            RelocElement *newReloc = new RelocElement();
 
            newReloc->setLocation(currReloc->location);
            
            Word dstIndex =
                currReloc->destination - dstSect->startingAddress();
 
            // set destination element
            if (dstSect->isCodeSection()) {
                CodeSection* codeSect =
                    dynamic_cast<CodeSection*>(dstSect);
                
                newReloc->setDestination(&codeSect->instruction(dstIndex));
                
            } else if (dstSect->type() == Section::ST_DATA ||
                       dstSect->type() == Section::ST_LEDATA ||
                       dstSect->type() == Section::ST_UDATA) {
                
                UDataSection* uDataSect =
                    dynamic_cast<UDataSection*>(dstSect);
                
                Word byteOffset = uDataSect->MAUsToBytes(dstIndex);
               
                newReloc->setDestination(uDataSect->chunk(byteOffset));
 
            } else {
                abortWithError("Unknown dst section of relocation.");
            }
 
            newReloc->setASpace(currReloc->dstASpace);
            newReloc->setType(RelocElement::RT_SELF);
            newReloc->setChunked(false);
            newReloc->setSymbol(undefSymbol);
            newReloc->setSize(currReloc->bitWidth);
 
            relocSect->addElement(newReloc);
        }
 
    } catch(CompileError& e) {
        delete symbolSect;
        throw e;
    }
 
    bin_.addSection(symbolSect);
 
    cleanup();
}

References __func__, abortWithError, TPEF::Section::addElement(), TPEF::Binary::addSection(), assert, bin_, LabelManager::InternalRelocation::bitWidth, TPEF::RawSection::chunk(), cleanup(), ContainerTools::containsValue(), createSymbolWithReference(), LabelManager::InternalRelocation::destination, LabelManager::InternalRelocation::dstASpace, findOrCreateRelocationSection(), findRelocationDstSection(), findSectionByAddress(), globals_, TPEF::CodeSection::instruction(), TPEF::Section::isCodeSection(), labels_, LabelManager::InternalRelocation::location, TPEF::RawSection::MAUsToBytes(), LabelManager::InternalLabel::name, procedures_, relocs_, resources_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::SymbolElement::setAbsolute(), TPEF::RelocElement::setASpace(), TPEF::Section::setASpace(), TPEF::SymbolElement::setBinding(), TPEF::RelocElement::setChunked(), TPEF::RelocElement::setDestination(), TPEF::Section::setLink(), TPEF::RelocElement::setLocation(), TPEF::SymbolElement::setName(), TPEF::SymbolElement::setSection(), TPEF::RelocElement::setSize(), TPEF::RelocElement::setSymbol(), TPEF::RelocElement::setType(), TPEF::Section::startingAddress(), TPEF::StringSection::string2Chunk(), MachineResourceManager::stringSection(), Conversion::toString(), TPEF::Section::type(), MachineResourceManager::undefinedAddressSpace(), and writeProcedureSymbols().

Referenced by AssemblerParser::finalize().

Here is the call graph for this function:

◆ findOrCreateRelocationSection()

RelocSection * LabelManager::findOrCreateRelocationSection	(	InternalRelocation *	currReloc,
		TPEF::SymbolSection *	symbolSect
	)

private

Finds or creates relocation section for relocation.

Parameters

currReloc	Relocation whose section is looked for.
symbolSect	Strings for created section.

Returns: Suitable relocation section for requested relocation.

Definition at line 590 of file LabelManager.cc.

                                                              {
 
    RelocSection* relocSect = NULL;
 
    for (Word j = 0; j < bin_.sectionCount(Section::ST_RELOC); j++) {
        RelocSection* currSect =
            dynamic_cast<RelocSection*>(
                bin_.section(Section::ST_RELOC, j));
 
        if (currSect->referencedSection() ==
            currReloc->locationSect) {
            return currSect;
        }
    }
 
    // none found, create new reloc section
    if (relocSect == NULL) {
        relocSect = dynamic_cast<RelocSection*>(
            Section::createSection(Section::ST_RELOC));
 
        relocSect->setReferencedSection(currReloc->locationSect);
        relocSect->setASpace(resources_.undefinedAddressSpace());
        relocSect->setLink(symbolSect);
 
        bin_.addSection(relocSect);
    }
 
    return relocSect;
}

References TPEF::Binary::addSection(), bin_, LabelManager::InternalRelocation::locationSect, TPEF::RelocSection::referencedSection(), resources_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::setASpace(), TPEF::Section::setLink(), TPEF::RelocSection::setReferencedSection(), and MachineResourceManager::undefinedAddressSpace().

Referenced by finalize().

Here is the call graph for this function:

◆ findRelocationDstSection()

Section * LabelManager::findRelocationDstSection ( InternalRelocation * currReloc )

private

Returns destination section of the relocation.

Parameters

currReloc Relocation whose destination is wanted.

Returns: Destination section of the relocation.

Definition at line 628 of file LabelManager.cc.

                                                                    {
 
    for (Word j = 0; j < bin_.sectionCount(); j++) {
        Section* currSect = bin_.section(j);
 
        // check address space and starting address
        if (currSect->aSpace() == currReloc->dstASpace &&
            currSect->startingAddress() <= currReloc->destination) {
 
            if (currSect->isCodeSection()) {
                CodeSection* codeSect = dynamic_cast<CodeSection*>(currSect);
 
                // check that section is enough long
                if (codeSect->instructionCount() +
                    codeSect->startingAddress() > currReloc->destination) {
                    
                    return currSect;
                }
                
            } else if (currSect->type() == Section::ST_DATA ||
                       currSect->type() == Section::ST_LEDATA ||
                       currSect->type() == Section::ST_UDATA) {
                
                UDataSection* uDataSect =
                    dynamic_cast<UDataSection*>(currSect);
 
                // check that section is enough long
                if (uDataSect->lengthInMAUs() +
                    uDataSect->startingAddress() > currReloc->destination) {
 
                    return currSect;
                }
            }
        }
    }
 
    return NULL;
}

References TPEF::Section::aSpace(), bin_, LabelManager::InternalRelocation::destination, LabelManager::InternalRelocation::dstASpace, TPEF::CodeSection::instructionCount(), TPEF::Section::isCodeSection(), TPEF::RawSection::lengthInMAUs(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::startingAddress(), and TPEF::Section::type().

Referenced by finalize().

Here is the call graph for this function:

◆ findSectionByAddress()

Section * LabelManager::findSectionByAddress ( InternalLabel * currLabel )

private

Returns section that contains the address stored in label.

Parameters

currLabel Label whose destination section is returned.

Returns: Section that contains the address stored in label.

Definition at line 452 of file LabelManager.cc.

                                                           {
 
    // find section by address space
    for (Word i = 0; i < bin_.sectionCount(); i++) {
        Section *currSect = bin_.section(i);
 
        if (currSect->aSpace() == currLabel->aSpace) {
 
            // address must be found from section
            if (currSect->type() == Section::ST_DATA ||
                currSect->type() == Section::ST_LEDATA ||
                currSect->type() == Section::ST_UDATA) {
 
                UDataSection* sect =
                    dynamic_cast<UDataSection*>(currSect);
 
                assert(sect != NULL);
 
                if (currLabel->value >= sect->startingAddress() &&
                    currLabel->value - sect->startingAddress() <
                    sect->lengthInMAUs()) {
 
                    return currSect;
                }
 
            } else if (currSect->isCodeSection()) {
 
                CodeSection* sect = dynamic_cast<CodeSection*>(currSect);
 
                assert(sect != NULL);
 
                if (currLabel->value >= sect->startingAddress() &&
                    currLabel->value - sect->startingAddress() <
                    sect->instructionCount()) {
 
                    return currSect;
                }
 
            } else {
                abortWithError("Label must point to data or code section.");
            }
        }
 
    }
    return NULL;
}

References abortWithError, LabelManager::InternalLabel::aSpace, TPEF::Section::aSpace(), assert, bin_, TPEF::CodeSection::instructionCount(), TPEF::Section::isCodeSection(), TPEF::RawSection::lengthInMAUs(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::startingAddress(), TPEF::Section::type(), and LabelManager::InternalLabel::value.

Referenced by finalize().

Here is the call graph for this function:

◆ removeLabel()

void LabelManager::removeLabel ( std::string & name )

Removes a label from manager.

Parameters

name	Name of the label.

Exceptions

SymbolNotFound Label is not found.

Definition at line 183 of file LabelManager.cc.

                                         {
    if(!MapTools::containsKey(labels_, name)) {
        throw SymbolNotFound(
            __FILE__, __LINE__, __func__,
            "Can't find label: " + name);
    }
 
    labels_.erase(name);
}

References __func__, MapTools::containsKey(), and labels_.

Referenced by DataSectionCreator::finalize().

Here is the call graph for this function:

◆ resolveExpressionValue()

UValue LabelManager::resolveExpressionValue	(	UValue	asmLineNumber,
		LiteralOrExpression &	litOrExpr
	)

Resolves value of label expression.

Parameters

asmLineNumber	Current assembly code line number error information.
litOrExpr	Expression whose value to resolve.
labels	Label manager for resolving label values.

Returns: Value of expression.

Exceptions

CompileError There was error with resolving value.

Definition at line 678 of file LabelManager.cc.

                                                          {
    UValue retVal = 0;
 
    try {
        retVal = value(litOrExpr.expression.label);
 
    } catch (SymbolNotFound& e) {
        CompileError error(
            __FILE__, __LINE__, __func__,
            e.errorMessage());
 
        error.setCause(e);
        error.setCodeFileLineNumber(asmLineNumber);
 
        throw error;
    }
 
    if (litOrExpr.expression.hasOffset) {
        if (litOrExpr.expression.isMinus) {
            retVal -= litOrExpr.expression.offset;
        } else {
            retVal += litOrExpr.expression.offset;
        }
    }
 
    // check if value matches with label + offset
    if(litOrExpr.expression.hasValue) {
        if (litOrExpr.expression.value != retVal) {
 
            CompileError error(
                __FILE__, __LINE__, __func__,
                "Defined expression value (" +
                Conversion::toString(litOrExpr.expression.value) +
                ") does not match with resolved (" +
                Conversion::toString(retVal) +
                ") one.");
 
            error.setCodeFileLineNumber(asmLineNumber);
 
            throw error;
        }
    }
 
    return retVal;
}

References __func__, Exception::errorMessage(), LiteralOrExpression::expression, Expression::hasOffset, Expression::hasValue, Expression::isMinus, Expression::label, Expression::offset, Exception::setCause(), CompileError::setCodeFileLineNumber(), Conversion::toString(), value(), and Expression::value.

Referenced by CodeSectionCreator::addAnnotationes(), CodeSectionCreator::finalize(), and DataSectionCreator::writeDataLineToTPEF().

Here is the call graph for this function:

◆ setGlobal()

void LabelManager::setGlobal ( std::string & labelName )

Set's label to be global label.

Parameters

labelName Name of label to set global.

Definition at line 217 of file LabelManager.cc.

                                            {
    globals_.insert(labelName);
}

References globals_.

Referenced by SetGlobalActor::operator()().

◆ value()

UValue LabelManager::value ( std::string & name )

Returns value of a label by name.

Parameters

name	Name of the requested label.

Returns: Value of the label.

Exceptions

SymbolNotFound If there is not symbol for requested name.

Definition at line 110 of file LabelManager.cc.

                                   {
    if(!MapTools::containsKey(labels_, name)) {
 
        throw SymbolNotFound(
            __FILE__, __LINE__, __func__,
            "Can't find value for label: " + name);
    }
 
    return labels_[name]->value;
}

References __func__, MapTools::containsKey(), and labels_.

Referenced by addLabel(), and resolveExpressionValue().

Here is the call graph for this function:

◆ writeProcedureSymbols()

void LabelManager::writeProcedureSymbols	(	TPEF::CodeSection *	codeSect,
		TPEF::SymbolSection *	symbolSect,
		TPEF::StringSection *	strings
	)

private

Writes all procedure symbols of code section to symbol section.

Parameters

codeSect	Section whose symbols are written.
symbolSect	Section where to symbols are written.
string	Sectiong where symbol strings are stored.

Exceptions

CompileError Procedure declaration is is not in code section.

Definition at line 548 of file LabelManager.cc.

                                                                              {
    for (std::map<std::string, UValue>::iterator
             iter = procedures_.begin();
         iter != procedures_.end(); iter++) {
 
        std::string name = (*iter).first;
        UValue address = (*iter).second;
 
        if (address >=
            codeSect->instructionCount() +
            codeSect->startingAddress()) {
 
            throw CompileError(
                __FILE__, __LINE__, __func__,
                "Invalid procedure declaration: " +
                name);
        }
 
        ProcedSymElement *procedSym = new ProcedSymElement();
 
        procedSym->setReference(
            &codeSect->instruction(
                address - codeSect->startingAddress()));
 
        procedSym->setSection(codeSect);
        procedSym->setName(strings->string2Chunk(name));
        procedSym->setAbsolute(false);
        procedSym->setBinding(SymbolElement::STB_LOCAL);
 
        symbolSect->addElement(procedSym);
    }
}

References __func__, TPEF::Section::addElement(), TPEF::CodeSection::instruction(), TPEF::CodeSection::instructionCount(), procedures_, TPEF::SymbolElement::setAbsolute(), TPEF::SymbolElement::setBinding(), TPEF::SymbolElement::setName(), TPEF::CodeSymElement::setReference(), TPEF::SymbolElement::setSection(), TPEF::Section::startingAddress(), and TPEF::StringSection::string2Chunk().

Referenced by finalize().

Here is the call graph for this function:

Member Data Documentation

◆ bin_

TPEF::Binary& LabelManager::bin_

private

For finding sections containing relocated elements.

Definition at line 166 of file LabelManager.hh.

Referenced by aSpaceName(), finalize(), findOrCreateRelocationSection(), findRelocationDstSection(), and findSectionByAddress().

◆ globals_

std::set<std::string> LabelManager::globals_

private

Names of global symbols.

Definition at line 160 of file LabelManager.hh.

Referenced by cleanup(), finalize(), and setGlobal().

◆ labels_

SymbolMap LabelManager::labels_

private

Contains stored symbols by their name.

Definition at line 151 of file LabelManager.hh.

Referenced by addLabel(), aSpaceElement(), cleanup(), finalize(), removeLabel(), value(), and ~LabelManager().

◆ procedures_

std::map<std::string, UValue> LabelManager::procedures_

private

Names and addresses of procedure starts.

Definition at line 163 of file LabelManager.hh.

Referenced by addProcedure(), cleanup(), finalize(), and writeProcedureSymbols().

◆ relocs_

std::set<InternalRelocation*> LabelManager::relocs_

private

Added relocations.

Definition at line 154 of file LabelManager.hh.

Referenced by cleanup(), commitLastRelocations(), finalize(), and ~LabelManager().

◆ resources_

MachineResourceManager& LabelManager::resources_

private

Common resources of TPEF.

Definition at line 169 of file LabelManager.hh.

Referenced by finalize(), and findOrCreateRelocationSection().

◆ uncommittedRelocs_

std::set<InternalRelocation*> LabelManager::uncommittedRelocs_

private

Uncommitted relocations.

Definition at line 157 of file LabelManager.hh.

Referenced by addRelocation(), cleanup(), clearLastRelocations(), and commitLastRelocations().

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

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ SymbolMap

Constructor & Destructor Documentation

◆ LabelManager()

◆ ~LabelManager()

Member Function Documentation

◆ addLabel()

◆ addProcedure()

◆ addRelocation()

◆ aSpaceElement()

◆ aSpaceName()

◆ cleanup()

◆ clearLastRelocations()

◆ commitLastRelocations()

◆ createSymbolWithReference()

◆ finalize()

◆ findOrCreateRelocationSection()

◆ findRelocationDstSection()

◆ findSectionByAddress()

◆ removeLabel()

◆ resolveExpressionValue()

◆ setGlobal()

◆ value()

◆ writeProcedureSymbols()

Member Data Documentation

◆ bin_

◆ globals_

◆ labels_

◆ procedures_

◆ relocs_

◆ resources_

◆ uncommittedRelocs_