gdb/gdbtypes.c

   1 /* Support routines for manipulating internal types for GDB.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include <string.h>
  23 #include "bfd.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "language.h"
  30 #include "target.h"
  31 #include "value.h"
  32 #include "demangle.h"
  33 #include "complaints.h"
  34
  35 /* These variables point to the objects
  36    representing the predefined C data types.  */
  37
  38 struct type *builtin_type_void;
  39 struct type *builtin_type_char;
  40 struct type *builtin_type_short;
  41 struct type *builtin_type_int;
  42 struct type *builtin_type_long;
  43 struct type *builtin_type_long_long;
  44 struct type *builtin_type_signed_char;
  45 struct type *builtin_type_unsigned_char;
  46 struct type *builtin_type_unsigned_short;
  47 struct type *builtin_type_unsigned_int;
  48 struct type *builtin_type_unsigned_long;
  49 struct type *builtin_type_unsigned_long_long;
  50 struct type *builtin_type_float;
  51 struct type *builtin_type_double;
  52 struct type *builtin_type_long_double;
  53 struct type *builtin_type_complex;
  54 struct type *builtin_type_double_complex;
  55 struct type *builtin_type_string;
  56
  57 /* Alloc a new type structure and fill it with some defaults.  If
  58    OBJFILE is non-NULL, then allocate the space for the type structure
  59    in that objfile's type_obstack. */
  60
  61 struct type *
  62 alloc_type (objfile)
  63      struct objfile *objfile;
  64 {
  65   register struct type *type;
  66
  67   /* Alloc the structure and start off with all fields zeroed. */
  68
  69   if (objfile == NULL)
  70     {
  71       type  = (struct type *) xmalloc (sizeof (struct type));
  72     }
  73   else
  74     {
  75       type  = (struct type *) obstack_alloc (&objfile -> type_obstack,
  76                                              sizeof (struct type));
  77     }
  78   memset ((char *) type, 0, sizeof (struct type));
  79
  80   /* Initialize the fields that might not be zero. */
  81
  82   TYPE_CODE (type) = TYPE_CODE_UNDEF;
  83   TYPE_OBJFILE (type) = objfile;
  84   TYPE_VPTR_FIELDNO (type) = -1;
  85
  86   return (type);
  87 }
  88
  89 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
  90    to a pointer to memory where the pointer type should be stored.
  91    If *TYPEPTR is zero, update it to point to the pointer type we return.
  92    We allocate new memory if needed.  */
  93
  94 struct type *
  95 make_pointer_type (type, typeptr)
  96      struct type *type;
  97      struct type **typeptr;
  98 {
  99   register struct type *ntype;          /* New type */
 100   struct objfile *objfile;
 101
 102   ntype = TYPE_POINTER_TYPE (type);
 103
 104   if (ntype)
 105     if (typeptr == 0)
 106       return ntype;     /* Don't care about alloc, and have new type.  */
 107     else if (*typeptr == 0)
 108       {
 109         *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
 110         return ntype;
 111       }
 112
 113   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 114     {
 115       ntype = alloc_type (TYPE_OBJFILE (type));
 116       if (typeptr)
 117         *typeptr = ntype;
 118     }
 119   else                          /* We have storage, but need to reset it.  */
 120     {
 121       ntype = *typeptr;
 122       objfile = TYPE_OBJFILE (ntype);
 123       memset ((char *) ntype, 0, sizeof (struct type));
 124       TYPE_OBJFILE (ntype) = objfile;
 125     }
 126
 127   TYPE_TARGET_TYPE (ntype) = type;
 128   TYPE_POINTER_TYPE (type) = ntype;
 129
 130   /* FIXME!  Assume the machine has only one representation for pointers!  */
 131
 132   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 133   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 134
 135   /* pointers are unsigned */
 136   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 137
 138   if (!TYPE_POINTER_TYPE (type))        /* Remember it, if don't have one.  */
 139     TYPE_POINTER_TYPE (type) = ntype;
 140
 141   return ntype;
 142 }
 143
 144 /* Given a type TYPE, return a type of pointers to that type.
 145    May need to construct such a type if this is the first use.  */
 146
 147 struct type *
 148 lookup_pointer_type (type)
 149      struct type *type;
 150 {
 151   return make_pointer_type (type, (struct type **)0);
 152 }
 153
 154 /* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
 155    to a pointer to memory where the reference type should be stored.
 156    If *TYPEPTR is zero, update it to point to the reference type we return.
 157    We allocate new memory if needed.  */
 158
 159 struct type *
 160 make_reference_type (type, typeptr)
 161      struct type *type;
 162      struct type **typeptr;
 163 {
 164   register struct type *ntype;          /* New type */
 165   struct objfile *objfile;
 166
 167   ntype = TYPE_REFERENCE_TYPE (type);
 168
 169   if (ntype)
 170     if (typeptr == 0)
 171       return ntype;     /* Don't care about alloc, and have new type.  */
 172     else if (*typeptr == 0)
 173       {
 174         *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
 175         return ntype;
 176       }
 177
 178   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 179     {
 180       ntype = alloc_type (TYPE_OBJFILE (type));
 181       if (typeptr)
 182         *typeptr = ntype;
 183     }
 184   else                          /* We have storage, but need to reset it.  */
 185     {
 186       ntype = *typeptr;
 187       objfile = TYPE_OBJFILE (ntype);
 188       memset ((char *) ntype, 0, sizeof (struct type));
 189       TYPE_OBJFILE (ntype) = objfile;
 190     }
 191
 192   TYPE_TARGET_TYPE (ntype) = type;
 193   TYPE_REFERENCE_TYPE (type) = ntype;
 194
 195   /* FIXME!  Assume the machine has only one representation for references,
 196      and that it matches the (only) representation for pointers!  */
 197
 198   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 199   TYPE_CODE (ntype) = TYPE_CODE_REF;
 200
 201   if (!TYPE_REFERENCE_TYPE (type))      /* Remember it, if don't have one.  */
 202     TYPE_REFERENCE_TYPE (type) = ntype;
 203
 204   return ntype;
 205 }
 206
 207 /* Same as above, but caller doesn't care about memory allocation details.  */
 208
 209 struct type *
 210 lookup_reference_type (type)
 211      struct type *type;
 212 {
 213   return make_reference_type (type, (struct type **)0);
 214 }
 215
 216 /* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
 217    to a pointer to memory where the function type should be stored.
 218    If *TYPEPTR is zero, update it to point to the function type we return.
 219    We allocate new memory if needed.  */
 220
 221 struct type *
 222 make_function_type (type, typeptr)
 223      struct type *type;
 224      struct type **typeptr;
 225 {
 226   register struct type *ntype;          /* New type */
 227   struct objfile *objfile;
 228
 229   ntype = TYPE_FUNCTION_TYPE (type);
 230
 231   if (ntype)
 232     if (typeptr == 0)
 233       return ntype;     /* Don't care about alloc, and have new type.  */
 234     else if (*typeptr == 0)
 235       {
 236         *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
 237         return ntype;
 238       }
 239
 240   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 241     {
 242       ntype = alloc_type (TYPE_OBJFILE (type));
 243       if (typeptr)
 244         *typeptr = ntype;
 245     }
 246   else                          /* We have storage, but need to reset it.  */
 247     {
 248       ntype = *typeptr;
 249       objfile = TYPE_OBJFILE (ntype);
 250       memset ((char *) ntype, 0, sizeof (struct type));
 251       TYPE_OBJFILE (ntype) = objfile;
 252     }
 253
 254   TYPE_TARGET_TYPE (ntype) = type;
 255   TYPE_FUNCTION_TYPE (type) = ntype;
 256
 257   TYPE_LENGTH (ntype) = 1;
 258   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
 259
 260   if (!TYPE_FUNCTION_TYPE (type))       /* Remember it, if don't have one.  */
 261     TYPE_FUNCTION_TYPE (type) = ntype;
 262
 263   return ntype;
 264 }
 265
 266
 267 /* Given a type TYPE, return a type of functions that return that type.
 268    May need to construct such a type if this is the first use.  */
 269
 270 struct type *
 271 lookup_function_type (type)
 272      struct type *type;
 273 {
 274   return make_function_type (type, (struct type **)0);
 275 }
 276
 277 /* Implement direct support for MEMBER_TYPE in GNU C++.
 278    May need to construct such a type if this is the first use.
 279    The TYPE is the type of the member.  The DOMAIN is the type
 280    of the aggregate that the member belongs to.  */
 281
 282 struct type *
 283 lookup_member_type (type, domain)
 284      struct type *type;
 285      struct type *domain;
 286 {
 287   register struct type *mtype;
 288
 289   mtype = alloc_type (TYPE_OBJFILE (type));
 290   smash_to_member_type (mtype, domain, type);
 291   return (mtype);
 292 }
 293
 294 /* Allocate a stub method whose return type is TYPE.
 295    This apparently happens for speed of symbol reading, since parsing
 296    out the arguments to the method is cpu-intensive, the way we are doing
 297    it.  So, we will fill in arguments later.
 298    This always returns a fresh type.   */
 299
 300 struct type *
 301 allocate_stub_method (type)
 302      struct type *type;
 303 {
 304   struct type *mtype;
 305
 306   mtype = alloc_type (TYPE_OBJFILE (type));
 307   TYPE_TARGET_TYPE (mtype) = type;
 308   /*  _DOMAIN_TYPE (mtype) = unknown yet */
 309   /*  _ARG_TYPES (mtype) = unknown yet */
 310   TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
 311   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
 312   TYPE_LENGTH (mtype) = 1;
 313   return (mtype);
 314 }
 315
 316 /* Create a range type using either a blank type supplied in RESULT_TYPE,
 317    or creating a new type, inheriting the objfile from INDEX_TYPE.
 318
 319    Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
 320    HIGH_BOUND, inclusive.
 321
 322    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 323    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
 324
 325 struct type *
 326 create_range_type (result_type, index_type, low_bound, high_bound)
 327      struct type *result_type;
 328      struct type *index_type;
 329      int low_bound;
 330      int high_bound;
 331 {
 332   if (result_type == NULL)
 333     {
 334       result_type = alloc_type (TYPE_OBJFILE (index_type));
 335     }
 336   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
 337   TYPE_TARGET_TYPE (result_type) = index_type;
 338   TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
 339   TYPE_NFIELDS (result_type) = 2;
 340   TYPE_FIELDS (result_type) = (struct field *)
 341     TYPE_ALLOC (result_type, 2 * sizeof (struct field));
 342   memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
 343   TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
 344   TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
 345   TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;          /* FIXME */
 346   TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int;          /* FIXME */
 347
 348   return (result_type);
 349 }
 350
 351 /* A lot of code assumes that the "index type" of an array/string/
 352    set/bitstring is specifically a range type, though in some languages
 353    it can be any discrete type. */
 354
 355 struct type *
 356 force_to_range_type (type)
 357      struct type *type;
 358 {
 359   switch (TYPE_CODE (type))
 360     {
 361     case TYPE_CODE_RANGE:
 362       return type;
 363
 364     case TYPE_CODE_ENUM:
 365       {
 366         int low_bound = TYPE_FIELD_BITPOS (type, 0);
 367         int high_bound = TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
 368         struct type *range_type =
 369           create_range_type (NULL, type, low_bound, high_bound);
 370         TYPE_NAME (range_type) = TYPE_NAME (range_type);
 371         TYPE_DUMMY_RANGE (range_type) = 1;
 372         return range_type;
 373       }
 374     case TYPE_CODE_BOOL:
 375       {
 376         struct type *range_type = create_range_type (NULL, type, 0, 1);
 377         TYPE_NAME (range_type) = TYPE_NAME (range_type);
 378         TYPE_DUMMY_RANGE (range_type) = 1;
 379         return range_type;
 380       }
 381     case TYPE_CODE_CHAR:
 382       {
 383         struct type *range_type = create_range_type (NULL, type, 0, 255);
 384         TYPE_NAME (range_type) = TYPE_NAME (range_type);
 385         TYPE_DUMMY_RANGE (range_type) = 1;
 386         return range_type;
 387       }
 388     default:
 389       {
 390         static struct complaint msg =
 391           { "array index type must be a discrete type", 0, 0};
 392         complain (&msg);
 393
 394         return create_range_type (NULL, builtin_type_int, 0, 0);
 395       }
 396     }
 397 }
 398
 399 /* Create an array type using either a blank type supplied in RESULT_TYPE,
 400    or creating a new type, inheriting the objfile from RANGE_TYPE.
 401
 402    Elements will be of type ELEMENT_TYPE, the indices will be of type
 403    RANGE_TYPE.
 404
 405    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 406    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
 407
 408 struct type *
 409 create_array_type (result_type, element_type, range_type)
 410      struct type *result_type;
 411      struct type *element_type;
 412      struct type *range_type;
 413 {
 414   int low_bound;
 415   int high_bound;
 416
 417   range_type = force_to_range_type (range_type);
 418   if (result_type == NULL)
 419     {
 420       result_type = alloc_type (TYPE_OBJFILE (range_type));
 421     }
 422   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
 423   TYPE_TARGET_TYPE (result_type) = element_type;
 424   low_bound = TYPE_LOW_BOUND (range_type);
 425   high_bound = TYPE_HIGH_BOUND (range_type);
 426   TYPE_LENGTH (result_type) =
 427     TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
 428   TYPE_NFIELDS (result_type) = 1;
 429   TYPE_FIELDS (result_type) =
 430     (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
 431   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
 432   TYPE_FIELD_TYPE (result_type, 0) = range_type;
 433   TYPE_VPTR_FIELDNO (result_type) = -1;
 434
 435   return (result_type);
 436 }
 437
 438 /* Create a string type using either a blank type supplied in RESULT_TYPE,
 439    or creating a new type.  String types are similar enough to array of
 440    char types that we can use create_array_type to build the basic type
 441    and then bash it into a string type.
 442
 443    For fixed length strings, the range type contains 0 as the lower
 444    bound and the length of the string minus one as the upper bound.
 445
 446    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 447    sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
 448
 449 struct type *
 450 create_string_type (result_type, range_type)
 451      struct type *result_type;
 452      struct type *range_type;
 453 {
 454   result_type = create_array_type (result_type, builtin_type_char, range_type);
 455   TYPE_CODE (result_type) = TYPE_CODE_STRING;
 456   return (result_type);
 457 }
 458
 459 struct type *
 460 create_set_type (result_type, domain_type)
 461      struct type *result_type;
 462      struct type *domain_type;
 463 {
 464   int low_bound, high_bound, bit_length;
 465   if (result_type == NULL)
 466     {
 467       result_type = alloc_type (TYPE_OBJFILE (domain_type));
 468     }
 469   domain_type = force_to_range_type (domain_type);
 470   TYPE_CODE (result_type) = TYPE_CODE_SET;
 471   TYPE_NFIELDS (result_type) = 1;
 472   TYPE_FIELDS (result_type) = (struct field *)
 473     TYPE_ALLOC (result_type, 1 * sizeof (struct field));
 474   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
 475   TYPE_FIELD_TYPE (result_type, 0) = domain_type;
 476   low_bound = TYPE_LOW_BOUND (domain_type);
 477   high_bound = TYPE_HIGH_BOUND (domain_type);
 478   bit_length = high_bound - low_bound + 1;
 479   if (bit_length <= TARGET_CHAR_BIT)
 480     TYPE_LENGTH (result_type) = 1;
 481   else if (bit_length <= TARGET_SHORT_BIT)
 482     TYPE_LENGTH (result_type) = TARGET_SHORT_BIT / TARGET_CHAR_BIT;
 483   else
 484     TYPE_LENGTH (result_type)
 485       = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT)
 486         * TARGET_CHAR_BIT;
 487   return (result_type);
 488 }
 489
 490 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
 491    A MEMBER is a wierd thing -- it amounts to a typed offset into
 492    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
 493    include the offset (that's the value of the MEMBER itself), but does
 494    include the structure type into which it points (for some reason).
 495
 496    When "smashing" the type, we preserve the objfile that the
 497    old type pointed to, since we aren't changing where the type is actually
 498    allocated.  */
 499
 500 void
 501 smash_to_member_type (type, domain, to_type)
 502      struct type *type;
 503      struct type *domain;
 504      struct type *to_type;
 505 {
 506   struct objfile *objfile;
 507
 508   objfile = TYPE_OBJFILE (type);
 509
 510   memset ((char *) type, 0, sizeof (struct type));
 511   TYPE_OBJFILE (type) = objfile;
 512   TYPE_TARGET_TYPE (type) = to_type;
 513   TYPE_DOMAIN_TYPE (type) = domain;
 514   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 515   TYPE_CODE (type) = TYPE_CODE_MEMBER;
 516 }
 517
 518 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
 519    METHOD just means `function that gets an extra "this" argument'.
 520
 521    When "smashing" the type, we preserve the objfile that the
 522    old type pointed to, since we aren't changing where the type is actually
 523    allocated.  */
 524
 525 void
 526 smash_to_method_type (type, domain, to_type, args)
 527      struct type *type;
 528      struct type *domain;
 529      struct type *to_type;
 530      struct type **args;
 531 {
 532   struct objfile *objfile;
 533
 534   objfile = TYPE_OBJFILE (type);
 535
 536   memset ((char *) type, 0, sizeof (struct type));
 537   TYPE_OBJFILE (type) = objfile;
 538   TYPE_TARGET_TYPE (type) = to_type;
 539   TYPE_DOMAIN_TYPE (type) = domain;
 540   TYPE_ARG_TYPES (type) = args;
 541   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 542   TYPE_CODE (type) = TYPE_CODE_METHOD;
 543 }
 544
 545 /* Return a typename for a struct/union/enum type without "struct ",
 546    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 547
 548 char *
 549 type_name_no_tag (type)
 550      register const struct type *type;
 551 {
 552   if (TYPE_TAG_NAME (type) != NULL)
 553     return TYPE_TAG_NAME (type);
 554
 555   /* Is there code which expects this to return the name if there is no
 556      tag name?  My guess is that this is mainly used for C++ in cases where
 557      the two will always be the same.  */
 558   return TYPE_NAME (type);
 559 }
 560
 561 /* Lookup a primitive type named NAME.
 562    Return zero if NAME is not a primitive type.*/
 563
 564 struct type *
 565 lookup_primitive_typename (name)
 566      char *name;
 567 {
 568    struct type ** const *p;
 569
 570    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
 571      {
 572        if (STREQ ((**p) -> name, name))
 573          {
 574            return (**p);
 575          }
 576      }
 577    return (NULL);
 578 }
 579
 580 /* Lookup a typedef or primitive type named NAME,
 581    visible in lexical block BLOCK.
 582    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 583
 584 struct type *
 585 lookup_typename (name, block, noerr)
 586      char *name;
 587      struct block *block;
 588      int noerr;
 589 {
 590   register struct symbol *sym;
 591   register struct type *tmp;
 592
 593   sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
 594   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 595     {
 596       tmp = lookup_primitive_typename (name);
 597       if (tmp)
 598         {
 599           return (tmp);
 600         }
 601       else if (!tmp && noerr)
 602         {
 603           return (NULL);
 604         }
 605       else
 606         {
 607           error ("No type named %s.", name);
 608         }
 609     }
 610   return (SYMBOL_TYPE (sym));
 611 }
 612
 613 struct type *
 614 lookup_unsigned_typename (name)
 615      char *name;
 616 {
 617   char *uns = alloca (strlen (name) + 10);
 618
 619   strcpy (uns, "unsigned ");
 620   strcpy (uns + 9, name);
 621   return (lookup_typename (uns, (struct block *) NULL, 0));
 622 }
 623
 624 struct type *
 625 lookup_signed_typename (name)
 626      char *name;
 627 {
 628   struct type *t;
 629   char *uns = alloca (strlen (name) + 8);
 630
 631   strcpy (uns, "signed ");
 632   strcpy (uns + 7, name);
 633   t = lookup_typename (uns, (struct block *) NULL, 1);
 634   /* If we don't find "signed FOO" just try again with plain "FOO". */
 635   if (t != NULL)
 636     return t;
 637   return lookup_typename (name, (struct block *) NULL, 0);
 638 }
 639
 640 /* Lookup a structure type named "struct NAME",
 641    visible in lexical block BLOCK.  */
 642
 643 struct type *
 644 lookup_struct (name, block)
 645      char *name;
 646      struct block *block;
 647 {
 648   register struct symbol *sym;
 649
 650   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 651                        (struct symtab **) NULL);
 652
 653   if (sym == NULL)
 654     {
 655       error ("No struct type named %s.", name);
 656     }
 657   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 658     {
 659       error ("This context has class, union or enum %s, not a struct.", name);
 660     }
 661   return (SYMBOL_TYPE (sym));
 662 }
 663
 664 /* Lookup a union type named "union NAME",
 665    visible in lexical block BLOCK.  */
 666
 667 struct type *
 668 lookup_union (name, block)
 669      char *name;
 670      struct block *block;
 671 {
 672   register struct symbol *sym;
 673
 674   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 675                        (struct symtab **) NULL);
 676
 677   if (sym == NULL)
 678     {
 679       error ("No union type named %s.", name);
 680     }
 681   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
 682     {
 683       error ("This context has class, struct or enum %s, not a union.", name);
 684     }
 685   return (SYMBOL_TYPE (sym));
 686 }
 687
 688 /* Lookup an enum type named "enum NAME",
 689    visible in lexical block BLOCK.  */
 690
 691 struct type *
 692 lookup_enum (name, block)
 693      char *name;
 694      struct block *block;
 695 {
 696   register struct symbol *sym;
 697
 698   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 699                        (struct symtab **) NULL);
 700   if (sym == NULL)
 701     {
 702       error ("No enum type named %s.", name);
 703     }
 704   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
 705     {
 706       error ("This context has class, struct or union %s, not an enum.", name);
 707     }
 708   return (SYMBOL_TYPE (sym));
 709 }
 710
 711 /* Lookup a template type named "template NAME<TYPE>",
 712    visible in lexical block BLOCK.  */
 713
 714 struct type *
 715 lookup_template_type (name, type, block)
 716      char *name;
 717      struct type *type;
 718      struct block *block;
 719 {
 720   struct symbol *sym;
 721   char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
 722   strcpy (nam, name);
 723   strcat (nam, "<");
 724   strcat (nam, type->name);
 725   strcat (nam, " >");   /* FIXME, extra space still introduced in gcc? */
 726
 727   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
 728
 729   if (sym == NULL)
 730     {
 731       error ("No template type named %s.", name);
 732     }
 733   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 734     {
 735       error ("This context has class, union or enum %s, not a struct.", name);
 736     }
 737   return (SYMBOL_TYPE (sym));
 738 }
 739
 740 /* Given a type TYPE, lookup the type of the component of type named NAME.
 741
 742    TYPE can be either a struct or union, or a pointer or reference to a struct or
 743    union.  If it is a pointer or reference, its target type is automatically used.
 744    Thus '.' and '->' are interchangable, as specified for the definitions of the
 745    expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
 746
 747    If NOERR is nonzero, return zero if NAME is not suitably defined.
 748    If NAME is the name of a baseclass type, return that type.  */
 749
 750 struct type *
 751 lookup_struct_elt_type (type, name, noerr)
 752      struct type *type;
 753      char *name;
 754     int noerr;
 755 {
 756   int i;
 757
 758   while (TYPE_CODE (type) == TYPE_CODE_PTR ||
 759       TYPE_CODE (type) == TYPE_CODE_REF)
 760       type = TYPE_TARGET_TYPE (type);
 761
 762   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
 763       TYPE_CODE (type) != TYPE_CODE_UNION)
 764     {
 765       target_terminal_ours ();
 766       gdb_flush (gdb_stdout);
 767       fprintf_unfiltered (gdb_stderr, "Type ");
 768       type_print (type, "", gdb_stderr, -1);
 769       error (" is not a structure or union type.");
 770     }
 771
 772   check_stub_type (type);
 773
 774 #if 0
 775   /* FIXME:  This change put in by Michael seems incorrect for the case where
 776      the structure tag name is the same as the member name.  I.E. when doing
 777      "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
 778      Disabled by fnf. */
 779   {
 780     char *typename;
 781
 782     typename = type_name_no_tag (type);
 783     if (typename != NULL && STREQ (typename, name))
 784       return type;
 785   }
 786 #endif
 787
 788   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 789     {
 790       char *t_field_name = TYPE_FIELD_NAME (type, i);
 791
 792       if (t_field_name && STREQ (t_field_name, name))
 793         {
 794           return TYPE_FIELD_TYPE (type, i);
 795         }
 796     }
 797
 798   /* OK, it's not in this class.  Recursively check the baseclasses.  */
 799   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
 800     {
 801       struct type *t;
 802
 803       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
 804       if (t != NULL)
 805         {
 806           return t;
 807         }
 808     }
 809
 810   if (noerr)
 811     {
 812       return NULL;
 813     }
 814
 815   target_terminal_ours ();
 816   gdb_flush (gdb_stdout);
 817   fprintf_unfiltered (gdb_stderr, "Type ");
 818   type_print (type, "", gdb_stderr, -1);
 819   fprintf_unfiltered (gdb_stderr, " has no component named ");
 820   fputs_filtered (name, gdb_stderr);
 821   error (".");
 822   return (struct type *)-1;     /* For lint */
 823 }
 824
 825 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
 826    valid.  Callers should be aware that in some cases (for example,
 827    the type or one of its baseclasses is a stub type and we are
 828    debugging a .o file), this function will not be able to find the virtual
 829    function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
 830    will remain NULL.  */
 831
 832 void
 833 fill_in_vptr_fieldno (type)
 834      struct type *type;
 835 {
 836   check_stub_type (type);
 837
 838   if (TYPE_VPTR_FIELDNO (type) < 0)
 839     {
 840       int i;
 841
 842       /* We must start at zero in case the first (and only) baseclass is
 843          virtual (and hence we cannot share the table pointer).  */
 844       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 845         {
 846           fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
 847           if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
 848             {
 849               TYPE_VPTR_FIELDNO (type)
 850                 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
 851               TYPE_VPTR_BASETYPE (type)
 852                 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
 853               break;
 854             }
 855         }
 856     }
 857 }
 858
 859 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
 860
 861    If this is a stubbed struct (i.e. declared as struct foo *), see if
 862    we can find a full definition in some other file. If so, copy this
 863    definition, so we can use it in future.  There used to be a comment (but
 864    not any code) that if we don't find a full definition, we'd set a flag
 865    so we don't spend time in the future checking the same type.  That would
 866    be a mistake, though--we might load in more symbols which contain a
 867    full definition for the type.
 868
 869    This used to be coded as a macro, but I don't think it is called
 870    often enough to merit such treatment.  */
 871
 872 struct complaint stub_noname_complaint =
 873   {"stub type has NULL name", 0, 0};
 874
 875 void
 876 check_stub_type (type)
 877      struct type *type;
 878 {
 879   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
 880     {
 881       char* name = type_name_no_tag (type);
 882       /* FIXME: shouldn't we separately check the TYPE_NAME and the
 883          TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
 884          as appropriate?  (this code was written before TYPE_NAME and
 885          TYPE_TAG_NAME were separate).  */
 886       struct symbol *sym;
 887       if (name == NULL)
 888         {
 889           complain (&stub_noname_complaint);
 890           return;
 891         }
 892       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
 893                            (struct symtab **) NULL);
 894       if (sym)
 895         {
 896           memcpy ((char *)type,
 897                   (char *)SYMBOL_TYPE(sym),
 898                   sizeof (struct type));
 899         }
 900     }
 901
 902   if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
 903     {
 904       struct type *range_type;
 905
 906       check_stub_type (TYPE_TARGET_TYPE (type));
 907       if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
 908           && TYPE_CODE (type) == TYPE_CODE_ARRAY
 909           && TYPE_NFIELDS (type) == 1
 910           && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
 911               == TYPE_CODE_RANGE))
 912         {
 913           /* Now recompute the length of the array type, based on its
 914              number of elements and the target type's length.  */
 915           TYPE_LENGTH (type) =
 916             ((TYPE_FIELD_BITPOS (range_type, 1)
 917               - TYPE_FIELD_BITPOS (range_type, 0)
 918               + 1)
 919              * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
 920           TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
 921         }
 922     }
 923 }
 924
 925 /* Ugly hack to convert method stubs into method types.
 926
 927    He ain't kiddin'.  This demangles the name of the method into a string
 928    including argument types, parses out each argument type, generates
 929    a string casting a zero to that type, evaluates the string, and stuffs
 930    the resulting type into an argtype vector!!!  Then it knows the type
 931    of the whole function (including argument types for overloading),
 932    which info used to be in the stab's but was removed to hack back
 933    the space required for them.  */
 934
 935 void
 936 check_stub_method (type, i, j)
 937      struct type *type;
 938      int i;
 939      int j;
 940 {
 941   struct fn_field *f;
 942   char *mangled_name = gdb_mangle_name (type, i, j);
 943   char *demangled_name = cplus_demangle (mangled_name,
 944                                          DMGL_PARAMS | DMGL_ANSI);
 945   char *argtypetext, *p;
 946   int depth = 0, argcount = 1;
 947   struct type **argtypes;
 948   struct type *mtype;
 949
 950   if (demangled_name == NULL)
 951     {
 952       error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
 953     }
 954
 955   /* Now, read in the parameters that define this type.  */
 956   argtypetext = strchr (demangled_name, '(') + 1;
 957   p = argtypetext;
 958   while (*p)
 959     {
 960       if (*p == '(')
 961         {
 962           depth += 1;
 963         }
 964       else if (*p == ')')
 965         {
 966           depth -= 1;
 967         }
 968       else if (*p == ',' && depth == 0)
 969         {
 970           argcount += 1;
 971         }
 972
 973       p += 1;
 974     }
 975
 976   /* We need two more slots: one for the THIS pointer, and one for the
 977      NULL [...] or void [end of arglist].  */
 978
 979   argtypes = (struct type **)
 980     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
 981   p = argtypetext;
 982   argtypes[0] = lookup_pointer_type (type);
 983   argcount = 1;
 984
 985   if (*p != ')')                        /* () means no args, skip while */
 986     {
 987       depth = 0;
 988       while (*p)
 989         {
 990           if (depth <= 0 && (*p == ',' || *p == ')'))
 991             {
 992               /* Avoid parsing of ellipsis, they will be handled below.  */
 993               if (strncmp (argtypetext, "...", p - argtypetext) != 0)
 994                 {
 995                   argtypes[argcount] =
 996                       parse_and_eval_type (argtypetext, p - argtypetext);
 997                   argcount += 1;
 998                 }
 999               argtypetext = p + 1;
1000             }
1001
1002           if (*p == '(')
1003             {
1004               depth += 1;
1005             }
1006           else if (*p == ')')
1007             {
1008               depth -= 1;
1009             }
1010
1011           p += 1;
1012         }
1013     }
1014
1015   if (p[-2] != '.')                     /* Not '...' */
1016     {
1017       argtypes[argcount] = builtin_type_void;   /* List terminator */
1018     }
1019   else
1020     {
1021       argtypes[argcount] = NULL;                /* Ellist terminator */
1022     }
1023
1024   free (demangled_name);
1025
1026   f = TYPE_FN_FIELDLIST1 (type, i);
1027   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
1028
1029   /* Now update the old "stub" type into a real type.  */
1030   mtype = TYPE_FN_FIELD_TYPE (f, j);
1031   TYPE_DOMAIN_TYPE (mtype) = type;
1032   TYPE_ARG_TYPES (mtype) = argtypes;
1033   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
1034   TYPE_FN_FIELD_STUB (f, j) = 0;
1035 }
1036
1037 const struct cplus_struct_type cplus_struct_default;
1038
1039 void
1040 allocate_cplus_struct_type (type)
1041      struct type *type;
1042 {
1043   if (!HAVE_CPLUS_STRUCT (type))
1044     {
1045       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1046         TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1047       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
1048     }
1049 }
1050
1051 /* Helper function to initialize the standard scalar types.
1052
1053    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1054    of the string pointed to by name in the type_obstack for that objfile,
1055    and initialize the type name to that copy.  There are places (mipsread.c
1056    in particular, where init_type is called with a NULL value for NAME). */
1057
1058 struct type *
1059 init_type (code, length, flags, name, objfile)
1060      enum type_code code;
1061      int length;
1062      int flags;
1063      char *name;
1064      struct objfile *objfile;
1065 {
1066   register struct type *type;
1067
1068   type = alloc_type (objfile);
1069   TYPE_CODE (type) = code;
1070   TYPE_LENGTH (type) = length;
1071   TYPE_FLAGS (type) |= flags;
1072   if ((name != NULL) && (objfile != NULL))
1073     {
1074       TYPE_NAME (type) =
1075         obsavestring (name, strlen (name), &objfile -> type_obstack);
1076     }
1077   else
1078     {
1079       TYPE_NAME (type) = name;
1080     }
1081
1082   /* C++ fancies.  */
1083
1084   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
1085     {
1086       INIT_CPLUS_SPECIFIC (type);
1087     }
1088   return (type);
1089 }
1090
1091 /* Look up a fundamental type for the specified objfile.
1092    May need to construct such a type if this is the first use.
1093
1094    Some object file formats (ELF, COFF, etc) do not define fundamental
1095    types such as "int" or "double".  Others (stabs for example), do
1096    define fundamental types.
1097
1098    For the formats which don't provide fundamental types, gdb can create
1099    such types, using defaults reasonable for the current language and
1100    the current target machine.
1101
1102    NOTE:  This routine is obsolescent.  Each debugging format reader
1103    should manage it's own fundamental types, either creating them from
1104    suitable defaults or reading them from the debugging information,
1105    whichever is appropriate.  The DWARF reader has already been
1106    fixed to do this.  Once the other readers are fixed, this routine
1107    will go away.  Also note that fundamental types should be managed
1108    on a compilation unit basis in a multi-language environment, not
1109    on a linkage unit basis as is done here. */
1110
1111
1112 struct type *
1113 lookup_fundamental_type (objfile, typeid)
1114      struct objfile *objfile;
1115      int typeid;
1116 {
1117   register struct type **typep;
1118   register int nbytes;
1119
1120   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1121     {
1122       error ("internal error - invalid fundamental type id %d", typeid);
1123     }
1124
1125   /* If this is the first time we need a fundamental type for this objfile
1126      then we need to initialize the vector of type pointers. */
1127
1128   if (objfile -> fundamental_types == NULL)
1129     {
1130       nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1131       objfile -> fundamental_types = (struct type **)
1132         obstack_alloc (&objfile -> type_obstack, nbytes);
1133       memset ((char *) objfile -> fundamental_types, 0, nbytes);
1134     }
1135
1136   /* Look for this particular type in the fundamental type vector.  If one is
1137      not found, create and install one appropriate for the current language. */
1138
1139   typep = objfile -> fundamental_types + typeid;
1140   if (*typep == NULL)
1141     {
1142       *typep = create_fundamental_type (objfile, typeid);
1143     }
1144
1145   return (*typep);
1146 }
1147
1148 #if MAINTENANCE_CMDS
1149
1150 static void
1151 print_bit_vector (bits, nbits)
1152      B_TYPE *bits;
1153      int nbits;
1154 {
1155   int bitno;
1156
1157   for (bitno = 0; bitno < nbits; bitno++)
1158     {
1159       if ((bitno % 8) == 0)
1160         {
1161           puts_filtered (" ");
1162         }
1163       if (B_TST (bits, bitno))
1164         {
1165           printf_filtered ("1");
1166         }
1167       else
1168         {
1169           printf_filtered ("0");
1170         }
1171     }
1172 }
1173
1174 /* The args list is a strange beast.  It is either terminated by a NULL
1175    pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1176    type for normal fixed argcount functions.  (FIXME someday)
1177    Also note the first arg should be the "this" pointer, we may not want to
1178    include it since we may get into a infinitely recursive situation. */
1179
1180 static void
1181 print_arg_types (args, spaces)
1182      struct type **args;
1183      int spaces;
1184 {
1185   if (args != NULL)
1186     {
1187       while (*args != NULL)
1188         {
1189           recursive_dump_type (*args, spaces + 2);
1190           if ((*args++) -> code == TYPE_CODE_VOID)
1191             {
1192               break;
1193             }
1194         }
1195     }
1196 }
1197
1198 static void
1199 dump_fn_fieldlists (type, spaces)
1200      struct type *type;
1201      int spaces;
1202 {
1203   int method_idx;
1204   int overload_idx;
1205   struct fn_field *f;
1206
1207   printfi_filtered (spaces, "fn_fieldlists ");
1208   gdb_print_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
1209   printf_filtered ("\n");
1210   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
1211     {
1212       f = TYPE_FN_FIELDLIST1 (type, method_idx);
1213       printfi_filtered (spaces + 2, "[%d] name '%s' (",
1214                         method_idx,
1215                         TYPE_FN_FIELDLIST_NAME (type, method_idx));
1216       gdb_print_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
1217                          gdb_stdout);
1218       printf_filtered (") length %d\n",
1219                        TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
1220       for (overload_idx = 0;
1221            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
1222            overload_idx++)
1223         {
1224           printfi_filtered (spaces + 4, "[%d] physname '%s' (",
1225                             overload_idx,
1226                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
1227           gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
1228                              gdb_stdout);
1229           printf_filtered (")\n");
1230           printfi_filtered (spaces + 8, "type ");
1231           gdb_print_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
1232           printf_filtered ("\n");
1233
1234           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
1235                                spaces + 8 + 2);
1236
1237           printfi_filtered (spaces + 8, "args ");
1238           gdb_print_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
1239           printf_filtered ("\n");
1240
1241           print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
1242           printfi_filtered (spaces + 8, "fcontext ");
1243           gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
1244                              gdb_stdout);
1245           printf_filtered ("\n");
1246
1247           printfi_filtered (spaces + 8, "is_const %d\n",
1248                             TYPE_FN_FIELD_CONST (f, overload_idx));
1249           printfi_filtered (spaces + 8, "is_volatile %d\n",
1250                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
1251           printfi_filtered (spaces + 8, "is_private %d\n",
1252                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
1253           printfi_filtered (spaces + 8, "is_protected %d\n",
1254                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
1255           printfi_filtered (spaces + 8, "is_stub %d\n",
1256                             TYPE_FN_FIELD_STUB (f, overload_idx));
1257           printfi_filtered (spaces + 8, "voffset %u\n",
1258                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
1259         }
1260     }
1261 }
1262
1263 static void
1264 print_cplus_stuff (type, spaces)
1265      struct type *type;
1266      int spaces;
1267 {
1268   printfi_filtered (spaces, "n_baseclasses %d\n",
1269                     TYPE_N_BASECLASSES (type));
1270   printfi_filtered (spaces, "nfn_fields %d\n",
1271                     TYPE_NFN_FIELDS (type));
1272   printfi_filtered (spaces, "nfn_fields_total %d\n",
1273                     TYPE_NFN_FIELDS_TOTAL (type));
1274   if (TYPE_N_BASECLASSES (type) > 0)
1275     {
1276       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
1277                         TYPE_N_BASECLASSES (type));
1278       gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
1279       printf_filtered (")");
1280
1281       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
1282                         TYPE_N_BASECLASSES (type));
1283       puts_filtered ("\n");
1284     }
1285   if (TYPE_NFIELDS (type) > 0)
1286     {
1287       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
1288         {
1289           printfi_filtered (spaces, "private_field_bits (%d bits at *",
1290                             TYPE_NFIELDS (type));
1291           gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
1292           printf_filtered (")");
1293           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
1294                             TYPE_NFIELDS (type));
1295           puts_filtered ("\n");
1296         }
1297       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
1298         {
1299           printfi_filtered (spaces, "protected_field_bits (%d bits at *",
1300                             TYPE_NFIELDS (type));
1301           gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
1302           printf_filtered (")");
1303           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
1304                             TYPE_NFIELDS (type));
1305           puts_filtered ("\n");
1306         }
1307     }
1308   if (TYPE_NFN_FIELDS (type) > 0)
1309     {
1310       dump_fn_fieldlists (type, spaces);
1311     }
1312 }
1313
1314 void
1315 recursive_dump_type (type, spaces)
1316      struct type *type;
1317      int spaces;
1318 {
1319   int idx;
1320
1321   printfi_filtered (spaces, "type node ");
1322   gdb_print_address (type, gdb_stdout);
1323   printf_filtered ("\n");
1324   printfi_filtered (spaces, "name '%s' (",
1325                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
1326   gdb_print_address (TYPE_NAME (type), gdb_stdout);
1327   printf_filtered (")\n");
1328   if (TYPE_TAG_NAME (type) != NULL)
1329     {
1330       printfi_filtered (spaces, "tagname '%s' (",
1331                         TYPE_TAG_NAME (type));
1332       gdb_print_address (TYPE_TAG_NAME (type), gdb_stdout);
1333       printf_filtered (")\n");
1334     }
1335   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
1336   switch (TYPE_CODE (type))
1337     {
1338       case TYPE_CODE_UNDEF:
1339         printf_filtered ("(TYPE_CODE_UNDEF)");
1340         break;
1341       case TYPE_CODE_PTR:
1342         printf_filtered ("(TYPE_CODE_PTR)");
1343         break;
1344       case TYPE_CODE_ARRAY:
1345         printf_filtered ("(TYPE_CODE_ARRAY)");
1346         break;
1347       case TYPE_CODE_STRUCT:
1348         printf_filtered ("(TYPE_CODE_STRUCT)");
1349         break;
1350       case TYPE_CODE_UNION:
1351         printf_filtered ("(TYPE_CODE_UNION)");
1352         break;
1353       case TYPE_CODE_ENUM:
1354         printf_filtered ("(TYPE_CODE_ENUM)");
1355         break;
1356       case TYPE_CODE_FUNC:
1357         printf_filtered ("(TYPE_CODE_FUNC)");
1358         break;
1359       case TYPE_CODE_INT:
1360         printf_filtered ("(TYPE_CODE_INT)");
1361         break;
1362       case TYPE_CODE_FLT:
1363         printf_filtered ("(TYPE_CODE_FLT)");
1364         break;
1365       case TYPE_CODE_VOID:
1366         printf_filtered ("(TYPE_CODE_VOID)");
1367         break;
1368       case TYPE_CODE_SET:
1369         printf_filtered ("(TYPE_CODE_SET)");
1370         break;
1371       case TYPE_CODE_RANGE:
1372         printf_filtered ("(TYPE_CODE_RANGE)");
1373         break;
1374       case TYPE_CODE_STRING:
1375         printf_filtered ("(TYPE_CODE_STRING)");
1376         break;
1377       case TYPE_CODE_ERROR:
1378         printf_filtered ("(TYPE_CODE_ERROR)");
1379         break;
1380       case TYPE_CODE_MEMBER:
1381         printf_filtered ("(TYPE_CODE_MEMBER)");
1382         break;
1383       case TYPE_CODE_METHOD:
1384         printf_filtered ("(TYPE_CODE_METHOD)");
1385         break;
1386       case TYPE_CODE_REF:
1387         printf_filtered ("(TYPE_CODE_REF)");
1388         break;
1389       case TYPE_CODE_CHAR:
1390         printf_filtered ("(TYPE_CODE_CHAR)");
1391         break;
1392       case TYPE_CODE_BOOL:
1393         printf_filtered ("(TYPE_CODE_BOOL)");
1394         break;
1395       default:
1396         printf_filtered ("(UNKNOWN TYPE CODE)");
1397         break;
1398     }
1399   puts_filtered ("\n");
1400   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
1401   printfi_filtered (spaces, "objfile ");
1402   gdb_print_address (TYPE_OBJFILE (type), gdb_stdout);
1403   printf_filtered ("\n");
1404   printfi_filtered (spaces, "target_type ");
1405   gdb_print_address (TYPE_TARGET_TYPE (type), gdb_stdout);
1406   printf_filtered ("\n");
1407   if (TYPE_TARGET_TYPE (type) != NULL)
1408     {
1409       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
1410     }
1411   printfi_filtered (spaces, "pointer_type ");
1412   gdb_print_address (TYPE_POINTER_TYPE (type), gdb_stdout);
1413   printf_filtered ("\n");
1414   printfi_filtered (spaces, "reference_type ");
1415   gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
1416   printf_filtered ("\n");
1417   printfi_filtered (spaces, "function_type ");
1418   gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
1419   printf_filtered ("\n");
1420   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
1421   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
1422     {
1423       puts_filtered (" TYPE_FLAG_UNSIGNED");
1424     }
1425   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1426     {
1427       puts_filtered (" TYPE_FLAG_STUB");
1428     }
1429   puts_filtered ("\n");
1430   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
1431   gdb_print_address (TYPE_FIELDS (type), gdb_stdout);
1432   puts_filtered ("\n");
1433   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
1434     {
1435       printfi_filtered (spaces + 2,
1436                         "[%d] bitpos %d bitsize %d type ",
1437                         idx, TYPE_FIELD_BITPOS (type, idx),
1438                         TYPE_FIELD_BITSIZE (type, idx));
1439       gdb_print_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
1440       printf_filtered (" name '%s' (",
1441                        TYPE_FIELD_NAME (type, idx) != NULL
1442                        ? TYPE_FIELD_NAME (type, idx)
1443                        : "<NULL>");
1444       gdb_print_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
1445       printf_filtered (")\n");
1446       if (TYPE_FIELD_TYPE (type, idx) != NULL)
1447         {
1448           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
1449         }
1450     }
1451   printfi_filtered (spaces, "vptr_basetype ");
1452   gdb_print_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
1453   puts_filtered ("\n");
1454   if (TYPE_VPTR_BASETYPE (type) != NULL)
1455     {
1456       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
1457     }
1458   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
1459   switch (TYPE_CODE (type))
1460     {
1461       case TYPE_CODE_METHOD:
1462       case TYPE_CODE_FUNC:
1463         printfi_filtered (spaces, "arg_types ");
1464         gdb_print_address (TYPE_ARG_TYPES (type), gdb_stdout);
1465         puts_filtered ("\n");
1466         print_arg_types (TYPE_ARG_TYPES (type), spaces);
1467         break;
1468
1469       case TYPE_CODE_STRUCT:
1470         printfi_filtered (spaces, "cplus_stuff ");
1471         gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
1472         puts_filtered ("\n");
1473         print_cplus_stuff (type, spaces);
1474         break;
1475
1476       default:
1477         /* We have to pick one of the union types to be able print and test
1478            the value.  Pick cplus_struct_type, even though we know it isn't
1479            any particular one. */
1480         printfi_filtered (spaces, "type_specific ");
1481         gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
1482         if (TYPE_CPLUS_SPECIFIC (type) != NULL)
1483           {
1484             printf_filtered (" (unknown data form)");
1485           }
1486         printf_filtered ("\n");
1487         break;
1488
1489     }
1490 }
1491
1492 #endif  /* MAINTENANCE_CMDS */
1493
1494 void
1495 _initialize_gdbtypes ()
1496 {
1497   builtin_type_void =
1498     init_type (TYPE_CODE_VOID, 1,
1499                0,
1500                "void", (struct objfile *) NULL);
1501   builtin_type_char =
1502     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1503                0,
1504                "char", (struct objfile *) NULL);
1505   builtin_type_signed_char =
1506     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1507                0,
1508                "signed char", (struct objfile *) NULL);
1509   builtin_type_unsigned_char =
1510     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1511                TYPE_FLAG_UNSIGNED,
1512                "unsigned char", (struct objfile *) NULL);
1513   builtin_type_short =
1514     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1515                0,
1516                "short", (struct objfile *) NULL);
1517   builtin_type_unsigned_short =
1518     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1519                TYPE_FLAG_UNSIGNED,
1520                "unsigned short", (struct objfile *) NULL);
1521   builtin_type_int =
1522     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1523                0,
1524                "int", (struct objfile *) NULL);
1525   builtin_type_unsigned_int =
1526     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1527                TYPE_FLAG_UNSIGNED,
1528                "unsigned int", (struct objfile *) NULL);
1529   builtin_type_long =
1530     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1531                0,
1532                "long", (struct objfile *) NULL);
1533   builtin_type_unsigned_long =
1534     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1535                TYPE_FLAG_UNSIGNED,
1536                "unsigned long", (struct objfile *) NULL);
1537   builtin_type_long_long =
1538     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1539                0,
1540                "long long", (struct objfile *) NULL);
1541   builtin_type_unsigned_long_long =
1542     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1543                TYPE_FLAG_UNSIGNED,
1544                "unsigned long long", (struct objfile *) NULL);
1545   builtin_type_float =
1546     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1547                0,
1548                "float", (struct objfile *) NULL);
1549   builtin_type_double =
1550     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1551                0,
1552                "double", (struct objfile *) NULL);
1553   builtin_type_long_double =
1554     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1555                0,
1556                "long double", (struct objfile *) NULL);
1557   builtin_type_complex =
1558     init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1559                0,
1560                "complex", (struct objfile *) NULL);
1561   builtin_type_double_complex =
1562     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1563                0,
1564                "double complex", (struct objfile *) NULL);
1565   builtin_type_string =
1566     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1567                0,
1568                "string", (struct objfile *) NULL);
1569 }