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   /* FIXME: This is wrong for static member functions.  */
 983   argtypes[0] = lookup_pointer_type (type);
 984   argcount = 1;
 985
 986   if (*p != ')')                        /* () means no args, skip while */
 987     {
 988       depth = 0;
 989       while (*p)
 990         {
 991           if (depth <= 0 && (*p == ',' || *p == ')'))
 992             {
 993               /* Avoid parsing of ellipsis, they will be handled below.  */
 994               if (strncmp (argtypetext, "...", p - argtypetext) != 0)
 995                 {
 996                   argtypes[argcount] =
 997                       parse_and_eval_type (argtypetext, p - argtypetext);
 998                   argcount += 1;
 999                 }
1000               argtypetext = p + 1;
1001             }
1002
1003           if (*p == '(')
1004             {
1005               depth += 1;
1006             }
1007           else if (*p == ')')
1008             {
1009               depth -= 1;
1010             }
1011
1012           p += 1;
1013         }
1014     }
1015
1016   if (p[-2] != '.')                     /* Not '...' */
1017     {
1018       argtypes[argcount] = builtin_type_void;   /* List terminator */
1019     }
1020   else
1021     {
1022       argtypes[argcount] = NULL;                /* Ellist terminator */
1023     }
1024
1025   free (demangled_name);
1026
1027   f = TYPE_FN_FIELDLIST1 (type, i);
1028   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
1029
1030   /* Now update the old "stub" type into a real type.  */
1031   mtype = TYPE_FN_FIELD_TYPE (f, j);
1032   TYPE_DOMAIN_TYPE (mtype) = type;
1033   TYPE_ARG_TYPES (mtype) = argtypes;
1034   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
1035   TYPE_FN_FIELD_STUB (f, j) = 0;
1036 }
1037
1038 const struct cplus_struct_type cplus_struct_default;
1039
1040 void
1041 allocate_cplus_struct_type (type)
1042      struct type *type;
1043 {
1044   if (!HAVE_CPLUS_STRUCT (type))
1045     {
1046       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1047         TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1048       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
1049     }
1050 }
1051
1052 /* Helper function to initialize the standard scalar types.
1053
1054    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1055    of the string pointed to by name in the type_obstack for that objfile,
1056    and initialize the type name to that copy.  There are places (mipsread.c
1057    in particular, where init_type is called with a NULL value for NAME). */
1058
1059 struct type *
1060 init_type (code, length, flags, name, objfile)
1061      enum type_code code;
1062      int length;
1063      int flags;
1064      char *name;
1065      struct objfile *objfile;
1066 {
1067   register struct type *type;
1068
1069   type = alloc_type (objfile);
1070   TYPE_CODE (type) = code;
1071   TYPE_LENGTH (type) = length;
1072   TYPE_FLAGS (type) |= flags;
1073   if ((name != NULL) && (objfile != NULL))
1074     {
1075       TYPE_NAME (type) =
1076         obsavestring (name, strlen (name), &objfile -> type_obstack);
1077     }
1078   else
1079     {
1080       TYPE_NAME (type) = name;
1081     }
1082
1083   /* C++ fancies.  */
1084
1085   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
1086     {
1087       INIT_CPLUS_SPECIFIC (type);
1088     }
1089   return (type);
1090 }
1091
1092 /* Look up a fundamental type for the specified objfile.
1093    May need to construct such a type if this is the first use.
1094
1095    Some object file formats (ELF, COFF, etc) do not define fundamental
1096    types such as "int" or "double".  Others (stabs for example), do
1097    define fundamental types.
1098
1099    For the formats which don't provide fundamental types, gdb can create
1100    such types, using defaults reasonable for the current language and
1101    the current target machine.
1102
1103    NOTE:  This routine is obsolescent.  Each debugging format reader
1104    should manage it's own fundamental types, either creating them from
1105    suitable defaults or reading them from the debugging information,
1106    whichever is appropriate.  The DWARF reader has already been
1107    fixed to do this.  Once the other readers are fixed, this routine
1108    will go away.  Also note that fundamental types should be managed
1109    on a compilation unit basis in a multi-language environment, not
1110    on a linkage unit basis as is done here. */
1111
1112
1113 struct type *
1114 lookup_fundamental_type (objfile, typeid)
1115      struct objfile *objfile;
1116      int typeid;
1117 {
1118   register struct type **typep;
1119   register int nbytes;
1120
1121   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1122     {
1123       error ("internal error - invalid fundamental type id %d", typeid);
1124     }
1125
1126   /* If this is the first time we need a fundamental type for this objfile
1127      then we need to initialize the vector of type pointers. */
1128
1129   if (objfile -> fundamental_types == NULL)
1130     {
1131       nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1132       objfile -> fundamental_types = (struct type **)
1133         obstack_alloc (&objfile -> type_obstack, nbytes);
1134       memset ((char *) objfile -> fundamental_types, 0, nbytes);
1135     }
1136
1137   /* Look for this particular type in the fundamental type vector.  If one is
1138      not found, create and install one appropriate for the current language. */
1139
1140   typep = objfile -> fundamental_types + typeid;
1141   if (*typep == NULL)
1142     {
1143       *typep = create_fundamental_type (objfile, typeid);
1144     }
1145
1146   return (*typep);
1147 }
1148
1149 #if MAINTENANCE_CMDS
1150
1151 static void
1152 print_bit_vector (bits, nbits)
1153      B_TYPE *bits;
1154      int nbits;
1155 {
1156   int bitno;
1157
1158   for (bitno = 0; bitno < nbits; bitno++)
1159     {
1160       if ((bitno % 8) == 0)
1161         {
1162           puts_filtered (" ");
1163         }
1164       if (B_TST (bits, bitno))
1165         {
1166           printf_filtered ("1");
1167         }
1168       else
1169         {
1170           printf_filtered ("0");
1171         }
1172     }
1173 }
1174
1175 /* The args list is a strange beast.  It is either terminated by a NULL
1176    pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1177    type for normal fixed argcount functions.  (FIXME someday)
1178    Also note the first arg should be the "this" pointer, we may not want to
1179    include it since we may get into a infinitely recursive situation. */
1180
1181 static void
1182 print_arg_types (args, spaces)
1183      struct type **args;
1184      int spaces;
1185 {
1186   if (args != NULL)
1187     {
1188       while (*args != NULL)
1189         {
1190           recursive_dump_type (*args, spaces + 2);
1191           if ((*args++) -> code == TYPE_CODE_VOID)
1192             {
1193               break;
1194             }
1195         }
1196     }
1197 }
1198
1199 static void
1200 dump_fn_fieldlists (type, spaces)
1201      struct type *type;
1202      int spaces;
1203 {
1204   int method_idx;
1205   int overload_idx;
1206   struct fn_field *f;
1207
1208   printfi_filtered (spaces, "fn_fieldlists ");
1209   gdb_print_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
1210   printf_filtered ("\n");
1211   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
1212     {
1213       f = TYPE_FN_FIELDLIST1 (type, method_idx);
1214       printfi_filtered (spaces + 2, "[%d] name '%s' (",
1215                         method_idx,
1216                         TYPE_FN_FIELDLIST_NAME (type, method_idx));
1217       gdb_print_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
1218                          gdb_stdout);
1219       printf_filtered (") length %d\n",
1220                        TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
1221       for (overload_idx = 0;
1222            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
1223            overload_idx++)
1224         {
1225           printfi_filtered (spaces + 4, "[%d] physname '%s' (",
1226                             overload_idx,
1227                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
1228           gdb_print_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
1229                              gdb_stdout);
1230           printf_filtered (")\n");
1231           printfi_filtered (spaces + 8, "type ");
1232           gdb_print_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
1233           printf_filtered ("\n");
1234
1235           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
1236                                spaces + 8 + 2);
1237
1238           printfi_filtered (spaces + 8, "args ");
1239           gdb_print_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
1240           printf_filtered ("\n");
1241
1242           print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
1243           printfi_filtered (spaces + 8, "fcontext ");
1244           gdb_print_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
1245                              gdb_stdout);
1246           printf_filtered ("\n");
1247
1248           printfi_filtered (spaces + 8, "is_const %d\n",
1249                             TYPE_FN_FIELD_CONST (f, overload_idx));
1250           printfi_filtered (spaces + 8, "is_volatile %d\n",
1251                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
1252           printfi_filtered (spaces + 8, "is_private %d\n",
1253                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
1254           printfi_filtered (spaces + 8, "is_protected %d\n",
1255                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
1256           printfi_filtered (spaces + 8, "is_stub %d\n",
1257                             TYPE_FN_FIELD_STUB (f, overload_idx));
1258           printfi_filtered (spaces + 8, "voffset %u\n",
1259                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
1260         }
1261     }
1262 }
1263
1264 static void
1265 print_cplus_stuff (type, spaces)
1266      struct type *type;
1267      int spaces;
1268 {
1269   printfi_filtered (spaces, "n_baseclasses %d\n",
1270                     TYPE_N_BASECLASSES (type));
1271   printfi_filtered (spaces, "nfn_fields %d\n",
1272                     TYPE_NFN_FIELDS (type));
1273   printfi_filtered (spaces, "nfn_fields_total %d\n",
1274                     TYPE_NFN_FIELDS_TOTAL (type));
1275   if (TYPE_N_BASECLASSES (type) > 0)
1276     {
1277       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
1278                         TYPE_N_BASECLASSES (type));
1279       gdb_print_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
1280       printf_filtered (")");
1281
1282       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
1283                         TYPE_N_BASECLASSES (type));
1284       puts_filtered ("\n");
1285     }
1286   if (TYPE_NFIELDS (type) > 0)
1287     {
1288       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
1289         {
1290           printfi_filtered (spaces, "private_field_bits (%d bits at *",
1291                             TYPE_NFIELDS (type));
1292           gdb_print_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
1293           printf_filtered (")");
1294           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
1295                             TYPE_NFIELDS (type));
1296           puts_filtered ("\n");
1297         }
1298       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
1299         {
1300           printfi_filtered (spaces, "protected_field_bits (%d bits at *",
1301                             TYPE_NFIELDS (type));
1302           gdb_print_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
1303           printf_filtered (")");
1304           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
1305                             TYPE_NFIELDS (type));
1306           puts_filtered ("\n");
1307         }
1308     }
1309   if (TYPE_NFN_FIELDS (type) > 0)
1310     {
1311       dump_fn_fieldlists (type, spaces);
1312     }
1313 }
1314
1315 void
1316 recursive_dump_type (type, spaces)
1317      struct type *type;
1318      int spaces;
1319 {
1320   int idx;
1321
1322   printfi_filtered (spaces, "type node ");
1323   gdb_print_address (type, gdb_stdout);
1324   printf_filtered ("\n");
1325   printfi_filtered (spaces, "name '%s' (",
1326                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
1327   gdb_print_address (TYPE_NAME (type), gdb_stdout);
1328   printf_filtered (")\n");
1329   if (TYPE_TAG_NAME (type) != NULL)
1330     {
1331       printfi_filtered (spaces, "tagname '%s' (",
1332                         TYPE_TAG_NAME (type));
1333       gdb_print_address (TYPE_TAG_NAME (type), gdb_stdout);
1334       printf_filtered (")\n");
1335     }
1336   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
1337   switch (TYPE_CODE (type))
1338     {
1339       case TYPE_CODE_UNDEF:
1340         printf_filtered ("(TYPE_CODE_UNDEF)");
1341         break;
1342       case TYPE_CODE_PTR:
1343         printf_filtered ("(TYPE_CODE_PTR)");
1344         break;
1345       case TYPE_CODE_ARRAY:
1346         printf_filtered ("(TYPE_CODE_ARRAY)");
1347         break;
1348       case TYPE_CODE_STRUCT:
1349         printf_filtered ("(TYPE_CODE_STRUCT)");
1350         break;
1351       case TYPE_CODE_UNION:
1352         printf_filtered ("(TYPE_CODE_UNION)");
1353         break;
1354       case TYPE_CODE_ENUM:
1355         printf_filtered ("(TYPE_CODE_ENUM)");
1356         break;
1357       case TYPE_CODE_FUNC:
1358         printf_filtered ("(TYPE_CODE_FUNC)");
1359         break;
1360       case TYPE_CODE_INT:
1361         printf_filtered ("(TYPE_CODE_INT)");
1362         break;
1363       case TYPE_CODE_FLT:
1364         printf_filtered ("(TYPE_CODE_FLT)");
1365         break;
1366       case TYPE_CODE_VOID:
1367         printf_filtered ("(TYPE_CODE_VOID)");
1368         break;
1369       case TYPE_CODE_SET:
1370         printf_filtered ("(TYPE_CODE_SET)");
1371         break;
1372       case TYPE_CODE_RANGE:
1373         printf_filtered ("(TYPE_CODE_RANGE)");
1374         break;
1375       case TYPE_CODE_STRING:
1376         printf_filtered ("(TYPE_CODE_STRING)");
1377         break;
1378       case TYPE_CODE_ERROR:
1379         printf_filtered ("(TYPE_CODE_ERROR)");
1380         break;
1381       case TYPE_CODE_MEMBER:
1382         printf_filtered ("(TYPE_CODE_MEMBER)");
1383         break;
1384       case TYPE_CODE_METHOD:
1385         printf_filtered ("(TYPE_CODE_METHOD)");
1386         break;
1387       case TYPE_CODE_REF:
1388         printf_filtered ("(TYPE_CODE_REF)");
1389         break;
1390       case TYPE_CODE_CHAR:
1391         printf_filtered ("(TYPE_CODE_CHAR)");
1392         break;
1393       case TYPE_CODE_BOOL:
1394         printf_filtered ("(TYPE_CODE_BOOL)");
1395         break;
1396       default:
1397         printf_filtered ("(UNKNOWN TYPE CODE)");
1398         break;
1399     }
1400   puts_filtered ("\n");
1401   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
1402   printfi_filtered (spaces, "objfile ");
1403   gdb_print_address (TYPE_OBJFILE (type), gdb_stdout);
1404   printf_filtered ("\n");
1405   printfi_filtered (spaces, "target_type ");
1406   gdb_print_address (TYPE_TARGET_TYPE (type), gdb_stdout);
1407   printf_filtered ("\n");
1408   if (TYPE_TARGET_TYPE (type) != NULL)
1409     {
1410       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
1411     }
1412   printfi_filtered (spaces, "pointer_type ");
1413   gdb_print_address (TYPE_POINTER_TYPE (type), gdb_stdout);
1414   printf_filtered ("\n");
1415   printfi_filtered (spaces, "reference_type ");
1416   gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
1417   printf_filtered ("\n");
1418   printfi_filtered (spaces, "function_type ");
1419   gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
1420   printf_filtered ("\n");
1421   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
1422   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
1423     {
1424       puts_filtered (" TYPE_FLAG_UNSIGNED");
1425     }
1426   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1427     {
1428       puts_filtered (" TYPE_FLAG_STUB");
1429     }
1430   puts_filtered ("\n");
1431   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
1432   gdb_print_address (TYPE_FIELDS (type), gdb_stdout);
1433   puts_filtered ("\n");
1434   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
1435     {
1436       printfi_filtered (spaces + 2,
1437                         "[%d] bitpos %d bitsize %d type ",
1438                         idx, TYPE_FIELD_BITPOS (type, idx),
1439                         TYPE_FIELD_BITSIZE (type, idx));
1440       gdb_print_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
1441       printf_filtered (" name '%s' (",
1442                        TYPE_FIELD_NAME (type, idx) != NULL
1443                        ? TYPE_FIELD_NAME (type, idx)
1444                        : "<NULL>");
1445       gdb_print_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
1446       printf_filtered (")\n");
1447       if (TYPE_FIELD_TYPE (type, idx) != NULL)
1448         {
1449           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
1450         }
1451     }
1452   printfi_filtered (spaces, "vptr_basetype ");
1453   gdb_print_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
1454   puts_filtered ("\n");
1455   if (TYPE_VPTR_BASETYPE (type) != NULL)
1456     {
1457       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
1458     }
1459   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
1460   switch (TYPE_CODE (type))
1461     {
1462       case TYPE_CODE_METHOD:
1463       case TYPE_CODE_FUNC:
1464         printfi_filtered (spaces, "arg_types ");
1465         gdb_print_address (TYPE_ARG_TYPES (type), gdb_stdout);
1466         puts_filtered ("\n");
1467         print_arg_types (TYPE_ARG_TYPES (type), spaces);
1468         break;
1469
1470       case TYPE_CODE_STRUCT:
1471         printfi_filtered (spaces, "cplus_stuff ");
1472         gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
1473         puts_filtered ("\n");
1474         print_cplus_stuff (type, spaces);
1475         break;
1476
1477       default:
1478         /* We have to pick one of the union types to be able print and test
1479            the value.  Pick cplus_struct_type, even though we know it isn't
1480            any particular one. */
1481         printfi_filtered (spaces, "type_specific ");
1482         gdb_print_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
1483         if (TYPE_CPLUS_SPECIFIC (type) != NULL)
1484           {
1485             printf_filtered (" (unknown data form)");
1486           }
1487         printf_filtered ("\n");
1488         break;
1489
1490     }
1491 }
1492
1493 #endif  /* MAINTENANCE_CMDS */
1494
1495 void
1496 _initialize_gdbtypes ()
1497 {
1498   builtin_type_void =
1499     init_type (TYPE_CODE_VOID, 1,
1500                0,
1501                "void", (struct objfile *) NULL);
1502   builtin_type_char =
1503     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1504                0,
1505                "char", (struct objfile *) NULL);
1506   builtin_type_signed_char =
1507     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1508                0,
1509                "signed char", (struct objfile *) NULL);
1510   builtin_type_unsigned_char =
1511     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1512                TYPE_FLAG_UNSIGNED,
1513                "unsigned char", (struct objfile *) NULL);
1514   builtin_type_short =
1515     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1516                0,
1517                "short", (struct objfile *) NULL);
1518   builtin_type_unsigned_short =
1519     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1520                TYPE_FLAG_UNSIGNED,
1521                "unsigned short", (struct objfile *) NULL);
1522   builtin_type_int =
1523     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1524                0,
1525                "int", (struct objfile *) NULL);
1526   builtin_type_unsigned_int =
1527     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1528                TYPE_FLAG_UNSIGNED,
1529                "unsigned int", (struct objfile *) NULL);
1530   builtin_type_long =
1531     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1532                0,
1533                "long", (struct objfile *) NULL);
1534   builtin_type_unsigned_long =
1535     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1536                TYPE_FLAG_UNSIGNED,
1537                "unsigned long", (struct objfile *) NULL);
1538   builtin_type_long_long =
1539     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1540                0,
1541                "long long", (struct objfile *) NULL);
1542   builtin_type_unsigned_long_long =
1543     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1544                TYPE_FLAG_UNSIGNED,
1545                "unsigned long long", (struct objfile *) NULL);
1546   builtin_type_float =
1547     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1548                0,
1549                "float", (struct objfile *) NULL);
1550   builtin_type_double =
1551     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1552                0,
1553                "double", (struct objfile *) NULL);
1554   builtin_type_long_double =
1555     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1556                0,
1557                "long double", (struct objfile *) NULL);
1558   builtin_type_complex =
1559     init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1560                0,
1561                "complex", (struct objfile *) NULL);
1562   builtin_type_double_complex =
1563     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1564                0,
1565                "double complex", (struct objfile *) NULL);
1566   builtin_type_string =
1567     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1568                0,
1569                "string", (struct objfile *) NULL);
1570 }