gdb/gdbtypes.c

   1 /* Support routines for manipulating internal types for GDB.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include <string.h>
  23 #include "bfd.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "language.h"
  30 #include "target.h"
  31 #include "value.h"
  32 #include "demangle.h"
  33
  34 /* Alloc a new type structure and fill it with some defaults.  If
  35    OBJFILE is non-NULL, then allocate the space for the type structure
  36    in that objfile's type_obstack. */
  37
  38 struct type *
  39 alloc_type (objfile)
  40      struct objfile *objfile;
  41 {
  42   register struct type *type;
  43
  44   /* Alloc the structure and start off with all fields zeroed. */
  45
  46   if (objfile == NULL)
  47     {
  48       type  = (struct type *) xmalloc (sizeof (struct type));
  49     }
  50   else
  51     {
  52       type  = (struct type *) obstack_alloc (&objfile -> type_obstack,
  53                                              sizeof (struct type));
  54     }
  55   memset ((char *)type, 0, sizeof (struct type));
  56
  57   /* Initialize the fields that might not be zero. */
  58
  59   TYPE_CODE (type) = TYPE_CODE_UNDEF;
  60   TYPE_OBJFILE (type) = objfile;
  61   TYPE_VPTR_FIELDNO (type) = -1;
  62
  63   return (type);
  64 }
  65
  66 /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
  67    to a pointer to memory where the pointer type should be stored.
  68    If *TYPEPTR is zero, update it to point to the pointer type we return.
  69    We allocate new memory if needed.  */
  70
  71 struct type *
  72 make_pointer_type (type, typeptr)
  73      struct type *type;
  74      struct type **typeptr;
  75 {
  76   register struct type *ntype;          /* New type */
  77   struct objfile *objfile;
  78
  79   ntype = TYPE_POINTER_TYPE (type);
  80
  81   if (ntype)
  82     if (typeptr == 0)
  83       return ntype;     /* Don't care about alloc, and have new type.  */
  84     else if (*typeptr == 0)
  85       {
  86         *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
  87         return ntype;
  88       }
  89
  90   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
  91     {
  92       ntype = alloc_type (TYPE_OBJFILE (type));
  93       if (typeptr)
  94         *typeptr = ntype;
  95     }
  96   else                          /* We have storage, but need to reset it.  */
  97     {
  98       ntype = *typeptr;
  99       objfile = TYPE_OBJFILE (ntype);
 100       memset ((char *)ntype, 0, sizeof (struct type));
 101       TYPE_OBJFILE (ntype) = objfile;
 102     }
 103
 104   TYPE_TARGET_TYPE (ntype) = type;
 105   TYPE_POINTER_TYPE (type) = ntype;
 106
 107   /* FIXME!  Assume the machine has only one representation for pointers!  */
 108
 109   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 110   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 111
 112   /* pointers are unsigned */
 113   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 114
 115   if (!TYPE_POINTER_TYPE (type))        /* Remember it, if don't have one.  */
 116     TYPE_POINTER_TYPE (type) = ntype;
 117
 118   return ntype;
 119 }
 120
 121 /* Given a type TYPE, return a type of pointers to that type.
 122    May need to construct such a type if this is the first use.  */
 123
 124 struct type *
 125 lookup_pointer_type (type)
 126      struct type *type;
 127 {
 128   return make_pointer_type (type, (struct type **)0);
 129 }
 130
 131 /* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
 132    to a pointer to memory where the reference type should be stored.
 133    If *TYPEPTR is zero, update it to point to the reference type we return.
 134    We allocate new memory if needed.  */
 135
 136 struct type *
 137 make_reference_type (type, typeptr)
 138      struct type *type;
 139      struct type **typeptr;
 140 {
 141   register struct type *ntype;          /* New type */
 142   struct objfile *objfile;
 143
 144   ntype = TYPE_REFERENCE_TYPE (type);
 145
 146   if (ntype)
 147     if (typeptr == 0)
 148       return ntype;     /* Don't care about alloc, and have new type.  */
 149     else if (*typeptr == 0)
 150       {
 151         *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
 152         return ntype;
 153       }
 154
 155   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 156     {
 157       ntype = alloc_type (TYPE_OBJFILE (type));
 158       if (typeptr)
 159         *typeptr = ntype;
 160     }
 161   else                          /* We have storage, but need to reset it.  */
 162     {
 163       ntype = *typeptr;
 164       objfile = TYPE_OBJFILE (ntype);
 165       memset ((char *)ntype, 0, sizeof (struct type));
 166       TYPE_OBJFILE (ntype) = objfile;
 167     }
 168
 169   TYPE_TARGET_TYPE (ntype) = type;
 170   TYPE_REFERENCE_TYPE (type) = ntype;
 171
 172   /* FIXME!  Assume the machine has only one representation for references,
 173      and that it matches the (only) representation for pointers!  */
 174
 175   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
 176   TYPE_CODE (ntype) = TYPE_CODE_REF;
 177
 178   if (!TYPE_REFERENCE_TYPE (type))      /* Remember it, if don't have one.  */
 179     TYPE_REFERENCE_TYPE (type) = ntype;
 180
 181   return ntype;
 182 }
 183
 184 /* Same as above, but caller doesn't care about memory allocation details.  */
 185
 186 struct type *
 187 lookup_reference_type (type)
 188      struct type *type;
 189 {
 190   return make_reference_type (type, (struct type **)0);
 191 }
 192
 193 /* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
 194    to a pointer to memory where the function type should be stored.
 195    If *TYPEPTR is zero, update it to point to the function type we return.
 196    We allocate new memory if needed.  */
 197
 198 struct type *
 199 make_function_type (type, typeptr)
 200      struct type *type;
 201      struct type **typeptr;
 202 {
 203   register struct type *ntype;          /* New type */
 204   struct objfile *objfile;
 205
 206   ntype = TYPE_FUNCTION_TYPE (type);
 207
 208   if (ntype)
 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   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
 218     {
 219       ntype = alloc_type (TYPE_OBJFILE (type));
 220       if (typeptr)
 221         *typeptr = ntype;
 222     }
 223   else                          /* We have storage, but need to reset it.  */
 224     {
 225       ntype = *typeptr;
 226       objfile = TYPE_OBJFILE (ntype);
 227       memset ((char *)ntype, 0, sizeof (struct type));
 228       TYPE_OBJFILE (ntype) = objfile;
 229     }
 230
 231   TYPE_TARGET_TYPE (ntype) = type;
 232   TYPE_FUNCTION_TYPE (type) = ntype;
 233
 234   TYPE_LENGTH (ntype) = 1;
 235   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
 236
 237   if (!TYPE_FUNCTION_TYPE (type))       /* Remember it, if don't have one.  */
 238     TYPE_FUNCTION_TYPE (type) = ntype;
 239
 240   return ntype;
 241 }
 242
 243
 244 /* Given a type TYPE, return a type of functions that return that type.
 245    May need to construct such a type if this is the first use.  */
 246
 247 struct type *
 248 lookup_function_type (type)
 249      struct type *type;
 250 {
 251   return make_function_type (type, (struct type **)0);
 252 }
 253
 254 /* Implement direct support for MEMBER_TYPE in GNU C++.
 255    May need to construct such a type if this is the first use.
 256    The TYPE is the type of the member.  The DOMAIN is the type
 257    of the aggregate that the member belongs to.  */
 258
 259 struct type *
 260 lookup_member_type (type, domain)
 261      struct type *type;
 262      struct type *domain;
 263 {
 264   register struct type *mtype;
 265
 266   mtype = alloc_type (TYPE_OBJFILE (type));
 267   smash_to_member_type (mtype, domain, type);
 268   return (mtype);
 269 }
 270
 271 /* Allocate a stub method whose return type is TYPE.
 272    This apparently happens for speed of symbol reading, since parsing
 273    out the arguments to the method is cpu-intensive, the way we are doing
 274    it.  So, we will fill in arguments later.
 275    This always returns a fresh type.   */
 276
 277 struct type *
 278 allocate_stub_method (type)
 279      struct type *type;
 280 {
 281   struct type *mtype;
 282
 283   mtype = alloc_type (TYPE_OBJFILE (type));
 284   TYPE_TARGET_TYPE (mtype) = type;
 285   /*  _DOMAIN_TYPE (mtype) = unknown yet */
 286   /*  _ARG_TYPES (mtype) = unknown yet */
 287   TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
 288   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
 289   TYPE_LENGTH (mtype) = 1;
 290   return (mtype);
 291 }
 292
 293 /* Create an array type.  Elements will be of type TYPE, and there will
 294    be NUM of them.
 295
 296    Eventually this should be extended to take two more arguments which
 297    specify the bounds of the array and the type of the index.
 298    It should also be changed to be a "lookup" function, with the
 299    appropriate data structures added to the type field.
 300    Then read array type should call here.  */
 301
 302 struct type *
 303 create_array_type (element_type, number)
 304      struct type *element_type;
 305      int number;
 306 {
 307   struct type *result_type;
 308   struct type *range_type;
 309
 310   result_type = alloc_type (TYPE_OBJFILE (element_type));
 311
 312   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
 313   TYPE_TARGET_TYPE (result_type) = element_type;
 314   TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type);
 315   TYPE_NFIELDS (result_type) = 1;
 316   TYPE_FIELDS (result_type) = (struct field *)
 317     obstack_alloc (&TYPE_OBJFILE (result_type) -> type_obstack,
 318                    sizeof (struct field));
 319
 320   {
 321     /* Create range type.  */
 322     range_type = alloc_type (TYPE_OBJFILE (result_type));
 323     TYPE_CODE (range_type) = TYPE_CODE_RANGE;
 324     TYPE_TARGET_TYPE (range_type) = builtin_type_int;  /* FIXME */
 325
 326     /* This should never be needed.  */
 327     TYPE_LENGTH (range_type) = sizeof (int);
 328
 329     TYPE_NFIELDS (range_type) = 2;
 330     TYPE_FIELDS (range_type) = (struct field *)
 331       obstack_alloc (&TYPE_OBJFILE (range_type) -> type_obstack,
 332                      2 * sizeof (struct field));
 333     TYPE_FIELD_BITPOS (range_type, 0) = 0; /* FIXME */
 334     TYPE_FIELD_BITPOS (range_type, 1) = number-1; /* FIXME */
 335     TYPE_FIELD_TYPE (range_type, 0) = builtin_type_int; /* FIXME */
 336     TYPE_FIELD_TYPE (range_type, 1) = builtin_type_int; /* FIXME */
 337   }
 338   TYPE_FIELD_TYPE (result_type, 0) = range_type;
 339   TYPE_VPTR_FIELDNO (result_type) = -1;
 340
 341   return (result_type);
 342 }
 343
 344
 345 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
 346    A MEMBER is a wierd thing -- it amounts to a typed offset into
 347    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
 348    include the offset (that's the value of the MEMBER itself), but does
 349    include the structure type into which it points (for some reason).
 350
 351    When "smashing" the type, we preserve the objfile that the
 352    old type pointed to, since we aren't changing where the type is actually
 353    allocated.  */
 354
 355 void
 356 smash_to_member_type (type, domain, to_type)
 357      struct type *type;
 358      struct type *domain;
 359      struct type *to_type;
 360 {
 361   struct objfile *objfile;
 362
 363   objfile = TYPE_OBJFILE (type);
 364
 365   memset ((char *)type, 0, sizeof (struct type));
 366   TYPE_OBJFILE (type) = objfile;
 367   TYPE_TARGET_TYPE (type) = to_type;
 368   TYPE_DOMAIN_TYPE (type) = domain;
 369   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 370   TYPE_CODE (type) = TYPE_CODE_MEMBER;
 371 }
 372
 373 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
 374    METHOD just means `function that gets an extra "this" argument'.
 375
 376    When "smashing" the type, we preserve the objfile that the
 377    old type pointed to, since we aren't changing where the type is actually
 378    allocated.  */
 379
 380 void
 381 smash_to_method_type (type, domain, to_type, args)
 382      struct type *type;
 383      struct type *domain;
 384      struct type *to_type;
 385      struct type **args;
 386 {
 387   struct objfile *objfile;
 388
 389   objfile = TYPE_OBJFILE (type);
 390
 391   memset ((char *)type, 0, sizeof (struct type));
 392   TYPE_OBJFILE (type) = objfile;
 393   TYPE_TARGET_TYPE (type) = to_type;
 394   TYPE_DOMAIN_TYPE (type) = domain;
 395   TYPE_ARG_TYPES (type) = args;
 396   TYPE_LENGTH (type) = 1;       /* In practice, this is never needed.  */
 397   TYPE_CODE (type) = TYPE_CODE_METHOD;
 398 }
 399
 400 /* Return a typename for a struct/union/enum type
 401    without the tag qualifier.  If the type has a NULL name,
 402    NULL is returned.  */
 403
 404 char *
 405 type_name_no_tag (type)
 406      register const struct type *type;
 407 {
 408   register char *name;
 409
 410   if ((name = TYPE_NAME (type)) != NULL)
 411     {
 412       switch (TYPE_CODE (type))
 413         {
 414           case TYPE_CODE_STRUCT:
 415             if(!strncmp (name, "struct ", 7))
 416               {
 417                 name += 7;
 418               }
 419             break;
 420           case TYPE_CODE_UNION:
 421             if(!strncmp (name, "union ", 6))
 422               {
 423                 name += 6;
 424               }
 425             break;
 426           case TYPE_CODE_ENUM:
 427             if(!strncmp (name, "enum ", 5))
 428               {
 429                 name += 5;
 430               }
 431             break;
 432           default:              /* To avoid -Wall warnings */
 433             break;
 434         }
 435     }
 436   return (name);
 437 }
 438
 439 /* Lookup a primitive type named NAME.
 440    Return zero if NAME is not a primitive type.*/
 441
 442 struct type *
 443 lookup_primitive_typename (name)
 444      char *name;
 445 {
 446    struct type ** const *p;
 447
 448    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
 449      {
 450        if (!strcmp ((**p) -> name, name))
 451          {
 452            return (**p);
 453          }
 454      }
 455    return (NULL);
 456 }
 457
 458 /* Lookup a typedef or primitive type named NAME,
 459    visible in lexical block BLOCK.
 460    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 461
 462 struct type *
 463 lookup_typename (name, block, noerr)
 464      char *name;
 465      struct block *block;
 466      int noerr;
 467 {
 468   register struct symbol *sym;
 469   register struct type *tmp;
 470
 471   sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
 472   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 473     {
 474       tmp = lookup_primitive_typename (name);
 475       if (tmp)
 476         {
 477           return (tmp);
 478         }
 479       else if (!tmp && noerr)
 480         {
 481           return (NULL);
 482         }
 483       else
 484         {
 485           error ("No type named %s.", name);
 486         }
 487     }
 488   return (SYMBOL_TYPE (sym));
 489 }
 490
 491 struct type *
 492 lookup_unsigned_typename (name)
 493      char *name;
 494 {
 495   char *uns = alloca (strlen (name) + 10);
 496
 497   strcpy (uns, "unsigned ");
 498   strcpy (uns + 9, name);
 499   return (lookup_typename (uns, (struct block *) NULL, 0));
 500 }
 501
 502 /* Lookup a structure type named "struct NAME",
 503    visible in lexical block BLOCK.  */
 504
 505 struct type *
 506 lookup_struct (name, block)
 507      char *name;
 508      struct block *block;
 509 {
 510   register struct symbol *sym;
 511
 512   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 513                        (struct symtab **) NULL);
 514
 515   if (sym == NULL)
 516     {
 517       error ("No struct type named %s.", name);
 518     }
 519   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 520     {
 521       error ("This context has class, union or enum %s, not a struct.", name);
 522     }
 523   return (SYMBOL_TYPE (sym));
 524 }
 525
 526 /* Lookup a union type named "union NAME",
 527    visible in lexical block BLOCK.  */
 528
 529 struct type *
 530 lookup_union (name, block)
 531      char *name;
 532      struct block *block;
 533 {
 534   register struct symbol *sym;
 535
 536   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 537                        (struct symtab **) NULL);
 538
 539   if (sym == NULL)
 540     {
 541       error ("No union type named %s.", name);
 542     }
 543   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
 544     {
 545       error ("This context has class, struct or enum %s, not a union.", name);
 546     }
 547   return (SYMBOL_TYPE (sym));
 548 }
 549
 550 /* Lookup an enum type named "enum NAME",
 551    visible in lexical block BLOCK.  */
 552
 553 struct type *
 554 lookup_enum (name, block)
 555      char *name;
 556      struct block *block;
 557 {
 558   register struct symbol *sym;
 559
 560   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
 561                        (struct symtab **) NULL);
 562   if (sym == NULL)
 563     {
 564       error ("No enum type named %s.", name);
 565     }
 566   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
 567     {
 568       error ("This context has class, struct or union %s, not an enum.", name);
 569     }
 570   return (SYMBOL_TYPE (sym));
 571 }
 572
 573 /* Lookup a template type named "template NAME<TYPE>",
 574    visible in lexical block BLOCK.  */
 575
 576 struct type *
 577 lookup_template_type (name, type, block)
 578      char *name;
 579      struct type *type;
 580      struct block *block;
 581 {
 582   struct symbol *sym;
 583   char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
 584   strcpy (nam, name);
 585   strcat (nam, "<");
 586   strcat (nam, type->name);
 587   strcat (nam, " >");   /* FIXME, extra space still introduced in gcc? */
 588
 589   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
 590
 591   if (sym == NULL)
 592     {
 593       error ("No template type named %s.", name);
 594     }
 595   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 596     {
 597       error ("This context has class, union or enum %s, not a struct.", name);
 598     }
 599   return (SYMBOL_TYPE (sym));
 600 }
 601
 602 /* Given a type TYPE, lookup the type of the component of type named
 603    NAME.
 604    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 605
 606 struct type *
 607 lookup_struct_elt_type (type, name, noerr)
 608      struct type *type;
 609      char *name;
 610     int noerr;
 611 {
 612   int i;
 613
 614   if (TYPE_CODE (type) == TYPE_CODE_PTR ||
 615       TYPE_CODE (type) == TYPE_CODE_REF)
 616       type = TYPE_TARGET_TYPE (type);
 617
 618   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
 619       TYPE_CODE (type) != TYPE_CODE_UNION)
 620     {
 621       target_terminal_ours ();
 622       fflush (stdout);
 623       fprintf (stderr, "Type ");
 624       type_print (type, "", stderr, -1);
 625       error (" is not a structure or union type.");
 626     }
 627
 628   check_stub_type (type);
 629
 630   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 631     {
 632       char *t_field_name = TYPE_FIELD_NAME (type, i);
 633
 634       if (t_field_name && !strcmp (t_field_name, name))
 635         {
 636           return TYPE_FIELD_TYPE (type, i);
 637         }
 638     }
 639
 640   /* OK, it's not in this class.  Recursively check the baseclasses.  */
 641   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
 642     {
 643       struct type *t;
 644
 645       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 0);
 646       if (t != NULL)
 647         {
 648           return t;
 649         }
 650     }
 651
 652   if (noerr)
 653     {
 654       return NULL;
 655     }
 656
 657   target_terminal_ours ();
 658   fflush (stdout);
 659   fprintf (stderr, "Type ");
 660   type_print (type, "", stderr, -1);
 661   fprintf (stderr, " has no component named ");
 662   fputs_filtered (name, stderr);
 663   error (".");
 664   return (struct type *)-1;     /* For lint */
 665 }
 666
 667 /* This function is really horrible, but to avoid it, there would need
 668    to be more filling in of forward references.  */
 669
 670 void
 671 fill_in_vptr_fieldno (type)
 672      struct type *type;
 673 {
 674   if (TYPE_VPTR_FIELDNO (type) < 0)
 675     {
 676       int i;
 677       for (i = 1; i < TYPE_N_BASECLASSES (type); i++)
 678         {
 679           fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
 680           if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
 681             {
 682               TYPE_VPTR_FIELDNO (type)
 683                 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
 684               TYPE_VPTR_BASETYPE (type)
 685                 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
 686               break;
 687             }
 688         }
 689     }
 690 }
 691
 692 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
 693
 694    If this is a stubbed struct (i.e. declared as struct foo *), see if
 695    we can find a full definition in some other file. If so, copy this
 696    definition, so we can use it in future.  If not, set a flag so we
 697    don't waste too much time in future.  (FIXME, this doesn't seem
 698    to be happening...)
 699
 700    This used to be coded as a macro, but I don't think it is called
 701    often enough to merit such treatment.
 702 */
 703
 704 struct complaint stub_noname_complaint =
 705   {"stub type has NULL name", 0, 0};
 706
 707 void
 708 check_stub_type (type)
 709      struct type *type;
 710 {
 711   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
 712     {
 713       char* name = type_name_no_tag (type);
 714       struct symbol *sym;
 715       if (name == NULL)
 716         {
 717           complain (&stub_noname_complaint, 0);
 718           return;
 719         }
 720       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
 721                            (struct symtab **) NULL);
 722       if (sym)
 723         {
 724           memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type));
 725         }
 726     }
 727 }
 728
 729 /* Ugly hack to convert method stubs into method types.
 730
 731    He ain't kiddin'.  This demangles the name of the method into a string
 732    including argument types, parses out each argument type, generates
 733    a string casting a zero to that type, evaluates the string, and stuffs
 734    the resulting type into an argtype vector!!!  Then it knows the type
 735    of the whole function (including argument types for overloading),
 736    which info used to be in the stab's but was removed to hack back
 737    the space required for them.  */
 738
 739 void
 740 check_stub_method (type, i, j)
 741      struct type *type;
 742      int i;
 743      int j;
 744 {
 745   struct fn_field *f;
 746   char *mangled_name = gdb_mangle_name (type, i, j);
 747   char *demangled_name = cplus_demangle (mangled_name,
 748                                          DMGL_PARAMS | DMGL_ANSI);
 749   char *argtypetext, *p;
 750   int depth = 0, argcount = 1;
 751   struct type **argtypes;
 752   struct type *mtype;
 753
 754   if (demangled_name == NULL)
 755     {
 756       error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
 757     }
 758
 759   /* Now, read in the parameters that define this type.  */
 760   argtypetext = strchr (demangled_name, '(') + 1;
 761   p = argtypetext;
 762   while (*p)
 763     {
 764       if (*p == '(')
 765         {
 766           depth += 1;
 767         }
 768       else if (*p == ')')
 769         {
 770           depth -= 1;
 771         }
 772       else if (*p == ',' && depth == 0)
 773         {
 774           argcount += 1;
 775         }
 776
 777       p += 1;
 778     }
 779
 780   /* We need two more slots: one for the THIS pointer, and one for the
 781      NULL [...] or void [end of arglist].  */
 782
 783   argtypes = (struct type **)
 784     obstack_alloc (&TYPE_OBJFILE (type) -> type_obstack,
 785                    (argcount+2) * sizeof (struct type *));
 786   p = argtypetext;
 787   argtypes[0] = lookup_pointer_type (type);
 788   argcount = 1;
 789
 790   if (*p != ')')                        /* () means no args, skip while */
 791     {
 792       depth = 0;
 793       while (*p)
 794         {
 795           if (depth <= 0 && (*p == ',' || *p == ')'))
 796             {
 797               argtypes[argcount] =
 798                   parse_and_eval_type (argtypetext, p - argtypetext);
 799               argcount += 1;
 800               argtypetext = p + 1;
 801             }
 802
 803           if (*p == '(')
 804             {
 805               depth += 1;
 806             }
 807           else if (*p == ')')
 808             {
 809               depth -= 1;
 810             }
 811
 812           p += 1;
 813         }
 814     }
 815
 816   if (p[-2] != '.')                     /* ... */
 817     {
 818       argtypes[argcount] = builtin_type_void;   /* Ellist terminator */
 819     }
 820   else
 821     {
 822       argtypes[argcount] = NULL;                /* List terminator */
 823     }
 824
 825   free (demangled_name);
 826
 827   f = TYPE_FN_FIELDLIST1 (type, i);
 828   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
 829
 830   /* Now update the old "stub" type into a real type.  */
 831   mtype = TYPE_FN_FIELD_TYPE (f, j);
 832   TYPE_DOMAIN_TYPE (mtype) = type;
 833   TYPE_ARG_TYPES (mtype) = argtypes;
 834   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
 835   TYPE_FN_FIELD_STUB (f, j) = 0;
 836 }
 837
 838 const struct cplus_struct_type cplus_struct_default;
 839
 840 void
 841 allocate_cplus_struct_type (type)
 842      struct type *type;
 843 {
 844   if (!HAVE_CPLUS_STRUCT (type))
 845     {
 846       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
 847         obstack_alloc (&current_objfile -> type_obstack,
 848                        sizeof (struct cplus_struct_type));
 849       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
 850     }
 851 }
 852
 853 /* Helper function to initialize the standard scalar types.
 854
 855    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
 856    of the string pointed to by name in the type_obstack for that objfile,
 857    and initialize the type name to that copy.  There are places (mipsread.c
 858    in particular, where init_type is called with a NULL value for NAME). */
 859
 860 struct type *
 861 init_type (code, length, flags, name, objfile)
 862      enum type_code code;
 863      int length;
 864      int flags;
 865      char *name;
 866      struct objfile *objfile;
 867 {
 868   register struct type *type;
 869
 870   type = alloc_type (objfile);
 871   TYPE_CODE (type) = code;
 872   TYPE_LENGTH (type) = length;
 873   TYPE_FLAGS (type) |= flags;
 874   if ((name != NULL) && (objfile != NULL))
 875     {
 876       TYPE_NAME (type) =
 877         obsavestring (name, strlen (name), &objfile -> type_obstack);
 878     }
 879   else
 880     {
 881       TYPE_NAME (type) = name;
 882     }
 883
 884   /* C++ fancies.  */
 885
 886   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 887     {
 888       INIT_CPLUS_SPECIFIC (type);
 889     }
 890   return (type);
 891 }
 892
 893 /* Look up a fundamental type for the specified objfile.
 894    May need to construct such a type if this is the first use.
 895
 896    Some object file formats (ELF, COFF, etc) do not define fundamental
 897    types such as "int" or "double".  Others (stabs for example), do
 898    define fundamental types.
 899
 900    For the formats which don't provide fundamental types, gdb can create
 901    such types, using defaults reasonable for the current target machine.
 902
 903    FIXME:  Some compilers distinguish explicitly signed integral types
 904    (signed short, signed int, signed long) from "regular" integral types
 905    (short, int, long) in the debugging information.  There is some dis-
 906    agreement as to how useful this feature is.  In particular, gcc does
 907    not support this.  Also, only some debugging formats allow the
 908    distinction to be passed on to a debugger.  For now, we always just
 909    use "short", "int", or "long" as the type name, for both the implicit
 910    and explicitly signed types.  This also makes life easier for the
 911    gdb test suite since we don't have to account for the differences
 912    in output depending upon what the compiler and debugging format
 913    support.  We will probably have to re-examine the issue when gdb
 914    starts taking it's fundamental type information directly from the
 915    debugging information supplied by the compiler.  [email protected] */
 916
 917 struct type *
 918 lookup_fundamental_type (objfile, typeid)
 919      struct objfile *objfile;
 920      int typeid;
 921 {
 922   register struct type *type = NULL;
 923   register struct type **typep;
 924   register int nbytes;
 925
 926   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
 927     {
 928       error ("internal error - invalid fundamental type id %d", typeid);
 929     }
 930   else
 931     {
 932       /* If this is the first time we */
 933       if (objfile -> fundamental_types == NULL)
 934         {
 935           nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
 936           objfile -> fundamental_types = (struct type **)
 937             obstack_alloc (&objfile -> type_obstack, nbytes);
 938           memset ((char *)objfile -> fundamental_types, 0, nbytes);
 939         }
 940       typep = objfile -> fundamental_types + typeid;
 941       if ((type = *typep) == NULL)
 942         {
 943           switch (typeid)
 944             {
 945               default:
 946                 error ("internal error: unhandled type id %d", typeid);
 947                 break;
 948               case FT_VOID:
 949                 type = init_type (TYPE_CODE_VOID,
 950                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 951                                   0,
 952                                   "void", objfile);
 953                 break;
 954               case FT_BOOLEAN:
 955                 type = init_type (TYPE_CODE_INT,
 956                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 957                                   TYPE_FLAG_UNSIGNED,
 958                                   "boolean", objfile);
 959                 break;
 960               case FT_STRING:
 961                 type = init_type (TYPE_CODE_PASCAL_ARRAY,
 962                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 963                                   0,
 964                                   "string", objfile);
 965                 break;
 966               case FT_CHAR:
 967                 type = init_type (TYPE_CODE_INT,
 968                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 969                                   0,
 970                                   "char", objfile);
 971                 break;
 972               case FT_SIGNED_CHAR:
 973                 type = init_type (TYPE_CODE_INT,
 974                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 975                                   TYPE_FLAG_SIGNED,
 976                                   "signed char", objfile);
 977                 break;
 978               case FT_UNSIGNED_CHAR:
 979                 type = init_type (TYPE_CODE_INT,
 980                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 981                                   TYPE_FLAG_UNSIGNED,
 982                                   "unsigned char", objfile);
 983                 break;
 984               case FT_SHORT:
 985                 type = init_type (TYPE_CODE_INT,
 986                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 987                                   0,
 988                                   "short", objfile);
 989                 break;
 990               case FT_SIGNED_SHORT:
 991                 type = init_type (TYPE_CODE_INT,
 992                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 993                                   TYPE_FLAG_SIGNED,
 994                                   "short", objfile);    /* FIXME -fnf */
 995                 break;
 996               case FT_UNSIGNED_SHORT:
 997                 type = init_type (TYPE_CODE_INT,
 998                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 999                                   TYPE_FLAG_UNSIGNED,
1000                                   "unsigned short", objfile);
1001                 break;
1002               case FT_INTEGER:
1003                 type = init_type (TYPE_CODE_INT,
1004                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1005                                   0,
1006                                   "int", objfile);
1007                 break;
1008               case FT_SIGNED_INTEGER:
1009                 type = init_type (TYPE_CODE_INT,
1010                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1011                                   TYPE_FLAG_SIGNED,
1012                                   "int", objfile);      /* FIXME -fnf */
1013                 break;
1014               case FT_UNSIGNED_INTEGER:
1015                 type = init_type (TYPE_CODE_INT,
1016                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1017                                   TYPE_FLAG_UNSIGNED,
1018                                   "unsigned int", objfile);
1019                 break;
1020               case FT_FIXED_DECIMAL:
1021                 type = init_type (TYPE_CODE_INT,
1022                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1023                                   0,
1024                                   "fixed decimal", objfile);
1025                 break;
1026               case FT_LONG:
1027                 type = init_type (TYPE_CODE_INT,
1028                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1029                                   0,
1030                                   "long", objfile);
1031                 break;
1032               case FT_SIGNED_LONG:
1033                 type = init_type (TYPE_CODE_INT,
1034                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1035                                   TYPE_FLAG_SIGNED,
1036                                   "long", objfile);     /* FIXME -fnf */
1037                 break;
1038               case FT_UNSIGNED_LONG:
1039                 type = init_type (TYPE_CODE_INT,
1040                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1041                                   TYPE_FLAG_UNSIGNED,
1042                                   "unsigned long", objfile);
1043                 break;
1044               case FT_LONG_LONG:
1045                 type = init_type (TYPE_CODE_INT,
1046                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1047                                   0,
1048                                   "long long", objfile);
1049                 break;
1050               case FT_SIGNED_LONG_LONG:
1051                 type = init_type (TYPE_CODE_INT,
1052                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1053                                   TYPE_FLAG_SIGNED,
1054                                   "signed long long", objfile);
1055                 break;
1056               case FT_UNSIGNED_LONG_LONG:
1057                 type = init_type (TYPE_CODE_INT,
1058                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1059                                   TYPE_FLAG_UNSIGNED,
1060                                   "unsigned long long", objfile);
1061                 break;
1062               case FT_FLOAT:
1063                 type = init_type (TYPE_CODE_FLT,
1064                                   TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1065                                   0,
1066                                   "float", objfile);
1067                 break;
1068               case FT_DBL_PREC_FLOAT:
1069                 type = init_type (TYPE_CODE_FLT,
1070                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1071                                   0,
1072                                   "double", objfile);
1073                 break;
1074               case FT_FLOAT_DECIMAL:
1075                 type = init_type (TYPE_CODE_FLT,
1076                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1077                                   0,
1078                                   "floating decimal", objfile);
1079                 break;
1080               case FT_EXT_PREC_FLOAT:
1081                 type = init_type (TYPE_CODE_FLT,
1082                                   TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1083                                   0,
1084                                   "long double", objfile);
1085                 break;
1086               case FT_COMPLEX:
1087                 type = init_type (TYPE_CODE_FLT,
1088                                   TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1089                                   0,
1090                                   "complex", objfile);
1091                 break;
1092               case FT_DBL_PREC_COMPLEX:
1093                 type = init_type (TYPE_CODE_FLT,
1094                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1095                                   0,
1096                                   "double complex", objfile);
1097                 break;
1098               case FT_EXT_PREC_COMPLEX:
1099                 type = init_type (TYPE_CODE_FLT,
1100                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1101                                   0,
1102                                   "long double complex", objfile);
1103                 break;
1104             }
1105           /* Install the newly created type in the objfile's fundamental_types
1106              vector. */
1107           *typep = type;
1108         }
1109     }
1110   return (type);
1111 }
1112
1113 #if MAINTENANCE_CMDS
1114
1115 static void
1116 print_bit_vector (bits, nbits)
1117      B_TYPE *bits;
1118      int nbits;
1119 {
1120   int bitno;
1121
1122   for (bitno = 0; bitno < nbits; bitno++)
1123     {
1124       if ((bitno % 8) == 0)
1125         {
1126           puts_filtered (" ");
1127         }
1128       if (B_TST (bits, bitno))
1129         {
1130           printf_filtered ("1");
1131         }
1132       else
1133         {
1134           printf_filtered ("0");
1135         }
1136     }
1137 }
1138
1139 static void
1140 print_cplus_stuff (type, spaces)
1141      struct type *type;
1142      int spaces;
1143 {
1144   int bitno;
1145
1146   printfi_filtered (spaces, "cplus_stuff: @ 0x%x\n",
1147                     TYPE_CPLUS_SPECIFIC (type));
1148   printfi_filtered (spaces, "n_baseclasses: %d\n",
1149                     TYPE_N_BASECLASSES (type));
1150   if (TYPE_N_BASECLASSES (type) > 0)
1151     {
1152       printfi_filtered (spaces, "virtual_field_bits: %d @ 0x%x:",
1153                         TYPE_N_BASECLASSES (type),
1154                         TYPE_FIELD_VIRTUAL_BITS (type));
1155       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
1156                         TYPE_N_BASECLASSES (type));
1157       puts_filtered ("\n");
1158     }
1159   if (TYPE_NFIELDS (type) > 0)
1160     {
1161       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
1162         {
1163           printfi_filtered (spaces, "private_field_bits: %d @ 0x%x:",
1164                             TYPE_NFIELDS (type),
1165                             TYPE_FIELD_PRIVATE_BITS (type));
1166           print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
1167                             TYPE_NFIELDS (type));
1168           puts_filtered ("\n");
1169         }
1170       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
1171         {
1172           printfi_filtered (spaces, "protected_field_bits: %d @ 0x%x:",
1173                             TYPE_NFIELDS (type),
1174                             TYPE_FIELD_PROTECTED_BITS (type));
1175           print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
1176                             TYPE_NFIELDS (type));
1177           puts_filtered ("\n");
1178         }
1179     }
1180 }
1181
1182 void
1183 recursive_dump_type (type, spaces)
1184      struct type *type;
1185      int spaces;
1186 {
1187   int idx;
1188
1189   printfi_filtered (spaces, "type node @ 0x%x\n", type);
1190   printfi_filtered (spaces, "name: @ 0x%x '%s'\n", TYPE_NAME (type),
1191                     TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
1192   printfi_filtered (spaces, "code: 0x%x ", TYPE_CODE (type));
1193   switch (TYPE_CODE (type))
1194     {
1195       case TYPE_CODE_UNDEF:
1196         printf_filtered ("TYPE_CODE_UNDEF");
1197         break;
1198       case TYPE_CODE_PTR:
1199         printf_filtered ("TYPE_CODE_PTR");
1200         break;
1201       case TYPE_CODE_ARRAY:
1202         printf_filtered ("TYPE_CODE_ARRAY");
1203         break;
1204       case TYPE_CODE_STRUCT:
1205         printf_filtered ("TYPE_CODE_STRUCT");
1206         break;
1207       case TYPE_CODE_UNION:
1208         printf_filtered ("TYPE_CODE_UNION");
1209         break;
1210       case TYPE_CODE_ENUM:
1211         printf_filtered ("TYPE_CODE_ENUM");
1212         break;
1213       case TYPE_CODE_FUNC:
1214         printf_filtered ("TYPE_CODE_FUNC");
1215         break;
1216       case TYPE_CODE_INT:
1217         printf_filtered ("TYPE_CODE_INT");
1218         break;
1219       case TYPE_CODE_FLT:
1220         printf_filtered ("TYPE_CODE_FLT");
1221         break;
1222       case TYPE_CODE_VOID:
1223         printf_filtered ("TYPE_CODE_VOID");
1224         break;
1225       case TYPE_CODE_SET:
1226         printf_filtered ("TYPE_CODE_SET");
1227         break;
1228       case TYPE_CODE_RANGE:
1229         printf_filtered ("TYPE_CODE_RANGE");
1230         break;
1231       case TYPE_CODE_PASCAL_ARRAY:
1232         printf_filtered ("TYPE_CODE_PASCAL_ARRAY");
1233         break;
1234       case TYPE_CODE_ERROR:
1235         printf_filtered ("TYPE_CODE_ERROR");
1236         break;
1237       case TYPE_CODE_MEMBER:
1238         printf_filtered ("TYPE_CODE_MEMBER");
1239         break;
1240       case TYPE_CODE_METHOD:
1241         printf_filtered ("TYPE_CODE_METHOD");
1242         break;
1243       case TYPE_CODE_REF:
1244         printf_filtered ("TYPE_CODE_REF");
1245         break;
1246       case TYPE_CODE_CHAR:
1247         printf_filtered ("TYPE_CODE_CHAR");
1248         break;
1249       case TYPE_CODE_BOOL:
1250         printf_filtered ("TYPE_CODE_BOOL");
1251         break;
1252       default:
1253         printf_filtered ("<UNKNOWN TYPE CODE>");
1254         break;
1255     }
1256   puts_filtered ("\n");
1257   printfi_filtered (spaces, "length: %d\n", TYPE_LENGTH (type));
1258   printfi_filtered (spaces, "objfile: @ 0x%x\n", TYPE_OBJFILE (type));
1259   printfi_filtered (spaces, "target_type: @ 0x%x\n", TYPE_TARGET_TYPE (type));
1260   if (TYPE_TARGET_TYPE (type) != NULL)
1261     {
1262       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
1263     }
1264   printfi_filtered (spaces, "pointer_type: @ 0x%x\n",
1265                     TYPE_POINTER_TYPE (type));
1266   printfi_filtered (spaces, "reference_type: @ 0x%x\n",
1267                     TYPE_REFERENCE_TYPE (type));
1268   printfi_filtered (spaces, "function_type: @ 0x%x\n",
1269                     TYPE_FUNCTION_TYPE (type));
1270   printfi_filtered (spaces, "flags: 0x%x", TYPE_FLAGS (type));
1271   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
1272     {
1273       puts_filtered (" TYPE_FLAG_UNSIGNED");
1274     }
1275   if (TYPE_FLAGS (type) & TYPE_FLAG_SIGNED)
1276     {
1277       puts_filtered (" TYPE_FLAG_SIGNED");
1278     }
1279   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1280     {
1281       puts_filtered (" TYPE_FLAG_STUB");
1282     }
1283   puts_filtered ("\n");
1284   printfi_filtered (spaces, "nfields: %d @ 0x%x\n", TYPE_NFIELDS (type),
1285                     TYPE_FIELDS (type));
1286   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
1287     {
1288       printfi_filtered (spaces + 2,
1289                         "[%d] bitpos %d bitsize %d type 0x%x name 0x%x '%s'\n",
1290                         idx, TYPE_FIELD_BITPOS (type, idx),
1291                         TYPE_FIELD_BITSIZE (type, idx),
1292                         TYPE_FIELD_TYPE (type, idx),
1293                         TYPE_FIELD_NAME (type, idx),
1294                         TYPE_FIELD_NAME (type, idx) != NULL
1295                           ? TYPE_FIELD_NAME (type, idx)
1296                           : "<NULL>");
1297       if (TYPE_FIELD_TYPE (type, idx) != NULL)
1298         {
1299           recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
1300         }
1301     }
1302   printfi_filtered (spaces, "vptr_basetype: @ 0x%x\n",
1303                     TYPE_VPTR_BASETYPE (type));
1304   if (TYPE_VPTR_BASETYPE (type) != NULL)
1305     {
1306       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
1307     }
1308   printfi_filtered (spaces, "vptr_fieldno: %d\n", TYPE_VPTR_FIELDNO (type));
1309   switch (TYPE_CODE (type))
1310     {
1311       case TYPE_CODE_METHOD:
1312       case TYPE_CODE_FUNC:
1313         printfi_filtered (spaces, "arg_types: @ 0x%x\n",
1314                           TYPE_ARG_TYPES (type));
1315         break;
1316
1317       case TYPE_CODE_STRUCT:
1318         print_cplus_stuff (type, spaces);
1319         break;
1320     }
1321 }
1322
1323 #endif  /* MAINTENANCE_CMDS */