ieee.h

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA)
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 
 *      Floating Point Number Libary.
 *      Copyright (c) 1995-2006 by Iouri Kharon.
 *                        E-mail: yjh@styx.cabel.net
 *
 */
 
#ifndef _IEEE_H_
#define _IEEE_H_

 
struct fpvalue_t;       // processor-independent representation of floats
 
#define FPVAL_NWORDS 8  

enum fpvalue_kind_t
{
  FPV_BADARG,  
  FPV_NORM,    
  FPV_NAN,     
  FPV_PINF,    
  FPV_NINF,    
};

const uint32
  MAXEXP_FLOAT  = 0x80,   
  MAXEXP_DOUBLE = 0x400,  
  MAXEXP_LNGDBL = 0x4000; 

enum fpvalue_error_t
{
  REAL_ERROR_OK = 1,       
  REAL_ERROR_FORMAT  = -1, 
  REAL_ERROR_RANGE   = -2, 
  REAL_ERROR_BADDATA = -3, 
  REAL_ERROR_FPOVER  = 2,  
  REAL_ERROR_BADSTR  = 3,  
  REAL_ERROR_ZERODIV = 4,  
  REAL_ERROR_INTOVER = 5,  
};

 
idaman THREAD_SAFE fpvalue_error_t ida_export ieee_realcvt(void *m, fpvalue_t *out, uint16 swt);
 
// Helper functions. Better use members of fpvalue_t, they are nicer.
idaman THREAD_SAFE void ida_export realtoasc(char *buf, size_t bufsize, const fpvalue_t &x, uint mode);
idaman THREAD_SAFE fpvalue_error_t ida_export asctoreal(const char **sss, fpvalue_t *out);
idaman THREAD_SAFE void ida_export eltoe(sval_t l, fpvalue_t *vout);
idaman THREAD_SAFE void ida_export eltoe64(int64 l, fpvalue_t *vout);
idaman THREAD_SAFE void ida_export eltoe64u(uint64 l, fpvalue_t *vout);
idaman THREAD_SAFE fpvalue_error_t ida_export eetol(sval_t *out, const fpvalue_t &a, bool roundflg);
idaman THREAD_SAFE fpvalue_error_t ida_export eetol64(int64 *out, const fpvalue_t &a, bool roundflg);
idaman THREAD_SAFE fpvalue_error_t ida_export eetol64u(uint64 *out, const fpvalue_t &a, bool roundflg);
idaman THREAD_SAFE fpvalue_error_t ida_export eldexp(const fpvalue_t &a, int32 pwr2, fpvalue_t *zout);
idaman THREAD_SAFE fpvalue_error_t ida_export eadd(const fpvalue_t &a, const fpvalue_t &b, fpvalue_t *zout, bool subflg);
idaman THREAD_SAFE fpvalue_error_t ida_export emul(const fpvalue_t &a, const fpvalue_t &b, fpvalue_t *zout);
idaman THREAD_SAFE fpvalue_error_t ida_export ediv(const fpvalue_t &a, const fpvalue_t &b, fpvalue_t *zout);
idaman THREAD_SAFE int ida_export ecmp(const fpvalue_t &a, const fpvalue_t &b);
idaman THREAD_SAFE fpvalue_kind_t ida_export get_fpvalue_kind(const fpvalue_t &a, uint16 reserved = 0);
 
//------------------------------------------------------------------------
struct fpvalue_t
{
  uint16 w[FPVAL_NWORDS];
 
  void clear(void) { memset(this, 0, sizeof(*this)); }
  DECLARE_COMPARISONS(fpvalue_t) { return ecmp(*this, r); }

  fpvalue_error_t from_half(uint16 fpval) { return ieee_realcvt(&fpval, this, sizeof(fpval)/2-1); }
  fpvalue_error_t from_float(float fpval) { return ieee_realcvt(&fpval, this, sizeof(fpval)/2-1); }
  fpvalue_error_t from_double(double fpval) { return ieee_realcvt(&fpval, this, sizeof(fpval)/2-1); }

  fpvalue_error_t to_half(uint16 *fpval) const { return ieee_realcvt(fpval, (fpvalue_t*)this, 8|(sizeof(*fpval)/2-1)); }
  fpvalue_error_t to_float(float *fpval) const { return ieee_realcvt(fpval, (fpvalue_t*)this, 8|(sizeof(*fpval)/2-1)); }
  fpvalue_error_t to_double(double *fpval) const { return ieee_realcvt(fpval, (fpvalue_t*)this, 8|(sizeof(*fpval)/2-1)); }

  fpvalue_error_t from_10bytes(const void *fpval) { return ieee_realcvt((void *)fpval, this, 4); }
  fpvalue_error_t to_10bytes(void *fpval) const { return ieee_realcvt(fpval, (fpvalue_t*)this, 8|4); }

  fpvalue_error_t from_12bytes(const void *fpval) { return ieee_realcvt((void*)fpval, this, 5); }
  fpvalue_error_t to_12bytes(void *fpval) const { return ieee_realcvt(fpval, (fpvalue_t*)this, 8|5); }

  fpvalue_error_t from_str(const char **p_str) { return asctoreal(p_str, this); }

  void to_str(char *buf, size_t bufsize, uint mode) const { realtoasc(buf, bufsize, *this, mode); }

  void from_sval(sval_t x) { eltoe(x, this); }
  void from_int64(int64 x) { eltoe64(x, this); }
  void from_uint64(uint64 x) { eltoe64u(x, this); }

  fpvalue_error_t to_sval(sval_t *out, bool round=false) const { return eetol(out, *this, round); }
  fpvalue_error_t to_int64(int64 *out, bool round=false) const { return eetol64(out, *this, round); }
  fpvalue_error_t to_uint64(uint64 *out, bool round=false) const { return eetol64u(out, *this, round); }

  fpvalue_error_t fadd(const fpvalue_t &y) { return eadd(*this, y, this, false); }
  fpvalue_error_t fsub(const fpvalue_t &y) { return eadd(*this, y, this, true); }
  fpvalue_error_t fmul(const fpvalue_t &y) { return emul(*this, y, this); }
  fpvalue_error_t fdiv(const fpvalue_t &y) { return ediv(*this, y, this); }

  fpvalue_error_t mul_pow2(int32 power_of_2) { return eldexp(*this, power_of_2, this); }

  void eabs() { w[FPVAL_NWORDS-1] &= 0x7fff; }

  bool is_negative() const { return (w[FPVAL_NWORDS-1] & 0x8000) != 0; }

  void negate()
  {
    if ( w[FPVAL_NWORDS-1] != 0 )
      w[FPVAL_NWORDS-1] ^= 0x8000;
  }

  fpvalue_kind_t get_kind() const { return get_fpvalue_kind(*this, 0); }
};
 
//------------------------------------------------------------------------
#define IEEE_EXONE (0x3FFF)
#define E_SPECIAL_EXP 0x7FFF
#if !defined(NO_OBSOLETE_FUNCS) || defined(IEEE_SOURCE)
#define IEEE_NI (FPVAL_NWORDS+3) 
#define IEEE_E 1        
#define IEEE_M 2        
typedef uint16 eNI[IEEE_NI];
 
#ifdef IEEE_SOURCE
#  define IEEE_DEPRECATED
#else
#  define IEEE_DEPRECATED DEPRECATED
#endif
inline IEEE_DEPRECATED void ecleaz(eNI x)
{
  if ( x != nullptr )
    memset(x, 0, sizeof(eNI));
}
idaman IEEE_DEPRECATED THREAD_SAFE void ida_export emovo(const eNI a, fpvalue_t *vout); 
idaman IEEE_DEPRECATED THREAD_SAFE void ida_export emovi(const fpvalue_t &a, eNI vout); 
idaman IEEE_DEPRECATED THREAD_SAFE int  ida_export eshift(eNI x, int sc);        
idaman IEEE_DEPRECATED THREAD_SAFE bool ida_export emdnorm(eNI s, bool lost, bool subflg, int32 exp, int rndbase);
 
#endif
 
#endif