git.oblomov.eu Git - wine/blob - programs/winedbg/types.c

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