src/module/mangle.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
 *PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
 *adek336[at]o2.pl, panalix.prv.pl                          *
 *under GPLv3 license                                       *
 *                                                          *
 *panalix - small osdev project                             *
 ************************************************************
 *      mangle.cpp, version 1.0                            *
 ************************************************************
 *                                                          *
 *used for demangling names, f.ex. cxx demangling style.    *
 *                                                          *
 *31'05'04- first revision (1.0)                            *
 *                                                          *
 ***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/string.hpp"
#include "src/common/blist.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/module/coresyms.hpp"
#include "src/module/elf.hpp"
#include "src/module/mangle.hpp"

namespace Syms
{
   namespace Mangle
   {


      //demangle a name
      int demangle (char *name, class string * dest, uint32 * args)
      {
         int i;
         dest->done ();
         //try C++ style
         i = Cxx::demangle (name, dest, args);
         if (i == ESUCCESS)
            return ESUCCESS;
         //try C style (no mangling)
         i = C::demangle (name, dest, args);
         if (i == ESUCCESS)
            return ESUCCESS;

         //when failed
         return EFAIL;
      }

      namespace Cxx
      {

         /* based on the internet.
http://www.codesourcery.com/cxx-abi/abi.html#mangling */

#define isCipher(c)     ( ((c) >= '0') && ((c) <= '9') )

         int d_subst (char **name, string * dest, blist_t * li);        //get a subst
         int d_type (char **name, string * dest, blist_t * li, struct data_type *dt);   //get a datatype
         int d_number (char **name, int *i, int *lgth); //get a number
         int d_nestedname (char **t, string * dest, blist_t * li);      //get a nested name
         int d_sourcename (char **t, string * dest, blist_t * li);      //get a source name
         int d_name (char **t, string * dest, blist_t * li, bool flag1);        //get a name
         int d_symb (char **t, string * dest, blist_t * li);    //get a symbol's name
         int d_check (char **t, char *tx);      //check for a text
         int demangle (char *n, class string * dest, uint32 * args);    //demangle a name

         const int CXX_NULL = 0;        //type?
         const int CXX_OTHER = 1;       //other
         const int CXX_VOID = 2;        //void
         const int CXX_WCHAR_T = 3;     //wchar_t
         const int CXX_BOOL = 4;        //bool
         const int CXX_CHAR = 5;        //char
         const int CXX_SIGNED_CHAR = 6; //signed char
         const int CXX_UNSIGNED_CHAR = 7;       //unsigned char
         const int CXX_SHORT = 8;       //short
         const int CXX_UNSIGNED_SHORT = 9;      //unsigned short
         const int CXX_INT = 10;        //int
         const int CXX_UNSIGNED_INT = 11;       //unsigned int
         const int CXX_LONG = 12;       //long
         const int CXX_UNSIGNED_LONG = 13;      //unsigned long
         const int CXX_LONG_LONG = 14;  //long long, __int64
         const int CXX_UNSIGNED_LONG_LONG = 15; //unsigned long long, unsigned __int64
         const int CXX___INT128 = 16;   //__int128
         const int CXX_UNSIGNED___INT128 = 17;  //unsigned __int128
         const int CXX_FLOAT = 18;      //float
         const int CXX_DOUBLE = 19;     //double
         const int CXX_LONG_DOUBLE = 20;        //long double, __float80
         const int CXX___FLOAT128 = 21; //__float128
         const int CXX_ELLIPSIS = 22;   //ellipsis
         const int CXX_POINTER = 23;    //any regular pointer
         //               ::= u <source-name>    # vendor extended type

         struct data_type
         {
            uint32 size;        //the size of the type
            uint32 stack_size;  //how much does it take on the stack
            const char *name;
         };

#define __MAX1(a,b)  ((a)>(b)?(a):(b))
#define TYPE(name)              {sizeof(name),__MAX1((sizeof(name)),STACK_ALIGN), (#name)}

         struct data_type types[] = {
            {NULL, STACK_ALIGN, "type?"},
            {NULL, STACK_ALIGN, "n/a"},
            {NULL, NULL, "void"},
            TYPE (wchar_t),
            TYPE (bool),
            TYPE (char),
            TYPE (signed char),
            TYPE (unsigned char),
            TYPE (short),
            TYPE (unsigned short),
            TYPE (int),
            TYPE (unsigned int),
            TYPE (long),
            TYPE (unsigned long),
            TYPE (long long),
            TYPE (unsigned long long),
            {16, 16, "__int128"},       //i'm not sure about this
            {16, 16, "unsigned __int128"},
            TYPE (float),       //and this- does a float argument get pushed onto the stack?
            TYPE (double),
            TYPE (long double),
            {16, 16, "__float128"},     //not this. is this correct?
            {4, 4, "ellipsis"}, //what's this?
            {STACK_ALIGN, STACK_ALIGN, "void*"}
            //      TYPE(__int128)
            /*  {NULL,NULL,"type?"}, {NULL,NULL,"n/a"}, {NULL,NULL,"void"},
               {sizeof(wchar_t),MAX(STACK_ALIGN,sizeof(wchar_t)),"wchar_t"}, {sizeof(bool),STACK_ALIGN,"bool"},
               {sizeof(char),STACK_ALIGN,"char"},{sizeof(signed*/
         };
         // char *type_name[] = {"type?", "void", "n/a", "wchar_t", "bool", "char",      "signed char",
         //              "unsigned char", "short", "unsigned short", "int", "unsigned int",
         //              "long", "unsigned long", "long long", "unsigned long long", "__int128",
         //              "unsigned __int128", "float", "double", "long double", "__float128",
         //              "ellipsis" };

         //get a subst
         int d_subst (char **name, string * dest, blist_t * li)
         {
            int i = 0;
            bool flag = false;
            if (**name != 'S')
               return EFAIL;
            //get the number, base 36
            while (*(++(*name)) != '_')
            {
               if (**name == '\0')
                  return EINVAL;
               flag = true;
               i *= 36; //radix
               if (isCipher (**name))
                  i += **name - '0';    //cipher
               else
                  i += **name - 'A' + 10;
            }
            (*name)++;
            if (flag)
               i++;     //because "S_" is first, "S0_" is second, etc.
            //get the substition #i
            blist_s *item;
            for (item = li->head; item; item = item->next)
               if (i-- == 0)    //got there
               {
                  dest->strncat (bli_dt (item, char *));
                  return ESUCCESS;
               }
            return EFAIL;
         }

         //get a datatype
         int d_type (char **name, string * dest, blist_t * li,
               data_type * dt)
         {
            int i = CXX_NULL;
            //pointer types
            if (**name == 'P') {
               (*name)++;
               i = d_type (name, dest, li, dt);
               //this is a pointer, remember
               memmove (dt, &types[CXX_POINTER], sizeof (*dt));
               if (i == ESUCCESS)
                  dest->add_char ('*');
               return i;
            };
            //first try- builtin types:
            switch (**name) {
               case 'v':
                  i = CXX_VOID;
                  break;
               case 'w':
                  i = CXX_WCHAR_T;
                  break;
               case 'b':
                  i = CXX_BOOL;
                  break;
               case 'c':
                  i = CXX_CHAR;
                  break;
               case 'a':
                  i = CXX_SIGNED_CHAR;
                  break;
               case 'h':
                  i = CXX_UNSIGNED_CHAR;
                  break;
               case 's':
                  i = CXX_SHORT;
                  break;
               case 't':
                  i = CXX_UNSIGNED_SHORT;
                  break;
               case 'i':
                  i = CXX_INT;
                  break;
               case 'j':
                  i = CXX_UNSIGNED_INT;
                  break;
               case 'l':
                  i = CXX_LONG;
                  break;
               case 'm':
                  i = CXX_UNSIGNED_LONG;
                  break;
               case 'x':
                  i = CXX_LONG_LONG;
                  break;
               case 'y':
                  i = CXX_UNSIGNED_LONG_LONG;
                  break;
               case 'n':
                  i = CXX___INT128;
                  break;        //warning: the size argument might need to be adjusted here
               case 'o':
                  i = CXX_UNSIGNED___INT128;
                  break;
               case 'f':
                  i = CXX_FLOAT;
                  break;
               case 'd':
                  i = CXX_DOUBLE;
                  break;
               case 'e':
                  i = CXX_LONG_DOUBLE;
                  break;
               case 'g':
                  i = CXX___FLOAT128;
                  break;
               case 'z':
                  i = CXX_ELLIPSIS;
            };
            //bultin types- part two
            if (i != CXX_NULL) {
               (*name) += 1;
               dest->strncat (types[i].name);
               memmove (dt, &types[i], sizeof (*dt));
               return ESUCCESS;
            }
            //vendor extensions
            if (**name == 'u')
               (*name)++;
            //other
            memmove (dt, &types[CXX_OTHER], sizeof (*dt));
            return d_name (name, dest, li, false);
         }

         //get a number
         int d_number (char **name, int *i, int *lgth)
         {
            char ch;
            *i = 0;
            *lgth = 0;
            while (isCipher (**name) && (**name)) {
               (*lgth)++;
               ch = **name;
               (*name)++;
               (*i) *= 10;
               (*i) += ch - '0';
            }
            return ESUCCESS;
         }

         //get a nested name
         int d_nestedname (char **t, string * dest, blist_t * li)
         {
            int i;
            uint32 t1;
            char c;
            t1 = dest->length ();
            (*t)++;
            do {
               c = **t;
               i = d_name (t, dest, li, true);
               if (c != 'S') {
                  li->add (dest->v () + t1, dest->length () - t1 + 1,
                        NULL);
               }

               /*       if (**t == 'S') //substitution
                  i= d_subst(t,dest,li);
                  else
                  { i= d_sourcename(t,dest,NULL); li->add(dest->v()+t1, dest->length()-t1+1, NULL); }*/
               //end of nested name
               if (**t == 'E') {
                  (*t)++;
                  return ESUCCESS;
               }
               dest->strncat ("::");
               if (i != ESUCCESS)
                  return EINVAL;
            }
            while (1);

         }

         //get a sourcename
         int d_sourcename (char **t, string * dest, blist_t * li)
         {
            int j, i, n;
            char *t1;
            t1 = *t;
            //get the length
            if (!d_number (t, &i, &n))
               return EFAIL;
            //n- the length of the number, i- length of the text
            n += i;             //now n- the size of the source name
            //get the name
            j = i;
            for (; i > 0; i--)
               dest->add_char (*((*t)++));
            //add
            if (li) {
               li->add (t1 + 1, lgth (t1) - 1 /*j */  + 1, NULL);
            }
            return ESUCCESS;
         }

         //get a name
         int d_name (char **t, string * dest, blist_t * li, bool flag1)
         {
            //substitution
            if (**t == 'S')
               return d_subst (t, dest, li);
            //nested name
            if (**t == 'N')
               return d_nestedname (t, dest, li);
            //source name
            if ((**t >= '1') && (**t <= '9')) {
               if (flag1)
                  li = NULL;
               return d_sourcename (t, dest, li);
            }
            //constructors && destructors
            bool flag2 = false;
            if (**t == 'C') {
               (*t)++;
               if ((**t < '1') || (**t > '3'))
                  return EINVAL;
               (*t)++;
               flag2 = true;
            }
            if (**t == 'D') {
               (*t)++;
               if ((**t < '0') || (**t > '2'))
                  return EINVAL;
               (*t)++;
               flag2 = true;
               dest->add_char ('~');
            }
            if (flag2) {
               //get the name of the last chunk of text
               char *c, *d;
               d = c = bli_dt (li->tail, char *);
               c += lgth (c);
               while ((c > d) && (*(c - 1) != ':'))
                  c--;
               //copy the chunk
               while (*c)
                  dest->add_char (*(c++));
               return ESUCCESS;
            }

            return EFAIL;
         }

         //get a symbol's name
         int d_symb (char **t, string * dest, blist_t * li)
         {
            int i;
            //get the name
            i = d_name (t, dest, li, false);
            return i;
         }

         //check for a text
         int d_check (char **t, const char *tx)
         {
            char *t1;
            t1 = *t;
            do {
               if (*tx == '\0') {
                  return ESUCCESS;
               }
            }
            while (*((*t)++) == *(tx++));

            return EFAIL;
         }

         //demangle a name
         int demangle (char *n, class string * dest, uint32 * args)
       {
          char *pos = n;
          blist_t frags;
          int i;
          string arg_list, num;
          memset (&arg_list, 0, sizeof (arg_list));
          memset (&num, 0, sizeof (num));
          //init the list of fragments
          frags.init (FAC_OTHER | FAC_MANGLE);
          arg_list.verify (1);
          //work on the text
          do {
             //there should be a "_Z"        
             i = d_check (&pos, "_Z");
             if (i != ESUCCESS)
                break;
             //get a symbol
             i = d_symb (&pos, dest, &frags);
             //get the types
             int flag = 0;
             data_type last_type;       //the size on the stack of the last datatype
             if (i == ESUCCESS)
                while (*pos) {
                   if (flag == 0)
                      dest->add_char ('(');
                   if (flag > 0)
                      dest->strncat (", ");
                   //do we want to get the types here or get the later?
                   if (!args)
                      i = d_type (&pos, dest, &frags, &last_type);
                   else {
                      if ((*pos == 'v') && (*(pos + 1) == '\0'))        //break, if only type is "void"
                      {
                         dest->strncat ("void)");
                         i = ESUCCESS;
                         break;
                      }
                      //the num
                      num.decim (flag + 1);
                      //add an "A" and the number of the argument
                      dest->add_char ('A');
                      dest->strncat (num.v ());
                      //add to the second list
                      arg_list.strncat ("\n\t\tA");
                      arg_list.strncat (num.v ());
                      arg_list.strncat ("= (");
                      i = d_type (&pos, &arg_list, &frags,
                            &last_type);
                      arg_list.strncat (")\t");
                      arg_list.strncat ("0x");
                      // the arg. check how large is it's copy on the stack
                      if (last_type.stack_size == 4)
                         num.hex (*args, '0');
                      else
                         num.num64 (*(uint64 *) args, 0x10,
                               0x1000000000000000ll, 1, '0',
                               0);
                      // add the arg value to the string
                      args = (uint32 *) ((uint32) args + last_type.stack_size); //next, please
                      arg_list.strncat (num.v ());
                   }
                   flag++;
                   if (i != ESUCCESS)
                      break;
                }
             if (flag > 0)
                dest->add_char (')');
          }
          while (0);

      //add the args values now, if enabled
      if (args) {
         dest->strncat (arg_list.v ());
      }
      //free temporary memory
      frags.done ();
      arg_list.done ();
      if (i == ESUCCESS) {
      } else
         dest->strncat ("n/a");
      return i;
       }


       };                       /*namespace Cxx */

       // c mangling- no mangling
       namespace C
       {


          //demangle a name
          int demangle (char *name, class string * dest, uint32 * args)
          {
             dest->copy (name);
             return ESUCCESS;
          }



        };                      /*namespace C */

    };                          /*namespace Mangle */
};                              /*namespace Syms */

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---