/*
* File:        ELFSourceFile.cpp
*
* Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
* See included license file for license details.
*/

#include "ELFSourceFile.h"
#include "Logging.h"
#include "GHSSecInfo.h"
#include <ctype.h>
#include <algorithm>
#include "string.h"

//! The name of the toolset option.
#define kToolsetOptionName "toolset"
#define kGHSToolsetName "GHS"
#define kGCCToolsetName "GCC"
#define kGNUToolsetName "GNU"
#define kADSToolsetName "ADS"

//! Name of the option to control .secinfo action.
#define kSecinfoClearOptionName "secinfoClear"
#define kSecinfoDefaultName "DEFAULT"
#define kSecinfoIgnoreName "IGNORE"
#define kSecinfoROMName "ROM"
#define kSecinfoCName "C"

using namespace elftosb;

ELFSourceFile::ELFSourceFile(const std::string & path)
:       SourceFile(path),
       m_toolset(kUnknownToolset),
       m_secinfoOption(kSecinfoDefault)
{
}

ELFSourceFile::~ELFSourceFile()
{
}

bool ELFSourceFile::isELFFile(std::istream & stream)
{
       try
       {
               StELFFile elf(stream);
               return true;
       }
       catch (...)
       {
               return false;
       }
}

void ELFSourceFile::open()
{
       // Read toolset option
       m_toolset = readToolsetOption();

       // Read option and select default value
       m_secinfoOption = readSecinfoClearOption();
       if (m_secinfoOption == kSecinfoDefault)
       {
               m_secinfoOption = kSecinfoCStartupClear;
       }

       // Open the stream
       SourceFile::open();

       m_file = new StELFFile(*m_stream);
//      m_file->dumpSections();

       // Set toolset in elf file object
       switch (m_toolset)
       {
       // default toolset is GHS
               case kGHSToolset:
       case kUnknownToolset:
                       m_file->setELFVariant(eGHSVariant);
                       break;
               case kGCCToolset:
                       m_file->setELFVariant(eGCCVariant);
                       break;
               case kADSToolset:
                       m_file->setELFVariant(eARMVariant);
                       break;
       }
}

void ELFSourceFile::close()
{
       SourceFile::close();

       m_file.safe_delete();
}

elf_toolset_t ELFSourceFile::readToolsetOption()
{
       do {
               const OptionContext * options = getOptions();
               if (!options || !options->hasOption(kToolsetOptionName))
               {
                       break;
               }

               const Value * value = options->getOption(kToolsetOptionName);
               const StringValue * stringValue = dynamic_cast<const StringValue*>(value);
               if (!stringValue)
               {
                       // Not a string value, warn the user.
                       Log::log(Logger::WARNING, "invalid type for 'toolset' option\n");
                       break;
               }

               std::string toolsetName = *stringValue;

               // convert option value to uppercase
               std::transform<std::string::const_iterator, std::string::iterator, int (*)(int)>(toolsetName.begin(), toolsetName.end(), toolsetName.begin(), toupper);

               if (toolsetName == kGHSToolsetName)
               {
                       return kGHSToolset;
               }
               else if (toolsetName == kGCCToolsetName || toolsetName == kGNUToolsetName)
               {
                       return kGCCToolset;
               }
               else if (toolsetName == kADSToolsetName)
               {
                       return kADSToolset;
               }

               // Unrecognized option value, log a warning.
               Log::log(Logger::WARNING, "unrecognized value for 'toolset' option\n");
       } while (0);

       return kUnknownToolset;
}

//! It is up to the caller to convert from kSecinfoDefault to the actual default
//! value.
secinfo_clear_t ELFSourceFile::readSecinfoClearOption()
{
       do {
               const OptionContext * options = getOptions();
               if (!options || !options->hasOption(kSecinfoClearOptionName))
               {
                       break;
               }

               const Value * value = options->getOption(kSecinfoClearOptionName);
               const StringValue * stringValue = dynamic_cast<const StringValue*>(value);
               if (!stringValue)
               {
                       // Not a string value, warn the user.
                       Log::log(Logger::WARNING, "invalid type for 'secinfoClear' option\n");
                       break;
               }

               std::string secinfoOption = *stringValue;

               // convert option value to uppercase
               std::transform<std::string::const_iterator, std::string::iterator, int (*)(int)>(secinfoOption.begin(), secinfoOption.end(), secinfoOption.begin(), toupper);

               if (secinfoOption == kSecinfoDefaultName)
               {
                       return kSecinfoDefault;
               }
               else if (secinfoOption == kSecinfoIgnoreName)
               {
                       return kSecinfoIgnore;
               }
               else if (secinfoOption == kSecinfoROMName)
               {
                       return kSecinfoROMClear;
               }
               else if (secinfoOption == kSecinfoCName)
               {
                       return kSecinfoCStartupClear;
               }

               // Unrecognized option value, log a warning.
               Log::log(Logger::WARNING, "unrecognized value for 'secinfoClear' option\n");
       } while (0);

       return kSecinfoDefault;
}

//! To create a data source for all sections of the ELF file, a WildcardMatcher
//! is instantiated and passed to createDataSource(StringMatcher&).
DataSource * ELFSourceFile::createDataSource()
{
       WildcardMatcher matcher;
       return createDataSource(matcher);
}

DataSource * ELFSourceFile::createDataSource(StringMatcher & matcher)
{
       assert(m_file);
       ELFDataSource * source = new ELFDataSource(m_file);
       source->setSecinfoOption(m_secinfoOption);

       Log::log(Logger::DEBUG2, "filtering sections of file: %s\n", getPath().c_str());

       // We start at section 1 to skip the null section that is always first.
       unsigned index = 1;
       for (; index < m_file->getSectionCount(); ++index)
       {
               const Elf32_Shdr & header = m_file->getSectionAtIndex(index);
               std::string name = m_file->getSectionNameAtIndex(header.sh_name);

               // Ignore most section types
               if (!(header.sh_type == SHT_PROGBITS || header.sh_type == SHT_NOBITS))
               {
                       continue;
               }

               // Ignore sections that don't have the allocate flag set.
               if ((header.sh_flags & SHF_ALLOC) == 0)
               {
                       continue;
               }

               if (matcher.match(name))
               {
                       Log::log(Logger::DEBUG2, "creating segment for section %s\n", name.c_str());
                       source->addSection(index);
               }
               else
               {
                       Log::log(Logger::DEBUG2, "section %s did not match\n", name.c_str());
               }
       }

       return source;
}

//! It is assumed that all ELF files have an entry point.
//!
bool ELFSourceFile::hasEntryPoint()
{
       return true;
}

//! The StELFFile::getTypeOfSymbolAtIndex() method uses different methods of determining
//! ARM/Thumb mode depending on the toolset.
uint32_t ELFSourceFile::getEntryPointAddress()
{
       uint32_t entryPoint = 0;

       // get entry point address
       const Elf32_Ehdr & header = m_file->getFileHeader();

       // find symbol corresponding to entry point and determine if
       // it is arm or thumb mode
       unsigned symbolIndex = m_file->getIndexOfSymbolAtAddress(header.e_entry);
       if (symbolIndex != 0)
       {
               ARMSymbolType_t symbolType = m_file->getTypeOfSymbolAtIndex(symbolIndex);
               bool entryPointIsThumb = (symbolType == eThumbSymbol);
               const Elf32_Sym & symbol = m_file->getSymbolAtIndex(symbolIndex);
               std::string symbolName = m_file->getSymbolName(symbol);

               Log::log(Logger::DEBUG2, "Entry point is %s@0x%08x (%s)\n", symbolName.c_str(), symbol.st_value, entryPointIsThumb ? "Thumb" : "ARM");

               // set entry point, setting the low bit if it is thumb mode
               entryPoint = header.e_entry + (entryPointIsThumb ? 1 : 0);
       }
       else
       {
               entryPoint = header.e_entry;
       }

       return entryPoint;
}

//! \return A DataTarget that describes the named section.
//! \retval NULL There was no section with the requested name.
DataTarget * ELFSourceFile::createDataTargetForSection(const std::string & section)
{
       assert(m_file);
       unsigned index = m_file->getIndexOfSectionWithName(section);
       if (index == SHN_UNDEF)
       {
               return NULL;
       }

       const Elf32_Shdr & sectionHeader = m_file->getSectionAtIndex(index);
       uint32_t beginAddress = sectionHeader.sh_addr;
       uint32_t endAddress = beginAddress + sectionHeader.sh_size;
       ConstantDataTarget * target = new ConstantDataTarget(beginAddress, endAddress);
       return target;
}

//! \return A DataTarget instance pointing at the requested symbol.
//! \retval NULL No symbol matching the requested name was found.
DataTarget * ELFSourceFile::createDataTargetForSymbol(const std::string & symbol)
{
       assert(m_file);
       unsigned symbolCount = m_file->getSymbolCount();
       unsigned i;

       for (i=0; i < symbolCount; ++i)
       {
               const Elf32_Sym & symbolHeader = m_file->getSymbolAtIndex(i);
               std::string symbolName = m_file->getSymbolName(symbolHeader);
               if (symbolName == symbol)
               {
           ARMSymbolType_t symbolType = m_file->getTypeOfSymbolAtIndex(i);
           bool symbolIsThumb = (symbolType == eThumbSymbol);

                       uint32_t beginAddress = symbolHeader.st_value + (symbolIsThumb ? 1 : 0);
                       uint32_t endAddress = beginAddress + symbolHeader.st_size;
                       ConstantDataTarget * target = new ConstantDataTarget(beginAddress, endAddress);
                       return target;
               }
       }

       // didn't find a matching symbol
       return NULL;
}

bool ELFSourceFile::hasSymbol(const std::string & name)
{
       Elf32_Sym symbol;
       return lookupSymbol(name, symbol);
}

uint32_t ELFSourceFile::getSymbolValue(const std::string & name)
{
       unsigned symbolCount = m_file->getSymbolCount();
       unsigned i;

       for (i=0; i < symbolCount; ++i)
       {
               const Elf32_Sym & symbolHeader = m_file->getSymbolAtIndex(i);
               std::string symbolName = m_file->getSymbolName(symbolHeader);
               if (symbolName == name)
               {
           // If the symbol is a function, then we check to see if it is Thumb code and set bit 0 if so.
           if (ELF32_ST_TYPE(symbolHeader.st_info) == STT_FUNC)
           {
               ARMSymbolType_t symbolType = m_file->getTypeOfSymbolAtIndex(i);
               bool symbolIsThumb = (symbolType == eThumbSymbol);
               return symbolHeader.st_value + (symbolIsThumb ? 1 : 0);
           }
           else
           {
                           return symbolHeader.st_value;
           }
               }
       }

   // Couldn't find the symbol, so return 0.
       return 0;
}

unsigned ELFSourceFile::getSymbolSize(const std::string & name)
{
       Elf32_Sym symbol;
       if (!lookupSymbol(name, symbol))
       {
               return 0;
       }

       return symbol.st_size;
}

//! \param name The name of the symbol on which info is wanted.
//! \param[out] info Upon succssful return this is filled in with the symbol's information.
//!
//! \retval true The symbol was found and \a info is valid.
//! \retval false No symbol with \a name was found in the file.
bool ELFSourceFile::lookupSymbol(const std::string & name, Elf32_Sym & info)
{
       assert(m_file);
       unsigned symbolCount = m_file->getSymbolCount();
       unsigned i;

       for (i=0; i < symbolCount; ++i)
       {
               const Elf32_Sym & symbol = m_file->getSymbolAtIndex(i);
               std::string thisSymbolName = m_file->getSymbolName(symbol);

               // Is this the symbol we're looking for?
               if (thisSymbolName == name)
               {
                       info = symbol;
                       return true;
               }
       }

       // Didn't file the symbol.
       return false;
}

ELFSourceFile::ELFDataSource::~ELFDataSource()
{
       segment_vector_t::iterator it = m_segments.begin();
       for (; it != m_segments.end(); ++it)
       {
               delete *it;
       }
}

//! Not all sections will actually result in a new segment being created. Only
//! those sections whose type is #SHT_PROGBITS or #SHT_NOBITS will create
//! a new segment. Also, only sections whose size is non-zero will actually
//! create a segment.
//!
//! In addition to this, ELF files that have been marked as being created by
//! the Green Hills Software toolset have an extra step. #SHT_NOBITS sections
//! are looked up in the .secinfo section to determine if they really
//! should be filled. If not in the .secinfo table, no segment will be
//! created for the section.
void ELFSourceFile::ELFDataSource::addSection(unsigned sectionIndex)
{
       // get section info
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(sectionIndex);
       if (section.sh_size == 0)
       {
               // empty section, so ignore it
               return;
       }

       // create the right segment subclass based on the section type
       DataSource::Segment * segment = NULL;
       if (section.sh_type == SHT_PROGBITS)
       {
               segment = new ProgBitsSegment(*this, m_elf, sectionIndex);
       }
       else if (section.sh_type == SHT_NOBITS)
       {
               // Always add NOBITS sections by default.
               bool addNobits = true;

               // For GHS ELF files, we use the secinfoClear option to figure out what to do.
               // If set to ignore, treat like a normal ELF file and always add. If set to
               // ROM, then only clear if the section is listed in .secinfo. Otherwise if set
               // to C startup, then let the C startup do all clearing.
               if (m_elf->ELFVariant() == eGHSVariant)
               {
                       GHSSecInfo secinfo(m_elf);

                       // If there isn't a .secinfo section present then use the normal ELF rules
                       // and always add NOBITS sections.
                       if (secinfo.hasSecinfo() && m_secinfoOption != kSecinfoIgnore)
                       {
                               switch (m_secinfoOption)
                               {
                                       case kSecinfoROMClear:
                                               addNobits = secinfo.isSectionFilled(section);
                                               break;

                                       case kSecinfoCStartupClear:
                                               addNobits = false;
                                               break;
                               }
                       }
               }

               if (addNobits)
               {
                       segment = new NoBitsSegment(*this, m_elf, sectionIndex);
               }
               else
               {
                       std::string name = m_elf->getSectionNameAtIndex(section.sh_name);
                       Log::log(Logger::DEBUG2, "..section %s is not filled\n", name.c_str());
               }
       }

       // add segment if one was created
       if (segment)
       {
               m_segments.push_back(segment);
       }
}

ELFSourceFile::ELFDataSource::ProgBitsSegment::ProgBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index)
:       DataSource::Segment(source), m_elf(elf), m_sectionIndex(index)
{
}

unsigned ELFSourceFile::ELFDataSource::ProgBitsSegment::getData(unsigned offset, unsigned maxBytes, uint8_t * buffer)
{
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(m_sectionIndex);
       uint8_t * data = m_elf->getSectionDataAtIndex(m_sectionIndex);

       assert(offset < section.sh_size);

       unsigned copyBytes = std::min<unsigned>(section.sh_size - offset, maxBytes);
       if (copyBytes)
       {
               memcpy(buffer, &data[offset], copyBytes);
       }

       return copyBytes;
}

unsigned ELFSourceFile::ELFDataSource::ProgBitsSegment::getLength()
{
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(m_sectionIndex);
       return section.sh_size;
}

uint32_t ELFSourceFile::ELFDataSource::ProgBitsSegment::getBaseAddress()
{
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(m_sectionIndex);
       return section.sh_addr;
}

ELFSourceFile::ELFDataSource::NoBitsSegment::NoBitsSegment(ELFDataSource & source, StELFFile * elf, unsigned index)
:       DataSource::PatternSegment(source), m_elf(elf), m_sectionIndex(index)
{
}

unsigned ELFSourceFile::ELFDataSource::NoBitsSegment::getLength()
{
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(m_sectionIndex);
       return section.sh_size;
}

uint32_t ELFSourceFile::ELFDataSource::NoBitsSegment::getBaseAddress()
{
       const Elf32_Shdr & section = m_elf->getSectionAtIndex(m_sectionIndex);
       return section.sh_addr;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.