demangle.hpp

Go to the documentation of this file.

/*
 *      CPP/D/Swift Demangler.
 *      Copyright (c) 2000-2018 by Iouri Kharon.
 *                        E-mail: yjh@styx.cabel.net
 *
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _DEMANGLE_HPP
#define _DEMANGLE_HPP
 
// int32 result code
#define ME_INTERR   -1  
#define ME_PARAMERR -2  
#define ME_ILLSTR   -3  
#define ME_SMALLANS -4  
#define ME_FRAME    -5  
#define ME_NOCOMP   -6  
#define ME_ERRAUTO  -7  
#define ME_NOHASHMEM -8 
#define ME_NOSTRMEM  -9 
 
#define ME_NOERROR_LIMIT  -10 
 
#define M_PRCMSK     0x0000000F 
#define MT_DEFAULT    0x00000001 
#define MT_CDECL      0x00000002 
#define MT_PASCAL     0x00000003 
#define MT_STDCALL    0x00000004 
#define MT_FASTCALL   0x00000005 
#define MT_THISCALL   0x00000006 
#define MT_FORTRAN    0x00000007 
#define MT_SYSCALL    0x00000008 
#define MT_INTERRUPT  0x00000009 
#define MT_MSFASTCALL 0x0000000A 
#define MT_CLRCALL    0x0000000B 
#define MT_DMDCALL    0x0000000C 
#define MT_VECTORCALL 0x0000000D 
#define MT_REGCALL    0x0000000E 
 
//   reserved
#define MT_LOCALNAME  0x0000000F 
 
#define M_SAVEREGS   0x00000010 
 
#define M_CLASS     0x000000E0  
#define MT_PUBLIC    0x00000020 
#define MT_PRIVATE   0x00000040 
#define MT_PROTECT   0x00000060 
#define MT_MEMBER    0x00000080 
#define MT_VTABLE    0x000000A0 
#define MT_RTTI      0x000000C0 
//   reserved
 
#define M_PARMSK   0x0000FF00 
#define MT_PARSHF      8      
#define MT_PARMAX     0xFF    
#define M_ELLIPSIS 0x00010000   
#define MT_VOIDARG  0x0001FF00  
#define M_STATIC   0x00020000   
#define M_VIRTUAL  0x00040000   
#define M_AUTOCRT  0x00080000   
 
#define M_TYPMASK  0x00700000   
#define MT_OPERAT   0x00100000    
#define MT_CONSTR   0x00200000    
#define MT_DESTR    0x00300000    
#define MT_CASTING  0x00400000    
#define MT_CLRCDTOR 0x00500000    
//  reserved
 
#define M_TRUNCATE 0x00800000 
#define M_THUNK    0x01000000 
#define M_ANONNSP  0x02000000 
#define M_TMPLNAM  0x04000000 
#define M_DBGNAME  0x08000000 
 
#define M_COMPILER 0x70000000 
#define MT_MSCOMP   0x10000000  
#define MT_BORLAN   0x20000000  
#define MT_WATCOM   0x30000000  
#define MT_OTHER    0x40000000  
// !!! The following definitions must be last and in this order!
#define MT_GNU      0x50000000  
#define MT_GCC3     0x60000000  
#define MT_VISAGE   0x70000000  
//---------------------------------------------------------------------------
// Flags to inhibit different parts of the demangled name
#define MNG_PTRMSK       0x7  
// DO NOT change order in this group (PtrType)
#define MNG_DEFNEAR       0x0 
#define MNG_DEFNEARANY    0x1 
#define MNG_DEFFAR        0x2 
#define MNG_NOPTRTYP16    0x3 
#define MNG_DEFHUGE       0x4 
#define MNG_DEFPTR64      0x5 
#define MNG_DEFNONE       0x6 
#define MNG_NOPTRTYP      0x7 
//
#define MNG_NODEFINIT    0x00000008 
//
#define MNG_NOUNDERSCORE 0x00000010 
#define MNG_NOTYPE       0x00000020 
#define MNG_NORETTYPE    0x00000040 
#define MNG_NOBASEDT     0x00000080 
#define MNG_NOCALLC      0x00000100 
#define MNG_NOPOSTFC     0x00000200 
#define MNG_NOSCTYP      0x00000400 
#define MNG_NOTHROW      0x00000800 
#define MNG_NOSTVIR      0x00001000 
#define MNG_NOECSU       0x00002000 
#define MNG_NOCSVOL      0x00004000 
#define MNG_NOCLOSUR     0x00008000 
#define MNG_NOUNALG      0x00010000 
#define MNG_NOMANAGE     0x00020000 
#define MNG_NOMODULE     0x00040000 
//                       0x00080000
//
#define MNG_SHORT_S      0x00100000 
#define MNG_SHORT_U      0x00200000 
#define MNG_ZPT_SPACE    0x00400000 
#define MNG_DROP_IMP     0x00800000 
//
//                       0x01000000
#define MNG_IGN_ANYWAY   0x02000000 
#define MNG_IGN_JMP      0x04000000 
#define MNG_MOVE_JMP     0x08000000 
                                      // If both MNG_IGN_JMP and MNG_MOVE_JMP
                                      // are set then move the prefix only if
                                      // the name was not truncated
//
#define MNG_COMPILER_MSK 0x70000000 // Compiler mask (0-autodetect)
 
#define MNG_SHORT_FORM  (MNG_NOTYPE|MNG_NORETTYPE|MNG_NOPOSTFC|MNG_NOPTRTYP \
      | MNG_NOSCTYP|MNG_NOTHROW|MNG_NOSTVIR|MNG_NOECSU|MNG_NOCLOSUR \
      | MNG_SHORT_U|MNG_DROP_IMP|MNG_NOUNALG|MNG_NOMANAGE \
      | MNG_IGN_JMP|MNG_MOVE_JMP|MNG_IGN_ANYWAY)
#define MNG_LONG_FORM (MNG_ZPT_SPACE | MNG_IGN_JMP | MNG_IGN_ANYWAY | MNG_NOPTRTYP)
 
// The description of the following symbol is in the notes
#define MNG_CALC_VALID (MNG_COMPILER_MSK|MNG_IGN_JMP|MNG_IGN_ANYWAY)
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#ifndef H2ASH
 
#if !defined(NO_OBSOLETE_FUNCS) || defined(__DEFINE_DEMANGLE__)
typedef int32 ida_export demangler_t(
        char *answer,
        uint answer_length,
        const char *str,
        uint32 disable_mask);
idaman demangler_t demangle;
#endif
 
// If answer_length == 0 then no demangling is performed neither. The function
// will check if demangling is possible and what compiler is used to mangle
// the name. If the name cannot be demangled then the function will return 0.
// NOTE: the answer MT_MSCOMP+1 means __msfastcall
//       (or borland class name with "_4" suffix) and the demangling is possible
//        either as MS (__fastcall) or as bc (__msfastcall)
// NOTE: the answer MT_GCC3+1 means POSSIBLE mingw/cygwin with
//       __stdcall/__fastcall but it might also mean ms-stdcall.
//       In essense it means that the demangler cannot determine the compiler
//       precisely.
//       It also means that the demangling is possible in the gcc3 mode
//       ONLY when the compiler is explicitly set to gcc3 and MNG_NODEFINIT
//       bit is not set.
 
// If answer == NULL then the demangler will return check if the demangling
// is possible and only return the flags.
// In this case answer_length should be enough to hold the demangled name.
 
// NOTE: If int32(answer_length) < 0 then the demangler will calcuate the
//       the number of purged bytes for the given name. In this case
//       disable_mask may contain only bits included in MNG_CALC_VALID,
//       and -answer_length must be equal to the register size (e.g.
//       sizeof(uint16/uint32/uint64)). The value of the register size
//       is used to check the numeric value in the ms stdcall/fastcall
//       encoding (it is used in the gcc mode too).
//       if return value <= 0 - no purged bytes or valid information.
//       If (value & 1) != 0 - ms stdcall (definite npurged is value-1.
//       If (value & 1) == 0 - 'encoded' counter (not implemented yet).
 
// If answer != NULL (and answer_length != 0) - perform demangling and fill out.
// NOTE: if int32(answer_length) < 0 then the buffer size will be -answer_length
//       but 'answer' is interpreted not as a pointer to the output buffer but
//       as a pointer to pointer to the output buffer (char**).
//       In this case if the function succeeds,a pointer to the answer end
//       will be returned in the pointer (like stpcpy). In this form 'answer'
//       cannot be NULL and *(char**)answer cannot be NULL.
//       answer_length must be greater than 9 for the 'truncated' answer.
 
typedef int mangled_name_type_t;
const mangled_name_type_t MANGLED_CODE = 0;
const mangled_name_type_t MANGLED_DATA = 1;
const mangled_name_type_t MANGLED_UNKNOWN = 2;
 
idaman mangled_name_type_t ida_export get_mangled_name_type(const char *name);
 
#endif // H2ASH
#endif // _DEMANGLE_HPP