---

codeglob.h

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
*/
#ifndef FILE_CODEGLOB_H
#define FILE_CODEGLOB_H

#include <list>
#include <stack>
#include "x86dasm.h"
#include "symbols.h"
#include "module.h"
#include "utils/range.hpp"
#include "utils/fixvect.hpp"
#include "utils/f77auto_ptr"
#include "code.h"
#include "codescan.h"
#include "byteinfo.h"
#include "references.h"

template <class C,class Item>
inline bool IsPresent(const C& c,const Item& item)
{
  return ( c.find(item) != c.end() );
}

struct TempReference:public IstrReference
{
  uchar  priority;
};

// tipi di dati
typedef std::stack< TempReference,std::list<TempReference> > TTempRefs;
typedef std::set< vma_t,std::less<vma_t> > TAddresses;
typedef std::map< vma_t,vma_t,std::less<vma_t> > TApiAlias;
// !!! non set e disassembly ??
typedef std::map< vma_t,vma_t,std::less<vma_t> > TApiCalls;
typedef std::set< vma_t,std::less<vma_t> > TTempComplexReference;

// funzioni globali
void WriteInstruction(const Instruction& instruction,FILE* file = stdout);

// legge istruzione all'indirizzo specificato
int GetInstruction(ObjectModule& module,vma_t address,Instruction& instruction);

// utilità per sezioni
#define FOR_EACH_SECTION_CODE_BEGIN(module,iter) \
  FOR_EACH_CONST_BEGIN(ObjectModule::TSections,module->GetSections(),iter) \
  if ((*iter).IsCode()) {
#define FOR_EACH_SECTION_CODE_END(module,iter) \
  } \
  FOR_EACH_CONST_END(ObjectModule::TSections,module->GetSections(),iter)

#define FOR_EACH_SECTION_BEGIN(module,iter) \
  FOR_EACH_CONST_BEGIN(ObjectModule::TSections,module->GetSections(),iter)
#define FOR_EACH_SECTION_END(module,iter) \
  FOR_EACH_CONST_END(ObjectModule::TSections,module->GetSections(),iter)

// !!! other file
inline bool IsNullAddress(vma_t address)
{ return address == 0; }

// informazioni sul codice
class CodeInfo
{
public:
  CodeInfo():pTempRefs(0) {};

  // riferimenti a variabili
  IstrReferences varReferences; // user by codescan.cpp

  // riferimenti salvati
  IstrReferences istrReferences; // user by codeprn.cpp and codescan.cpp


  ByteInfos byteInfo; // user by heuristic.cpp, codeprn.cpp and codesca.cpp
  // salti a api tenuti per visualizzazione
  TApiAlias apiAlias; // used by codeprn.cpp
  // indirizzi reference complessi
  TTempComplexReference complexReference;

  ObjectModule* module;

protected:
  // riferimenti in sospeso da processare
  // !!! usato solo in code.cpp, dovrebbe sparire da qui
  TTempRefs* pTempRefs;

  // costanti che potrebbero essere codice
  // !!! usato solo in code.cpp, dovrebbe sparire da qui
  TAddresses addrConstants;

  // puntatori a dati e/o codice
  // !!! usato solo in code.cpp, dovrebbe sparire da qui
  TAddresses addrGeneral;
};

void ParseCode(CSignFile& file,uint32_t imageBase,vma_t entryPoint,const RVAFileTranslator& rva,const Symbols& symbols,const Symbols& exportedSymbols);

class CodeParser: public CodeInfo
{
friend void ParseCode(CSignFile& file,uint32_t imageBase,vma_t entryPoint,const RVAFileTranslator& rva,const Symbols& symbols,const Symbols& exportedSymbols,
                      bool hasRelocation,const RelocationInfos& relocationInfos);
public:
  //
  // Temp flow manage
  //
  void AddExportTempFlow(vma_t to,enum ByteInfo::TPriority priority);
  bool AddTempFlow(enum FlowTypes flow,vma_t from,
    const Instruction& instruction,vma_t instAddress,
    enum ByteInfo::TPriority priority,bool bAddComplex=true);
  void AddTempFlow(enum FlowTypes flow,vma_t from,vma_t to,
    enum ByteInfo::TPriority priority);
  bool ExtractTempRef(TempReference& tempRef);

  //
  // Scanning
  //
  void _ReverseScan(IScanning* scanning,vma_t address,IMachineStatus* status);
  void ReverseScan(IScanning* scanning,vma_t address);

  bool ExecuteComplexReference(vma_t address);
  bool ExecuteComplexReferenceMemory(vma_t address,const Instruction& instruction);
  bool ExecuteComplexReferenceReg(vma_t address,const Instruction& instruction);

  //
  // Code scanning and marking
  //
  bool CheckCodeRecursively(vma_t address,ByteInfo::TPriority priority,bool _bSetLabel = true);
  bool CheckCode(vma_t& address,ByteInfo::TPriority priority,bool bSetLabel = true);

  // utility
  bool IsApiReference(const Param& arg) const;
  bool ContainValidAddress(const Param& param) const;
private:
  void Parse(CSignFile& _file,uint32_t imageBase,vma_t entryPoint,
    const RVAFileTranslator& rva,const Symbols& api,const Symbols& exportedApi,
    bool hasRelocation,const RelocationInfos& relocationInfos);
  void ExcludeFileRange(CSignFile& _file,const RVAFileTranslator& rva,uint32_t imageBase);

  //
  // Code scanning and marking
  //
  enum TScanCodeResult {
    scanCodeAlreadyProcessed, scanCodeNoError, scanCodeOverlapped,
    scanCodeInvalidJump, scanCodeInvalid, scanCodeMax = scanCodeInvalid };
  enum TScanCodeResult ScanCode(vma_t& address,ByteInfo::TPriority priority,bool bSetLabel = true);
  // verifica se esiste un riferimento a dati o codice
  void CheckForAddress(vma_t instAddress,const Instruction& instruction,enum ByteInfo::TPriority priority);
  void SetCodeRange(const range<vma_t>& r,ByteInfo::TPriority priority,bool bSetLabel = true);
  void ResetCodeRange(const range<vma_t>& r);
  void CheckImmediateCodeAddress(const Instruction& instruction);

  //
  // Statistic
  //
  void GetStringStats(vma_t address,unsigned& len,unsigned& num_printable);
  struct PointerArrayStat
  {
    unsigned nCodePointer,nPointer,nNull,nFirstNull;
  };
  void GetPointerArrayStats(vma_t address,PointerArrayStat& stat);
  struct BitStat
  {
    unsigned int bit8[8];
    unsigned int bit16[16];
    unsigned int bit32[32];
  };
  void GetBitStat(vma_t address,unsigned numBytes,BitStat& stat);

  //
  // Printing
  //
  void CheckReference(vma_t address);
  void CheckJumpReference(vma_t address,const Instruction& instruction);
  void WriteCode();
  void WriteString(vma_t address,int len) const;
  void WriteBegin(vma_t address,int num_bytes) const;
};


#endif //FILE_CODEGLOB_H

---