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
 352 /* Create an array type using either a blank type supplied in RESULT_TYPE,
 353    or creating a new type, inheriting the objfile from RANGE_TYPE.
 354
 355    Elements will be of type ELEMENT_TYPE, the indices will be of type
 356    RANGE_TYPE.
 357
 358    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 359    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
 360
 361 struct type *
 362 create_array_type (result_type, element_type, range_type)
 363      struct type *result_type;
 364      struct type *element_type;
 365      struct type *range_type;
 366 {
 367   int low_bound;
 368   int high_bound;
 369
 370   if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
 371     {
 372       /* FIXME:  We only handle range types at the moment.  Complain and
 373          create a dummy range type to use. */
 374       warning ("internal error:  array index type must be a range type");
 375       range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type),
 376                                             FT_INTEGER);
 377       range_type = create_range_type ((struct type *) NULL, range_type, 0, 0);
 378     }
 379   if (result_type == NULL)
 380     {
 381       result_type = alloc_type (TYPE_OBJFILE (range_type));
 382     }
 383   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
 384   TYPE_TARGET_TYPE (result_type) = element_type;
 385   low_bound = TYPE_FIELD_BITPOS (range_type, 0);
 386   high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 387   TYPE_LENGTH (result_type) =
 388     TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
 389   TYPE_NFIELDS (result_type) = 1;
 390   TYPE_FIELDS (result_type) =
 391     (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
 392   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
 393   TYPE_FIELD_TYPE (result_type, 0) = range_type;
 394   TYPE_VPTR_FIELDNO (result_type) = -1;
 395
 396   return (result_type);
 397 }
 398
 399 /* Create a string type using either a blank type supplied in RESULT_TYPE,
 400    or creating a new type.  String types are similar enough to array of
 401    char types that we can use create_array_type to build the basic type
 402    and then bash it into a string type.
 403
 404    For fixed length strings, the range type contains 0 as the lower
 405    bound and the length of the string minus one as the upper bound.
 406
 407    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 408    sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
 409
 410 struct type *
 411 create_string_type (result_type, range_type)
 412      struct type *result_type;
 413      struct type *range_type;
 414 {
 415   result_type = create_array_type (result_type, builtin_type_char, range_type);
 416   TYPE_CODE (result_type) = TYPE_CODE_STRING;
 417   return (result_type);
 418 }
 419
 420 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
 421    A MEMBER is a wierd thing -- it amounts to a typed offset into
 422    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
 423    include the offset (that's the value of the MEMBER itself), but does
 424    include the structure type into which it points (for some reason).
 425
 426    When "smashing" the type, we preserve the objfile that the
 427    old type pointed to, since we aren't changing where the type is actually
 428    allocated.  */
 429
 430 void
 431 smash_to_member_type (type, domain, to_type)
 432      struct type *type;
 433      struct type *domain;
 434      struct type *to_type;
 435 {
 436   struct objfile *objfile;
 437
 438   objfile = TYPE_OBJFILE (type);
 439
 440   memset ((char *) type, 0, sizeof (struct type));
 441   TYPE_OBJFILE (type) = objfile;
 442   TYPE_TARGET_TYPE (type) = to_type;
 443   TYPE_DOMAIN_TYPE (type) = domain;
 444   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 445   TYPE_CODE (type) = TYPE_CODE_MEMBER;
 446 }
 447
 448 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
 449    METHOD just means `function that gets an extra "this" argument'.
 450
 451    When "smashing" the type, we preserve the objfile that the
 452    old type pointed to, since we aren't changing where the type is actually
 453    allocated.  */
 454
 455 void
 456 smash_to_method_type (type, domain, to_type, args)
 457      struct type *type;
 458      struct type *domain;
 459      struct type *to_type;
 460      struct type **args;
 461 {
 462   struct objfile *objfile;
 463
 464   objfile = TYPE_OBJFILE (type);
 465
 466   memset ((char *) type, 0, sizeof (struct type));
 467   TYPE_OBJFILE (type) = objfile;
 468   TYPE_TARGET_TYPE (type) = to_type;
 469   TYPE_DOMAIN_TYPE (type) = domain;
 470   TYPE_ARG_TYPES (type) = args;
 471   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 472   TYPE_CODE (type) = TYPE_CODE_METHOD;
 473 }
 474
 475 /* Return a typename for a struct/union/enum type without "struct ",
 476    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 477
 478 char *
 479 type_name_no_tag (type)
 480      register const struct type *type;
 481 {
 482   if (TYPE_TAG_NAME (type) != NULL)
 483     return TYPE_TAG_NAME (type);
 484
 485   /* Is there code which expects this to return the name if there is no
 486      tag name?  My guess is that this is mainly used for C++ in cases where
 487      the two will always be the same.  */
 488   return TYPE_NAME (type);
 489 }
 490
 491 /* Lookup a primitive type named NAME.
 492    Return zero if NAME is not a primitive type.*/
 493
 494 struct type *
 495 lookup_primitive_typename (name)
 496      char *name;
 497 {
 498    struct type ** const *p;
 499
 500    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
 501      {
 502        if (STREQ ((**p) -> name, name))
 503          {
 504            return (**p);
 505          }
 506      }
 507    return (NULL);
 508 }
 509
 510 /* Lookup a typedef or primitive type named NAME,
 511    visible in lexical block BLOCK.
 512    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 513
 514 struct type *
 515 lookup_typename (name, block, noerr)
 516      char *name;
 517      struct block *block;
 518      int noerr;
 519 {
 520   register struct symbol *sym;
 521   register struct type *tmp;
 522
 523   sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
 524   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 525     {
 526       tmp = lookup_primitive_typename (name);
 527       if (tmp)
 528         {
 529           return (tmp);
 530         }
 531       else if (!tmp && noerr)
 532         {
 533           return (NULL);
 534         }
 535       else
 536         {
 537           error ("No type named %s.", name);
 538         }
 539     }
 540   return (SYMBOL_TYPE (sym));
 541 }
 542
 543 struct type *
 544 lookup_unsigned_typename (name)
 545      char *name;
 546 {
 547   char *uns = alloca (strlen (name) + 10);
 548
 549   strcpy (uns, "unsigned ");
 550   strcpy (uns + 9, name);
 551   return (lookup_typename (uns, (struct block *) NULL, 0));
 552 }
 553
 554 struct type *
 555 lookup_signed_typename (name)
 556      char *name;
 557 {
 558   struct type *t;
 559   char *uns = alloca (strlen (name) + 8);
 560
 561   strcpy (uns, "signed ");
 562   strcpy (uns + 7, name);
 563   t = lookup_typename (uns, (struct block *) NULL, 1);
 564   /* If we don't find "signed FOO" just try again with plain "FOO". */
 565   if (t != NULL)
 566     return t;
 567   return lookup_typename (name, (struct block *) NULL, 0);
 568 }
 569
 570 /* Lookup a structure type named "struct NAME",
 571    visible in lexical block BLOCK.  */
 572
 573 struct type *
 574 lookup_struct (name, block)
 575      char *name;
 576      struct block *block;
 577 {
 578   register struct symbol *sym;
 579
 580   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 581                        (struct symtab **) NULL);
 582
 583   if (sym == NULL)
 584     {
 585       error ("No struct type named %s.", name);
 586     }
 587   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 588     {
 589       error ("This context has class, union or enum %s, not a struct.", name);
 590     }
 591   return (SYMBOL_TYPE (sym));
 592 }
 593
 594 /* Lookup a union type named "union NAME",
 595    visible in lexical block BLOCK.  */
 596
 597 struct type *
 598 lookup_union (name, block)
 599      char *name;
 600      struct block *block;
 601 {
 602   register struct symbol *sym;
 603
 604   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 605                        (struct symtab **) NULL);
 606
 607   if (sym == NULL)
 608     {
 609       error ("No union type named %s.", name);
 610     }
 611   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
 612     {
 613       error ("This context has class, struct or enum %s, not a union.", name);
 614     }
 615   return (SYMBOL_TYPE (sym));
 616 }
 617
 618 /* Lookup an enum type named "enum NAME",
 619    visible in lexical block BLOCK.  */
 620
 621 struct type *
 622 lookup_enum (name, block)
 623      char *name;
 624      struct block *block;
 625 {
 626   register struct symbol *sym;
 627
 628   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 629                        (struct symtab **) NULL);
 630   if (sym == NULL)
 631     {
 632       error ("No enum type named %s.", name);
 633     }
 634   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
 635     {
 636       error ("This context has class, struct or union %s, not an enum.", name);
 637     }
 638   return (SYMBOL_TYPE (sym));
 639 }
 640
 641 /* Lookup a template type named "template NAME<TYPE>",
 642    visible in lexical block BLOCK.  */
 643
 644 struct type *
 645 lookup_template_type (name, type, block)
 646      char *name;
 647      struct type *type;
 648      struct block *block;
 649 {
 650   struct symbol *sym;
 651   char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
 652   strcpy (nam, name);
 653   strcat (nam, "<");
 654   strcat (nam, type->name);
 655   strcat (nam, " >");   /* FIXME, extra space still introduced in gcc? */
 656
 657   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
 658
 659   if (sym == NULL)
 660     {
 661       error ("No template type named %s.", name);
 662     }
 663   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 664     {
 665       error ("This context has class, union or enum %s, not a struct.", name);
 666     }
 667   return (SYMBOL_TYPE (sym));
 668 }
 669
 670 /* Given a type TYPE, lookup the type of the component of type named NAME.
 671
 672    TYPE can be either a struct or union, or a pointer or reference to a struct or
 673    union.  If it is a pointer or reference, its target type is automatically used.
 674    Thus '.' and '->' are interchangable, as specified for the definitions of the
 675    expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
 676
 677    If NOERR is nonzero, return zero if NAME is not suitably defined.
 678    If NAME is the name of a baseclass type, return that type.  */
 679
 680 struct type *
 681 lookup_struct_elt_type (type, name, noerr)
 682      struct type *type;
 683      char *name;
 684     int noerr;
 685 {
 686   int i;
 687
 688   if (TYPE_CODE (type) == TYPE_CODE_PTR ||
 689       TYPE_CODE (type) == TYPE_CODE_REF)
 690       type = TYPE_TARGET_TYPE (type);
 691
 692   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
 693       TYPE_CODE (type) != TYPE_CODE_UNION)
 694     {
 695       target_terminal_ours ();
 696       fflush (stdout);
 697       fprintf (stderr, "Type ");
 698       type_print (type, "", stderr, -1);
 699       error (" is not a structure or union type.");
 700     }
 701
 702   check_stub_type (type);
 703
 704 #if 0
 705   /* FIXME:  This change put in by Michael seems incorrect for the case where
 706      the structure tag name is the same as the member name.  I.E. when doing
 707      "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
 708      Disabled by fnf. */
 709   {
 710     char *typename;
 711
 712     typename = type_name_no_tag (type);
 713     if (typename != NULL && STREQ (typename, name))
 714       return type;
 715   }
 716 #endif
 717
 718   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 719     {
 720       char *t_field_name = TYPE_FIELD_NAME (type, i);
 721
 722       if (t_field_name && STREQ (t_field_name, name))
 723         {
 724           return TYPE_FIELD_TYPE (type, i);
 725         }
 726     }
 727
 728   /* OK, it's not in this class.  Recursively check the baseclasses.  */
 729   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
 730     {
 731       struct type *t;
 732
 733       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
 734       if (t != NULL)
 735         {
 736           return t;
 737         }
 738     }
 739
 740   if (noerr)
 741     {
 742       return NULL;
 743     }
 744
 745   target_terminal_ours ();
 746   fflush (stdout);
 747   fprintf (stderr, "Type ");
 748   type_print (type, "", stderr, -1);
 749   fprintf (stderr, " has no component named ");
 750   fputs_filtered (name, stderr);
 751   error (".");
 752   return (struct type *)-1;     /* For lint */
 753 }
 754
 755 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
 756    valid.  Callers should be aware that in some cases (for example,
 757    the type or one of its baseclasses is a stub type and we are
 758    debugging a .o file), this function will not be able to find the virtual
 759    function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
 760    will remain NULL.  */
 761
 762 void
 763 fill_in_vptr_fieldno (type)
 764      struct type *type;
 765 {
 766   check_stub_type (type);
 767
 768   if (TYPE_VPTR_FIELDNO (type) < 0)
 769     {
 770       int i;
 771
 772       /* We must start at zero in case the first (and only) baseclass is
 773          virtual (and hence we cannot share the table pointer).  */
 774       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 775         {
 776           fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
 777           if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
 778             {
 779               TYPE_VPTR_FIELDNO (type)
 780                 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
 781               TYPE_VPTR_BASETYPE (type)
 782                 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
 783               break;
 784             }
 785         }
 786     }
 787 }
 788
 789 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
 790
 791    If this is a stubbed struct (i.e. declared as struct foo *), see if
 792    we can find a full definition in some other file. If so, copy this
 793    definition, so we can use it in future.  If not, set a flag so we
 794    don't waste too much time in future.  (FIXME, this doesn't seem
 795    to be happening...)
 796
 797    This used to be coded as a macro, but I don't think it is called
 798    often enough to merit such treatment.
 799 */
 800
 801 struct complaint stub_noname_complaint =
 802   {"stub type has NULL name", 0, 0};
 803
 804 void
 805 check_stub_type (type)
 806      struct type *type;
 807 {
 808   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
 809     {
 810       char* name = type_name_no_tag (type);
 811       /* FIXME: shouldn't we separately check the TYPE_NAME and the
 812          TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
 813          as appropriate?  (this code was written before TYPE_NAME and
 814          TYPE_TAG_NAME were separate).  */
 815       struct symbol *sym;
 816       if (name == NULL)
 817         {
 818           complain (&stub_noname_complaint);
 819           return;
 820         }
 821       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
 822                            (struct symtab **) NULL);
 823       if (sym)
 824         {
 825           memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type));
 826         }
 827     }
 828 }
 829
 830 /* Ugly hack to convert method stubs into method types.
 831
 832    He ain't kiddin'.  This demangles the name of the method into a string
 833    including argument types, parses out each argument type, generates
 834    a string casting a zero to that type, evaluates the string, and stuffs
 835    the resulting type into an argtype vector!!!  Then it knows the type
 836    of the whole function (including argument types for overloading),
 837    which info used to be in the stab's but was removed to hack back
 838    the space required for them.  */
 839
 840 void
 841 check_stub_method (type, i, j)
 842      struct type *type;
 843      int i;
 844      int j;
 845 {
 846   struct fn_field *f;
 847   char *mangled_name = gdb_mangle_name (type, i, j);
 848   char *demangled_name = cplus_demangle (mangled_name,
 849                                          DMGL_PARAMS | DMGL_ANSI);
 850   char *argtypetext, *p;
 851   int depth = 0, argcount = 1;
 852   struct type **argtypes;
 853   struct type *mtype;
 854
 855   if (demangled_name == NULL)
 856     {
 857       error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
 858     }
 859
 860   /* Now, read in the parameters that define this type.  */
 861   argtypetext = strchr (demangled_name, '(') + 1;
 862   p = argtypetext;
 863   while (*p)
 864     {
 865       if (*p == '(')
 866         {
 867           depth += 1;
 868         }
 869       else if (*p == ')')
 870         {
 871           depth -= 1;
 872         }
 873       else if (*p == ',' && depth == 0)
 874         {
 875           argcount += 1;
 876         }
 877
 878       p += 1;
 879     }
 880
 881   /* We need two more slots: one for the THIS pointer, and one for the
 882      NULL [...] or void [end of arglist].  */
 883
 884   argtypes = (struct type **)
 885     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
 886   p = argtypetext;
 887   argtypes[0] = lookup_pointer_type (type);
 888   argcount = 1;
 889
 890   if (*p != ')')                        /* () means no args, skip while */
 891     {
 892       depth = 0;
 893       while (*p)
 894         {
 895           if (depth <= 0 && (*p == ',' || *p == ')'))
 896             {
 897               argtypes[argcount] =
 898                   parse_and_eval_type (argtypetext, p - argtypetext);
 899               argcount += 1;
 900               argtypetext = p + 1;
 901             }
 902
 903           if (*p == '(')
 904             {
 905               depth += 1;
 906             }
 907           else if (*p == ')')
 908             {
 909               depth -= 1;
 910             }
 911
 912           p += 1;
 913         }
 914     }
 915
 916   if (p[-2] != '.')                     /* Not '...' */
 917     {
 918       argtypes[argcount] = builtin_type_void;   /* List terminator */
 919     }
 920   else
 921     {
 922       argtypes[argcount] = NULL;                /* Ellist terminator */
 923     }
 924
 925   free (demangled_name);
 926
 927   f = TYPE_FN_FIELDLIST1 (type, i);
 928   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
 929
 930   /* Now update the old "stub" type into a real type.  */
 931   mtype = TYPE_FN_FIELD_TYPE (f, j);
 932   TYPE_DOMAIN_TYPE (mtype) = type;
 933   TYPE_ARG_TYPES (mtype) = argtypes;
 934   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
 935   TYPE_FN_FIELD_STUB (f, j) = 0;
 936 }
 937
 938 const struct cplus_struct_type cplus_struct_default;
 939
 940 void
 941 allocate_cplus_struct_type (type)
 942      struct type *type;
 943 {
 944   if (!HAVE_CPLUS_STRUCT (type))
 945     {
 946       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
 947         TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
 948       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
 949     }
 950 }
 951
 952 /* Helper function to initialize the standard scalar types.
 953
 954    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
 955    of the string pointed to by name in the type_obstack for that objfile,
 956    and initialize the type name to that copy.  There are places (mipsread.c
 957    in particular, where init_type is called with a NULL value for NAME). */
 958
 959 struct type *
 960 init_type (code, length, flags, name, objfile)
 961      enum type_code code;
 962      int length;
 963      int flags;
 964      char *name;
 965      struct objfile *objfile;
 966 {
 967   register struct type *type;
 968
 969   type = alloc_type (objfile);
 970   TYPE_CODE (type) = code;
 971   TYPE_LENGTH (type) = length;
 972   TYPE_FLAGS (type) |= flags;
 973   if ((name != NULL) && (objfile != NULL))
 974     {
 975       TYPE_NAME (type) =
 976         obsavestring (name, strlen (name), &objfile -> type_obstack);
 977     }
 978   else
 979     {
 980       TYPE_NAME (type) = name;
 981     }
 982
 983   /* C++ fancies.  */
 984
 985   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 986     {
 987       INIT_CPLUS_SPECIFIC (type);
 988     }
 989   return (type);
 990 }
 991
 992 /* Look up a fundamental type for the specified objfile.
 993    May need to construct such a type if this is the first use.
 994
 995    Some object file formats (ELF, COFF, etc) do not define fundamental
 996    types such as "int" or "double".  Others (stabs for example), do
 997    define fundamental types.
 998
 999    For the formats which don't provide fundamental types, gdb can create
1000    such types, using defaults reasonable for the current language and
1001    the current target machine.
1002
1003    NOTE:  This routine is obsolescent.  Each debugging format reader
1004    should manage it's own fundamental types, either creating them from
1005    suitable defaults or reading them from the debugging information,
1006    whichever is appropriate.  The DWARF reader has already been
1007    fixed to do this.  Once the other readers are fixed, this routine
1008    will go away.  Also note that fundamental types should be managed
1009    on a compilation unit basis in a multi-language environment, not
1010    on a linkage unit basis as is done here. */
1011
1012
1013 struct type *
1014 lookup_fundamental_type (objfile, typeid)
1015      struct objfile *objfile;
1016      int typeid;
1017 {
1018   register struct type **typep;
1019   register int nbytes;
1020
1021   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1022     {
1023       error ("internal error - invalid fundamental type id %d", typeid);
1024     }
1025
1026   /* If this is the first time we need a fundamental type for this objfile
1027      then we need to initialize the vector of type pointers. */
1028
1029   if (objfile -> fundamental_types == NULL)
1030     {
1031       nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1032       objfile -> fundamental_types = (struct type **)
1033         obstack_alloc (&objfile -> type_obstack, nbytes);
1034       memset ((char *) objfile -> fundamental_types, 0, nbytes);
1035     }
1036
1037   /* Look for this particular type in the fundamental type vector.  If one is
1038      not found, create and install one appropriate for the current language. */
1039
1040   typep = objfile -> fundamental_types + typeid;
1041   if (*typep == NULL)
1042     {
1043       *typep = create_fundamental_type (objfile, typeid);
1044     }
1045
1046   return (*typep);
1047 }
1048
1049 #if MAINTENANCE_CMDS
1050
1051 static void
1052 print_bit_vector (bits, nbits)
1053      B_TYPE *bits;
1054      int nbits;
1055 {
1056   int bitno;
1057
1058   for (bitno = 0; bitno < nbits; bitno++)
1059     {
1060       if ((bitno % 8) == 0)
1061         {
1062           puts_filtered (" ");
1063         }
1064       if (B_TST (bits, bitno))
1065         {
1066           printf_filtered ("1");
1067         }
1068       else
1069         {
1070           printf_filtered ("0");
1071         }
1072     }
1073 }
1074
1075 /* The args list is a strange beast.  It is either terminated by a NULL
1076    pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1077    type for normal fixed argcount functions.  (FIXME someday)
1078    Also note the first arg should be the "this" pointer, we may not want to
1079    include it since we may get into a infinitely recursive situation. */
1080
1081 static void
1082 print_arg_types (args, spaces)
1083      struct type **args;
1084      int spaces;
1085 {
1086   if (args != NULL)
1087     {
1088       while (*args != NULL)
1089         {
1090           recursive_dump_type (*args, spaces + 2);
1091           if ((*args++) -> code == TYPE_CODE_VOID)
1092             {
1093               break;
1094             }
1095         }
1096     }
1097 }
1098
1099 static void
1100 dump_fn_fieldlists (type, spaces)
1101      struct type *type;
1102      int spaces;
1103 {
1104   int method_idx;
1105   int overload_idx;
1106   struct fn_field *f;
1107
1108   printfi_filtered (spaces, "fn_fieldlists 0x%x\n",
1109                     TYPE_FN_FIELDLISTS (type));
1110   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
1111     {
1112       f = TYPE_FN_FIELDLIST1 (type, method_idx);
1113       printfi_filtered (spaces + 2, "[%d] name '%s' (0x%x) length %d\n",
1114                         method_idx,
1115                         TYPE_FN_FIELDLIST_NAME (type, method_idx),
1116                         TYPE_FN_FIELDLIST_NAME (type, method_idx),
1117                         TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
1118       for (overload_idx = 0;
1119            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
1120            overload_idx++)
1121         {
1122           printfi_filtered (spaces + 4, "[%d] physname '%s' (0x%x)\n",
1123                             overload_idx,
1124                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
1125                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
1126           printfi_filtered (spaces + 8, "type 0x%x\n",
1127                             TYPE_FN_FIELD_TYPE (f, overload_idx));
1128           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
1129                                spaces + 8 + 2);
1130           printfi_filtered (spaces + 8, "args 0x%x\n",
1131                             TYPE_FN_FIELD_ARGS (f, overload_idx));
1132           print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
1133           printfi_filtered (spaces + 8, "fcontext 0x%x\n",
1134                             TYPE_FN_FIELD_FCONTEXT (f, overload_idx));
1135           printfi_filtered (spaces + 8, "is_const %d\n",
1136                             TYPE_FN_FIELD_CONST (f, overload_idx));
1137           printfi_filtered (spaces + 8, "is_volatile %d\n",
1138                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
1139           printfi_filtered (spaces + 8, "is_private %d\n",
1140                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
1141           printfi_filtered (spaces + 8, "is_protected %d\n",
1142                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
1143           printfi_filtered (spaces + 8, "is_stub %d\n",
1144                             TYPE_FN_FIELD_STUB (f, overload_idx));
1145           printfi_filtered (spaces + 8, "voffset %u\n",
1146                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
1147         }
1148     }
1149 }
1150
1151 static void
1152 print_cplus_stuff (type, spaces)
1153      struct type *type;
1154      int spaces;
1155 {
1156   printfi_filtered (spaces, "n_baseclasses %d\n",
1157                     TYPE_N_BASECLASSES (type));
1158   printfi_filtered (spaces, "nfn_fields %d\n",
1159                     TYPE_NFN_FIELDS (type));
1160   printfi_filtered (spaces, "nfn_fields_total %d\n",
1161                     TYPE_NFN_FIELDS_TOTAL (type));
1162   if (TYPE_N_BASECLASSES (type) > 0)
1163     {
1164       printfi_filtered (spaces, "virtual_field_bits (%d bits at *0x%x)",
1165                         TYPE_N_BASECLASSES (type),
1166                         TYPE_FIELD_VIRTUAL_BITS (type));
1167       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
1168                         TYPE_N_BASECLASSES (type));
1169       puts_filtered ("\n");
1170     }
1171   if (TYPE_NFIELDS (type) > 0)
1172     {
1173       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
1174         {
1175           printfi_filtered (spaces, "private_field_bits (%d bits at *0x%x)",
1176                             TYPE_NFIELDS (type),
1177                             TYPE_FIELD_PRIVATE_BITS (type));
1178           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
1179                             TYPE_NFIELDS (type));
1180           puts_filtered ("\n");
1181         }
1182       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
1183         {
1184           printfi_filtered (spaces, "protected_field_bits (%d bits at *0x%x)",
1185                             TYPE_NFIELDS (type),
1186                             TYPE_FIELD_PROTECTED_BITS (type));
1187           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
1188                             TYPE_NFIELDS (type));
1189           puts_filtered ("\n");
1190         }
1191     }
1192   if (TYPE_NFN_FIELDS (type) > 0)
1193     {
1194       dump_fn_fieldlists (type, spaces);
1195     }
1196 }
1197
1198 void
1199 recursive_dump_type (type, spaces)
1200      struct type *type;
1201      int spaces;
1202 {
1203   int idx;
1204
1205   printfi_filtered (spaces, "type node 0x%lx\n", (unsigned long)type);
1206   printfi_filtered (spaces, "name '%s' (0x%lx)\n",
1207                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>",
1208                     (unsigned long)TYPE_NAME (type));
1209   if (TYPE_TAG_NAME (type) != NULL)
1210     printfi_filtered (spaces, "tagname '%s' (0x%lx)\n",
1211                       TYPE_TAG_NAME (type),
1212                       (unsigned long)TYPE_TAG_NAME (type));
1213   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
1214   switch (TYPE_CODE (type))
1215     {
1216       case TYPE_CODE_UNDEF:
1217         printf_filtered ("(TYPE_CODE_UNDEF)");
1218         break;
1219       case TYPE_CODE_PTR:
1220         printf_filtered ("(TYPE_CODE_PTR)");
1221         break;
1222       case TYPE_CODE_ARRAY:
1223         printf_filtered ("(TYPE_CODE_ARRAY)");
1224         break;
1225       case TYPE_CODE_STRUCT:
1226         printf_filtered ("(TYPE_CODE_STRUCT)");
1227         break;
1228       case TYPE_CODE_UNION:
1229         printf_filtered ("(TYPE_CODE_UNION)");
1230         break;
1231       case TYPE_CODE_ENUM:
1232         printf_filtered ("(TYPE_CODE_ENUM)");
1233         break;
1234       case TYPE_CODE_FUNC:
1235         printf_filtered ("(TYPE_CODE_FUNC)");
1236         break;
1237       case TYPE_CODE_INT:
1238         printf_filtered ("(TYPE_CODE_INT)");
1239         break;
1240       case TYPE_CODE_FLT:
1241         printf_filtered ("(TYPE_CODE_FLT)");
1242         break;
1243       case TYPE_CODE_VOID:
1244         printf_filtered ("(TYPE_CODE_VOID)");
1245         break;
1246       case TYPE_CODE_SET:
1247         printf_filtered ("(TYPE_CODE_SET)");
1248         break;
1249       case TYPE_CODE_RANGE:
1250         printf_filtered ("(TYPE_CODE_RANGE)");
1251         break;
1252       case TYPE_CODE_STRING:
1253         printf_filtered ("(TYPE_CODE_STRING)");
1254         break;
1255       case TYPE_CODE_ERROR:
1256         printf_filtered ("(TYPE_CODE_ERROR)");
1257         break;
1258       case TYPE_CODE_MEMBER:
1259         printf_filtered ("(TYPE_CODE_MEMBER)");
1260         break;
1261       case TYPE_CODE_METHOD:
1262         printf_filtered ("(TYPE_CODE_METHOD)");
1263         break;
1264       case TYPE_CODE_REF:
1265         printf_filtered ("(TYPE_CODE_REF)");
1266         break;
1267       case TYPE_CODE_CHAR:
1268         printf_filtered ("(TYPE_CODE_CHAR)");
1269         break;
1270       case TYPE_CODE_BOOL:
1271         printf_filtered ("(TYPE_CODE_BOOL)");
1272         break;
1273       default:
1274         printf_filtered ("(UNKNOWN TYPE CODE)");
1275         break;
1276     }
1277   puts_filtered ("\n");
1278   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
1279   printfi_filtered (spaces, "objfile 0x%x\n", TYPE_OBJFILE (type));
1280   printfi_filtered (spaces, "target_type 0x%x\n", TYPE_TARGET_TYPE (type));
1281   if (TYPE_TARGET_TYPE (type) != NULL)
1282     {
1283       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
1284     }
1285   printfi_filtered (spaces, "pointer_type 0x%x\n",
1286                     TYPE_POINTER_TYPE (type));
1287   printfi_filtered (spaces, "reference_type 0x%x\n",
1288                     TYPE_REFERENCE_TYPE (type));
1289   printfi_filtered (spaces, "function_type 0x%x\n",
1290                     TYPE_FUNCTION_TYPE (type));
1291   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
1292   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
1293     {
1294       puts_filtered (" TYPE_FLAG_UNSIGNED");
1295     }
1296   if (TYPE_FLAGS (type) & TYPE_FLAG_SIGNED)
1297     {
1298       puts_filtered (" TYPE_FLAG_SIGNED");
1299     }
1300   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1301     {
1302       puts_filtered (" TYPE_FLAG_STUB");
1303     }
1304   puts_filtered ("\n");
1305   printfi_filtered (spaces, "nfields %d 0x%x\n", TYPE_NFIELDS (type),
1306                     TYPE_FIELDS (type));
1307   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
1308     {
1309       printfi_filtered (spaces + 2,
1310                         "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
1311                         idx, TYPE_FIELD_BITPOS (type, idx),
1312                         TYPE_FIELD_BITSIZE (type, idx),
1313                         TYPE_FIELD_TYPE (type, idx),
1314                         TYPE_FIELD_NAME (type, idx),
1315                         TYPE_FIELD_NAME (type, idx) != NULL
1316                           ? TYPE_FIELD_NAME (type, idx)
1317                           : "<NULL>");
1318       if (TYPE_FIELD_TYPE (type, idx) != NULL)
1319         {
1320           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
1321         }
1322     }
1323   printfi_filtered (spaces, "vptr_basetype 0x%x\n",
1324                     TYPE_VPTR_BASETYPE (type));
1325   if (TYPE_VPTR_BASETYPE (type) != NULL)
1326     {
1327       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
1328     }
1329   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
1330   switch (TYPE_CODE (type))
1331     {
1332       case TYPE_CODE_METHOD:
1333       case TYPE_CODE_FUNC:
1334         printfi_filtered (spaces, "arg_types 0x%x\n", TYPE_ARG_TYPES (type));
1335         print_arg_types (TYPE_ARG_TYPES (type), spaces);
1336         break;
1337
1338       case TYPE_CODE_STRUCT:
1339         printfi_filtered (spaces, "cplus_stuff 0x%x\n",
1340                           TYPE_CPLUS_SPECIFIC (type));
1341         print_cplus_stuff (type, spaces);
1342         break;
1343
1344       default:
1345         /* We have to pick one of the union types to be able print and test
1346            the value.  Pick cplus_struct_type, even though we know it isn't
1347            any particular one. */
1348         printfi_filtered (spaces, "type_specific 0x%x",
1349                           TYPE_CPLUS_SPECIFIC (type));
1350         if (TYPE_CPLUS_SPECIFIC (type) != NULL)
1351           {
1352             printf_filtered (" (unknown data form)");
1353           }
1354         printf_filtered ("\n");
1355         break;
1356
1357     }
1358 }
1359
1360 #endif  /* MAINTENANCE_CMDS */
1361
1362 void
1363 _initialize_gdbtypes ()
1364 {
1365   builtin_type_void =
1366     init_type (TYPE_CODE_VOID, 1,
1367                0,
1368                "void", (struct objfile *) NULL);
1369   builtin_type_char =
1370     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1371                0,
1372                "char", (struct objfile *) NULL);
1373   builtin_type_signed_char =
1374     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1375                TYPE_FLAG_SIGNED,
1376                "signed char", (struct objfile *) NULL);
1377   builtin_type_unsigned_char =
1378     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1379                TYPE_FLAG_UNSIGNED,
1380                "unsigned char", (struct objfile *) NULL);
1381   builtin_type_short =
1382     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1383                0,
1384                "short", (struct objfile *) NULL);
1385   builtin_type_unsigned_short =
1386     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1387                TYPE_FLAG_UNSIGNED,
1388                "unsigned short", (struct objfile *) NULL);
1389   builtin_type_int =
1390     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1391                0,
1392                "int", (struct objfile *) NULL);
1393   builtin_type_unsigned_int =
1394     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1395                TYPE_FLAG_UNSIGNED,
1396                "unsigned int", (struct objfile *) NULL);
1397   builtin_type_long =
1398     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1399                0,
1400                "long", (struct objfile *) NULL);
1401   builtin_type_unsigned_long =
1402     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1403                TYPE_FLAG_UNSIGNED,
1404                "unsigned long", (struct objfile *) NULL);
1405   builtin_type_long_long =
1406     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1407                0,
1408                "long long", (struct objfile *) NULL);
1409   builtin_type_unsigned_long_long =
1410     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1411                TYPE_FLAG_UNSIGNED,
1412                "unsigned long long", (struct objfile *) NULL);
1413   builtin_type_float =
1414     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1415                0,
1416                "float", (struct objfile *) NULL);
1417   builtin_type_double =
1418     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1419                0,
1420                "double", (struct objfile *) NULL);
1421   builtin_type_long_double =
1422     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1423                0,
1424                "long double", (struct objfile *) NULL);
1425   builtin_type_complex =
1426     init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1427                0,
1428                "complex", (struct objfile *) NULL);
1429   builtin_type_double_complex =
1430     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1431                0,
1432                "double complex", (struct objfile *) NULL);
1433   builtin_type_string =
1434     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1435                0,
1436                "string", (struct objfile *) NULL);
1437 }