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