cvt64.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 2005-2025 Hex-Rays SA <support@hex-rays.com>
 *      ALL RIGHTS RESERVED.
 *
 *      Convert 'idb' file to 'i64' file.
 *
 *      Conversion is performed by IDA64 in the special conversion mode.
 *      To convert data we need to read it in the 32-bit format from the idb file,
 *      convert it to the 64-bit format and write it to the i64 file.
 *
 *      This file contains the conversion helpers functions for plugins.
 *
 *      Also see the following events:
 *        * processor_t::ev_cvt64_supval
 *        * processor_t::ev_cvt64_hashval
 *
 *      For more information check the cvt64.md file.
 */
 
#pragma once
 
//-------------------------------------------------------------------------
// Conversion of 32-bit databases to 64-bit is performed by ida64,
// only in IDA Pro and IDA Teams
#if !defined(IDAFREE) && !defined(IDAHOME)
#  if defined(__EA64__)
#    define CVT64
#  else
#    define UPG32 // enable the logic to upgrade 32-bit databases
#  endif
#endif
 
//------------------------------------------------------------------------
// This class keeps 32-bit addresses regardless of IDA bitness
struct range32_t
{
  ea32_t start_ea = 0;
  ea32_t end_ea = 0;
 
  range32_t() {}
  range32_t(ea_t ea1, ea_t ea2) : start_ea(ea1), end_ea(ea2) {}
};
 
//------------------------------------------------------------------------
THREAD_SAFE inline ea_t mmdsr_unpack_ea(memory_deserializer_t &mmdsr, ea_t base = 0)
{
#ifdef CVT64
  if ( is_cvt64() )
  {
    ea_t ea = ea32_t(mmdsr.unpack_dd()+base);
    return ea == BADADDR32 ? BADADDR : ea;
  }
#endif
  return mmdsr.unpack_ea()+base;
}
 
//------------------------------------------------------------------------
THREAD_SAFE inline ea_t mmdsr_unpack_ea_neg(memory_deserializer_t &mmdsr, ea_t base)
{
#ifdef CVT64
  if ( is_cvt64() )
  {
    ea_t ea = ea32_t(base - mmdsr.unpack_dd());
    return ea == BADADDR32 ? BADADDR : ea;
  }
#endif
  return base - mmdsr.unpack_ea();
}
 
//------------------------------------------------------------------------
THREAD_SAFE inline ea_t mmdsr_unpack_node2ea(memory_deserializer_t &mmdsr)
{
  nodeidx_t ndx = mmdsr_unpack_ea(mmdsr);
  return node2ea(ndx);
}
 
//------------------------------------------------------------------------
THREAD_SAFE inline sval_t mmdsr_unpack_sval(memory_deserializer_t &mmdsr, sval_t base=0)
{
#ifdef CVT64
  if ( is_cvt64() )
    return (int32)(mmdsr.unpack_dd() + base);
#endif
  return mmdsr.unpack_ea() + base;
}
 
//------------------------------------------------------------------------
THREAD_SAFE inline void mmdsr_unpack_eavec(
        eavec_t *vec,
        memory_deserializer_t &mmdsr,
        ea_t ea)
{
#ifdef CVT64
  if ( is_cvt64() )
  {
    ea_t old = ea;
    int n = mmdsr.unpack_dw();
    vec->resize_noinit(n);
    for ( int i=0; i < n; ++i )
    {
      old = mmdsr_unpack_ea(mmdsr, old);
      vec->at(i) = old;
    }
    return;
  }
#endif
  return mmdsr.unpack_eavec(vec, ea);
}
 
//------------------------------------------------------------------------
THREAD_SAFE inline ea_t mmdsr_read_ea(memory_deserializer_t &mmdsr)
{
#ifdef CVT64
  if ( is_cvt64() )
  {
    ea32_t ea32 = BADADDR32;
    mmdsr.read(&ea32, sizeof(ea32));
    return ea32;
  }
#endif
  ea_t ea = BADADDR;
  mmdsr.read(&ea, sizeof(ea));
  return ea;
}
 
//------------------------------------------------------------------------
inline int cvt64_blob(netnode node, nodeidx_t start, uchar tag)
{
  bytevec_t buf;
  if ( node.getblob(&buf, start, tag) > 0 )
  {
    node.setblob(buf.begin(), buf.size(), start, tag);
    return 1;
  }
  return 0;
}
 
#ifdef CVT64
//------------------------------------------------------------------------
struct cvt64_node_tag_t
{
  nodeidx_t node;

#define CVT64_ZERO_IDX  0x00800000    
  int tag;

  nodeidx_t exact_alt;
};
 
// Descriptors for popular database values
#define CVT64_NODE_DEVICE    { helper, stag, nodeidx_t(-1) }
#define CVT64_NODE_IDP_FLAGS { helper, atag|NETMAP_VAL, nodeidx_t(-1) }

 
idaman int ida_export cvt64_node_supval_for_event(
        va_list va,
        const cvt64_node_tag_t *node_info,
        size_t node_info_qty);
 
#endif // CVT64