gdb/gdbtypes.c

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