Subversion Repositories lxp32

/*

 * Copyright (c) 2016 by Alex I. Kuznetsov.

 *

 * Part of the LXP32 CPU IP core.

 *

 * This module implements members of the Linker class.

 */

#include "linker.h"

#include "linkableobject.h"

#include <iostream>

#include <fstream>

#include <sstream>

#include <map>

#include <stdexcept>

#include <cassert>

void Linker::addObject(LinkableObject &obj) {

        _objects.push_back(&obj);

}

void Linker::link(OutputWriter &writer) {

        if(_objects.empty()) throw std::runtime_error("Object set is empty");

// Merge symbol tables

        buildSymbolTable();

// Determine entry point

        if(_objects.size()==1) _entryObject=_objects[0];

        else {

                auto const it=_globalSymbolTable.find("entry");

                if(it==_globalSymbolTable.end())

                        throw std::runtime_error("Entry point not defined: cannot find \"entry\" symbol");

                if(it->second.rva!=0)

                        throw std::runtime_error(it->second.obj->name()+": Entry point must refer to the start of the object");

                _entryObject=it->second.obj;

        }

// Assign virtual addresses

        placeObjects();

// Perform relocations

        for(auto &obj: _objects) relocateObject(obj);

// Write binary data

        writeObjects(writer);

}

void Linker::setBase(LinkableObject::Word base) {

        _base=base;

}

void Linker::setAlignment(std::size_t align) {

        _align=align;

}

void Linker::setImageSize(std::size_t size) {

        _imageSize=size;

}

/*

 * Private members

 */

void Linker::buildSymbolTable() {

        _globalSymbolTable.clear();

        for(auto const &obj: _objects) {

                auto const &table=obj->symbols();

                for(auto const &item: table) {

// Insert item to the global symbol table if it doesn't exist yet

                        auto it=_globalSymbolTable.emplace(item.first,GlobalSymbolData()).first;

// If the symbol is local, check that it has not been already defined in another object

                        if(item.second.type==LinkableObject::Local) {

                                if(it->second.obj) {

                                        std::ostringstream msg;

                                        msg<<obj->name()<<": Duplicate definition of \""<<item.first;

                                        msg<<"\" (previously defined in "<<it->second.obj->name()<<")";

                                        throw std::runtime_error(msg.str());

                                }

                                it->second.obj=obj;

                                it->second.rva=item.second.rva;

                        }

// Merge reference tables

                        for(auto const &ref: item.second.refs) it->second.refs.emplace(obj,ref.rva);

                }

        }

// Check that no undefined symbols remain

        for(auto const &item: _globalSymbolTable) {

                if(item.second.obj==nullptr&&!item.second.refs.empty()) {

                        std::ostringstream msg;

                        msg<<"Undefined symbol: \""<<item.first<<"\"";

                        auto const it=item.second.refs.begin();

                        msg<<" (referenced from "<<it->first->name()<<")";

                        throw std::runtime_error(msg.str());

                }

        }

}

void Linker::placeObjects() {

        auto currentBase=_base;

// Make entry object the first

        if(_objects.size()>1) {

                for(auto it=_objects.begin();it!=_objects.end();++it) {

                        if(*it==_entryObject) {

                                std::swap(*it,_objects[0]);

                                break;

                        }

                }

        }

// Set base addresses

        for(auto it=_objects.begin();it!=_objects.end();++it) {

                (*it)->setVirtualAddress(currentBase);

                if(it+1!=_objects.end()) (*it)->addPadding(_align);

                else (*it)->addPadding();

                currentBase+=static_cast<LinkableObject::Word>((*it)->codeSize());

        }

}

void Linker::relocateObject(LinkableObject *obj) {

        for(auto const &sym: obj->symbols()) {

                auto it=_globalSymbolTable.find(sym.first);

                assert(it!=_globalSymbolTable.end());

                if(it->second.refs.empty()) continue;

                assert(it->second.obj);

                auto addr=it->second.obj->virtualAddress()+it->second.rva;

                for(auto const &ref: sym.second.refs) {

                        auto offset=obj->getWord(ref.rva);

                        obj->replaceWord(ref.rva,addr+offset);

                }

        }

}

void Linker::writeObjects(OutputWriter &writer) {

        std::size_t currentSize=0;

// Write entry object

        writer.write(reinterpret_cast<const char*>(_entryObject->code()),_entryObject->codeSize());

        currentSize+=_entryObject->codeSize();

// Write other objects

        for(auto const &obj: _objects) {

                if(obj==_entryObject) continue;

                writer.write(reinterpret_cast<const char*>(obj->code()),obj->codeSize());

                currentSize+=obj->codeSize();

        }

// Pad file if requested

        if(_imageSize>0) {

                if(currentSize>_imageSize)

                        throw std::runtime_error("Image size exceeds the specified value");

                else if(currentSize<_imageSize) writer.pad(_imageSize-currentSize);

        }

}