gdb/gdbtypes.c

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