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