gdb/gdbtypes.c

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