Subversion Repositories riscv_vhdl

/*

 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 */

#include "elfreader.h"

#include <iostream>

namespace debugger {

/** Class registration in the Core */

REGISTER_CLASS(ElfReaderService)

ElfReaderService::ElfReaderService(const char *name) : IService(name) {

    registerInterface(static_cast<IElfReader *>(this));

    registerAttribute("SourceProc", &sourceProc_);

    image_ = NULL;

    sectionNames_ = NULL;

    symbolList_.make_list(0);

    loadSectionList_.make_list(0);

    sourceProc_.make_string("");

    isrc_ = 0;

}

ElfReaderService::~ElfReaderService() {

    if (image_) {

        delete image_;

    }

}

void ElfReaderService::postinitService() {

    isrc_ = static_cast<ISourceCode *>(

       RISCV_get_service_iface(sourceProc_.to_string(),

                               IFACE_SOURCE_CODE));

    if (!isrc_) {

        RISCV_error("SourceCode interface '%s' not found",

                    sourceProc_.to_string());

    }

}

int ElfReaderService::readFile(const char *filename) {

    FILE *fp = fopen(filename, "rb");

    if (!fp) {

        RISCV_error("File '%s' not found", filename);

        return -1;

    }

    fseek(fp, 0, SEEK_END);

    int sz = ftell(fp);

    rewind(fp);

    if (image_) {

        delete image_;

        sectionNames_ = NULL;

        sourceProc_.make_list(0);

        symbolList_.make_list(0);

        loadSectionList_.make_list(0);

    }

    image_ = new uint8_t[sz];

    fread(image_, 1, sz, fp);

    if (readElfHeader() != 0) {

        fclose(fp);

        return 0;

    }

    symbolNames_ = 0;

    if (!header_->get_shoff()) {

        fclose(fp);

        return 0;

    }

    sh_tbl_ = new SectionHeaderType *[header_->get_shnum()];

    /** Search .shstrtab section */

    uint8_t *psh = &image_[header_->get_shoff()];

    for (int i = 0; i < header_->get_shnum(); i++) {

        sh_tbl_[i] = new SectionHeaderType(psh, header_);

        sectionNames_ = reinterpret_cast<char *>(&image_[sh_tbl_[i]->get_offset()]);

        if (sh_tbl_[i]->get_type() == SHT_STRTAB &&

            strcmp(sectionNames_ + sh_tbl_[i]->get_name(), ".shstrtab") != 0) {

            sectionNames_ = NULL;

        }

        if (header_->isElf32()) {

            psh += sizeof(Elf32_Shdr);

        } else {

            psh += sizeof(Elf64_Shdr);

        }

    }

    if (!sectionNames_) {

        printf("err: section .shstrtab not found.\n");

    }

    /** Search ".strtab" section with Debug symbols */

    SectionHeaderType *sh;

    for (int i = 0; i < header_->get_shnum(); i++) {

        sh = sh_tbl_[i];

        if (sectionNames_ == NULL || sh->get_type() != SHT_STRTAB) {

            continue;

        }

        if (strcmp(sectionNames_ + sh->get_name(), ".strtab")) {

            continue;

        }

        /**

            * This section holds strings, most commonly the strings that

            * represent the names associated with symbol table entries.

            * If the file has a loadable segment that includes the symbol

            * string table, the section's attributes will include the

            * SHF_ALLOC bit; otherwise, that bit will be turned off.

            */

        symbolNames_ = reinterpret_cast<char *>(&image_[sh->get_offset()]);

    }

    if (!symbolNames_) {

        printf("err: section .strtab not found. No debug symbols.\n");

    }

    /** Direct loading via tap interface: */

    int bytes_loaded = loadSections();

    RISCV_info("Loaded: %d B", bytes_loaded);

    if (header_->get_phoff()) {

        //readProgramHeader();

    }

    fclose(fp);

    return 0;

}

int ElfReaderService::readElfHeader() {

    header_ = new ElfHeaderType(image_);

    if (header_->isElf()) {

        return 0;

    }

    RISCV_error("File format is not ELF", NULL);

    return -1;

}

int ElfReaderService::loadSections() {

    SectionHeaderType *sh;

    uint64_t total_bytes = 0;

    AttributeType tsymb;

    for (int i = 0; i < header_->get_shnum(); i++) {

        sh = sh_tbl_[i];

        if (sh->get_size() == 0) {

            continue;

        }

        if (sectionNames_ && (sh->get_flags() & SHF_ALLOC)) {

            RISCV_info("Reading '%s' section", &sectionNames_[sh->get_name()]);

        }

        if (sh->get_type() == SHT_PROGBITS && (sh->get_flags() & SHF_ALLOC) != 0) {

            /**

             * @brief   Instructions or other processor's information

             * @details This section holds information defined by the program,

             *          whose format and meaning are determined solely by the

             *          program.

             */

            AttributeType loadsec;

            loadsec.make_list(LoadSh_Total);

            if (sectionNames_) {

                loadsec[LoadSh_name].make_string(&sectionNames_[sh->get_name()]);

            } else {

                loadsec[LoadSh_name].make_string("unknown");

            }

            loadsec[LoadSh_addr].make_uint64(sh->get_addr());

            loadsec[LoadSh_size].make_uint64(sh->get_size());

            loadsec[LoadSh_data].make_data(static_cast<unsigned>(sh->get_size()),

                                           &image_[sh->get_offset()]);

            loadSectionList_.add_to_list(&loadsec);

            total_bytes += sh->get_size();

        } else if (sh->get_type() == SHT_NOBITS

                    && (sh->get_flags() & SHF_ALLOC) != 0) {

            /**

             * @brief   Initialized data

             * @details A section of this type occupies no space in  the file

             *          but otherwise resembles SHT_PROGBITS.  Although this

             *          section contains no bytes, the sh_offset member

             *          contains the conceptual file offset.

             */

            AttributeType loadsec;

            loadsec.make_list(LoadSh_Total);

            if (sectionNames_) {

                loadsec[LoadSh_name].make_string(&sectionNames_[sh->get_name()]);

            } else {

                loadsec[LoadSh_name].make_string("unknown");

            }

            loadsec[LoadSh_addr].make_uint64(sh->get_addr());

            loadsec[LoadSh_size].make_uint64(sh->get_size());

            loadsec[LoadSh_data].make_data(static_cast<unsigned>(sh->get_size()));

            memset(loadsec[LoadSh_data].data(),

                        0, static_cast<size_t>(sh->get_size()));

            loadSectionList_.add_to_list(&loadsec);

            total_bytes += sh->get_size();

        } else if (sh->get_type() == SHT_SYMTAB || sh->get_type() == SHT_DYNSYM) {

            processDebugSymbol(sh);

        }

    }

    symbolList_.sort(LoadSh_name);

    if (isrc_) {

        isrc_->addSymbols(&symbolList_);

    }

    return static_cast<int>(total_bytes);

}

void ElfReaderService::processDebugSymbol(SectionHeaderType *sh) {

    uint64_t symbol_off = 0;

    SymbolTableType *st;

    AttributeType tsymb;

    uint8_t st_type;

    const char *symb_name;

    //const char *file_name = 0;

    if (!symbolNames_) {

        return;

    }

    while (symbol_off < sh->get_size()) {

        st = new SymbolTableType(&image_[sh->get_offset() + symbol_off],

                                header_);

        symb_name = &symbolNames_[st->get_name()];

        st_type = st->get_info() & 0xF;

        if ((st_type == STT_OBJECT || st_type == STT_FUNC) && st->get_value()) {

            tsymb.make_list(Symbol_Total);

            tsymb[Symbol_Name].make_string(symb_name);

            tsymb[Symbol_Addr].make_uint64(st->get_value());

            tsymb[Symbol_Size].make_uint64(st->get_size());

            if (st_type == STT_FUNC) {

                tsymb[Symbol_Type].make_uint64(SYMBOL_TYPE_FUNCTION);

            } else {

                tsymb[Symbol_Type].make_uint64(SYMBOL_TYPE_DATA);

            }

            symbolList_.add_to_list(&tsymb);

        } else if (st_type == STT_FILE) {

            //file_name = symb_name;

        }

        if (sh->get_entsize()) {

            // section with elements of fixed size

            symbol_off += sh->get_entsize();

        } else if (st->get_size()) {

            symbol_off += st->get_size();

        } else {

            if (header_->isElf32()) {

                symbol_off += sizeof(Elf32_Sym);

            } else {

                symbol_off += sizeof(Elf64_Sym);

            }

        }

        delete st;

    }

}

}  // namespace debugger