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