gdb/gdbtypes.c

   1 /* Support routines for manipulating internal types for GDB.
   2    Copyright (C) 1992, 93, 94, 95, 96, 1998 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., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "bfd.h"
  25 #include "symtab.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "gdbtypes.h"
  29 #include "expression.h"
  30 #include "language.h"
  31 #include "target.h"
  32 #include "value.h"
  33 #include "demangle.h"
  34 #include "complaints.h"
  35 #include "gdbcmd.h"
  36 #include "wrapper.h"
  37
  38 /* These variables point to the objects
  39    representing the predefined C data types.  */
  40
  41 struct type *builtin_type_void;
  42 struct type *builtin_type_char;
  43 struct type *builtin_type_true_char;
  44 struct type *builtin_type_short;
  45 struct type *builtin_type_int;
  46 struct type *builtin_type_long;
  47 struct type *builtin_type_long_long;
  48 struct type *builtin_type_signed_char;
  49 struct type *builtin_type_unsigned_char;
  50 struct type *builtin_type_unsigned_short;
  51 struct type *builtin_type_unsigned_int;
  52 struct type *builtin_type_unsigned_long;
  53 struct type *builtin_type_unsigned_long_long;
  54 struct type *builtin_type_float;
  55 struct type *builtin_type_double;
  56 struct type *builtin_type_long_double;
  57 struct type *builtin_type_complex;
  58 struct type *builtin_type_double_complex;
  59 struct type *builtin_type_string;
  60 struct type *builtin_type_int8;
  61 struct type *builtin_type_uint8;
  62 struct type *builtin_type_int16;
  63 struct type *builtin_type_uint16;
  64 struct type *builtin_type_int32;
  65 struct type *builtin_type_uint32;
  66 struct type *builtin_type_int64;
  67 struct type *builtin_type_uint64;
  68 struct type *builtin_type_bool;
  69 struct type *builtin_type_v4sf;
  70 struct type *builtin_type_v4si;
  71 struct type *builtin_type_v8qi;
  72 struct type *builtin_type_v4hi;
  73 struct type *builtin_type_v2si;
  74 struct type *builtin_type_ptr;
  75 struct type *builtin_type_CORE_ADDR;
  76 struct type *builtin_type_bfd_vma;
  77
  78 int opaque_type_resolution = 1;
  79 int overload_debug = 0;
  80
  81 struct extra
  82   {
  83     char str[128];
  84     int len;
  85   };                            /* maximum extention is 128! FIXME */
  86
  87 static void add_name PARAMS ((struct extra *, char *));
  88 static void add_mangled_type PARAMS ((struct extra *, struct type *));
  89 #if 0
  90 static void cfront_mangle_name PARAMS ((struct type *, int, int));
  91 #endif
  92 static void print_bit_vector PARAMS ((B_TYPE *, int));
  93 static void print_arg_types PARAMS ((struct type **, int));
  94 static void dump_fn_fieldlists PARAMS ((struct type *, int));
  95 static void print_cplus_stuff PARAMS ((struct type *, int));
  96 static void virtual_base_list_aux PARAMS ((struct type * dclass));
  97
  98
  99 /* Alloc a new type structure and fill it with some defaults.  If
 100    OBJFILE is non-NULL, then allocate the space for the type structure
 101    in that objfile's type_obstack. */
 102
 103 struct type *
 104 alloc_type (objfile)
 105      struct objfile *objfile;
 106 {
 107   register struct type *type;
 108
 109   /* Alloc the structure and start off with all fields zeroed. */
 110
 111   if (objfile == NULL)
 112     {
 113       type = (struct type *) xmalloc (sizeof (struct type));
 114     }
 115   else
 116     {
 117       type = (struct type *) obstack_alloc (&objfile->type_obstack,
 118                                             sizeof (struct type));
 119       OBJSTAT (objfile, n_types++);
 120     }
 121   memset ((char *) type, 0, sizeof (struct type));
 122
 123   /* Initialize the fields that might not be zero. */
 124
 125   TYPE_CODE (type) = TYPE_CODE_UNDEF;
 126   TYPE_OBJFILE (type) = objfile;
 127   TYPE_VPTR_FIELDNO (type) = -1;
 128   TYPE_CV_TYPE (type) = type;   /* chain back to itself */
 129
 130   return (type);
 131 }
 132
 133 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
 134    to a pointer to memory where the pointer type should be stored.
 135    If *TYPEPTR is zero, update it to point to the pointer type we return.
 136    We allocate new memory if needed.  */
 137
 138 struct type *
 139 make_pointer_type (type, typeptr)
 140      struct type *type;
 141      struct type **typeptr;
 142 {
 143   register struct type *ntype;  /* New type */
 144   struct objfile *objfile;
 145
 146   ntype = TYPE_POINTER_TYPE (type);
 147
 148   if (ntype)
 149     {
 150       if (typeptr == 0)
 151         return ntype;           /* Don't care about alloc, and have new type.  */
 152       else if (*typeptr == 0)
 153         {
 154           *typeptr = ntype;     /* Tracking alloc, and we have new type.  */
 155           return ntype;
 156         }
 157     }
 158
 159   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 160     {
 161       ntype = alloc_type (TYPE_OBJFILE (type));
 162       if (typeptr)
 163         *typeptr = ntype;
 164     }
 165   else
 166     /* We have storage, but need to reset it.  */
 167     {
 168       ntype = *typeptr;
 169       objfile = TYPE_OBJFILE (ntype);
 170       memset ((char *) ntype, 0, sizeof (struct type));
 171       TYPE_OBJFILE (ntype) = objfile;
 172     }
 173
 174   TYPE_TARGET_TYPE (ntype) = type;
 175   TYPE_POINTER_TYPE (type) = ntype;
 176
 177   /* FIXME!  Assume the machine has only one representation for pointers!  */
 178
 179   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 180   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 181
 182   /* pointers are unsigned */
 183   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 184
 185   if (!TYPE_POINTER_TYPE (type))        /* Remember it, if don't have one.  */
 186     TYPE_POINTER_TYPE (type) = ntype;
 187
 188   return ntype;
 189 }
 190
 191 /* Given a type TYPE, return a type of pointers to that type.
 192    May need to construct such a type if this is the first use.  */
 193
 194 struct type *
 195 lookup_pointer_type (type)
 196      struct type *type;
 197 {
 198   return make_pointer_type (type, (struct type **) 0);
 199 }
 200
 201 /* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
 202    to a pointer to memory where the reference type should be stored.
 203    If *TYPEPTR is zero, update it to point to the reference type we return.
 204    We allocate new memory if needed.  */
 205
 206 struct type *
 207 make_reference_type (type, typeptr)
 208      struct type *type;
 209      struct type **typeptr;
 210 {
 211   register struct type *ntype;  /* New type */
 212   struct objfile *objfile;
 213
 214   ntype = TYPE_REFERENCE_TYPE (type);
 215
 216   if (ntype)
 217     {
 218       if (typeptr == 0)
 219         return ntype;           /* Don't care about alloc, and have new type.  */
 220       else if (*typeptr == 0)
 221         {
 222           *typeptr = ntype;     /* Tracking alloc, and we have new type.  */
 223           return ntype;
 224         }
 225     }
 226
 227   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 228     {
 229       ntype = alloc_type (TYPE_OBJFILE (type));
 230       if (typeptr)
 231         *typeptr = ntype;
 232     }
 233   else
 234     /* We have storage, but need to reset it.  */
 235     {
 236       ntype = *typeptr;
 237       objfile = TYPE_OBJFILE (ntype);
 238       memset ((char *) ntype, 0, sizeof (struct type));
 239       TYPE_OBJFILE (ntype) = objfile;
 240     }
 241
 242   TYPE_TARGET_TYPE (ntype) = type;
 243   TYPE_REFERENCE_TYPE (type) = ntype;
 244
 245   /* FIXME!  Assume the machine has only one representation for references,
 246      and that it matches the (only) representation for pointers!  */
 247
 248   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 249   TYPE_CODE (ntype) = TYPE_CODE_REF;
 250
 251   if (!TYPE_REFERENCE_TYPE (type))      /* Remember it, if don't have one.  */
 252     TYPE_REFERENCE_TYPE (type) = ntype;
 253
 254   return ntype;
 255 }
 256
 257 /* Same as above, but caller doesn't care about memory allocation details.  */
 258
 259 struct type *
 260 lookup_reference_type (type)
 261      struct type *type;
 262 {
 263   return make_reference_type (type, (struct type **) 0);
 264 }
 265
 266 /* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
 267    to a pointer to memory where the function type should be stored.
 268    If *TYPEPTR is zero, update it to point to the function type we return.
 269    We allocate new memory if needed.  */
 270
 271 struct type *
 272 make_function_type (type, typeptr)
 273      struct type *type;
 274      struct type **typeptr;
 275 {
 276   register struct type *ntype;  /* New type */
 277   struct objfile *objfile;
 278
 279   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 280     {
 281       ntype = alloc_type (TYPE_OBJFILE (type));
 282       if (typeptr)
 283         *typeptr = ntype;
 284     }
 285   else
 286     /* We have storage, but need to reset it.  */
 287     {
 288       ntype = *typeptr;
 289       objfile = TYPE_OBJFILE (ntype);
 290       memset ((char *) ntype, 0, sizeof (struct type));
 291       TYPE_OBJFILE (ntype) = objfile;
 292     }
 293
 294   TYPE_TARGET_TYPE (ntype) = type;
 295
 296   TYPE_LENGTH (ntype) = 1;
 297   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
 298
 299   return ntype;
 300 }
 301
 302
 303 /* Given a type TYPE, return a type of functions that return that type.
 304    May need to construct such a type if this is the first use.  */
 305
 306 struct type *
 307 lookup_function_type (type)
 308      struct type *type;
 309 {
 310   return make_function_type (type, (struct type **) 0);
 311 }
 312
 313
 314 /* Make a "c-v" variant of a type -- a type that is identical to the
 315    one supplied except that it may have const or volatile attributes
 316    CNST is a flag for setting the const attribute
 317    VOLTL is a flag for setting the volatile attribute
 318    TYPE is the base type whose variant we are creating.
 319    TYPEPTR, if nonzero, points
 320    to a pointer to memory where the reference type should be stored.
 321    If *TYPEPTR is zero, update it to point to the reference type we return.
 322    We allocate new memory if needed.  */
 323
 324 struct type *
 325 make_cv_type (cnst, voltl, type, typeptr)
 326      int cnst;
 327      int voltl;
 328      struct type *type;
 329      struct type **typeptr;
 330 {
 331   register struct type *ntype;  /* New type */
 332   register struct type *tmp_type = type;        /* tmp type */
 333   struct objfile *objfile;
 334
 335   ntype = TYPE_CV_TYPE (type);
 336
 337   while (ntype != type)
 338     {
 339       if ((TYPE_CONST (ntype) == cnst) &&
 340           (TYPE_VOLATILE (ntype) == voltl))
 341         {
 342           if (typeptr == 0)
 343             return ntype;
 344           else if (*typeptr == 0)
 345             {
 346               *typeptr = ntype; /* Tracking alloc, and we have new type.  */
 347               return ntype;
 348             }
 349         }
 350       tmp_type = ntype;
 351       ntype = TYPE_CV_TYPE (ntype);
 352     }
 353
 354   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 355     {
 356       ntype = alloc_type (TYPE_OBJFILE (type));
 357       if (typeptr)
 358         *typeptr = ntype;
 359     }
 360   else
 361     /* We have storage, but need to reset it.  */
 362     {
 363       ntype = *typeptr;
 364       objfile = TYPE_OBJFILE (ntype);
 365       /* memset ((char *) ntype, 0, sizeof (struct type)); */
 366       TYPE_OBJFILE (ntype) = objfile;
 367     }
 368
 369   /* Copy original type */
 370   memcpy ((char *) ntype, (char *) type, sizeof (struct type));
 371   /* But zero out fields that shouldn't be copied */
 372   TYPE_POINTER_TYPE (ntype) = (struct type *) 0;        /* Need new pointer kind */
 373   TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;      /* Need new referene kind */
 374   /* Note: TYPE_TARGET_TYPE can be left as is */
 375
 376   /* Set flags appropriately */
 377   if (cnst)
 378     TYPE_FLAGS (ntype) |= TYPE_FLAG_CONST;
 379   else
 380     TYPE_FLAGS (ntype) &= ~TYPE_FLAG_CONST;
 381
 382   if (voltl)
 383     TYPE_FLAGS (ntype) |= TYPE_FLAG_VOLATILE;
 384   else
 385     TYPE_FLAGS (ntype) &= ~TYPE_FLAG_VOLATILE;
 386
 387   /* Fix the chain of cv variants */
 388   TYPE_CV_TYPE (ntype) = type;
 389   TYPE_CV_TYPE (tmp_type) = ntype;
 390
 391   return ntype;
 392 }
 393
 394
 395
 396
 397 /* Implement direct support for MEMBER_TYPE in GNU C++.
 398    May need to construct such a type if this is the first use.
 399    The TYPE is the type of the member.  The DOMAIN is the type
 400    of the aggregate that the member belongs to.  */
 401
 402 struct type *
 403 lookup_member_type (type, domain)
 404      struct type *type;
 405      struct type *domain;
 406 {
 407   register struct type *mtype;
 408
 409   mtype = alloc_type (TYPE_OBJFILE (type));
 410   smash_to_member_type (mtype, domain, type);
 411   return (mtype);
 412 }
 413
 414 /* Allocate a stub method whose return type is TYPE.
 415    This apparently happens for speed of symbol reading, since parsing
 416    out the arguments to the method is cpu-intensive, the way we are doing
 417    it.  So, we will fill in arguments later.
 418    This always returns a fresh type.   */
 419
 420 struct type *
 421 allocate_stub_method (type)
 422      struct type *type;
 423 {
 424   struct type *mtype;
 425
 426   mtype = alloc_type (TYPE_OBJFILE (type));
 427   TYPE_TARGET_TYPE (mtype) = type;
 428   /*  _DOMAIN_TYPE (mtype) = unknown yet */
 429   /*  _ARG_TYPES (mtype) = unknown yet */
 430   TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
 431   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
 432   TYPE_LENGTH (mtype) = 1;
 433   return (mtype);
 434 }
 435
 436 /* Create a range type using either a blank type supplied in RESULT_TYPE,
 437    or creating a new type, inheriting the objfile from INDEX_TYPE.
 438
 439    Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
 440    HIGH_BOUND, inclusive.
 441
 442    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 443    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
 444
 445 struct type *
 446 create_range_type (result_type, index_type, low_bound, high_bound)
 447      struct type *result_type;
 448      struct type *index_type;
 449      int low_bound;
 450      int high_bound;
 451 {
 452   if (result_type == NULL)
 453     {
 454       result_type = alloc_type (TYPE_OBJFILE (index_type));
 455     }
 456   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
 457   TYPE_TARGET_TYPE (result_type) = index_type;
 458   if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB)
 459     TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
 460   else
 461     TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
 462   TYPE_NFIELDS (result_type) = 2;
 463   TYPE_FIELDS (result_type) = (struct field *)
 464     TYPE_ALLOC (result_type, 2 * sizeof (struct field));
 465   memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
 466   TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
 467   TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
 468   TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;  /* FIXME */
 469   TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int;  /* FIXME */
 470
 471   if (low_bound >= 0)
 472     TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
 473
 474   return (result_type);
 475 }
 476
 477 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
 478    Return 1 of type is a range type, 0 if it is discrete (and bounds
 479    will fit in LONGEST), or -1 otherwise. */
 480
 481 int
 482 get_discrete_bounds (type, lowp, highp)
 483      struct type *type;
 484      LONGEST *lowp, *highp;
 485 {
 486   CHECK_TYPEDEF (type);
 487   switch (TYPE_CODE (type))
 488     {
 489     case TYPE_CODE_RANGE:
 490       *lowp = TYPE_LOW_BOUND (type);
 491       *highp = TYPE_HIGH_BOUND (type);
 492       return 1;
 493     case TYPE_CODE_ENUM:
 494       if (TYPE_NFIELDS (type) > 0)
 495         {
 496           /* The enums may not be sorted by value, so search all
 497              entries */
 498           int i;
 499
 500           *lowp = *highp = TYPE_FIELD_BITPOS (type, 0);
 501           for (i = 0; i < TYPE_NFIELDS (type); i++)
 502             {
 503               if (TYPE_FIELD_BITPOS (type, i) < *lowp)
 504                 *lowp = TYPE_FIELD_BITPOS (type, i);
 505               if (TYPE_FIELD_BITPOS (type, i) > *highp)
 506                 *highp = TYPE_FIELD_BITPOS (type, i);
 507             }
 508
 509           /* Set unsigned indicator if warranted. */
 510           if (*lowp >= 0)
 511             {
 512               TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
 513             }
 514         }
 515       else
 516         {
 517           *lowp = 0;
 518           *highp = -1;
 519         }
 520       return 0;
 521     case TYPE_CODE_BOOL:
 522       *lowp = 0;
 523       *highp = 1;
 524       return 0;
 525     case TYPE_CODE_INT:
 526       if (TYPE_LENGTH (type) > sizeof (LONGEST))        /* Too big */
 527         return -1;
 528       if (!TYPE_UNSIGNED (type))
 529         {
 530           *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
 531           *highp = -*lowp - 1;
 532           return 0;
 533         }
 534       /* ... fall through for unsigned ints ... */
 535     case TYPE_CODE_CHAR:
 536       *lowp = 0;
 537       /* This round-about calculation is to avoid shifting by
 538          TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
 539          if TYPE_LENGTH (type) == sizeof (LONGEST). */
 540       *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
 541       *highp = (*highp - 1) | *highp;
 542       return 0;
 543     default:
 544       return -1;
 545     }
 546 }
 547
 548 /* Create an array type using either a blank type supplied in RESULT_TYPE,
 549    or creating a new type, inheriting the objfile from RANGE_TYPE.
 550
 551    Elements will be of type ELEMENT_TYPE, the indices will be of type
 552    RANGE_TYPE.
 553
 554    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 555    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
 556
 557 struct type *
 558 create_array_type (result_type, element_type, range_type)
 559      struct type *result_type;
 560      struct type *element_type;
 561      struct type *range_type;
 562 {
 563   LONGEST low_bound, high_bound;
 564
 565   if (result_type == NULL)
 566     {
 567       result_type = alloc_type (TYPE_OBJFILE (range_type));
 568     }
 569   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
 570   TYPE_TARGET_TYPE (result_type) = element_type;
 571   if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 572     low_bound = high_bound = 0;
 573   CHECK_TYPEDEF (element_type);
 574   TYPE_LENGTH (result_type) =
 575     TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
 576   TYPE_NFIELDS (result_type) = 1;
 577   TYPE_FIELDS (result_type) =
 578     (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
 579   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
 580   TYPE_FIELD_TYPE (result_type, 0) = range_type;
 581   TYPE_VPTR_FIELDNO (result_type) = -1;
 582
 583   /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
 584   if (TYPE_LENGTH (result_type) == 0)
 585     TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
 586
 587   return (result_type);
 588 }
 589
 590 /* Create a string type using either a blank type supplied in RESULT_TYPE,
 591    or creating a new type.  String types are similar enough to array of
 592    char types that we can use create_array_type to build the basic type
 593    and then bash it into a string type.
 594
 595    For fixed length strings, the range type contains 0 as the lower
 596    bound and the length of the string minus one as the upper bound.
 597
 598    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 599    sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
 600
 601 struct type *
 602 create_string_type (result_type, range_type)
 603      struct type *result_type;
 604      struct type *range_type;
 605 {
 606   result_type = create_array_type (result_type,
 607                                    *current_language->string_char_type,
 608                                    range_type);
 609   TYPE_CODE (result_type) = TYPE_CODE_STRING;
 610   return (result_type);
 611 }
 612
 613 struct type *
 614 create_set_type (result_type, domain_type)
 615      struct type *result_type;
 616      struct type *domain_type;
 617 {
 618   LONGEST low_bound, high_bound, bit_length;
 619   if (result_type == NULL)
 620     {
 621       result_type = alloc_type (TYPE_OBJFILE (domain_type));
 622     }
 623   TYPE_CODE (result_type) = TYPE_CODE_SET;
 624   TYPE_NFIELDS (result_type) = 1;
 625   TYPE_FIELDS (result_type) = (struct field *)
 626     TYPE_ALLOC (result_type, 1 * sizeof (struct field));
 627   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
 628
 629   if (!(TYPE_FLAGS (domain_type) & TYPE_FLAG_STUB))
 630     {
 631       if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
 632         low_bound = high_bound = 0;
 633       bit_length = high_bound - low_bound + 1;
 634       TYPE_LENGTH (result_type)
 635         = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
 636     }
 637   TYPE_FIELD_TYPE (result_type, 0) = domain_type;
 638
 639   if (low_bound >= 0)
 640     TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
 641
 642   return (result_type);
 643 }
 644
 645
 646 /* Construct and return a type of the form:
 647         struct NAME { ELT_TYPE ELT_NAME[N]; }
 648    We use these types for SIMD registers.  For example, the type of
 649    the SSE registers on the late x86-family processors is:
 650         struct __builtin_v4sf { float f[4]; }
 651    built by the function call:
 652         init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
 653    The type returned is a permanent type, allocated using malloc; it
 654    doesn't live in any objfile's obstack.  */
 655 static struct type *
 656 init_simd_type (char *name,
 657                 struct type *elt_type,
 658                 char *elt_name,
 659                 int n)
 660 {
 661   struct type *t;
 662   struct field *f;
 663
 664   /* Build the field structure.  */
 665   f = xmalloc (sizeof (*f));
 666   memset (f, 0, sizeof (*f));
 667   f->loc.bitpos = 0;
 668   f->type = create_array_type (0, elt_type,
 669                                create_range_type (0, builtin_type_int,
 670                                                   0, n-1));
 671   f->name = elt_name;
 672
 673   /* Build a struct type with that field.  */
 674   t = init_type (TYPE_CODE_STRUCT, n * TYPE_LENGTH (elt_type), 0, 0, 0);
 675   t->nfields = 1;
 676   t->fields = f;
 677   t->tag_name = name;
 678
 679   return t;
 680 }
 681
 682
 683 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
 684    A MEMBER is a wierd thing -- it amounts to a typed offset into
 685    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
 686    include the offset (that's the value of the MEMBER itself), but does
 687    include the structure type into which it points (for some reason).
 688
 689    When "smashing" the type, we preserve the objfile that the
 690    old type pointed to, since we aren't changing where the type is actually
 691    allocated.  */
 692
 693 void
 694 smash_to_member_type (type, domain, to_type)
 695      struct type *type;
 696      struct type *domain;
 697      struct type *to_type;
 698 {
 699   struct objfile *objfile;
 700
 701   objfile = TYPE_OBJFILE (type);
 702
 703   memset ((char *) type, 0, sizeof (struct type));
 704   TYPE_OBJFILE (type) = objfile;
 705   TYPE_TARGET_TYPE (type) = to_type;
 706   TYPE_DOMAIN_TYPE (type) = domain;
 707   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 708   TYPE_CODE (type) = TYPE_CODE_MEMBER;
 709 }
 710
 711 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
 712    METHOD just means `function that gets an extra "this" argument'.
 713
 714    When "smashing" the type, we preserve the objfile that the
 715    old type pointed to, since we aren't changing where the type is actually
 716    allocated.  */
 717
 718 void
 719 smash_to_method_type (type, domain, to_type, args)
 720      struct type *type;
 721      struct type *domain;
 722      struct type *to_type;
 723      struct type **args;
 724 {
 725   struct objfile *objfile;
 726
 727   objfile = TYPE_OBJFILE (type);
 728
 729   memset ((char *) type, 0, sizeof (struct type));
 730   TYPE_OBJFILE (type) = objfile;
 731   TYPE_TARGET_TYPE (type) = to_type;
 732   TYPE_DOMAIN_TYPE (type) = domain;
 733   TYPE_ARG_TYPES (type) = args;
 734   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 735   TYPE_CODE (type) = TYPE_CODE_METHOD;
 736 }
 737
 738 /* Return a typename for a struct/union/enum type without "struct ",
 739    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
 740
 741 char *
 742 type_name_no_tag (type)
 743      register const struct type *type;
 744 {
 745   if (TYPE_TAG_NAME (type) != NULL)
 746     return TYPE_TAG_NAME (type);
 747
 748   /* Is there code which expects this to return the name if there is no
 749      tag name?  My guess is that this is mainly used for C++ in cases where
 750      the two will always be the same.  */
 751   return TYPE_NAME (type);
 752 }
 753
 754 /* Lookup a primitive type named NAME.
 755    Return zero if NAME is not a primitive type. */
 756
 757 struct type *
 758 lookup_primitive_typename (name)
 759      char *name;
 760 {
 761   struct type **const *p;
 762
 763   for (p = current_language->la_builtin_type_vector; *p != NULL; p++)
 764     {
 765       if (STREQ ((**p)->name, name))
 766         {
 767           return (**p);
 768         }
 769     }
 770   return (NULL);
 771 }
 772
 773 /* Lookup a typedef or primitive type named NAME,
 774    visible in lexical block BLOCK.
 775    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 776
 777 struct type *
 778 lookup_typename (name, block, noerr)
 779      char *name;
 780      struct block *block;
 781      int noerr;
 782 {
 783   register struct symbol *sym;
 784   register struct type *tmp;
 785
 786   sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
 787   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 788     {
 789       tmp = lookup_primitive_typename (name);
 790       if (tmp)
 791         {
 792           return (tmp);
 793         }
 794       else if (!tmp && noerr)
 795         {
 796           return (NULL);
 797         }
 798       else
 799         {
 800           error ("No type named %s.", name);
 801         }
 802     }
 803   return (SYMBOL_TYPE (sym));
 804 }
 805
 806 struct type *
 807 lookup_unsigned_typename (name)
 808      char *name;
 809 {
 810   char *uns = alloca (strlen (name) + 10);
 811
 812   strcpy (uns, "unsigned ");
 813   strcpy (uns + 9, name);
 814   return (lookup_typename (uns, (struct block *) NULL, 0));
 815 }
 816
 817 struct type *
 818 lookup_signed_typename (name)
 819      char *name;
 820 {
 821   struct type *t;
 822   char *uns = alloca (strlen (name) + 8);
 823
 824   strcpy (uns, "signed ");
 825   strcpy (uns + 7, name);
 826   t = lookup_typename (uns, (struct block *) NULL, 1);
 827   /* If we don't find "signed FOO" just try again with plain "FOO". */
 828   if (t != NULL)
 829     return t;
 830   return lookup_typename (name, (struct block *) NULL, 0);
 831 }
 832
 833 /* Lookup a structure type named "struct NAME",
 834    visible in lexical block BLOCK.  */
 835
 836 struct type *
 837 lookup_struct (name, block)
 838      char *name;
 839      struct block *block;
 840 {
 841   register struct symbol *sym;
 842
 843   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 844                        (struct symtab **) NULL);
 845
 846   if (sym == NULL)
 847     {
 848       error ("No struct type named %s.", name);
 849     }
 850   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 851     {
 852       error ("This context has class, union or enum %s, not a struct.", name);
 853     }
 854   return (SYMBOL_TYPE (sym));
 855 }
 856
 857 /* Lookup a union type named "union NAME",
 858    visible in lexical block BLOCK.  */
 859
 860 struct type *
 861 lookup_union (name, block)
 862      char *name;
 863      struct block *block;
 864 {
 865   register struct symbol *sym;
 866   struct type *t;
 867
 868   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 869                        (struct symtab **) NULL);
 870
 871   if (sym == NULL)
 872     error ("No union type named %s.", name);
 873
 874   t = SYMBOL_TYPE (sym);
 875
 876   if (TYPE_CODE (t) == TYPE_CODE_UNION)
 877     return (t);
 878
 879   /* C++ unions may come out with TYPE_CODE_CLASS, but we look at
 880    * a further "declared_type" field to discover it is really a union.
 881    */
 882   if (HAVE_CPLUS_STRUCT (t))
 883     if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
 884       return (t);
 885
 886   /* If we get here, it's not a union */
 887   error ("This context has class, struct or enum %s, not a union.", name);
 888 }
 889
 890
 891 /* Lookup an enum type named "enum NAME",
 892    visible in lexical block BLOCK.  */
 893
 894 struct type *
 895 lookup_enum (name, block)
 896      char *name;
 897      struct block *block;
 898 {
 899   register struct symbol *sym;
 900
 901   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 902                        (struct symtab **) NULL);
 903   if (sym == NULL)
 904     {
 905       error ("No enum type named %s.", name);
 906     }
 907   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
 908     {
 909       error ("This context has class, struct or union %s, not an enum.", name);
 910     }
 911   return (SYMBOL_TYPE (sym));
 912 }
 913
 914 /* Lookup a template type named "template NAME<TYPE>",
 915    visible in lexical block BLOCK.  */
 916
 917 struct type *
 918 lookup_template_type (name, type, block)
 919      char *name;
 920      struct type *type;
 921      struct block *block;
 922 {
 923   struct symbol *sym;
 924   char *nam = (char *) alloca (strlen (name) + strlen (type->name) + 4);
 925   strcpy (nam, name);
 926   strcat (nam, "<");
 927   strcat (nam, type->name);
 928   strcat (nam, " >");           /* FIXME, extra space still introduced in gcc? */
 929
 930   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
 931
 932   if (sym == NULL)
 933     {
 934       error ("No template type named %s.", name);
 935     }
 936   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 937     {
 938       error ("This context has class, union or enum %s, not a struct.", name);
 939     }
 940   return (SYMBOL_TYPE (sym));
 941 }
 942
 943 /* Given a type TYPE, lookup the type of the component of type named NAME.
 944
 945    TYPE can be either a struct or union, or a pointer or reference to a struct or
 946    union.  If it is a pointer or reference, its target type is automatically used.
 947    Thus '.' and '->' are interchangable, as specified for the definitions of the
 948    expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
 949
 950    If NOERR is nonzero, return zero if NAME is not suitably defined.
 951    If NAME is the name of a baseclass type, return that type.  */
 952
 953 struct type *
 954 lookup_struct_elt_type (type, name, noerr)
 955      struct type *type;
 956      char *name;
 957      int noerr;
 958 {
 959   int i;
 960
 961   for (;;)
 962     {
 963       CHECK_TYPEDEF (type);
 964       if (TYPE_CODE (type) != TYPE_CODE_PTR
 965           && TYPE_CODE (type) != TYPE_CODE_REF)
 966         break;
 967       type = TYPE_TARGET_TYPE (type);
 968     }
 969
 970   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
 971       TYPE_CODE (type) != TYPE_CODE_UNION)
 972     {
 973       target_terminal_ours ();
 974       gdb_flush (gdb_stdout);
 975       fprintf_unfiltered (gdb_stderr, "Type ");
 976       type_print (type, "", gdb_stderr, -1);
 977       error (" is not a structure or union type.");
 978     }
 979
 980 #if 0
 981   /* FIXME:  This change put in by Michael seems incorrect for the case where
 982      the structure tag name is the same as the member name.  I.E. when doing
 983      "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
 984      Disabled by fnf. */
 985   {
 986     char *typename;
 987
 988     typename = type_name_no_tag (type);
 989     if (typename != NULL && STREQ (typename, name))
 990       return type;
 991   }
 992 #endif
 993
 994   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 995     {
 996       char *t_field_name = TYPE_FIELD_NAME (type, i);
 997
 998       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
 999         {
1000           return TYPE_FIELD_TYPE (type, i);
1001         }
1002     }
1003
1004   /* OK, it's not in this class.  Recursively check the baseclasses.  */
1005   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1006     {
1007       struct type *t;
1008
1009       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
1010       if (t != NULL)
1011         {
1012           return t;
1013         }
1014     }
1015
1016   if (noerr)
1017     {
1018       return NULL;
1019     }
1020
1021   target_terminal_ours ();
1022   gdb_flush (gdb_stdout);
1023   fprintf_unfiltered (gdb_stderr, "Type ");
1024   type_print (type, "", gdb_stderr, -1);
1025   fprintf_unfiltered (gdb_stderr, " has no component named ");
1026   fputs_filtered (name, gdb_stderr);
1027   error (".");
1028   return (struct type *) -1;    /* For lint */
1029 }
1030
1031 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
1032    valid.  Callers should be aware that in some cases (for example,
1033    the type or one of its baseclasses is a stub type and we are
1034    debugging a .o file), this function will not be able to find the virtual
1035    function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
1036    will remain NULL.  */
1037
1038 void
1039 fill_in_vptr_fieldno (type)
1040      struct type *type;
1041 {
1042   CHECK_TYPEDEF (type);
1043
1044   if (TYPE_VPTR_FIELDNO (type) < 0)
1045     {
1046       int i;
1047
1048       /* We must start at zero in case the first (and only) baseclass is
1049          virtual (and hence we cannot share the table pointer).  */
1050       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1051         {
1052           fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
1053           if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
1054             {
1055               TYPE_VPTR_FIELDNO (type)
1056                 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
1057               TYPE_VPTR_BASETYPE (type)
1058                 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
1059               break;
1060             }
1061         }
1062     }
1063 }
1064
1065 /* Find the method and field indices for the destructor in class type T.
1066    Return 1 if the destructor was found, otherwise, return 0.  */
1067
1068 int
1069 get_destructor_fn_field (t, method_indexp, field_indexp)
1070      struct type *t;
1071      int *method_indexp;
1072      int *field_indexp;
1073 {
1074   int i;
1075
1076   for (i = 0; i < TYPE_NFN_FIELDS (t); i++)
1077     {
1078       int j;
1079       struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1080
1081       for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++)
1082         {
1083           if (DESTRUCTOR_PREFIX_P (TYPE_FN_FIELD_PHYSNAME (f, j)))
1084             {
1085               *method_indexp = i;
1086               *field_indexp = j;
1087               return 1;
1088             }
1089         }
1090     }
1091   return 0;
1092 }
1093
1094 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
1095
1096    If this is a stubbed struct (i.e. declared as struct foo *), see if
1097    we can find a full definition in some other file. If so, copy this
1098    definition, so we can use it in future.  There used to be a comment (but
1099    not any code) that if we don't find a full definition, we'd set a flag
1100    so we don't spend time in the future checking the same type.  That would
1101    be a mistake, though--we might load in more symbols which contain a
1102    full definition for the type.
1103
1104    This used to be coded as a macro, but I don't think it is called
1105    often enough to merit such treatment.  */
1106
1107 struct complaint stub_noname_complaint =
1108 {"stub type has NULL name", 0, 0};
1109
1110 struct type *
1111 check_typedef (type)
1112      register struct type *type;
1113 {
1114   struct type *orig_type = type;
1115   while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1116     {
1117       if (!TYPE_TARGET_TYPE (type))
1118         {
1119           char *name;
1120           struct symbol *sym;
1121
1122           /* It is dangerous to call lookup_symbol if we are currently
1123              reading a symtab.  Infinite recursion is one danger. */
1124           if (currently_reading_symtab)
1125             return type;
1126
1127           name = type_name_no_tag (type);
1128           /* FIXME: shouldn't we separately check the TYPE_NAME and the
1129              TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1130              as appropriate?  (this code was written before TYPE_NAME and
1131              TYPE_TAG_NAME were separate).  */
1132           if (name == NULL)
1133             {
1134               complain (&stub_noname_complaint);
1135               return type;
1136             }
1137           sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
1138                                (struct symtab **) NULL);
1139           if (sym)
1140             TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1141           else
1142             TYPE_TARGET_TYPE (type) = alloc_type (NULL);        /* TYPE_CODE_UNDEF */
1143         }
1144       type = TYPE_TARGET_TYPE (type);
1145     }
1146
1147   /* If this is a struct/class/union with no fields, then check whether a
1148      full definition exists somewhere else.  This is for systems where a
1149      type definition with no fields is issued for such types, instead of
1150      identifying them as stub types in the first place */
1151
1152   if (TYPE_IS_OPAQUE (type) && opaque_type_resolution && !currently_reading_symtab)
1153     {
1154       char *name = type_name_no_tag (type);
1155       struct type *newtype;
1156       if (name == NULL)
1157         {
1158           complain (&stub_noname_complaint);
1159           return type;
1160         }
1161       newtype = lookup_transparent_type (name);
1162       if (newtype)
1163         {
1164           memcpy ((char *) type, (char *) newtype, sizeof (struct type));
1165         }
1166     }
1167   /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
1168   else if ((TYPE_FLAGS (type) & TYPE_FLAG_STUB) && !currently_reading_symtab)
1169     {
1170       char *name = type_name_no_tag (type);
1171       /* FIXME: shouldn't we separately check the TYPE_NAME and the
1172          TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
1173          as appropriate?  (this code was written before TYPE_NAME and
1174          TYPE_TAG_NAME were separate).  */
1175       struct symbol *sym;
1176       if (name == NULL)
1177         {
1178           complain (&stub_noname_complaint);
1179           return type;
1180         }
1181       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL);
1182       if (sym)
1183         {
1184           memcpy ((char *) type, (char *) SYMBOL_TYPE (sym), sizeof (struct type));
1185         }
1186     }
1187
1188   if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
1189     {
1190       struct type *range_type;
1191       struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1192
1193       if (TYPE_FLAGS (target_type) & (TYPE_FLAG_STUB | TYPE_FLAG_TARGET_STUB))
1194         {
1195         }
1196       else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1197                && TYPE_NFIELDS (type) == 1
1198                && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
1199                    == TYPE_CODE_RANGE))
1200         {
1201           /* Now recompute the length of the array type, based on its
1202              number of elements and the target type's length.  */
1203           TYPE_LENGTH (type) =
1204             ((TYPE_FIELD_BITPOS (range_type, 1)
1205               - TYPE_FIELD_BITPOS (range_type, 0)
1206               + 1)
1207              * TYPE_LENGTH (target_type));
1208           TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1209         }
1210       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1211         {
1212           TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1213           TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
1214         }
1215     }
1216   /* Cache TYPE_LENGTH for future use. */
1217   TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1218   return type;
1219 }
1220
1221 /* New code added to support parsing of Cfront stabs strings */
1222 #include <ctype.h>
1223 #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
1224 #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
1225
1226 static void
1227 add_name (pextras, n)
1228      struct extra *pextras;
1229      char *n;
1230 {
1231   int nlen;
1232
1233   if ((nlen = (n ? strlen (n) : 0)) == 0)
1234     return;
1235   sprintf (pextras->str + pextras->len, "%d%s", nlen, n);
1236   pextras->len = strlen (pextras->str);
1237 }
1238
1239 static void
1240 add_mangled_type (pextras, t)
1241      struct extra *pextras;
1242      struct type *t;
1243 {
1244   enum type_code tcode;
1245   int tlen, tflags;
1246   char *tname;
1247
1248   tcode = TYPE_CODE (t);
1249   tlen = TYPE_LENGTH (t);
1250   tflags = TYPE_FLAGS (t);
1251   tname = TYPE_NAME (t);
1252   /* args of "..." seem to get mangled as "e" */
1253
1254   switch (tcode)
1255     {
1256     case TYPE_CODE_INT:
1257       if (tflags == 1)
1258         ADD_EXTRA ('U');
1259       switch (tlen)
1260         {
1261         case 1:
1262           ADD_EXTRA ('c');
1263           break;
1264         case 2:
1265           ADD_EXTRA ('s');
1266           break;
1267         case 4:
1268           {
1269             char *pname;
1270             if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long"))
1271               {
1272                 ADD_EXTRA ('l');
1273               }
1274             else
1275               {
1276                 ADD_EXTRA ('i');
1277               }
1278           }
1279           break;
1280         default:
1281           {
1282
1283             static struct complaint msg =
1284             {"Bad int type code length x%x\n", 0, 0};
1285
1286             complain (&msg, tlen);
1287
1288           }
1289         }
1290       break;
1291     case TYPE_CODE_FLT:
1292       switch (tlen)
1293         {
1294         case 4:
1295           ADD_EXTRA ('f');
1296           break;
1297         case 8:
1298           ADD_EXTRA ('d');
1299           break;
1300         case 16:
1301           ADD_EXTRA ('r');
1302           break;
1303         default:
1304           {
1305             static struct complaint msg =
1306             {"Bad float type code length x%x\n", 0, 0};
1307             complain (&msg, tlen);
1308           }
1309         }
1310       break;
1311     case TYPE_CODE_REF:
1312       ADD_EXTRA ('R');
1313       /* followed by what it's a ref to */
1314       break;
1315     case TYPE_CODE_PTR:
1316       ADD_EXTRA ('P');
1317       /* followed by what it's a ptr to */
1318       break;
1319     case TYPE_CODE_TYPEDEF:
1320       {
1321         static struct complaint msg =
1322         {"Typedefs in overloaded functions not yet supported\n", 0, 0};
1323         complain (&msg);
1324       }
1325       /* followed by type bytes & name */
1326       break;
1327     case TYPE_CODE_FUNC:
1328       ADD_EXTRA ('F');
1329       /* followed by func's arg '_' & ret types */
1330       break;
1331     case TYPE_CODE_VOID:
1332       ADD_EXTRA ('v');
1333       break;
1334     case TYPE_CODE_METHOD:
1335       ADD_EXTRA ('M');
1336       /* followed by name of class and func's arg '_' & ret types */
1337       add_name (pextras, tname);
1338       ADD_EXTRA ('F');          /* then mangle function */
1339       break;
1340     case TYPE_CODE_STRUCT:      /* C struct */
1341     case TYPE_CODE_UNION:       /* C union */
1342     case TYPE_CODE_ENUM:        /* Enumeration type */
1343       /* followed by name of type */
1344       add_name (pextras, tname);
1345       break;
1346
1347       /* errors possible types/not supported */
1348     case TYPE_CODE_CHAR:
1349     case TYPE_CODE_ARRAY:       /* Array type */
1350     case TYPE_CODE_MEMBER:      /* Member type */
1351     case TYPE_CODE_BOOL:
1352     case TYPE_CODE_COMPLEX:     /* Complex float */
1353     case TYPE_CODE_UNDEF:
1354     case TYPE_CODE_SET: /* Pascal sets */
1355     case TYPE_CODE_RANGE:
1356     case TYPE_CODE_STRING:
1357     case TYPE_CODE_BITSTRING:
1358     case TYPE_CODE_ERROR:
1359     default:
1360       {
1361         static struct complaint msg =
1362         {"Unknown type code x%x\n", 0, 0};
1363         complain (&msg, tcode);
1364       }
1365     }
1366   if (t->target_type)
1367     add_mangled_type (pextras, t->target_type);
1368 }
1369
1370 #if 0
1371 void
1372 cfront_mangle_name (type, i, j)
1373      struct type *type;
1374      int i;
1375      int j;
1376 {
1377   struct fn_field *f;
1378   char *mangled_name = gdb_mangle_name (type, i, j);
1379
1380   f = TYPE_FN_FIELDLIST1 (type, i);     /* moved from below */
1381
1382   /* kludge to support cfront methods - gdb expects to find "F" for
1383      ARM_mangled names, so when we mangle, we have to add it here */
1384   if (ARM_DEMANGLING)
1385     {
1386       int k;
1387       char *arm_mangled_name;
1388       struct fn_field *method = &f[j];
1389       char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1390       char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1391       char *newname = type_name_no_tag (type);
1392
1393       struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
1394       int nargs = TYPE_NFIELDS (ftype);         /* number of args */
1395       struct extra extras, *pextras = &extras;
1396       INIT_EXTRA
1397
1398         if (TYPE_FN_FIELD_STATIC_P (f, j))      /* j for sublist within this list */
1399         ADD_EXTRA ('S')
1400           ADD_EXTRA ('F')
1401         /* add args here! */
1402           if (nargs <= 1)       /* no args besides this */
1403           ADD_EXTRA ('v')
1404             else
1405           {
1406             for (k = 1; k < nargs; k++)
1407               {
1408                 struct type *t;
1409                 t = TYPE_FIELD_TYPE (ftype, k);
1410                 add_mangled_type (pextras, t);
1411               }
1412           }
1413       ADD_EXTRA ('\0')
1414         printf ("add_mangled_type: %s\n", extras.str);  /* FIXME */
1415       arm_mangled_name = malloc (strlen (mangled_name) + extras.len);
1416       sprintf (arm_mangled_name, "%s%s", mangled_name, extras.str);
1417       free (mangled_name);
1418       mangled_name = arm_mangled_name;
1419     }
1420 }
1421 #endif /* 0 */
1422
1423 #undef ADD_EXTRA
1424 /* End of new code added to support parsing of Cfront stabs strings */
1425
1426 /* Parse a type expression in the string [P..P+LENGTH).  If an error occurs,
1427    silently return builtin_type_void. */
1428
1429 struct type *
1430 safe_parse_type (char *p, int length)
1431 {
1432   struct ui_file *saved_gdb_stderr;
1433   struct type *type;
1434
1435   /* Suppress error messages. */
1436   saved_gdb_stderr = gdb_stderr;
1437   gdb_stderr = ui_file_new ();
1438
1439   /* Call parse_and_eval_type() without fear of longjmp()s. */
1440   if (!gdb_parse_and_eval_type (p, length, &type))
1441     type = builtin_type_void;
1442
1443   /* Stop suppressing error messages. */
1444   ui_file_delete (gdb_stderr);
1445   gdb_stderr = saved_gdb_stderr;
1446
1447   return type;
1448 }
1449
1450 /* Ugly hack to convert method stubs into method types.
1451
1452    He ain't kiddin'.  This demangles the name of the method into a string
1453    including argument types, parses out each argument type, generates
1454    a string casting a zero to that type, evaluates the string, and stuffs
1455    the resulting type into an argtype vector!!!  Then it knows the type
1456    of the whole function (including argument types for overloading),
1457    which info used to be in the stab's but was removed to hack back
1458    the space required for them.  */
1459
1460 void
1461 check_stub_method (type, method_id, signature_id)
1462      struct type *type;
1463      int method_id;
1464      int signature_id;
1465 {
1466   struct fn_field *f;
1467   char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1468   char *demangled_name = cplus_demangle (mangled_name,
1469                                          DMGL_PARAMS | DMGL_ANSI);
1470   char *argtypetext, *p;
1471   int depth = 0, argcount = 1;
1472   struct type **argtypes;
1473   struct type *mtype;
1474
1475   /* Make sure we got back a function string that we can use.  */
1476   if (demangled_name)
1477     p = strchr (demangled_name, '(');
1478
1479   if (demangled_name == NULL || p == NULL)
1480     error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
1481
1482   /* Now, read in the parameters that define this type.  */
1483   p += 1;
1484   argtypetext = p;
1485   while (*p)
1486     {
1487       if (*p == '(' || *p == '<')
1488         {
1489           depth += 1;
1490         }
1491       else if (*p == ')' || *p == '>')
1492         {
1493           depth -= 1;
1494         }
1495       else if (*p == ',' && depth == 0)
1496         {
1497           argcount += 1;
1498         }
1499
1500       p += 1;
1501     }
1502
1503   /* We need two more slots: one for the THIS pointer, and one for the
1504      NULL [...] or void [end of arglist].  */
1505
1506   argtypes = (struct type **)
1507     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
1508   p = argtypetext;
1509   /* FIXME: This is wrong for static member functions.  */
1510   argtypes[0] = lookup_pointer_type (type);
1511   argcount = 1;
1512
1513   if (*p != ')')                /* () means no args, skip while */
1514     {
1515       depth = 0;
1516       while (*p)
1517         {
1518           if (depth <= 0 && (*p == ',' || *p == ')'))
1519             {
1520               /* Avoid parsing of ellipsis, they will be handled below.  */
1521               if (strncmp (argtypetext, "...", p - argtypetext) != 0)
1522                 {
1523                   argtypes[argcount] =
1524                     safe_parse_type (argtypetext, p - argtypetext);
1525                   argcount += 1;
1526                 }
1527               argtypetext = p + 1;
1528             }
1529
1530           if (*p == '(' || *p == '<')
1531             {
1532               depth += 1;
1533             }
1534           else if (*p == ')' || *p == '>')
1535             {
1536               depth -= 1;
1537             }
1538
1539           p += 1;
1540         }
1541     }
1542
1543   if (p[-2] != '.')             /* Not '...' */
1544     {
1545       argtypes[argcount] = builtin_type_void;   /* List terminator */
1546     }
1547   else
1548     {
1549       argtypes[argcount] = NULL;        /* Ellist terminator */
1550     }
1551
1552   free (demangled_name);
1553
1554   f = TYPE_FN_FIELDLIST1 (type, method_id);
1555
1556   TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1557
1558   /* Now update the old "stub" type into a real type.  */
1559   mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1560   TYPE_DOMAIN_TYPE (mtype) = type;
1561   TYPE_ARG_TYPES (mtype) = argtypes;
1562   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
1563   TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1564 }
1565
1566 const struct cplus_struct_type cplus_struct_default;
1567
1568 void
1569 allocate_cplus_struct_type (type)
1570      struct type *type;
1571 {
1572   if (!HAVE_CPLUS_STRUCT (type))
1573     {
1574       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1575         TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1576       *(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1577     }
1578 }
1579
1580 /* Helper function to initialize the standard scalar types.
1581
1582    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
1583    of the string pointed to by name in the type_obstack for that objfile,
1584    and initialize the type name to that copy.  There are places (mipsread.c
1585    in particular, where init_type is called with a NULL value for NAME). */
1586
1587 struct type *
1588 init_type (code, length, flags, name, objfile)
1589      enum type_code code;
1590      int length;
1591      int flags;
1592      char *name;
1593      struct objfile *objfile;
1594 {
1595   register struct type *type;
1596
1597   type = alloc_type (objfile);
1598   TYPE_CODE (type) = code;
1599   TYPE_LENGTH (type) = length;
1600   TYPE_FLAGS (type) |= flags;
1601   if ((name != NULL) && (objfile != NULL))
1602     {
1603       TYPE_NAME (type) =
1604         obsavestring (name, strlen (name), &objfile->type_obstack);
1605     }
1606   else
1607     {
1608       TYPE_NAME (type) = name;
1609     }
1610
1611   /* C++ fancies.  */
1612
1613   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
1614     {
1615       INIT_CPLUS_SPECIFIC (type);
1616     }
1617   return (type);
1618 }
1619
1620 /* Look up a fundamental type for the specified objfile.
1621    May need to construct such a type if this is the first use.
1622
1623    Some object file formats (ELF, COFF, etc) do not define fundamental
1624    types such as "int" or "double".  Others (stabs for example), do
1625    define fundamental types.
1626
1627    For the formats which don't provide fundamental types, gdb can create
1628    such types, using defaults reasonable for the current language and
1629    the current target machine.
1630
1631    NOTE:  This routine is obsolescent.  Each debugging format reader
1632    should manage it's own fundamental types, either creating them from
1633    suitable defaults or reading them from the debugging information,
1634    whichever is appropriate.  The DWARF reader has already been
1635    fixed to do this.  Once the other readers are fixed, this routine
1636    will go away.  Also note that fundamental types should be managed
1637    on a compilation unit basis in a multi-language environment, not
1638    on a linkage unit basis as is done here. */
1639
1640
1641 struct type *
1642 lookup_fundamental_type (objfile, typeid)
1643      struct objfile *objfile;
1644      int typeid;
1645 {
1646   register struct type **typep;
1647   register int nbytes;
1648
1649   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1650     {
1651       error ("internal error - invalid fundamental type id %d", typeid);
1652     }
1653
1654   /* If this is the first time we need a fundamental type for this objfile
1655      then we need to initialize the vector of type pointers. */
1656
1657   if (objfile->fundamental_types == NULL)
1658     {
1659       nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1660       objfile->fundamental_types = (struct type **)
1661         obstack_alloc (&objfile->type_obstack, nbytes);
1662       memset ((char *) objfile->fundamental_types, 0, nbytes);
1663       OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
1664     }
1665
1666   /* Look for this particular type in the fundamental type vector.  If one is
1667      not found, create and install one appropriate for the current language. */
1668
1669   typep = objfile->fundamental_types + typeid;
1670   if (*typep == NULL)
1671     {
1672       *typep = create_fundamental_type (objfile, typeid);
1673     }
1674
1675   return (*typep);
1676 }
1677
1678 int
1679 can_dereference (t)
1680      struct type *t;
1681 {
1682   /* FIXME: Should we return true for references as well as pointers?  */
1683   CHECK_TYPEDEF (t);
1684   return
1685     (t != NULL
1686      && TYPE_CODE (t) == TYPE_CODE_PTR
1687      && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1688 }
1689
1690 int
1691 is_integral_type (t)
1692      struct type *t;
1693 {
1694   CHECK_TYPEDEF (t);
1695   return
1696     ((t != NULL)
1697      && ((TYPE_CODE (t) == TYPE_CODE_INT)
1698          || (TYPE_CODE (t) == TYPE_CODE_ENUM)
1699          || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1700          || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1701          || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
1702 }
1703
1704 /* Chill varying string and arrays are represented as follows:
1705
1706    struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
1707
1708    Return true if TYPE is such a Chill varying type. */
1709
1710 int
1711 chill_varying_type (type)
1712      struct type *type;
1713 {
1714   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1715       || TYPE_NFIELDS (type) != 2
1716       || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0)
1717     return 0;
1718   return 1;
1719 }
1720
1721 /* Check whether BASE is an ancestor or base class or DCLASS
1722    Return 1 if so, and 0 if not.
1723    Note: callers may want to check for identity of the types before
1724    calling this function -- identical types are considered to satisfy
1725    the ancestor relationship even if they're identical */
1726
1727 int
1728 is_ancestor (base, dclass)
1729      struct type *base;
1730      struct type *dclass;
1731 {
1732   int i;
1733
1734   CHECK_TYPEDEF (base);
1735   CHECK_TYPEDEF (dclass);
1736
1737   if (base == dclass)
1738     return 1;
1739
1740   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1741     if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
1742       return 1;
1743
1744   return 0;
1745 }
1746
1747
1748
1749 /* See whether DCLASS has a virtual table.  This routine is aimed at
1750    the HP/Taligent ANSI C++ runtime model, and may not work with other
1751    runtime models.  Return 1 => Yes, 0 => No.  */
1752
1753 int
1754 has_vtable (dclass)
1755      struct type *dclass;
1756 {
1757   /* In the HP ANSI C++ runtime model, a class has a vtable only if it
1758      has virtual functions or virtual bases.  */
1759
1760   register int i;
1761
1762   if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1763     return 0;
1764
1765   /* First check for the presence of virtual bases */
1766   if (TYPE_FIELD_VIRTUAL_BITS (dclass))
1767     for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1768       if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
1769         return 1;
1770
1771   /* Next check for virtual functions */
1772   if (TYPE_FN_FIELDLISTS (dclass))
1773     for (i = 0; i < TYPE_NFN_FIELDS (dclass); i++)
1774       if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0))
1775         return 1;
1776
1777   /* Recurse on non-virtual bases to see if any of them needs a vtable */
1778   if (TYPE_FIELD_VIRTUAL_BITS (dclass))
1779     for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1780       if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)) &&
1781           (has_vtable (TYPE_FIELD_TYPE (dclass, i))))
1782         return 1;
1783
1784   /* Well, maybe we don't need a virtual table */
1785   return 0;
1786 }
1787
1788 /* Return a pointer to the "primary base class" of DCLASS.
1789
1790    A NULL return indicates that DCLASS has no primary base, or that it
1791    couldn't be found (insufficient information).
1792
1793    This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1794    and may not work with other runtime models.  */
1795
1796 struct type *
1797 primary_base_class (dclass)
1798      struct type *dclass;
1799 {
1800   /* In HP ANSI C++'s runtime model, a "primary base class" of a class
1801      is the first directly inherited, non-virtual base class that
1802      requires a virtual table */
1803
1804   register int i;
1805
1806   if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1807     return NULL;
1808
1809   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1810     if (!TYPE_FIELD_VIRTUAL (dclass, i) &&
1811         has_vtable (TYPE_FIELD_TYPE (dclass, i)))
1812       return TYPE_FIELD_TYPE (dclass, i);
1813
1814   return NULL;
1815 }
1816
1817 /* Global manipulated by virtual_base_list[_aux]() */
1818
1819 static struct vbase *current_vbase_list = NULL;
1820
1821 /* Return a pointer to a null-terminated list of struct vbase
1822    items. The vbasetype pointer of each item in the list points to the
1823    type information for a virtual base of the argument DCLASS.
1824
1825    Helper function for virtual_base_list().
1826    Note: the list goes backward, right-to-left. virtual_base_list()
1827    copies the items out in reverse order.  */
1828
1829 static void
1830 virtual_base_list_aux (dclass)
1831      struct type *dclass;
1832 {
1833   struct vbase *tmp_vbase;
1834   register int i;
1835
1836   if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
1837     return;
1838
1839   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
1840     {
1841       /* Recurse on this ancestor, first */
1842       virtual_base_list_aux (TYPE_FIELD_TYPE (dclass, i));
1843
1844       /* If this current base is itself virtual, add it to the list */
1845       if (BASETYPE_VIA_VIRTUAL (dclass, i))
1846         {
1847           struct type *basetype = TYPE_FIELD_TYPE (dclass, i);
1848
1849           /* Check if base already recorded */
1850           tmp_vbase = current_vbase_list;
1851           while (tmp_vbase)
1852             {
1853               if (tmp_vbase->vbasetype == basetype)
1854                 break;          /* found it */
1855               tmp_vbase = tmp_vbase->next;
1856             }
1857
1858           if (!tmp_vbase)       /* normal exit from loop */
1859             {
1860               /* Allocate new item for this virtual base */
1861               tmp_vbase = (struct vbase *) xmalloc (sizeof (struct vbase));
1862
1863               /* Stick it on at the end of the list */
1864               tmp_vbase->vbasetype = basetype;
1865               tmp_vbase->next = current_vbase_list;
1866               current_vbase_list = tmp_vbase;
1867             }
1868         }                       /* if virtual */
1869     }                           /* for loop over bases */
1870 }
1871
1872
1873 /* Compute the list of virtual bases in the right order.  Virtual
1874    bases are laid out in the object's memory area in order of their
1875    occurrence in a depth-first, left-to-right search through the
1876    ancestors.
1877
1878    Argument DCLASS is the type whose virtual bases are required.
1879    Return value is the address of a null-terminated array of pointers
1880    to struct type items.
1881
1882    This routine is aimed at the HP/Taligent ANSI C++ runtime model,
1883    and may not work with other runtime models.
1884
1885    This routine merely hands off the argument to virtual_base_list_aux()
1886    and then copies the result into an array to save space.  */
1887
1888 struct type **
1889 virtual_base_list (dclass)
1890      struct type *dclass;
1891 {
1892   register struct vbase *tmp_vbase;
1893   register struct vbase *tmp_vbase_2;
1894   register int i;
1895   int count;
1896   struct type **vbase_array;
1897
1898   current_vbase_list = NULL;
1899   virtual_base_list_aux (dclass);
1900
1901   for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
1902     /* no body */ ;
1903
1904   count = i;
1905
1906   vbase_array = (struct type **) xmalloc ((count + 1) * sizeof (struct type *));
1907
1908   for (i = count - 1, tmp_vbase = current_vbase_list; i >= 0; i--, tmp_vbase = tmp_vbase->next)
1909     vbase_array[i] = tmp_vbase->vbasetype;
1910
1911   /* Get rid of constructed chain */
1912   tmp_vbase_2 = tmp_vbase = current_vbase_list;
1913   while (tmp_vbase)
1914     {
1915       tmp_vbase = tmp_vbase->next;
1916       free (tmp_vbase_2);
1917       tmp_vbase_2 = tmp_vbase;
1918     }
1919
1920   vbase_array[count] = NULL;
1921   return vbase_array;
1922 }
1923
1924 /* Return the length of the virtual base list of the type DCLASS.  */
1925
1926 int
1927 virtual_base_list_length (dclass)
1928      struct type *dclass;
1929 {
1930   register int i;
1931   register struct vbase *tmp_vbase;
1932
1933   current_vbase_list = NULL;
1934   virtual_base_list_aux (dclass);
1935
1936   for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
1937     /* no body */ ;
1938   return i;
1939 }
1940
1941 /* Return the number of elements of the virtual base list of the type
1942    DCLASS, ignoring those appearing in the primary base (and its
1943    primary base, recursively).  */
1944
1945 int
1946 virtual_base_list_length_skip_primaries (dclass)
1947      struct type *dclass;
1948 {
1949   register int i;
1950   register struct vbase *tmp_vbase;
1951   struct type *primary;
1952
1953   primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
1954
1955   if (!primary)
1956     return virtual_base_list_length (dclass);
1957
1958   current_vbase_list = NULL;
1959   virtual_base_list_aux (dclass);
1960
1961   for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; tmp_vbase = tmp_vbase->next)
1962     {
1963       if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
1964         continue;
1965       i++;
1966     }
1967   return i;
1968 }
1969
1970
1971 /* Return the index (position) of type BASE, which is a virtual base
1972    class of DCLASS, in the latter's virtual base list.  A return of -1
1973    indicates "not found" or a problem.  */
1974
1975 int
1976 virtual_base_index (base, dclass)
1977      struct type *base;
1978      struct type *dclass;
1979 {
1980   register struct type *vbase;
1981   register int i;
1982
1983   if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
1984       (TYPE_CODE (base) != TYPE_CODE_CLASS))
1985     return -1;
1986
1987   i = 0;
1988   vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[0];
1989   while (vbase)
1990     {
1991       if (vbase == base)
1992         break;
1993       vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[++i];
1994     }
1995
1996   return vbase ? i : -1;
1997 }
1998
1999
2000
2001 /* Return the index (position) of type BASE, which is a virtual base
2002    class of DCLASS, in the latter's virtual base list. Skip over all
2003    bases that may appear in the virtual base list of the primary base
2004    class of DCLASS (recursively).  A return of -1 indicates "not
2005    found" or a problem.  */
2006
2007 int
2008 virtual_base_index_skip_primaries (base, dclass)
2009      struct type *base;
2010      struct type *dclass;
2011 {
2012   register struct type *vbase;
2013   register int i, j;
2014   struct type *primary;
2015
2016   if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) ||
2017       (TYPE_CODE (base) != TYPE_CODE_CLASS))
2018     return -1;
2019
2020   primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL;
2021
2022   j = -1;
2023   i = 0;
2024   vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[0];
2025   while (vbase)
2026     {
2027       if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
2028         j++;
2029       if (vbase == base)
2030         break;
2031       vbase = TYPE_VIRTUAL_BASE_LIST (dclass)[++i];
2032     }
2033
2034   return vbase ? j : -1;
2035 }
2036
2037 /* Return position of a derived class DCLASS in the list of
2038  * primary bases starting with the remotest ancestor.
2039  * Position returned is 0-based. */
2040
2041 int
2042 class_index_in_primary_list (dclass)
2043      struct type *dclass;
2044 {
2045   struct type *pbc;             /* primary base class */
2046
2047   /* Simply recurse on primary base */
2048   pbc = TYPE_PRIMARY_BASE (dclass);
2049   if (pbc)
2050     return 1 + class_index_in_primary_list (pbc);
2051   else
2052     return 0;
2053 }
2054
2055 /* Return a count of the number of virtual functions a type has.
2056  * This includes all the virtual functions it inherits from its
2057  * base classes too.
2058  */
2059
2060 /* pai: FIXME This doesn't do the right thing: count redefined virtual
2061  * functions only once (latest redefinition)
2062  */
2063
2064 int
2065 count_virtual_fns (dclass)
2066      struct type *dclass;
2067 {
2068   int fn, oi;                   /* function and overloaded instance indices */
2069   int vfuncs;                   /* count to return */
2070
2071   /* recurse on bases that can share virtual table */
2072   struct type *pbc = primary_base_class (dclass);
2073   if (pbc)
2074     vfuncs = count_virtual_fns (pbc);
2075
2076   for (fn = 0; fn < TYPE_NFN_FIELDS (dclass); fn++)
2077     for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn); oi++)
2078       if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, fn), oi))
2079         vfuncs++;
2080
2081   return vfuncs;
2082 }
2083 \f
2084
2085
2086 /* Functions for overload resolution begin here */
2087
2088 /* Compare two badness vectors A and B and return the result.
2089  * 0 => A and B are identical
2090  * 1 => A and B are incomparable
2091  * 2 => A is better than B
2092  * 3 => A is worse than B */
2093
2094 int
2095 compare_badness (a, b)
2096      struct badness_vector *a;
2097      struct badness_vector *b;
2098 {
2099   int i;
2100   int tmp;
2101   short found_pos = 0;          /* any positives in c? */
2102   short found_neg = 0;          /* any negatives in c? */
2103
2104   /* differing lengths => incomparable */
2105   if (a->length != b->length)
2106     return 1;
2107
2108   /* Subtract b from a */
2109   for (i = 0; i < a->length; i++)
2110     {
2111       tmp = a->rank[i] - b->rank[i];
2112       if (tmp > 0)
2113         found_pos = 1;
2114       else if (tmp < 0)
2115         found_neg = 1;
2116     }
2117
2118   if (found_pos)
2119     {
2120       if (found_neg)
2121         return 1;               /* incomparable */
2122       else
2123         return 3;               /* A > B */
2124     }
2125   else
2126     /* no positives */
2127     {
2128       if (found_neg)
2129         return 2;               /* A < B */
2130       else
2131         return 0;               /* A == B */
2132     }
2133 }
2134
2135 /* Rank a function by comparing its parameter types (PARMS, length NPARMS),
2136  * to the types of an argument list (ARGS, length NARGS).
2137  * Return a pointer to a badness vector. This has NARGS + 1 entries. */
2138
2139 struct badness_vector *
2140 rank_function (parms, nparms, args, nargs)
2141      struct type **parms;
2142      int nparms;
2143      struct type **args;
2144      int nargs;
2145 {
2146   int i;
2147   struct badness_vector *bv;
2148   int min_len = nparms < nargs ? nparms : nargs;
2149
2150   bv = xmalloc (sizeof (struct badness_vector));
2151   bv->length = nargs + 1;       /* add 1 for the length-match rank */
2152   bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2153
2154   /* First compare the lengths of the supplied lists.
2155    * If there is a mismatch, set it to a high value. */
2156
2157   /* pai/1997-06-03 FIXME: when we have debug info about default
2158    * arguments and ellipsis parameter lists, we should consider those
2159    * and rank the length-match more finely. */
2160
2161   LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
2162
2163   /* Now rank all the parameters of the candidate function */
2164   for (i = 1; i <= min_len; i++)
2165     bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
2166
2167   /* If more arguments than parameters, add dummy entries */
2168   for (i = min_len + 1; i <= nargs; i++)
2169     bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2170
2171   return bv;
2172 }
2173
2174 /* Compare one type (PARM) for compatibility with another (ARG).
2175  * PARM is intended to be the parameter type of a function; and
2176  * ARG is the supplied argument's type.  This function tests if
2177  * the latter can be converted to the former.
2178  *
2179  * Return 0 if they are identical types;
2180  * Otherwise, return an integer which corresponds to how compatible
2181  * PARM is to ARG. The higher the return value, the worse the match.
2182  * Generally the "bad" conversions are all uniformly assigned a 100 */
2183
2184 int
2185 rank_one_type (parm, arg)
2186      struct type *parm;
2187      struct type *arg;
2188 {
2189   /* Identical type pointers */
2190   /* However, this still doesn't catch all cases of same type for arg
2191    * and param. The reason is that builtin types are different from
2192    * the same ones constructed from the object. */
2193   if (parm == arg)
2194     return 0;
2195
2196   /* Resolve typedefs */
2197   if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2198     parm = check_typedef (parm);
2199   if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2200     arg = check_typedef (arg);
2201
2202   /*
2203      Well, damnit, if the names are exactly the same,
2204      i'll say they are exactly the same. This happens when we generate
2205      method stubs. The types won't point to the same address, but they
2206      really are the same.
2207   */
2208
2209   if (TYPE_NAME (parm) == TYPE_NAME (arg))
2210       return 0;
2211
2212   /* Check if identical after resolving typedefs */
2213   if (parm == arg)
2214     return 0;
2215
2216   /* See through references, since we can almost make non-references
2217      references. */
2218   if (TYPE_CODE (arg) == TYPE_CODE_REF)
2219     return (rank_one_type (TYPE_TARGET_TYPE (arg), parm)
2220             + REFERENCE_CONVERSION_BADNESS);
2221   if (TYPE_CODE (parm) == TYPE_CODE_REF)
2222     return (rank_one_type (arg, TYPE_TARGET_TYPE (parm))
2223             + REFERENCE_CONVERSION_BADNESS);
2224   if (overload_debug)
2225   /* Debugging only. */
2226     fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
2227         TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
2228
2229   /* x -> y means arg of type x being supplied for parameter of type y */
2230
2231   switch (TYPE_CODE (parm))
2232     {
2233     case TYPE_CODE_PTR:
2234       switch (TYPE_CODE (arg))
2235         {
2236         case TYPE_CODE_PTR:
2237           if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2238             return VOID_PTR_CONVERSION_BADNESS;
2239           else
2240             return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2241         case TYPE_CODE_ARRAY:
2242           return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2243         case TYPE_CODE_FUNC:
2244           return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
2245         case TYPE_CODE_INT:
2246         case TYPE_CODE_ENUM:
2247         case TYPE_CODE_CHAR:
2248         case TYPE_CODE_RANGE:
2249         case TYPE_CODE_BOOL:
2250           return POINTER_CONVERSION_BADNESS;
2251         default:
2252           return INCOMPATIBLE_TYPE_BADNESS;
2253         }
2254     case TYPE_CODE_ARRAY:
2255       switch (TYPE_CODE (arg))
2256         {
2257         case TYPE_CODE_PTR:
2258         case TYPE_CODE_ARRAY:
2259           return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
2260         default:
2261           return INCOMPATIBLE_TYPE_BADNESS;
2262         }
2263     case TYPE_CODE_FUNC:
2264       switch (TYPE_CODE (arg))
2265         {
2266         case TYPE_CODE_PTR:     /* funcptr -> func */
2267           return rank_one_type (parm, TYPE_TARGET_TYPE (arg));
2268         default:
2269           return INCOMPATIBLE_TYPE_BADNESS;
2270         }
2271     case TYPE_CODE_INT:
2272       switch (TYPE_CODE (arg))
2273         {
2274         case TYPE_CODE_INT:
2275           if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2276             {
2277               /* Deal with signed, unsigned, and plain chars and
2278                  signed and unsigned ints */
2279               if (TYPE_NOSIGN (parm))
2280                 {
2281                   /* This case only for character types */
2282                   if (TYPE_NOSIGN (arg))        /* plain char -> plain char */
2283                     return 0;
2284                   else
2285                     return INTEGER_COERCION_BADNESS;    /* signed/unsigned char -> plain char */
2286                 }
2287               else if (TYPE_UNSIGNED (parm))
2288                 {
2289                   if (TYPE_UNSIGNED (arg))
2290                     {
2291                       if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
2292                         return 0;       /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
2293                       else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
2294                         return INTEGER_PROMOTION_BADNESS;       /* unsigned int -> unsigned long */
2295                       else
2296                         return INTEGER_COERCION_BADNESS;        /* unsigned long -> unsigned int */
2297                     }
2298                   else
2299                     {
2300                       if (!strcmp_iw (TYPE_NAME (arg), "long") && !strcmp_iw (TYPE_NAME (parm), "int"))
2301                         return INTEGER_COERCION_BADNESS;        /* signed long -> unsigned int */
2302                       else
2303                         return INTEGER_CONVERSION_BADNESS;      /* signed int/long -> unsigned int/long */
2304                     }
2305                 }
2306               else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2307                 {
2308                   if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg)))
2309                     return 0;
2310                   else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long"))
2311                     return INTEGER_PROMOTION_BADNESS;
2312                   else
2313                     return INTEGER_COERCION_BADNESS;
2314                 }
2315               else
2316                 return INTEGER_COERCION_BADNESS;
2317             }
2318           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2319             return INTEGER_PROMOTION_BADNESS;
2320           else
2321             return INTEGER_COERCION_BADNESS;
2322         case TYPE_CODE_ENUM:
2323         case TYPE_CODE_CHAR:
2324         case TYPE_CODE_RANGE:
2325         case TYPE_CODE_BOOL:
2326           return INTEGER_PROMOTION_BADNESS;
2327         case TYPE_CODE_FLT:
2328           return INT_FLOAT_CONVERSION_BADNESS;
2329         case TYPE_CODE_PTR:
2330           return NS_POINTER_CONVERSION_BADNESS;
2331         default:
2332           return INCOMPATIBLE_TYPE_BADNESS;
2333         }
2334       break;
2335     case TYPE_CODE_ENUM:
2336       switch (TYPE_CODE (arg))
2337         {
2338         case TYPE_CODE_INT:
2339         case TYPE_CODE_CHAR:
2340         case TYPE_CODE_RANGE:
2341         case TYPE_CODE_BOOL:
2342         case TYPE_CODE_ENUM:
2343           return INTEGER_COERCION_BADNESS;
2344         case TYPE_CODE_FLT:
2345           return INT_FLOAT_CONVERSION_BADNESS;
2346         default:
2347           return INCOMPATIBLE_TYPE_BADNESS;
2348         }
2349       break;
2350     case TYPE_CODE_CHAR:
2351       switch (TYPE_CODE (arg))
2352         {
2353         case TYPE_CODE_RANGE:
2354         case TYPE_CODE_BOOL:
2355         case TYPE_CODE_ENUM:
2356           return INTEGER_COERCION_BADNESS;
2357         case TYPE_CODE_FLT:
2358           return INT_FLOAT_CONVERSION_BADNESS;
2359         case TYPE_CODE_INT:
2360           if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2361             return INTEGER_COERCION_BADNESS;
2362           else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2363             return INTEGER_PROMOTION_BADNESS;
2364           /* >>> !! else fall through !! <<< */
2365         case TYPE_CODE_CHAR:
2366           /* Deal with signed, unsigned, and plain chars for C++
2367              and with int cases falling through from previous case */
2368           if (TYPE_NOSIGN (parm))
2369             {
2370               if (TYPE_NOSIGN (arg))
2371                 return 0;
2372               else
2373                 return INTEGER_COERCION_BADNESS;
2374             }
2375           else if (TYPE_UNSIGNED (parm))
2376             {
2377               if (TYPE_UNSIGNED (arg))
2378                 return 0;
2379               else
2380                 return INTEGER_PROMOTION_BADNESS;
2381             }
2382           else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2383             return 0;
2384           else
2385             return INTEGER_COERCION_BADNESS;
2386         default:
2387           return INCOMPATIBLE_TYPE_BADNESS;
2388         }
2389       break;
2390     case TYPE_CODE_RANGE:
2391       switch (TYPE_CODE (arg))
2392         {
2393         case TYPE_CODE_INT:
2394         case TYPE_CODE_CHAR:
2395         case TYPE_CODE_RANGE:
2396         case TYPE_CODE_BOOL:
2397         case TYPE_CODE_ENUM:
2398           return INTEGER_COERCION_BADNESS;
2399         case TYPE_CODE_FLT:
2400           return INT_FLOAT_CONVERSION_BADNESS;
2401         default:
2402           return INCOMPATIBLE_TYPE_BADNESS;
2403         }
2404       break;
2405     case TYPE_CODE_BOOL:
2406       switch (TYPE_CODE (arg))
2407         {
2408         case TYPE_CODE_INT:
2409         case TYPE_CODE_CHAR:
2410         case TYPE_CODE_RANGE:
2411         case TYPE_CODE_ENUM:
2412         case TYPE_CODE_FLT:
2413         case TYPE_CODE_PTR:
2414           return BOOLEAN_CONVERSION_BADNESS;
2415         case TYPE_CODE_BOOL:
2416           return 0;
2417         default:
2418           return INCOMPATIBLE_TYPE_BADNESS;
2419         }
2420       break;
2421     case TYPE_CODE_FLT:
2422       switch (TYPE_CODE (arg))
2423         {
2424         case TYPE_CODE_FLT:
2425           if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2426             return FLOAT_PROMOTION_BADNESS;
2427           else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2428             return 0;
2429           else
2430             return FLOAT_CONVERSION_BADNESS;
2431         case TYPE_CODE_INT:
2432         case TYPE_CODE_BOOL:
2433         case TYPE_CODE_ENUM:
2434         case TYPE_CODE_RANGE:
2435         case TYPE_CODE_CHAR:
2436           return INT_FLOAT_CONVERSION_BADNESS;
2437         default:
2438           return INCOMPATIBLE_TYPE_BADNESS;
2439         }
2440       break;
2441     case TYPE_CODE_COMPLEX:
2442       switch (TYPE_CODE (arg))
2443         {                       /* Strictly not needed for C++, but... */
2444         case TYPE_CODE_FLT:
2445           return FLOAT_PROMOTION_BADNESS;
2446         case TYPE_CODE_COMPLEX:
2447           return 0;
2448         default:
2449           return INCOMPATIBLE_TYPE_BADNESS;
2450         }
2451       break;
2452     case TYPE_CODE_STRUCT:
2453       /* currently same as TYPE_CODE_CLASS */
2454       switch (TYPE_CODE (arg))
2455         {
2456         case TYPE_CODE_STRUCT:
2457           /* Check for derivation */
2458           if (is_ancestor (parm, arg))
2459             return BASE_CONVERSION_BADNESS;
2460           /* else fall through */
2461         default:
2462           return INCOMPATIBLE_TYPE_BADNESS;
2463         }
2464       break;
2465     case TYPE_CODE_UNION:
2466       switch (TYPE_CODE (arg))
2467         {
2468         case TYPE_CODE_UNION:
2469         default:
2470           return INCOMPATIBLE_TYPE_BADNESS;
2471         }
2472       break;
2473     case TYPE_CODE_MEMBER:
2474       switch (TYPE_CODE (arg))
2475         {
2476         default:
2477           return INCOMPATIBLE_TYPE_BADNESS;
2478         }
2479       break;
2480     case TYPE_CODE_METHOD:
2481       switch (TYPE_CODE (arg))
2482         {
2483
2484         default:
2485           return INCOMPATIBLE_TYPE_BADNESS;
2486         }
2487       break;
2488     case TYPE_CODE_REF:
2489       switch (TYPE_CODE (arg))
2490         {
2491
2492         default:
2493           return INCOMPATIBLE_TYPE_BADNESS;
2494         }
2495
2496       break;
2497     case TYPE_CODE_SET:
2498       switch (TYPE_CODE (arg))
2499         {
2500           /* Not in C++ */
2501         case TYPE_CODE_SET:
2502           return rank_one_type (TYPE_FIELD_TYPE (parm, 0), TYPE_FIELD_TYPE (arg, 0));
2503         default:
2504           return INCOMPATIBLE_TYPE_BADNESS;
2505         }
2506       break;
2507     case TYPE_CODE_VOID:
2508     default:
2509       return INCOMPATIBLE_TYPE_BADNESS;
2510     }                           /* switch (TYPE_CODE (arg)) */
2511 }
2512
2513
2514 /* End of functions for overload resolution */
2515
2516 static void
2517 print_bit_vector (bits, nbits)
2518      B_TYPE *bits;
2519      int nbits;
2520 {
2521   int bitno;
2522
2523   for (bitno = 0; bitno < nbits; bitno++)
2524     {
2525       if ((bitno % 8) == 0)
2526         {
2527           puts_filtered (" ");
2528         }
2529       if (B_TST (bits, bitno))
2530         {
2531           printf_filtered ("1");
2532         }
2533       else
2534         {
2535           printf_filtered ("0");
2536         }
2537     }
2538 }
2539
2540 /* The args list is a strange beast.  It is either terminated by a NULL
2541    pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
2542    type for normal fixed argcount functions.  (FIXME someday)
2543    Also note the first arg should be the "this" pointer, we may not want to
2544    include it since we may get into a infinitely recursive situation. */
2545
2546 static void
2547 print_arg_types (args, spaces)
2548      struct type **args;
2549      int spaces;
2550 {
2551   if (args != NULL)
2552     {
2553       while (*args != NULL)
2554         {
2555           recursive_dump_type (*args, spaces + 2);
2556           if ((*args++)->code == TYPE_CODE_VOID)
2557             {
2558               break;
2559             }
2560         }
2561     }
2562 }
2563
2564 static void
2565 dump_fn_fieldlists (type, spaces)
2566      struct type *type;
2567      int spaces;
2568 {
2569   int method_idx;
2570   int overload_idx;
2571   struct fn_field *f;
2572
2573   printfi_filtered (spaces, "fn_fieldlists ");
2574   gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2575   printf_filtered ("\n");
2576   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2577     {
2578       f = TYPE_FN_FIELDLIST1 (type, method_idx);
2579       printfi_filtered (spaces + 2, "[%d] name '%s' (",
2580                         method_idx,
2581                         TYPE_FN_FIELDLIST_NAME (type, method_idx));
2582       gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2583                               gdb_stdout);
2584       printf_filtered (") length %d\n",
2585                        TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2586       for (overload_idx = 0;
2587            overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2588            overload_idx++)
2589         {
2590           printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2591                             overload_idx,
2592                             TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2593           gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2594                                   gdb_stdout);
2595           printf_filtered (")\n");
2596           printfi_filtered (spaces + 8, "type ");
2597           gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
2598           printf_filtered ("\n");
2599
2600           recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2601                                spaces + 8 + 2);
2602
2603           printfi_filtered (spaces + 8, "args ");
2604           gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
2605           printf_filtered ("\n");
2606
2607           print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
2608           printfi_filtered (spaces + 8, "fcontext ");
2609           gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2610                                   gdb_stdout);
2611           printf_filtered ("\n");
2612
2613           printfi_filtered (spaces + 8, "is_const %d\n",
2614                             TYPE_FN_FIELD_CONST (f, overload_idx));
2615           printfi_filtered (spaces + 8, "is_volatile %d\n",
2616                             TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2617           printfi_filtered (spaces + 8, "is_private %d\n",
2618                             TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2619           printfi_filtered (spaces + 8, "is_protected %d\n",
2620                             TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2621           printfi_filtered (spaces + 8, "is_stub %d\n",
2622                             TYPE_FN_FIELD_STUB (f, overload_idx));
2623           printfi_filtered (spaces + 8, "voffset %u\n",
2624                             TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2625         }
2626     }
2627 }
2628
2629 static void
2630 print_cplus_stuff (type, spaces)
2631      struct type *type;
2632      int spaces;
2633 {
2634   printfi_filtered (spaces, "n_baseclasses %d\n",
2635                     TYPE_N_BASECLASSES (type));
2636   printfi_filtered (spaces, "nfn_fields %d\n",
2637                     TYPE_NFN_FIELDS (type));
2638   printfi_filtered (spaces, "nfn_fields_total %d\n",
2639                     TYPE_NFN_FIELDS_TOTAL (type));
2640   if (TYPE_N_BASECLASSES (type) > 0)
2641     {
2642       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2643                         TYPE_N_BASECLASSES (type));
2644       gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
2645       printf_filtered (")");
2646
2647       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2648                         TYPE_N_BASECLASSES (type));
2649       puts_filtered ("\n");
2650     }
2651   if (TYPE_NFIELDS (type) > 0)
2652     {
2653       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2654         {
2655           printfi_filtered (spaces, "private_field_bits (%d bits at *",
2656                             TYPE_NFIELDS (type));
2657           gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
2658           printf_filtered (")");
2659           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2660                             TYPE_NFIELDS (type));
2661           puts_filtered ("\n");
2662         }
2663       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2664         {
2665           printfi_filtered (spaces, "protected_field_bits (%d bits at *",
2666                             TYPE_NFIELDS (type));
2667           gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
2668           printf_filtered (")");
2669           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2670                             TYPE_NFIELDS (type));
2671           puts_filtered ("\n");
2672         }
2673     }
2674   if (TYPE_NFN_FIELDS (type) > 0)
2675     {
2676       dump_fn_fieldlists (type, spaces);
2677     }
2678 }
2679
2680 static struct obstack dont_print_type_obstack;
2681
2682 void
2683 recursive_dump_type (type, spaces)
2684      struct type *type;
2685      int spaces;
2686 {
2687   int idx;
2688
2689   if (spaces == 0)
2690     obstack_begin (&dont_print_type_obstack, 0);
2691
2692   if (TYPE_NFIELDS (type) > 0
2693       || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
2694     {
2695       struct type **first_dont_print
2696       = (struct type **) obstack_base (&dont_print_type_obstack);
2697
2698       int i = (struct type **) obstack_next_free (&dont_print_type_obstack)
2699       - first_dont_print;
2700
2701       while (--i >= 0)
2702         {
2703           if (type == first_dont_print[i])
2704             {
2705               printfi_filtered (spaces, "type node ");
2706               gdb_print_host_address (type, gdb_stdout);
2707               printf_filtered (" <same as already seen type>\n");
2708               return;
2709             }
2710         }
2711
2712       obstack_ptr_grow (&dont_print_type_obstack, type);
2713     }
2714
2715   printfi_filtered (spaces, "type node ");
2716   gdb_print_host_address (type, gdb_stdout);
2717   printf_filtered ("\n");
2718   printfi_filtered (spaces, "name '%s' (",
2719                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
2720   gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
2721   printf_filtered (")\n");
2722   if (TYPE_TAG_NAME (type) != NULL)
2723     {
2724       printfi_filtered (spaces, "tagname '%s' (",
2725                         TYPE_TAG_NAME (type));
2726       gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
2727       printf_filtered (")\n");
2728     }
2729   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
2730   switch (TYPE_CODE (type))
2731     {
2732     case TYPE_CODE_UNDEF:
2733       printf_filtered ("(TYPE_CODE_UNDEF)");
2734       break;
2735     case TYPE_CODE_PTR:
2736       printf_filtered ("(TYPE_CODE_PTR)");
2737       break;
2738     case TYPE_CODE_ARRAY:
2739       printf_filtered ("(TYPE_CODE_ARRAY)");
2740       break;
2741     case TYPE_CODE_STRUCT:
2742       printf_filtered ("(TYPE_CODE_STRUCT)");
2743       break;
2744     case TYPE_CODE_UNION:
2745       printf_filtered ("(TYPE_CODE_UNION)");
2746       break;
2747     case TYPE_CODE_ENUM:
2748       printf_filtered ("(TYPE_CODE_ENUM)");
2749       break;
2750     case TYPE_CODE_FUNC:
2751       printf_filtered ("(TYPE_CODE_FUNC)");
2752       break;
2753     case TYPE_CODE_INT:
2754       printf_filtered ("(TYPE_CODE_INT)");
2755       break;
2756     case TYPE_CODE_FLT:
2757       printf_filtered ("(TYPE_CODE_FLT)");
2758       break;
2759     case TYPE_CODE_VOID:
2760       printf_filtered ("(TYPE_CODE_VOID)");
2761       break;
2762     case TYPE_CODE_SET:
2763       printf_filtered ("(TYPE_CODE_SET)");
2764       break;
2765     case TYPE_CODE_RANGE:
2766       printf_filtered ("(TYPE_CODE_RANGE)");
2767       break;
2768     case TYPE_CODE_STRING:
2769       printf_filtered ("(TYPE_CODE_STRING)");
2770       break;
2771     case TYPE_CODE_ERROR:
2772       printf_filtered ("(TYPE_CODE_ERROR)");
2773       break;
2774     case TYPE_CODE_MEMBER:
2775       printf_filtered ("(TYPE_CODE_MEMBER)");
2776       break;
2777     case TYPE_CODE_METHOD:
2778       printf_filtered ("(TYPE_CODE_METHOD)");
2779       break;
2780     case TYPE_CODE_REF:
2781       printf_filtered ("(TYPE_CODE_REF)");
2782       break;
2783     case TYPE_CODE_CHAR:
2784       printf_filtered ("(TYPE_CODE_CHAR)");
2785       break;
2786     case TYPE_CODE_BOOL:
2787       printf_filtered ("(TYPE_CODE_BOOL)");
2788       break;
2789     case TYPE_CODE_TYPEDEF:
2790       printf_filtered ("(TYPE_CODE_TYPEDEF)");
2791       break;
2792     default:
2793       printf_filtered ("(UNKNOWN TYPE CODE)");
2794       break;
2795     }
2796   puts_filtered ("\n");
2797   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
2798   printfi_filtered (spaces, "objfile ");
2799   gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout);
2800   printf_filtered ("\n");
2801   printfi_filtered (spaces, "target_type ");
2802   gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
2803   printf_filtered ("\n");
2804   if (TYPE_TARGET_TYPE (type) != NULL)
2805     {
2806       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
2807     }
2808   printfi_filtered (spaces, "pointer_type ");
2809   gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
2810   printf_filtered ("\n");
2811   printfi_filtered (spaces, "reference_type ");
2812   gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
2813   printf_filtered ("\n");
2814   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
2815   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
2816     {
2817       puts_filtered (" TYPE_FLAG_UNSIGNED");
2818     }
2819   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
2820     {
2821       puts_filtered (" TYPE_FLAG_STUB");
2822     }
2823   puts_filtered ("\n");
2824   printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
2825   gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
2826   puts_filtered ("\n");
2827   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
2828     {
2829       printfi_filtered (spaces + 2,
2830                         "[%d] bitpos %d bitsize %d type ",
2831                         idx, TYPE_FIELD_BITPOS (type, idx),
2832                         TYPE_FIELD_BITSIZE (type, idx));
2833       gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
2834       printf_filtered (" name '%s' (",
2835                        TYPE_FIELD_NAME (type, idx) != NULL
2836                        ? TYPE_FIELD_NAME (type, idx)
2837                        : "<NULL>");
2838       gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
2839       printf_filtered (")\n");
2840       if (TYPE_FIELD_TYPE (type, idx) != NULL)
2841         {
2842           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
2843         }
2844     }
2845   printfi_filtered (spaces, "vptr_basetype ");
2846   gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
2847   puts_filtered ("\n");
2848   if (TYPE_VPTR_BASETYPE (type) != NULL)
2849     {
2850       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
2851     }
2852   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
2853   switch (TYPE_CODE (type))
2854     {
2855     case TYPE_CODE_METHOD:
2856     case TYPE_CODE_FUNC:
2857       printfi_filtered (spaces, "arg_types ");
2858       gdb_print_host_address (TYPE_ARG_TYPES (type), gdb_stdout);
2859       puts_filtered ("\n");
2860       print_arg_types (TYPE_ARG_TYPES (type), spaces);
2861       break;
2862
2863     case TYPE_CODE_STRUCT:
2864       printfi_filtered (spaces, "cplus_stuff ");
2865       gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
2866       puts_filtered ("\n");
2867       print_cplus_stuff (type, spaces);
2868       break;
2869
2870     default:
2871       /* We have to pick one of the union types to be able print and test
2872          the value.  Pick cplus_struct_type, even though we know it isn't
2873          any particular one. */
2874       printfi_filtered (spaces, "type_specific ");
2875       gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
2876       if (TYPE_CPLUS_SPECIFIC (type) != NULL)
2877         {
2878           printf_filtered (" (unknown data form)");
2879         }
2880       printf_filtered ("\n");
2881       break;
2882
2883     }
2884   if (spaces == 0)
2885     obstack_free (&dont_print_type_obstack, NULL);
2886 }
2887
2888 static void build_gdbtypes PARAMS ((void));
2889 static void
2890 build_gdbtypes ()
2891 {
2892   builtin_type_void =
2893     init_type (TYPE_CODE_VOID, 1,
2894                0,
2895                "void", (struct objfile *) NULL);
2896   builtin_type_char =
2897     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
2898                0,
2899                "char", (struct objfile *) NULL);
2900   TYPE_FLAGS (builtin_type_char) |= TYPE_FLAG_NOSIGN;
2901   builtin_type_true_char =
2902     init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
2903                0,
2904                "true character", (struct objfile *) NULL);
2905   builtin_type_signed_char =
2906     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
2907                0,
2908                "signed char", (struct objfile *) NULL);
2909   builtin_type_unsigned_char =
2910     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
2911                TYPE_FLAG_UNSIGNED,
2912                "unsigned char", (struct objfile *) NULL);
2913   builtin_type_short =
2914     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
2915                0,
2916                "short", (struct objfile *) NULL);
2917   builtin_type_unsigned_short =
2918     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
2919                TYPE_FLAG_UNSIGNED,
2920                "unsigned short", (struct objfile *) NULL);
2921   builtin_type_int =
2922     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
2923                0,
2924                "int", (struct objfile *) NULL);
2925   builtin_type_unsigned_int =
2926     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
2927                TYPE_FLAG_UNSIGNED,
2928                "unsigned int", (struct objfile *) NULL);
2929   builtin_type_long =
2930     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
2931                0,
2932                "long", (struct objfile *) NULL);
2933   builtin_type_unsigned_long =
2934     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
2935                TYPE_FLAG_UNSIGNED,
2936                "unsigned long", (struct objfile *) NULL);
2937   builtin_type_long_long =
2938     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
2939                0,
2940                "long long", (struct objfile *) NULL);
2941   builtin_type_unsigned_long_long =
2942     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
2943                TYPE_FLAG_UNSIGNED,
2944                "unsigned long long", (struct objfile *) NULL);
2945   builtin_type_float =
2946     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
2947                0,
2948                "float", (struct objfile *) NULL);
2949   builtin_type_double =
2950     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
2951                0,
2952                "double", (struct objfile *) NULL);
2953   builtin_type_long_double =
2954     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
2955                0,
2956                "long double", (struct objfile *) NULL);
2957   builtin_type_complex =
2958     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
2959                0,
2960                "complex", (struct objfile *) NULL);
2961   TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
2962   builtin_type_double_complex =
2963     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
2964                0,
2965                "double complex", (struct objfile *) NULL);
2966   TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
2967   builtin_type_string =
2968     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
2969                0,
2970                "string", (struct objfile *) NULL);
2971   builtin_type_int8 =
2972     init_type (TYPE_CODE_INT, 8 / 8,
2973                0,
2974                "int8_t", (struct objfile *) NULL);
2975   builtin_type_uint8 =
2976     init_type (TYPE_CODE_INT, 8 / 8,
2977                TYPE_FLAG_UNSIGNED,
2978                "uint8_t", (struct objfile *) NULL);
2979   builtin_type_int16 =
2980     init_type (TYPE_CODE_INT, 16 / 8,
2981                0,
2982                "int16_t", (struct objfile *) NULL);
2983   builtin_type_uint16 =
2984     init_type (TYPE_CODE_INT, 16 / 8,
2985                TYPE_FLAG_UNSIGNED,
2986                "uint16_t", (struct objfile *) NULL);
2987   builtin_type_int32 =
2988     init_type (TYPE_CODE_INT, 32 / 8,
2989                0,
2990                "int32_t", (struct objfile *) NULL);
2991   builtin_type_uint32 =
2992     init_type (TYPE_CODE_INT, 32 / 8,
2993                TYPE_FLAG_UNSIGNED,
2994                "uint32_t", (struct objfile *) NULL);
2995   builtin_type_int64 =
2996     init_type (TYPE_CODE_INT, 64 / 8,
2997                0,
2998                "int64_t", (struct objfile *) NULL);
2999   builtin_type_uint64 =
3000     init_type (TYPE_CODE_INT, 64 / 8,
3001                TYPE_FLAG_UNSIGNED,
3002                "uint64_t", (struct objfile *) NULL);
3003   builtin_type_bool =
3004     init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3005                0,
3006                "bool", (struct objfile *) NULL);
3007
3008   /* Add user knob for controlling resolution of opaque types */
3009   add_show_from_set
3010     (add_set_cmd ("opaque-type-resolution", class_support, var_boolean, (char *) &opaque_type_resolution,
3011                   "Set resolution of opaque struct/class/union types (if set before loading symbols).",
3012                   &setlist),
3013      &showlist);
3014   opaque_type_resolution = 1;
3015
3016
3017   /* Build SIMD types.  */
3018   builtin_type_v4sf
3019     = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
3020   builtin_type_v4si
3021     = init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4);
3022   builtin_type_v8qi
3023     = init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8);
3024   builtin_type_v4hi
3025     = init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4);
3026   builtin_type_v2si
3027     = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);
3028
3029   /* Pointer/Address types. */
3030   /* NOTE: At present there is no way of differentiating between at
3031      target address and the target C language pointer type type even
3032      though the two can be different (cf d10v) */
3033   builtin_type_ptr =
3034     init_type (TYPE_CODE_INT, TARGET_PTR_BIT / 8,
3035                TYPE_FLAG_UNSIGNED,
3036                "__ptr", (struct objfile *) NULL);
3037   builtin_type_CORE_ADDR =
3038     init_type (TYPE_CODE_INT, TARGET_PTR_BIT / 8,
3039                TYPE_FLAG_UNSIGNED,
3040                "__CORE_ADDR", (struct objfile *) NULL);
3041   builtin_type_bfd_vma =
3042     init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT / 8,
3043                TYPE_FLAG_UNSIGNED,
3044                "__bfd_vma", (struct objfile *) NULL);
3045 }
3046
3047
3048 extern void _initialize_gdbtypes PARAMS ((void));
3049 void
3050 _initialize_gdbtypes ()
3051 {
3052   struct cmd_list_element *c;
3053   build_gdbtypes ();
3054
3055   /* FIXME - For the moment, handle types by swapping them in and out.
3056      Should be using the per-architecture data-pointer and a large
3057      struct. */
3058   register_gdbarch_swap (&builtin_type_void, sizeof (struct type *), NULL);
3059   register_gdbarch_swap (&builtin_type_char, sizeof (struct type *), NULL);
3060   register_gdbarch_swap (&builtin_type_short, sizeof (struct type *), NULL);
3061   register_gdbarch_swap (&builtin_type_int, sizeof (struct type *), NULL);
3062   register_gdbarch_swap (&builtin_type_long, sizeof (struct type *), NULL);
3063   register_gdbarch_swap (&builtin_type_long_long, sizeof (struct type *), NULL);
3064   register_gdbarch_swap (&builtin_type_signed_char, sizeof (struct type *), NULL);
3065   register_gdbarch_swap (&builtin_type_unsigned_char, sizeof (struct type *), NULL);
3066   register_gdbarch_swap (&builtin_type_unsigned_short, sizeof (struct type *), NULL);
3067   register_gdbarch_swap (&builtin_type_unsigned_int, sizeof (struct type *), NULL);
3068   register_gdbarch_swap (&builtin_type_unsigned_long, sizeof (struct type *), NULL);
3069   register_gdbarch_swap (&builtin_type_unsigned_long_long, sizeof (struct type *), NULL);
3070   register_gdbarch_swap (&builtin_type_float, sizeof (struct type *), NULL);
3071   register_gdbarch_swap (&builtin_type_double, sizeof (struct type *), NULL);
3072   register_gdbarch_swap (&builtin_type_long_double, sizeof (struct type *), NULL);
3073   register_gdbarch_swap (&builtin_type_complex, sizeof (struct type *), NULL);
3074   register_gdbarch_swap (&builtin_type_double_complex, sizeof (struct type *), NULL);
3075   register_gdbarch_swap (&builtin_type_string, sizeof (struct type *), NULL);
3076   register_gdbarch_swap (&builtin_type_int8, sizeof (struct type *), NULL);
3077   register_gdbarch_swap (&builtin_type_uint8, sizeof (struct type *), NULL);
3078   register_gdbarch_swap (&builtin_type_int16, sizeof (struct type *), NULL);
3079   register_gdbarch_swap (&builtin_type_uint16, sizeof (struct type *), NULL);
3080   register_gdbarch_swap (&builtin_type_int32, sizeof (struct type *), NULL);
3081   register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL);
3082   register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL);
3083   register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL);
3084   register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL);
3085   register_gdbarch_swap (&builtin_type_v4si, sizeof (struct type *), NULL);
3086   register_gdbarch_swap (&builtin_type_v8qi, sizeof (struct type *), NULL);
3087   register_gdbarch_swap (&builtin_type_v4hi, sizeof (struct type *), NULL);
3088   register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL);
3089   REGISTER_GDBARCH_SWAP (builtin_type_ptr);
3090   REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
3091   REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
3092   register_gdbarch_swap (NULL, 0, build_gdbtypes);
3093
3094   add_show_from_set (
3095                      add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
3096                                   "Set debugging of C++ overloading.\n\
3097                           When enabled, ranking of the functions\n\
3098                           is displayed.", &setdebuglist),
3099                      &showdebuglist);
3100 }