---

byteinfo.h

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2002 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_BYTEINFO_H
#define FILE_BYTEINFO_H

#include <map>
#include "utils/fixvect.hpp"
#include "utils/f77auto_ptr"

// informazioni su ogni byte riguardo all'istruzione
/**
 * Mantain info for a byte of file
 */
struct ByteInfo
{
public:
        /**
         * How sure is program about this byte
         */
  enum TPriority
  {
    priNone,           /**< not code */
                priCheckOnly,      /**< internal use */
                priFiller,         /**< what's this? */
                priConstant,       /**< a constant in code reference this */
                priApi,            /**< code exported */
                priHeuristics,     /**< discovered by heuristic, not very safe */
                priExport,         /**< code exported */
                priSafeHeuristics, /**< discovered by heuristic, safe */
    priSafeExport,     /**< code exported, surely code */
                priEntryPoint,     /**< executed starting from entry-point */
                priMax = priEntryPoint
  };
        /**
         * Type of byte (contained in an instruction, a string, etc)
         */
  enum TType
  {
    typeNone, 
                typeInstruction = typeNone, /**< instruction */
                typeLoader,                 /**< used by loader, resource or other */
                typeInteger,                /**< part of an integer */
                typePointer,                /**< a pointer */
                typeASCIIZ,                 /**< asciiz string */
    typeMax = typeASCIIZ
  };
  uchar len; /**< len of istruction/data, for long data (>32) use ByteInfos::GetLen */

  // constructor and reinitialization
  ByteInfo():len(0),priority(priNone),flag(0),type(typeNone) {};
        /**
         * Delete all info for this byte
         */
  void Reset() { priority = priNone; len = 0; flag = 0; type = typeNone; };

  // priority and type access
  void SetPriority(enum TPriority pri)
  { _PRG_ASSERT(pri>=0 && pri<=priMax); priority = static_cast<uchar>(pri); };
  enum TPriority GetPriority() const
  { return static_cast<enum TPriority>(priority); };
  void SetType(enum TType typ)
  { _PRG_ASSERT(typ>=0 && typ<=typeMax); type = static_cast<uchar>(typ); };
  enum TType GetType() const { return static_cast<enum TType>(type); };

  // flag operation
        /**
         * Mark this istruction have another instruction before 
         * (and is not a unconditional jump)
         */
  void SetIsPrevInstruction() { flag |= 1; };
  int IsPrevInstruction() const { return flag&1; };
        /**
         * This byte if target of a jump or a data referenced from an instruction/constant
         */
  void SetIsLabel() { flag |= 2; };
  int IsLabel() const { return flag&2; };
        /**
         * Used to handle long data
         */
  void SetContinue() { flag |= 4; };
  int Continue() const { return flag&4; };
private:
  uchar priority;
  uchar flag;
  uchar type; // ?? type ??
};

/**
 * Mantain info for every byte of file
 */
class ByteInfos
{
public:
        /**
         * Return info for byte at given address
         * @param address address to query
         */
  ByteInfo& operator[](vma_t address);
  const ByteInfo& operator[](vma_t address) const;
        /**
         * Get length of instruction at given address
         * do not use for no instruction data
         */
  uchar GetIstrLen(vma_t) const;
        /**
         * Set data len (for long data (>32) )
         */
  void SetLen(vma_t address,unsigned len);
        /**
         * Get len of data
         */
  unsigned GetLen(vma_t address) const;
        /**
         * Check if data at given address is alredy marked
         */
  bool IsOccupied(vma_t address) const;
        /**
         * Check if data at given address is alredy marked
         */
  bool IsOccupied(vma_t address,int bytes) const;
  
//  typedef enum { Success } TSetInfoResult;
//  TSetInfoResult SetInfo(vma_t address,unsigned len,ByteInfo::TType type,ByteInfo::TPriority priority);
private:
  enum dummy { PageSize = 4096 };
  typedef fix_vector<ByteInfo,PageSize> TPage;
  typedef std::map< vma_t,freddy77::hp_auto_ptr<TPage>,std::less<vma_t> > TInfos;
  TInfos map;
  static ByteInfo emptyInfo;
};

#endif // FILE_BYTEINFO_H

---