---

module.cpp

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2003 Frediano Ziglio
-----

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-----

INFORMATION
  www: https://freddy77.tripod.com/perdr/
  e-mail: freddy77@angelfire.com
*/
#include "global.h"
#ifdef HAVE_HDRSTOP
#pragma hdrstop
#endif

#include "module.h"


// sezione errata. non contiene ne dati ne codice
const ObjectModule::Section ObjectModule::errorSection;

ObjectModule::ObjectModule(CFile& file,const RVAFileTranslator& rva,uint32_t imageBase,
                   bool _hasRelocation,const RelocationInfos& _relocationInfos,
                                                                         const Symbols& _symbols, const Symbols& _exportSymbols,
                                                                         vma_t _entryPoint):
  sections(rva.GetSectionCount()),
  hasRelocation(_hasRelocation),relocationInfos(_relocationInfos),
        symbols(_symbols),exportSymbols(_exportSymbols)
{
        entryPoint  = _entryPoint==0?0:_entryPoint+imageBase;
        
  unsigned numSection = rva.GetSectionCount();
        uint8_t *buffer;
  for (unsigned n=0;n<numSection;++n)
  {
    // se RawSize > RvaSize altri bytes non utilizzati (indirizzi invalidi)
    // se RvaSize > RawSize altri bytes non inizializzati
    // calcola dimensione sezione
          unsigned size = rva.GetSection(n)->RvaSize;
    // inizializza valori
    sections[n].begin = rva.GetSection(n)->RvaAddress + imageBase;
    sections[n].end   = rva.GetSection(n)->RvaAddress + imageBase + size;
    if ( rva.GetSection(n)->IsCode() )
      sections[n].SetIsCode();
    else
      sections[n].SetIsData();

    // inizializza buffer
    buffer = new uint8_t[size];
    memset(buffer,0,size);
                
    // se puntatore valido leggi da memoria
    if ( rva.GetSection(n)->RawAddress != 0 )
    {
      unsigned rawSize = rva.GetSection(n)->RawSize;
      file.Seek( rva.GetSection(n)->RawAddress );
      file.RawRead( buffer,size<rawSize?size:rawSize );
    }
                
                sections[n].data = buffer;
                sections[n].data_end = buffer+size;
                if (n != 0)
                        sections[n-1].next = &sections[n];
  }
}

ObjectModule::ObjectModule(vma_t start,const unsigned char *ptr, unsigned len):
  sections(1),hasRelocation(false)
{
        entryPoint  = start;
        
        uint8_t *buffer;
  // inizializza valori
  sections[0].begin = start;
  sections[0].end   = start + len;
  sections[0].SetIsCode();

  // inizializza buffer
  buffer = new uint8_t[len];
  memcpy(buffer, ptr, len);
                
        sections[0].data = buffer;
        sections[0].data_end = buffer+len;
}

ObjectModule::~ObjectModule()
{
}

// implementazione simile a SeekTo
bool ObjectModule::IsValid(vma_t address)
{
  // prova con la sezione corrente
//  if ( currSection && currSection->begin <= address && address < currSection->end )
//    return true;

  // cerca sezione
  for( TSections::size_type n=0; n < sections.size(); ++n )
  {
    vma_t begin = sections[n].begin;
    vma_t end   = sections[n].end;
    if (begin <= address && address < end)
    {
      return true;
    }
  }
        return false;
}

/*
vma_t ObjectModule::GetNextValid()
{
  if (IsValid(currPos))
    return currPos;

  vma_t pos = VMA_MAX;

  // trova il minimo fra le sezioni maggiori
  for( TSections::size_type n=0; n < sections.size(); ++n )
  {
    vma_t begin = sections[n].begin;
    if (begin < pos && begin >= currPos)
      pos = begin;
  }
  _PRG_ASSERT(IsValid(pos));
  return pos;
}
*/

const ObjectModule::Section* ObjectModule::GetSection(vma_t address) const
{
  // cerca sezione
  for( TSections::size_type n=0; n < sections.size(); ++n )
  {
    vma_t begin = sections[n].begin;
    vma_t end   = sections[n].end;
    if (begin <= address && address < end)
    {
      return &sections[n];
    }
  }
  return &errorSection;
}

ObjectModule::DataReader ObjectModule::GetDataReader(vma_t address)
{
        // !!! optimize saving last searched section 
        // find sectionBuffer
        Section* sec;
  for( TSections::size_type n=0; n < sections.size(); ++n )
  {
    vma_t begin = sections[n].begin;
    vma_t end   = sections[n].end;
    if (begin <= address && address < end)
    {
                        sec = &sections[n];
      return DataReader(sec,sec->data + (address - begin));
    }
  }
        
  throw OutOfAddress(address);
}

uint8_t ObjectModule::ReadByte(vma_t address)
{
        DataReader reader = GetDataReader(address);
        return reader.ReadByte();
}

uint16_t ObjectModule::ReadWord(vma_t address)
{
        DataReader reader = GetDataReader(address);
        return reader.ReadWord();
}

uint32_t ObjectModule::ReadDword(vma_t address)
{
        DataReader reader = GetDataReader(address);
        return reader.ReadDword();
}

ObjectModule::DataReader::DataReader(const Section* _sec,unsigned char* _ptr):
        sec(_sec),ptr(_ptr)
{
}

uint8_t ObjectModule::DataReader::ReadByte()
{
        _PRG_ASSERT(sec);
        _PRG_ASSERT(ptr >= sec->data && ptr <= sec->data_end);

  // test cell valid
        if (ptr < sec->data_end)
                return *ptr++;
                
        // next section continue this ??
        if (sec->next && sec->end == sec->next->begin)
        {
                /* !!! is posible a empty section ??? */
                sec = sec->next;
                ptr = sec->data;
                return *ptr++;
        }

  throw OutOfAddress(sec->end);
}

uint16_t ObjectModule::DataReader::ReadWord()
{
  // !!! define uint8fast_t
  uint8_t u = ReadByte();
  return uint16_t(u|(uint16_t(ReadByte())<<8));
}

uint32_t ObjectModule::DataReader::ReadDword()
{
  // !!! define uint16fast_t
  uint16_t u = ReadWord();
  return u|(uint32_t(ReadWord())<<16);
}

vma_t ObjectModule::DataReader::Tell()
{
        return sec->begin + (ptr - sec->data);
}

void ObjectModule::DataReader::UnReadByte()
{
        _PRG_ASSERT(sec);
        _PRG_ASSERT(ptr >= sec->data && ptr <= sec->data_end);

  // test cell valid
        if (ptr >= sec->data)
        {
                --ptr;
                return;
        }
                
        // !!! finish, go to other section
  throw OutOfAddress(sec->begin);
}

ObjectModule::Section::~Section()
{
        delete data;
}

---