debugger/types.c

   1 /*
   2  * File types.c - datatype handling stuff for internal debugger.
   3  *
   4  * Copyright (C) 1997, Eric Youngdale.
   5  *
   6  * This really doesn't do much at the moment, but it forms the framework
   7  * upon which full support for datatype handling will eventually be hung.
   8  */
   9
  10 #include "config.h"
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13
  14 #include <assert.h>
  15 #include <fcntl.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <limits.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21
  22 #include "pe_image.h"
  23 #include "peexe.h"
  24 #include "debugger.h"
  25
  26 #define NR_TYPE_HASH 521
  27
  28 int               DEBUG_nchar;
  29 static int        DEBUG_maxchar = 1024;
  30
  31 struct en_values
  32 {
  33   struct en_values* next;
  34   char            * name;
  35   int               value;
  36 };
  37
  38 struct member
  39 {
  40   struct member   * next;
  41   char            * name;
  42   struct datatype * type;
  43   int               offset;
  44   int               size;
  45 };
  46
  47 struct datatype
  48 {
  49   enum  debug_type type;
  50   struct datatype * next;
  51   char * name;
  52   union
  53   {
  54     struct
  55     {
  56       char    basic_type;
  57       char  * output_format;
  58       char    basic_size;
  59       unsigned b_signed:1;
  60     } basic;
  61     struct
  62     {
  63       unsigned short bitoff;
  64       unsigned short nbits;
  65       struct datatype * basetype;
  66     } bitfield;
  67
  68     struct
  69     {
  70       struct datatype * pointsto;
  71     } pointer;
  72     struct
  73     {
  74       struct datatype * rettype;
  75     } funct;
  76     struct
  77     {
  78       int               start;
  79       int               end;
  80       struct datatype * basictype;
  81     } array;
  82     struct
  83     {
  84       int               size;
  85       struct member * members;
  86     } structure;
  87     struct
  88     {
  89       struct en_values * members;
  90     } enumeration;
  91   } un;
  92 };
  93
  94 #define BASIC_INT               1
  95 #define BASIC_CHAR              2
  96 #define BASIC_LONG              3
  97 #define BASIC_UINT              4
  98 #define BASIC_LUI               5
  99 #define BASIC_LONGLONG          6
 100 #define BASIC_ULONGLONGI        7
 101 #define BASIC_SHORT             8
 102 #define BASIC_SHORTUI           9
 103 #define BASIC_SCHAR             10
 104 #define BASIC_UCHAR             11
 105 #define BASIC_FLT               12
 106 #define BASIC_LONG_DOUBLE       13
 107 #define BASIC_DOUBLE            14
 108 #define BASIC_CMPLX_INT         15
 109 #define BASIC_CMPLX_FLT         16
 110 #define BASIC_CMPLX_DBL         17
 111 #define BASIC_CMPLX_LONG_DBL    18
 112 #define BASIC_VOID              19
 113
 114 struct datatype * DEBUG_TypeInt = NULL;
 115 struct datatype * DEBUG_TypeIntConst = NULL;
 116 struct datatype * DEBUG_TypeUSInt = NULL;
 117 struct datatype * DEBUG_TypeString = NULL;
 118
 119 /*
 120  * All of the types that have been defined so far.
 121  */
 122 static struct datatype * type_hash_table[NR_TYPE_HASH + 1];
 123 static struct datatype * pointer_types = NULL;
 124
 125 static unsigned int type_hash( const char * name )
 126 {
 127     unsigned int hash = 0;
 128     unsigned int tmp;
 129     const char * p;
 130
 131     p = name;
 132
 133     while (*p)
 134       {
 135         hash = (hash << 4) + *p++;
 136
 137         if( (tmp = (hash & 0xf0000000)) )
 138           {
 139             hash ^= tmp >> 24;
 140           }
 141         hash &= ~tmp;
 142       }
 143     return hash % NR_TYPE_HASH;
 144 }
 145
 146
 147 static struct datatype *
 148 DEBUG_InitBasic(int type, char * name, int size, int b_signed,
 149                             char * output_format)
 150 {
 151   int hash;
 152
 153   struct datatype * dt;
 154   dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 155
 156   if( dt != NULL )
 157     {
 158       if( name != NULL )
 159         {
 160           hash = type_hash(name);
 161         }
 162       else
 163         {
 164           hash = NR_TYPE_HASH;
 165         }
 166
 167       dt->type = DT_BASIC;
 168       dt->name = name;
 169       dt->next = type_hash_table[hash];
 170       type_hash_table[hash] = dt;
 171       dt->un.basic.basic_type = type;
 172       dt->un.basic.basic_size = size;
 173       dt->un.basic.b_signed = b_signed;
 174       dt->un.basic.output_format = output_format;
 175     }
 176
 177   return dt;
 178 }
 179
 180 static
 181 struct datatype *
 182 DEBUG_LookupDataType(enum debug_type xtype, int hash, const char * typename)
 183 {
 184   struct datatype * dt = NULL;
 185
 186   if( typename != NULL )
 187     {
 188       for( dt = type_hash_table[hash]; dt; dt = dt->next )
 189         {
 190           if( xtype != dt->type || dt->name == NULL
 191               || dt->name[0] != typename[0])
 192             {
 193               continue;
 194             }
 195
 196           if( strcmp(dt->name, typename) == 0 )
 197             {
 198               return dt;
 199             }
 200         }
 201     }
 202
 203   return dt;
 204 }
 205
 206 struct datatype *
 207 DEBUG_NewDataType(enum debug_type xtype, const char * typename)
 208 {
 209   struct datatype * dt = NULL;
 210   int hash;
 211
 212   /*
 213    * The last bucket is special, and is used to hold typeless names.
 214    */
 215   if( typename == NULL )
 216     {
 217       hash = NR_TYPE_HASH;
 218     }
 219   else
 220     {
 221       hash = type_hash(typename);
 222     }
 223
 224   dt = DEBUG_LookupDataType(xtype, hash, typename);
 225
 226   if( dt == NULL )
 227     {
 228       dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 229
 230       if( dt != NULL )
 231         {
 232           memset(dt, 0, sizeof(*dt));
 233
 234           dt->type = xtype;
 235           if( typename != NULL )
 236             {
 237               dt->name = DBG_strdup(typename);
 238             }
 239           else
 240             {
 241               dt->name = NULL;
 242             }
 243           if( xtype == DT_POINTER )
 244             {
 245               dt->next = pointer_types;
 246               pointer_types = dt;
 247             }
 248           else
 249             {
 250               dt->next = type_hash_table[hash];
 251               type_hash_table[hash] = dt;
 252             }
 253         }
 254     }
 255
 256   return dt;
 257 }
 258
 259 struct datatype *
 260 DEBUG_FindOrMakePointerType(struct datatype * reftype)
 261 {
 262   struct datatype * dt = NULL;
 263
 264   if( reftype != NULL )
 265     {
 266       for( dt = pointer_types; dt; dt = dt->next )
 267         {
 268           if( dt->type != DT_POINTER )
 269             {
 270               continue;
 271             }
 272
 273           if( dt->un.pointer.pointsto == reftype )
 274             {
 275               return dt;
 276             }
 277         }
 278     }
 279
 280   if( dt == NULL )
 281     {
 282       dt = (struct datatype *) DBG_alloc(sizeof(struct datatype));
 283
 284       if( dt != NULL )
 285         {
 286           dt->type = DT_POINTER;
 287           dt->un.pointer.pointsto = reftype;
 288           dt->next = pointer_types;
 289           pointer_types = dt;
 290         }
 291     }
 292
 293   return dt;
 294 }
 295
 296 void
 297 DEBUG_InitTypes()
 298 {
 299   static int beenhere = 0;
 300   struct datatype * chartype;
 301
 302   if( beenhere++ != 0 )
 303     {
 304       return;
 305     }
 306
 307   /*
 308    * Special version of int used with constants of various kinds.
 309    */
 310   DEBUG_TypeIntConst = DEBUG_InitBasic(BASIC_INT,NULL,4,1,"%d");
 311
 312   /*
 313    * Initialize a few builtin types.
 314    */
 315
 316
 317   DEBUG_TypeInt = DEBUG_InitBasic(BASIC_INT,"int",4,1,"%d");
 318   chartype = DEBUG_InitBasic(BASIC_CHAR,"char",1,1,"'%c'");
 319   DEBUG_InitBasic(BASIC_LONG,"long int",4,1,"%d");
 320   DEBUG_TypeUSInt = DEBUG_InitBasic(BASIC_UINT,"unsigned int",4,0,"%d");
 321   DEBUG_InitBasic(BASIC_LUI,"long unsigned int",4,0,"%d");
 322   DEBUG_InitBasic(BASIC_LONGLONG,"long long int",8,1,"%ld");
 323   DEBUG_InitBasic(BASIC_ULONGLONGI,"long long unsigned int",8,0,"%ld");
 324   DEBUG_InitBasic(BASIC_SHORT,"short int",2,1,"%d");
 325   DEBUG_InitBasic(BASIC_SHORTUI,"short unsigned int",2,0,"%d");
 326   DEBUG_InitBasic(BASIC_SCHAR,"signed char",1,1,"'%c'");
 327   DEBUG_InitBasic(BASIC_UCHAR,"unsigned char",1,0,"'%c'");
 328   DEBUG_InitBasic(BASIC_FLT,"float",4,0,"%f");
 329   DEBUG_InitBasic(BASIC_LONG_DOUBLE,"double",8,0,"%lf");
 330   DEBUG_InitBasic(BASIC_DOUBLE,"long double",12,0,NULL);
 331   DEBUG_InitBasic(BASIC_CMPLX_INT,"complex int",8,1,NULL);
 332   DEBUG_InitBasic(BASIC_CMPLX_FLT,"complex float",8,0,NULL);
 333   DEBUG_InitBasic(BASIC_CMPLX_DBL,"complex double",16,0,NULL);
 334   DEBUG_InitBasic(BASIC_CMPLX_LONG_DBL,"complex long double",24,0,NULL);
 335   DEBUG_InitBasic(BASIC_VOID,"void",0,0,NULL);
 336
 337   DEBUG_TypeString = DEBUG_NewDataType(DT_POINTER, NULL);
 338   DEBUG_SetPointerType(DEBUG_TypeString, chartype);
 339
 340   /*
 341    * Now initialize the builtins for codeview.
 342    */
 343   DEBUG_InitCVDataTypes();
 344
 345 }
 346
 347 long long int
 348 DEBUG_GetExprValue(DBG_ADDR * addr, char ** format)
 349 {
 350   DBG_ADDR address = *addr;
 351   unsigned int rtn;
 352   struct datatype * type2 = NULL;
 353   struct en_values * e;
 354   char * def_format = "0x%x";
 355
 356   rtn = 0;
 357   address.seg = 0; /* FIXME? I don't quite get this... */
 358   assert(addr->type != NULL);
 359
 360   switch(addr->type->type)
 361     {
 362     case DT_BASIC:
 363       if (!DBG_CHECK_READ_PTR( &address,  addr->type->un.basic.basic_size))
 364         {
 365           return 0;
 366         }
 367
 368       memcpy(&rtn, (char *) addr->off, addr->type->un.basic.basic_size);
 369       if(    (addr->type->un.basic.b_signed)
 370           && ((addr->type->un.basic.basic_size & 3) != 0)
 371           && ((rtn >> (addr->type->un.basic.basic_size * 8 - 1)) != 0) )
 372         {
 373           rtn = rtn | ((-1) << (addr->type->un.basic.basic_size * 8));
 374         }
 375       if( addr->type->un.basic.output_format != NULL )
 376         {
 377           def_format = addr->type->un.basic.output_format;
 378         }
 379
 380       /*
 381        * Check for single character prints that are out of range.
 382        */
 383       if( addr->type->un.basic.basic_size == 1
 384           && strcmp(def_format, "'%c'") == 0
 385           && ((rtn < 0x20) || (rtn > 0x80)) )
 386         {
 387           def_format = "%d";
 388         }
 389       break;
 390     case DT_POINTER:
 391       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 392       rtn = (unsigned int)  *((unsigned char **)addr->off);
 393       type2 = addr->type->un.pointer.pointsto;
 394
 395       if (!type2)
 396       {
 397         def_format = "Internal symbol error: unable to access memory location 0x%08x";
 398         rtn = 0;
 399         break;
 400       }
 401
 402       if( type2->type == DT_BASIC && type2->un.basic.basic_size == 1 )
 403         {
 404           def_format = "\"%s\"";
 405           address.off = rtn;
 406           address.seg = 0;
 407           if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 408           break;
 409         }
 410       else
 411         {
 412           def_format = "0x%8.8x";
 413         }
 414       break;
 415     case DT_ARRAY:
 416     case DT_STRUCT:
 417       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 418       rtn = (unsigned int)  *((unsigned char **)addr->off);
 419       def_format = "0x%8.8x";
 420       break;
 421     case DT_ENUM:
 422       if (!DBG_CHECK_READ_PTR( &address, 1 )) return 0;
 423       rtn = (unsigned int)  *((unsigned char **)addr->off);
 424       for(e = addr->type->un.enumeration.members; e; e = e->next )
 425         {
 426           if( e->value == rtn )
 427             {
 428               break;
 429             }
 430         }
 431       if( e != NULL )
 432         {
 433           rtn = (int) e->name;
 434           def_format = "%s";
 435         }
 436       else
 437         {
 438           def_format = "%d";
 439         }
 440       break;
 441     default:
 442       rtn = 0;
 443       break;
 444     }
 445
 446
 447   if( format != NULL )
 448     {
 449       *format = def_format;
 450     }
 451   return rtn;
 452 }
 453
 454 unsigned int
 455 DEBUG_TypeDerefPointer(DBG_ADDR * addr, struct datatype ** newtype)
 456 {
 457   DBG_ADDR address = *addr;
 458
 459   /*
 460    * Make sure that this really makes sense.
 461    */
 462   if( addr->type->type != DT_POINTER )
 463     {
 464       *newtype = NULL;
 465       return 0;
 466     }
 467
 468   *newtype = addr->type->un.pointer.pointsto;
 469   address.off = *(unsigned int*) (addr->off);
 470   return (unsigned int)DBG_ADDR_TO_LIN(&address); /* FIXME: is this right (or "better") ? */
 471 }
 472
 473 unsigned int
 474 DEBUG_FindStructElement(DBG_ADDR * addr, const char * ele_name, int * tmpbuf)
 475 {
 476   struct member * m;
 477   unsigned int    mask;
 478
 479   /*
 480    * Make sure that this really makes sense.
 481    */
 482   if( addr->type->type != DT_STRUCT )
 483     {
 484       addr->type = NULL;
 485       return FALSE;
 486     }
 487
 488   for(m = addr->type->un.structure.members; m; m = m->next)
 489     {
 490       if( strcmp(m->name, ele_name) == 0 )
 491         {
 492           addr->type = m->type;
 493           if( (m->offset & 7) != 0 || (m->size & 7) != 0)
 494             {
 495               /*
 496                * Bitfield operation.  We have to extract the field and store
 497                * it in a temporary buffer so that we get it all right.
 498                */
 499               *tmpbuf = ((*(int* ) (addr->off + (m->offset >> 3))) >> (m->offset & 7));
 500               addr->off = (int) tmpbuf;
 501
 502               mask = 0xffffffff << (m->size);
 503               *tmpbuf &= ~mask;
 504               /*
 505                * OK, now we have the correct part of the number.
 506                * Check to see whether the basic type is signed or not, and if so,
 507                * we need to sign extend the number.
 508                */
 509               if( m->type->type == DT_BASIC && m->type->un.basic.b_signed != 0
 510                   && (*tmpbuf & (1 << (m->size - 1))) != 0 )
 511                 {
 512                   *tmpbuf |= mask;
 513                 }
 514             }
 515           else
 516             {
 517               addr->off += (m->offset >> 3);
 518             }
 519           return TRUE;
 520         }
 521     }
 522
 523   addr->type = NULL;
 524   return FALSE;
 525 }
 526
 527 int
 528 DEBUG_SetStructSize(struct datatype * dt, int size)
 529 {
 530   assert(dt->type == DT_STRUCT);
 531
 532   if( dt->un.structure.members != NULL )
 533     {
 534       return FALSE;
 535     }
 536
 537   dt->un.structure.size = size;
 538   dt->un.structure.members = NULL;
 539
 540   return TRUE;
 541 }
 542
 543 int
 544 DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2)
 545 {
 546
 547   assert( dt->type == dt2->type && ((dt->type == DT_STRUCT) || (dt->type == DT_ENUM)));
 548
 549   if( dt->type == DT_STRUCT )
 550     {
 551       dt->un.structure.members = dt2->un.structure.members;
 552     }
 553   else
 554     {
 555       dt->un.enumeration.members = dt2->un.enumeration.members;
 556     }
 557
 558   return TRUE;
 559 }
 560
 561 int
 562 DEBUG_AddStructElement(struct datatype * dt, char * name, struct datatype * type,
 563                        int offset, int size)
 564 {
 565   struct member * m;
 566   struct member * last;
 567   struct en_values * e;
 568
 569   if( dt->type == DT_STRUCT )
 570     {
 571       for(last = dt->un.structure.members; last; last = last->next)
 572         {
 573           if(    (last->name[0] == name[0])
 574               && (strcmp(last->name, name) == 0) )
 575             {
 576               return TRUE;
 577             }
 578           if( last->next == NULL )
 579             {
 580               break;
 581             }
 582         }
 583       m = (struct member *) DBG_alloc(sizeof(struct member));
 584       if( m == FALSE )
 585         {
 586           return FALSE;
 587         }
 588
 589       m->name = DBG_strdup(name);
 590       m->type = type;
 591       m->offset = offset;
 592       m->size = size;
 593       if( last == NULL )
 594         {
 595           m->next = dt->un.structure.members;
 596           dt->un.structure.members = m;
 597         }
 598       else
 599         {
 600           last->next = m;
 601           m->next = NULL;
 602         }
 603       /*
 604        * If the base type is bitfield, then adjust the offsets here so that we
 605        * are able to look things up without lots of falter-all.
 606        */
 607       if( type->type == DT_BITFIELD )
 608         {
 609           m->offset += m->type->un.bitfield.bitoff;
 610           m->size = m->type->un.bitfield.nbits;
 611           m->type = m->type->un.bitfield.basetype;
 612         }
 613     }
 614   else if( dt->type == DT_ENUM )
 615     {
 616       e = (struct en_values *) DBG_alloc(sizeof(struct en_values));
 617       if( e == FALSE )
 618         {
 619           return FALSE;
 620         }
 621
 622       e->name = DBG_strdup(name);
 623       e->value = offset;
 624       e->next = dt->un.enumeration.members;
 625       dt->un.enumeration.members = e;
 626     }
 627   else
 628     {
 629       assert(FALSE);
 630     }
 631   return TRUE;
 632 }
 633
 634 struct datatype *
 635 DEBUG_GetPointerType(struct datatype * dt)
 636 {
 637   if( dt->type == DT_POINTER )
 638     {
 639       return dt->un.pointer.pointsto;
 640     }
 641
 642   return NULL;
 643 }
 644
 645 int
 646 DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2)
 647 {
 648   switch(dt->type)
 649     {
 650     case DT_POINTER:
 651       dt->un.pointer.pointsto = dt2;
 652       break;
 653     case DT_FUNC:
 654       dt->un.funct.rettype = dt2;
 655       break;
 656     default:
 657       assert(FALSE);
 658     }
 659
 660   return TRUE;
 661 }
 662
 663 int
 664 DEBUG_SetArrayParams(struct datatype * dt, int min, int max, struct datatype * dt2)
 665 {
 666   assert(dt->type == DT_ARRAY);
 667   dt->un.array.start = min;
 668   dt->un.array.end   = max;
 669   dt->un.array.basictype = dt2;
 670
 671   return TRUE;
 672 }
 673
 674 int
 675 DEBUG_SetBitfieldParams(struct datatype * dt, int offset, int nbits,
 676                         struct datatype * dt2)
 677 {
 678   assert(dt->type == DT_BITFIELD);
 679   dt->un.bitfield.bitoff   = offset;
 680   dt->un.bitfield.nbits    = nbits;
 681   dt->un.bitfield.basetype = dt2;
 682
 683   return TRUE;
 684 }
 685
 686 int DEBUG_GetObjectSize(struct datatype * dt)
 687 {
 688   if( dt == NULL )
 689     {
 690       return 0;
 691     }
 692
 693   switch(dt->type)
 694     {
 695     case DT_BASIC:
 696       return dt->un.basic.basic_size;
 697     case DT_POINTER:
 698       return sizeof(int *);
 699     case DT_STRUCT:
 700       return dt->un.structure.size;
 701     case DT_ENUM:
 702       return sizeof(int);
 703     case DT_ARRAY:
 704       return (dt->un.array.end - dt->un.array.start)
 705         * DEBUG_GetObjectSize(dt->un.array.basictype);
 706     case DT_BITFIELD:
 707       /*
 708        * Bitfields have to be handled seperately later on
 709        * when we insert the element into the structure.
 710        */
 711       return 0;
 712     case DT_TYPEDEF:
 713     case DT_FUNC:
 714     case DT_CONST:
 715       assert(FALSE);
 716     }
 717   return 0;
 718 }
 719
 720 unsigned int
 721 DEBUG_ArrayIndex(DBG_ADDR * addr, DBG_ADDR * result, int index)
 722 {
 723   int size;
 724
 725   /*
 726    * Make sure that this really makes sense.
 727    */
 728   if( addr->type->type == DT_POINTER )
 729     {
 730       /*
 731        * Get the base type, so we know how much to index by.
 732        */
 733       size = DEBUG_GetObjectSize(addr->type->un.pointer.pointsto);
 734       result->type = addr->type->un.pointer.pointsto;
 735       result->off = (*(unsigned int*) (addr->off)) + size * index;
 736     }
 737   else if (addr->type->type == DT_ARRAY)
 738     {
 739       size = DEBUG_GetObjectSize(addr->type->un.array.basictype);
 740       result->type = addr->type->un.array.basictype;
 741       result->off = addr->off + size * (index - addr->type->un.array.start);
 742     }
 743
 744   return TRUE;
 745 }
 746
 747 /***********************************************************************
 748  *           DEBUG_Print
 749  *
 750  * Implementation of the 'print' command.
 751  */
 752 void
 753 DEBUG_Print( const DBG_ADDR *addr, int count, char format, int level )
 754 {
 755   DBG_ADDR        addr1;
 756   int             i;
 757   struct member * m;
 758   char          * pnt;
 759   int             size;
 760   long long int   value;
 761
 762   if (count != 1)
 763     {
 764       fprintf( stderr, "Count other than 1 is meaningless in 'print' command\n" );
 765       return;
 766     }
 767
 768   if( addr->type == NULL )
 769   {
 770       /* No type, just print the addr value */
 771       if (addr->seg && (addr->seg != 0xffffffff))
 772           DEBUG_nchar += fprintf( stderr, "0x%04lx: ", addr->seg );
 773       DEBUG_nchar += fprintf( stderr, "0x%08lx", addr->off );
 774       goto leave;
 775   }
 776
 777   if( level == 0 )
 778     {
 779       DEBUG_nchar = 0;
 780     }
 781
 782   if( DEBUG_nchar > DEBUG_maxchar )
 783     {
 784       fprintf(stderr, "...");
 785       goto leave;
 786     }
 787
 788   if( format == 'i' || format == 's' || format == 'w' || format == 'b' )
 789     {
 790       fprintf( stderr, "Format specifier '%c' is meaningless in 'print' command\n", format );
 791       format = '\0';
 792     }
 793
 794   switch(addr->type->type)
 795     {
 796     case DT_BASIC:
 797     case DT_ENUM:
 798     case DT_CONST:
 799     case DT_POINTER:
 800       DEBUG_PrintBasic(addr, 1, format);
 801       break;
 802     case DT_STRUCT:
 803       DEBUG_nchar += fprintf(stderr, "{");
 804       for(m = addr->type->un.structure.members; m; m = m->next)
 805         {
 806           addr1 = *addr;
 807           DEBUG_FindStructElement(&addr1, m->name,
 808                                   (int *) &value);
 809           DEBUG_nchar += fprintf(stderr, "%s=", m->name);
 810           DEBUG_Print(&addr1, 1, format, level + 1);
 811           if( m->next != NULL )
 812             {
 813               DEBUG_nchar += fprintf(stderr, ", ");
 814             }
 815           if( DEBUG_nchar > DEBUG_maxchar )
 816             {
 817               fprintf(stderr, "...}");
 818               goto leave;
 819             }
 820         }
 821       DEBUG_nchar += fprintf(stderr, "}");
 822       break;
 823     case DT_ARRAY:
 824       /*
 825        * Loop over all of the entries, printing stuff as we go.
 826        */
 827       size = DEBUG_GetObjectSize(addr->type->un.array.basictype);
 828       if( size == 1 )
 829         {
 830           /*
 831            * Special handling for character arrays.
 832            */
 833           pnt = (char *) addr->off;
 834           DEBUG_nchar += fprintf(stderr, "\"");
 835           for( i=addr->type->un.array.start; i < addr->type->un.array.end; i++ )
 836             {
 837               fputc(*pnt++, stderr);
 838               DEBUG_nchar++;
 839               if( DEBUG_nchar > DEBUG_maxchar )
 840                 {
 841                   fprintf(stderr, "...\"");
 842                   goto leave;
 843                 }
 844             }
 845           DEBUG_nchar += fprintf(stderr, "\"");
 846           break;
 847         }
 848       addr1 = *addr;
 849       addr1.type = addr->type->un.array.basictype;
 850       DEBUG_nchar += fprintf(stderr, "{");
 851       for( i=addr->type->un.array.start; i <= addr->type->un.array.end; i++ )
 852         {
 853           DEBUG_Print(&addr1, 1, format, level + 1);
 854           addr1.off += size;
 855           if( i == addr->type->un.array.end )
 856             {
 857               DEBUG_nchar += fprintf(stderr, "}");
 858             }
 859           else
 860             {
 861               DEBUG_nchar += fprintf(stderr, ", ");
 862             }
 863           if( DEBUG_nchar > DEBUG_maxchar )
 864             {
 865               fprintf(stderr, "...}");
 866               goto leave;
 867             }
 868         }
 869       break;
 870     default:
 871       assert(FALSE);
 872       break;
 873     }
 874
 875 leave:
 876
 877   if( level == 0 )
 878     {
 879       DEBUG_nchar += fprintf(stderr, "\n");
 880     }
 881   return;
 882 }
 883
 884 int
 885 DEBUG_DumpTypes()
 886 {
 887   struct datatype * dt = NULL;
 888   struct member * m;
 889   int hash;
 890   int nm;
 891   char * name;
 892   char * member_name;
 893
 894   for(hash = 0; hash < NR_TYPE_HASH + 1; hash++)
 895     {
 896       for( dt = type_hash_table[hash]; dt; dt = dt->next )
 897         {
 898           name =  "none";
 899           if( dt->name != NULL )
 900             {
 901               name = dt->name;
 902             }
 903           switch(dt->type)
 904             {
 905             case DT_BASIC:
 906               fprintf(stderr, "0x%p - BASIC(%s)\n",
 907                       dt, name);
 908               break;
 909             case DT_POINTER:
 910               fprintf(stderr, "0x%p - POINTER(%s)(%p)\n",
 911                       dt, name, dt->un.pointer.pointsto);
 912               break;
 913             case DT_STRUCT:
 914               member_name = "none";
 915               nm = 0;
 916               if( dt->un.structure.members != NULL
 917                   && dt->un.structure.members->name != NULL )
 918                 {
 919                   member_name = dt->un.structure.members->name;
 920                   for( m = dt->un.structure.members; m; m = m->next)
 921                     {
 922                       nm++;
 923                     }
 924                 }
 925               fprintf(stderr, "0x%p - STRUCT(%s) %d %d %s\n", dt, name,
 926                       dt->un.structure.size, nm, member_name);
 927               break;
 928             case DT_ARRAY:
 929               fprintf(stderr, "0x%p - ARRAY(%s)(%p)\n",
 930                       dt, name, dt->un.array.basictype);
 931               break;
 932             case DT_ENUM:
 933               fprintf(stderr, "0x%p - ENUM(%s)\n",
 934                       dt, name);
 935               break;
 936             case DT_BITFIELD:
 937               fprintf(stderr, "0x%p - BITFIELD(%s)\n", dt, name);
 938               break;
 939             case DT_FUNC:
 940               fprintf(stderr, "0x%p - FUNC(%s)(%p)\n",
 941                       dt, name, dt->un.funct.rettype);
 942               break;
 943             case DT_CONST:
 944             case DT_TYPEDEF:
 945               fprintf(stderr, "What???\n");
 946               break;
 947             }
 948         }
 949     }
 950   return TRUE;
 951 }
 952
 953
 954 enum debug_type DEBUG_GetType(struct datatype * dt)
 955 {
 956   return dt->type;
 957 }
 958
 959 struct datatype *
 960 DEBUG_TypeCast(enum debug_type type, const char * name)
 961 {
 962   int                     hash;
 963   struct datatype       * rtn;
 964
 965   /*
 966    * The last bucket is special, and is used to hold typeless names.
 967    */
 968   if( name == NULL )
 969     {
 970       hash = NR_TYPE_HASH;
 971     }
 972   else
 973     {
 974       hash = type_hash(name);
 975     }
 976
 977   rtn = DEBUG_LookupDataType(type, hash, name);
 978
 979   return rtn;
 980
 981 }
 982
 983 int
 984 DEBUG_PrintTypeCast(struct datatype * dt)
 985 {
 986   char          * name;
 987
 988   name =  "none";
 989   if( dt->name != NULL )
 990     {
 991       name = dt->name;
 992     }
 993
 994   switch(dt->type)
 995     {
 996     case DT_BASIC:
 997       fprintf(stderr, "%s", name);
 998       break;
 999     case DT_POINTER:
1000       DEBUG_PrintTypeCast(dt->un.pointer.pointsto);
1001       fprintf(stderr, "*");
1002       break;
1003     case DT_STRUCT:
1004       fprintf(stderr, "struct %s", name);
1005       break;
1006     case DT_ARRAY:
1007       fprintf(stderr, "%s[]", name);
1008       break;
1009     case DT_ENUM:
1010       fprintf(stderr, "enum %s", name);
1011       break;
1012     case DT_BITFIELD:
1013       fprintf(stderr, "unsigned %s", name);
1014       break;
1015     case DT_FUNC:
1016       DEBUG_PrintTypeCast(dt->un.funct.rettype);
1017       fprintf(stderr, "(*%s)()", name);
1018       break;
1019     case DT_CONST:
1020     case DT_TYPEDEF:
1021       fprintf(stderr, "What???\n");
1022       break;
1023     }
1024
1025   return TRUE;
1026 }
1027
1028