DataSectionCreator Class Reference

#include <DataSectionCreator.hh>

Collaboration diagram for DataSectionCreator:

Classes
struct	InternalSection

Public Member Functions
	DataSectionCreator (MachineResourceManager &resourceManager, AssemblyParserDiagnostic *parent)
	~DataSectionCreator ()
void	setAreaStartAddress (UValue address)
void	addDataLine (const DataLine &origLine)
void	finalize (TPEF::Binary &tpef, LabelManager &labels, bool littleEndian)
void	cleanup ()

Private Member Functions
void	resolveDataAreaSizesAndLabelAddresses (std::map< std::string, UValue > &addressSpaceUsedMAUs, std::vector< std::string > &addedLabels, LabelManager &labels)
UValue	writeDataLineToTPEF (DataLine *line, TPEF::DataSection *dataSection, LabelManager &labels, UValue currentMAUIndex)
int	sizeInWords (UValue value, int MAUWidth, bool isSigned) const

Private Attributes
MachineResourceManager &	resources_
	TPEF Resources and strings.
UValue	currentStartAddress_
	Start address of next line (if fixed address).
bool	isStartAddressDefined_
	Is next data line address fixed.
std::vector< InternalSection >	sections_
	Internal data sections.

Detailed Description

Collects data area information and parses data to tpef data sections.

Definition at line 52 of file DataSectionCreator.hh.

Constructor & Destructor Documentation

DataSectionCreator()

DataSectionCreator::DataSectionCreator	(	MachineResourceManager &	resourceManager,
		AssemblyParserDiagnostic *	parent
	)

Constructor.

Parameters

resourceManager

Resource manager for TPEF to create.

Definition at line 55 of file DataSectionCreator.cc.

                                                                        :
    resources_(resourceManager), currentStartAddress_(0),
    isStartAddressDefined_(false) {
}

~DataSectionCreator()

DataSectionCreator::~DataSectionCreator

(

)

Destructor.

Definition at line 64 of file DataSectionCreator.cc.

                                        {
    cleanup();
}

References cleanup().

Here is the call graph for this function:

Member Function Documentation

addDataLine()

void DataSectionCreator::addDataLine

(

const DataLine &

origLine

)

Adds data line.

Parameters

origLine

Parsed data line to copy to creator.

Definition at line 84 of file DataSectionCreator.cc.

                                                        {
 
    // make copy of original
    DataLine* line = new DataLine;
 
    line->dataSpace = origLine.dataSpace;
    line->width = origLine.width;
    line->initData = origLine.initData;
    line->labels = origLine.labels;
    line->asmLineNumber = origLine.asmLineNumber;
 
    // find out section where to we add line by
    // address and address space
    assert(line != NULL);
 
    InternalSection* foundSection = NULL;
    for (int foundIndex = sections_.size() - 1;
         foundIndex >= 0; foundIndex--) {
 
        InternalSection& section = sections_[foundIndex];
 
        // try to find last suitable section for the data line
        if (section.addressSpace == line->dataSpace) {
 
            // we always create new section for datalines with fixed address,
            // otherwise we just check, if last created section is fine for
            // currently added line
 
            if (section.isInitialized != line->initData.empty() &&
                !isStartAddressDefined_) {
 
                // section with same type of data lines was found
                foundSection = &section;
                break;
 
            } else {
                // section with same type of data lines
                // was not found -> create new section
                break;
            }
        }
    }
 
    // create new section if suitable is not found
    if (foundSection == NULL) {
        InternalSection newSection;
 
        newSection.isInitialized = !line->initData.empty();
        newSection.fixedStartAddress = isStartAddressDefined_;
        newSection.startAddress = currentStartAddress_;
        newSection.addressSpace = line->dataSpace;
        newSection.length = 0;
 
        sections_.push_back(newSection);
 
        // set found section
        foundSection = &sections_.back();
 
        isStartAddressDefined_ = false;
        currentStartAddress_ = 0;
    }
 
    assert(foundSection != NULL);
 
    // add line to section
    foundSection->lines.push_back(line);
}

References DataSectionCreator::InternalSection::addressSpace, DataLine::asmLineNumber, assert, currentStartAddress_, DataLine::dataSpace, DataSectionCreator::InternalSection::fixedStartAddress, DataLine::initData, DataSectionCreator::InternalSection::isInitialized, isStartAddressDefined_, DataLine::labels, DataSectionCreator::InternalSection::length, DataSectionCreator::InternalSection::lines, sections_, DataSectionCreator::InternalSection::startAddress, and DataLine::width.

Referenced by AddDataLineActor::operator()().

cleanup()

void DataSectionCreator::cleanup

(

)

Frees all internally allocated data.

Definition at line 156 of file DataSectionCreator.cc.

                            {
 
    for (unsigned int i = 0; i < sections_.size(); i++) {
        InternalSection &section = sections_[i];
 
        for (unsigned int j = 0; j < section.lines.size(); j++) {
            section.lines[j]->initData.clear();
            section.lines[j]->labels.clear();
            delete section.lines[j];
        }
 
        section.lines.clear();
    }
 
    sections_.clear();
 
    currentStartAddress_ = 0;
    isStartAddressDefined_ = false;
}

References currentStartAddress_, isStartAddressDefined_, DataSectionCreator::InternalSection::lines, and sections_.

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

finalize()

void DataSectionCreator::finalize	(	TPEF::Binary &	tpef,
		LabelManager &	labels,
		bool	littleEndian
	)

Writes created sections to given binary.

All data stored inside creator are freed after this call, unless exception is thrown.

In case of exception the creator restores its state to what it was before calling this method, and this method can be run again.

Parameters

tpef	Binary to which created sections should be added.
labels	LabelManager where to add data labels and relocations.

Exceptions

CompileError

If there is any errors during compiling.

Definition at line 190 of file DataSectionCreator.cc.

                                                           {
    // completed tpef data sections.
    std::vector<TPEF::Section*> completed;
 
    // find out start addresses of each section and resolve label values
    std::map<std::string, UValue> addressSpaceUsedMAUs;
    std::vector<std::string> addedLabels;
 
    try {
 
        resolveDataAreaSizesAndLabelAddresses(
            addressSpaceUsedMAUs, addedLabels, labels);
 
        // create TPEF sections and add initialization data + relocation 
        // elements
        for (unsigned int i = 0; i < sections_.size(); i++) {
            InternalSection  &section = sections_[i];
 
            Section* newSection = NULL;
 
            // if initialized, generate initialization data
            if (section.isInitialized) {
                if (littleEndian) {
                    newSection = Section::createSection(Section::ST_LEDATA);
                } else {
                    newSection = Section::createSection(Section::ST_DATA);
                }
            } else {
                newSection = Section::createSection(Section::ST_UDATA);
            }
 
            // add section to completed sections
            completed.push_back(newSection);
 
            newSection->setName(resources_.stringToChunk(""));
 
            assert(section.fixedStartAddress);
            newSection->setStartingAddress(section.startAddress);
 
            ASpaceElement* aSpace = NULL;
 
            // wrap IllegalMachine to
            // CompileError exception with linenumber
            try {
                aSpace = 
                    resources_.findDataAddressSpace(section.addressSpace);
 
            } catch (IllegalMachine& e) {
                CompileError error(
                    __FILE__, __LINE__, __func__, e.errorMessage());
 
                error.setCodeFileLineNumber(section.lines[0]->asmLineNumber);
                error.setCause(e);
 
                throw error;
 
            } catch (InvalidData& e) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Can't write data to instruction memory.");
 
                error.setCodeFileLineNumber(section.lines[0]->asmLineNumber);
                error.setCause(e);
 
                throw error;
            }
 
            assert(aSpace != NULL);
            newSection->setASpace(aSpace);
 
            // sets data section length in MAUs
            RawSection *rawSection = dynamic_cast<RawSection*>(newSection);
            assert(rawSection != NULL);
            rawSection->setLengthInMAUs(section.length);                   
 
            // aSpace had to be set before writing initialization data of 
            // section
            if (section.isInitialized) {
                DataSection *dataSection = 
                    dynamic_cast<DataSection*>(newSection);
 
                UValue currentMAUIndex = 0;
 
                for (unsigned int j = 0; j < section.lines.size(); j++) {
                    DataLine *line = section.lines[j];
                    currentMAUIndex += writeDataLineToTPEF(
                        line, dataSection, labels, currentMAUIndex);
                }
            }
        }
        
    } catch (CompileError& e) {
 
        labels.clearLastRelocations();
 
        // clean added labels
        for (unsigned int i = 0; i < addedLabels.size(); i++) {
            labels.removeLabel(addedLabels[i]);
        }
 
        // clean already created stuff and throw error forward
        for (UValue j = 0; j < completed.size(); j++) {
            delete completed[j];
        }
 
        completed.clear();
 
        throw e;
 
    }
 
    // really add relocations to manager
    labels.commitLastRelocations();
 
    // add completed sections to binary
    for (UValue i = 0; i < completed.size(); i++) {
        tpef.addSection(completed[i]);
    }
 
    cleanup();
}

References __func__, DataSectionCreator::InternalSection::addressSpace, TPEF::Binary::addSection(), assert, cleanup(), LabelManager::clearLastRelocations(), LabelManager::commitLastRelocations(), TPEF::Section::createSection(), Exception::errorMessage(), MachineResourceManager::findDataAddressSpace(), DataSectionCreator::InternalSection::fixedStartAddress, DataSectionCreator::InternalSection::isInitialized, DataSectionCreator::InternalSection::length, DataSectionCreator::InternalSection::lines, LabelManager::removeLabel(), resolveDataAreaSizesAndLabelAddresses(), resources_, sections_, TPEF::Section::setASpace(), Exception::setCause(), CompileError::setCodeFileLineNumber(), TPEF::RawSection::setLengthInMAUs(), TPEF::Section::setName(), TPEF::Section::setStartingAddress(), TPEF::Section::ST_DATA, TPEF::Section::ST_LEDATA, TPEF::Section::ST_UDATA, DataSectionCreator::InternalSection::startAddress, MachineResourceManager::stringToChunk(), and writeDataLineToTPEF().

Referenced by AssemblerParser::finalize().

Here is the call graph for this function:

resolveDataAreaSizesAndLabelAddresses()

void DataSectionCreator::resolveDataAreaSizesAndLabelAddresses ( std::map< std::string, UValue > &  addressSpaceUsedMAUs, std::vector< std::string > &  addedLabels, LabelManager &  labels  )

private

Resolves data area definition sizes, addresses and writes resolved data labels to label manager.

Parameters

addressSpaceUsedMAUs	Table for updating number of MAUs that are used for each section.
addedLabels	List of all labels added to label manager for error cleanup.
labels	Label bookkeeper.

Definition at line 324 of file DataSectionCreator.cc.

                                                             {
    // calculate sizes and addresses for each data section and
    // add values for labels
 
    for (unsigned int i = 0; i < sections_.size(); i++) {
        InternalSection  &section = sections_[i];
        UValue spaceLastAddress;
 
        if (!MapTools::containsKey(
                addressSpaceUsedMAUs, section.addressSpace)) {
 
            addressSpaceUsedMAUs[section.addressSpace] = 0;
        }
 
        // last used address of address space of current section
        spaceLastAddress = addressSpaceUsedMAUs[section.addressSpace];
 
        // check if we have to look, if current address is ok or
        // we set the address
        if (section.fixedStartAddress) {
            if (spaceLastAddress > section.startAddress) {
 
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Can't start data section from address: " +
                    Conversion::toString(section.startAddress) +
                    " first unused address in address space: " +
                    section.addressSpace +
                    " is: " + Conversion::toString(spaceLastAddress));
 
                error.setCodeFileLineNumber(section.lines[0]->asmLineNumber);
 
                throw error;
            }
        } else {
            section.startAddress = spaceLastAddress;
        }
 
        section.fixedStartAddress = true;
 
        // add also labels to label map
        UValue dataLineAddress = section.startAddress;
 
        for (unsigned int j = 0; j < section.lines.size(); j++) {
            DataLine *currentLine = section.lines[j];
 
            // wrap IllegalMachine and ObjectAlreadyExists exceptions
            // to CompileError exception with linenumber
            try {
 
                for (unsigned int k = 0;
                     k < currentLine->labels.size(); k++) {
 
                    labels.addLabel(
                        *resources_.findDataAddressSpace(
                            section.addressSpace),
                        currentLine->labels[k], dataLineAddress);
                    
                    // for cleanup 
                    addedLabels.push_back(currentLine->labels[k]);
                }
 
                dataLineAddress += currentLine->width;
 
            } catch (InvalidData& e) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Can't write data to instruction memory.");
 
                error.setCodeFileLineNumber(currentLine->asmLineNumber);
                error.setCause(e);
 
                throw error;
 
            } catch (Exception& e) {
 
                CompileError error(
                    __FILE__, __LINE__, __func__, e.errorMessage());
 
                error.setCodeFileLineNumber(currentLine->asmLineNumber);
                error.setCause(e);
 
                throw error;
            }
        }
 
        section.length = dataLineAddress - section.startAddress;
        addressSpaceUsedMAUs[section.addressSpace] = dataLineAddress;
#if 0
        // some useful dedug info about created data sections and mapping
        std::cerr << "Section length: " << section.length
                  << "\tSection start:  " << section.startAddress
                  << std::endl;
#endif
        // NOTE: here we can check if we can merge two sections together.
        //       If both are initialized or uninitialized and second
        //       section's start address is same that first section
        //       start address + first section size then merging can
        //       be done.
    }
}

References __func__, LabelManager::addLabel(), DataSectionCreator::InternalSection::addressSpace, DataLine::asmLineNumber, MapTools::containsKey(), Exception::errorMessage(), MachineResourceManager::findDataAddressSpace(), DataSectionCreator::InternalSection::fixedStartAddress, DataLine::labels, DataSectionCreator::InternalSection::length, DataSectionCreator::InternalSection::lines, resources_, sections_, Exception::setCause(), CompileError::setCodeFileLineNumber(), DataSectionCreator::InternalSection::startAddress, Conversion::toString(), and DataLine::width.

Referenced by finalize().

Here is the call graph for this function:

setAreaStartAddress()

void DataSectionCreator::setAreaStartAddress

(

UValue

address

)

Sets fixed address for the next data area definition.

Parameters

address

Start address of next data area definition.

Definition at line 73 of file DataSectionCreator.cc.

                                                           {
    currentStartAddress_ = address;
    isStartAddressDefined_ = true;
}

References currentStartAddress_, and isStartAddressDefined_.

Referenced by SetStartAddressActor::operator()().

sizeInWords()

int DataSectionCreator::sizeInWords ( UValue  value, int  width, bool  isSigned  ) const

private

Compute the minimum number of words of given bit width that are necessary to encode an integer value.

Parameters

value	Integer value to encode.
width	Bit width of the words.
isSigned	Tells whether the value had a sign ('+'/'-') in front of it.

Definition at line 544 of file DataSectionCreator.cc.

          {
 
    // maximum word width allowed: 32 bits
    assert(static_cast<unsigned int>(width) <= sizeof(value) * BYTE_BITWIDTH);
 
    int neededBits = 0;
    
    if (isSigned) {
        neededBits = MathTools::requiredBitsSigned(SLongWord(value));
    } else {
        neededBits = MathTools::requiredBits(value);     
    }
    
    int wordCount = static_cast<int>(
        ceil(static_cast<double>(neededBits) / 
             static_cast<double>(width)));
  
    return wordCount;
}

References assert, BYTE_BITWIDTH, MathTools::requiredBits(), and MathTools::requiredBitsSigned().

Referenced by writeDataLineToTPEF().

Here is the call graph for this function:

writeDataLineToTPEF()

UValue DataSectionCreator::writeDataLineToTPEF ( DataLine *  line, TPEF::DataSection *  dataSection, LabelManager &  labels, UValue  currentMAUIndex  )

private

Write one data line definition to TPEF data section.

Parameters

line	Data line to write.
dataSection	Section where to write data.
label	Label manager to resolve label values.
currentMAUIndex	MAU index to start of data line in TPEF.

Returns

MAU count that were written to TPEF.

Exceptions

CompileError

the data line contains errors.

Definition at line 439 of file DataSectionCreator.cc.

                            {
    UValue writtenMAUs = 0;
 
    // read maus from init data until inited data of line ends
    for (unsigned int k = 0; k < line->initData.size(); k++) {
        InitDataField &data = line->initData[k];
        
        UValue value = 0;
        bool isSigned = false;
 
        // if expression resolve value
        if(data.litOrExpr.isExpression) {
            value = labels.resolveExpressionValue(
                line->asmLineNumber, data.litOrExpr);
        } else {
            value = data.litOrExpr.value;
            isSigned = data.litOrExpr.isSigned;
        }
 
        UValue usedMAUs =
            sizeInWords(value, dataSection->aSpace()->MAU(), isSigned);
 
        // if data width is explicitely set use that width
        if (data.width != 0) {
            if (usedMAUs > data.width) {
 
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Init field contains too long value. Reserved MAUs: " +
                    Conversion::toString(data.width) +
                    " Needed MAUs: " +
                    Conversion::toString(usedMAUs));
 
                error.setCodeFileLineNumber(line->asmLineNumber);
 
                throw error;
            }
 
            usedMAUs = data.width;
        }
 
        // check if data line width is enough for writing next value
        if (writtenMAUs + usedMAUs > line->width) {
 
            CompileError error(
                __FILE__, __LINE__, __func__,
                "Data line contains too much init data. Reserved MAUs: " +
                Conversion::toString(line->width) +
                " Already inited MAUs: " +
                Conversion::toString(writtenMAUs));
 
            error.setCodeFileLineNumber(line->asmLineNumber);
 
            throw error;
        }
 
        // select extending for writing data to data section
        if (isSigned) {
            dataSection->writeValue(
                currentMAUIndex + writtenMAUs, 
                usedMAUs, static_cast<SValue>(value));
 
        } else {
            dataSection->writeValue(
                currentMAUIndex + writtenMAUs, usedMAUs, value);
        }
 
        // if expression then add relocation.
        if(data.litOrExpr.isExpression) {
            Chunk *srcChunk =
                dataSection->chunk(
                    dataSection->MAUsToBytes(
                        currentMAUIndex + writtenMAUs));
 
            labels.addRelocation(
                *dataSection, *srcChunk,
                labels.aSpaceElement(data.litOrExpr.expression.label),
                value, usedMAUs * dataSection->aSpace()->MAU());
        }
 
        writtenMAUs += usedMAUs;
    }
 
    if (writtenMAUs  < line->width) {
        dataSection->writeValue(currentMAUIndex+writtenMAUs, 1,
                                static_cast<unsigned long>(0));
        writtenMAUs++;
    }
 
    // increase index to data section
    return line->width;
}

References __func__, LabelManager::addRelocation(), DataLine::asmLineNumber, TPEF::Section::aSpace(), LabelManager::aSpaceElement(), TPEF::RawSection::chunk(), LiteralOrExpression::expression, DataLine::initData, LiteralOrExpression::isExpression, LiteralOrExpression::isSigned, Expression::label, InitDataField::litOrExpr, TPEF::ASpaceElement::MAU(), TPEF::RawSection::MAUsToBytes(), LabelManager::resolveExpressionValue(), CompileError::setCodeFileLineNumber(), sizeInWords(), Conversion::toString(), LiteralOrExpression::value, InitDataField::width, DataLine::width, and TPEF::DataSection::writeValue().

Referenced by finalize().

Here is the call graph for this function:

Member Data Documentation

currentStartAddress_

UValue DataSectionCreator::currentStartAddress_

private

Start address of next line (if fixed address).

Definition at line 104 of file DataSectionCreator.hh.

Referenced by addDataLine(), cleanup(), and setAreaStartAddress().

isStartAddressDefined_

bool DataSectionCreator::isStartAddressDefined_

private

Is next data line address fixed.

Definition at line 106 of file DataSectionCreator.hh.

Referenced by addDataLine(), cleanup(), and setAreaStartAddress().

resources_

MachineResourceManager& DataSectionCreator::resources_

private

TPEF Resources and strings.

Definition at line 101 of file DataSectionCreator.hh.

Referenced by finalize(), and resolveDataAreaSizesAndLabelAddresses().

sections_

std::vector<InternalSection> DataSectionCreator::sections_

private

Internal data sections.

Definition at line 109 of file DataSectionCreator.hh.

Referenced by addDataLine(), cleanup(), finalize(), and resolveDataAreaSizesAndLabelAddresses().

---

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

• DataSectionCreator.hh
• DataSectionCreator.cc