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