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