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   (void) 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   (void) 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   (void) 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_STRUCT &&
 615       TYPE_CODE (type) != TYPE_CODE_UNION)
 616     {
 617       target_terminal_ours ();
 618       fflush (stdout);
 619       fprintf (stderr, "Type ");
 620       type_print (type, "", stderr, -1);
 621       error (" is not a structure or union type.");
 622     }
 623
 624   check_stub_type (type);
 625
 626   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 627     {
 628       char *t_field_name = TYPE_FIELD_NAME (type, i);
 629
 630       if (t_field_name && !strcmp (t_field_name, name))
 631         {
 632           return TYPE_FIELD_TYPE (type, i);
 633         }
 634     }
 635
 636   /* OK, it's not in this class.  Recursively check the baseclasses.  */
 637   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
 638     {
 639       struct type *t;
 640
 641       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 0);
 642       if (t != NULL)
 643         {
 644           return t;
 645         }
 646     }
 647
 648   if (noerr)
 649     {
 650       return NULL;
 651     }
 652
 653   target_terminal_ours ();
 654   fflush (stdout);
 655   fprintf (stderr, "Type ");
 656   type_print (type, "", stderr, -1);
 657   fprintf (stderr, " has no component named ");
 658   fputs_filtered (name, stderr);
 659   error (".");
 660   return (struct type *)-1;     /* For lint */
 661 }
 662
 663 /* This function is really horrible, but to avoid it, there would need
 664    to be more filling in of forward references.  */
 665
 666 void
 667 fill_in_vptr_fieldno (type)
 668      struct type *type;
 669 {
 670   if (TYPE_VPTR_FIELDNO (type) < 0)
 671     {
 672       int i;
 673       for (i = 1; i < TYPE_N_BASECLASSES (type); i++)
 674         {
 675           fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
 676           if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
 677             {
 678               TYPE_VPTR_FIELDNO (type)
 679                 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
 680               TYPE_VPTR_BASETYPE (type)
 681                 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
 682               break;
 683             }
 684         }
 685     }
 686 }
 687
 688 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
 689
 690    If this is a stubbed struct (i.e. declared as struct foo *), see if
 691    we can find a full definition in some other file. If so, copy this
 692    definition, so we can use it in future.  If not, set a flag so we
 693    don't waste too much time in future.  (FIXME, this doesn't seem
 694    to be happening...)
 695
 696    This used to be coded as a macro, but I don't think it is called
 697    often enough to merit such treatment.
 698 */
 699
 700 struct complaint stub_noname_complaint =
 701   {"stub type has NULL name", 0, 0};
 702
 703 void
 704 check_stub_type (type)
 705      struct type *type;
 706 {
 707   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
 708     {
 709       char* name = type_name_no_tag (type);
 710       struct symbol *sym;
 711       if (name == NULL)
 712         {
 713           complain (&stub_noname_complaint, 0);
 714           return;
 715         }
 716       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
 717                            (struct symtab **) NULL);
 718       if (sym)
 719         {
 720           memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type));
 721         }
 722     }
 723 }
 724
 725 /* Ugly hack to convert method stubs into method types.
 726
 727    He ain't kiddin'.  This demangles the name of the method into a string
 728    including argument types, parses out each argument type, generates
 729    a string casting a zero to that type, evaluates the string, and stuffs
 730    the resulting type into an argtype vector!!!  Then it knows the type
 731    of the whole function (including argument types for overloading),
 732    which info used to be in the stab's but was removed to hack back
 733    the space required for them.  */
 734
 735 void
 736 check_stub_method (type, i, j)
 737      struct type *type;
 738      int i;
 739      int j;
 740 {
 741   struct fn_field *f;
 742   char *mangled_name = gdb_mangle_name (type, i, j);
 743   char *demangled_name = cplus_demangle (mangled_name, DMGL_PARAMS);
 744   char *argtypetext, *p;
 745   int depth = 0, argcount = 1;
 746   struct type **argtypes;
 747   struct type *mtype;
 748
 749   if (demangled_name == NULL)
 750     {
 751       error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
 752     }
 753
 754   /* Now, read in the parameters that define this type.  */
 755   argtypetext = strchr (demangled_name, '(') + 1;
 756   p = argtypetext;
 757   while (*p)
 758     {
 759       if (*p == '(')
 760         {
 761           depth += 1;
 762         }
 763       else if (*p == ')')
 764         {
 765           depth -= 1;
 766         }
 767       else if (*p == ',' && depth == 0)
 768         {
 769           argcount += 1;
 770         }
 771
 772       p += 1;
 773     }
 774
 775   /* We need two more slots: one for the THIS pointer, and one for the
 776      NULL [...] or void [end of arglist].  */
 777
 778   argtypes = (struct type **)
 779     obstack_alloc (&TYPE_OBJFILE (type) -> type_obstack,
 780                    (argcount+2) * sizeof (struct type *));
 781   p = argtypetext;
 782   argtypes[0] = lookup_pointer_type (type);
 783   argcount = 1;
 784
 785   if (*p != ')')                        /* () means no args, skip while */
 786     {
 787       depth = 0;
 788       while (*p)
 789         {
 790           if (depth <= 0 && (*p == ',' || *p == ')'))
 791             {
 792               argtypes[argcount] =
 793                   parse_and_eval_type (argtypetext, p - argtypetext);
 794               argcount += 1;
 795               argtypetext = p + 1;
 796             }
 797
 798           if (*p == '(')
 799             {
 800               depth += 1;
 801             }
 802           else if (*p == ')')
 803             {
 804               depth -= 1;
 805             }
 806
 807           p += 1;
 808         }
 809     }
 810
 811   if (p[-2] != '.')                     /* ... */
 812     {
 813       argtypes[argcount] = builtin_type_void;   /* Ellist terminator */
 814     }
 815   else
 816     {
 817       argtypes[argcount] = NULL;                /* List terminator */
 818     }
 819
 820   free (demangled_name);
 821
 822   f = TYPE_FN_FIELDLIST1 (type, i);
 823   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
 824
 825   /* Now update the old "stub" type into a real type.  */
 826   mtype = TYPE_FN_FIELD_TYPE (f, j);
 827   TYPE_DOMAIN_TYPE (mtype) = type;
 828   TYPE_ARG_TYPES (mtype) = argtypes;
 829   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
 830   TYPE_FN_FIELD_STUB (f, j) = 0;
 831 }
 832
 833 const struct cplus_struct_type cplus_struct_default;
 834
 835 void
 836 allocate_cplus_struct_type (type)
 837      struct type *type;
 838 {
 839   if (!HAVE_CPLUS_STRUCT (type))
 840     {
 841       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
 842         obstack_alloc (&current_objfile -> type_obstack,
 843                        sizeof (struct cplus_struct_type));
 844       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
 845     }
 846 }
 847
 848 /* Helper function to initialize the standard scalar types.  */
 849
 850 struct type *
 851 init_type (code, length, flags, name, objfile)
 852      enum type_code code;
 853      int length;
 854      int flags;
 855      char *name;
 856      struct objfile *objfile;
 857 {
 858   register struct type *type;
 859
 860   type = alloc_type (objfile);
 861   TYPE_CODE (type) = code;
 862   TYPE_LENGTH (type) = length;
 863   TYPE_FLAGS (type) |= flags;
 864   TYPE_NAME (type) = name;
 865
 866   /* C++ fancies.  */
 867
 868   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 869     {
 870       INIT_CPLUS_SPECIFIC (type);
 871     }
 872   return (type);
 873 }
 874
 875 /* Look up a fundamental type for the specified objfile.
 876    May need to construct such a type if this is the first use.
 877
 878    Some object file formats (ELF, COFF, etc) do not define fundamental
 879    types such as "int" or "double".  Others (stabs for example), do
 880    define fundamental types.
 881
 882    For the formats which don't provide fundamental types, gdb can create
 883    such types, using defaults reasonable for the current target machine.
 884
 885    FIXME:  Some compilers distinguish explicitly signed integral types
 886    (signed short, signed int, signed long) from "regular" integral types
 887    (short, int, long) in the debugging information.  There is some dis-
 888    agreement as to how useful this feature is.  In particular, gcc does
 889    not support this.  Also, only some debugging formats allow the
 890    distinction to be passed on to a debugger.  For now, we always just
 891    use "short", "int", or "long" as the type name, for both the implicit
 892    and explicitly signed types.  This also makes life easier for the
 893    gdb test suite since we don't have to account for the differences
 894    in output depending upon what the compiler and debugging format
 895    support.  We will probably have to re-examine the issue when gdb
 896    starts taking it's fundamental type information directly from the
 897    debugging information supplied by the compiler.  fnf@cygnus.com */
 898
 899 struct type *
 900 lookup_fundamental_type (objfile, typeid)
 901      struct objfile *objfile;
 902      int typeid;
 903 {
 904   register struct type *type = NULL;
 905   register struct type **typep;
 906   register int nbytes;
 907
 908   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
 909     {
 910       error ("internal error - invalid fundamental type id %d", typeid);
 911     }
 912   else
 913     {
 914       /* If this is the first time we */
 915       if (objfile -> fundamental_types == NULL)
 916         {
 917           nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
 918           objfile -> fundamental_types = (struct type **)
 919             obstack_alloc (&objfile -> type_obstack, nbytes);
 920           (void) memset ((char *)objfile -> fundamental_types, 0, nbytes);
 921         }
 922       typep = objfile -> fundamental_types + typeid;
 923       if ((type = *typep) == NULL)
 924         {
 925           switch (typeid)
 926             {
 927               default:
 928                 error ("internal error: unhandled type id %d", typeid);
 929                 break;
 930               case FT_VOID:
 931                 type = init_type (TYPE_CODE_VOID,
 932                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 933                                   0,
 934                                   "void", objfile);
 935                 break;
 936               case FT_BOOLEAN:
 937                 type = init_type (TYPE_CODE_INT,
 938                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 939                                   TYPE_FLAG_UNSIGNED,
 940                                   "boolean", objfile);
 941                 break;
 942               case FT_STRING:
 943                 type = init_type (TYPE_CODE_PASCAL_ARRAY,
 944                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 945                                   0,
 946                                   "string", objfile);
 947                 break;
 948               case FT_CHAR:
 949                 type = init_type (TYPE_CODE_INT,
 950                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 951                                   0,
 952                                   "char", objfile);
 953                 break;
 954               case FT_SIGNED_CHAR:
 955                 type = init_type (TYPE_CODE_INT,
 956                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 957                                   TYPE_FLAG_SIGNED,
 958                                   "signed char", objfile);
 959                 break;
 960               case FT_UNSIGNED_CHAR:
 961                 type = init_type (TYPE_CODE_INT,
 962                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 963                                   TYPE_FLAG_UNSIGNED,
 964                                   "unsigned char", objfile);
 965                 break;
 966               case FT_SHORT:
 967                 type = init_type (TYPE_CODE_INT,
 968                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 969                                   0,
 970                                   "short", objfile);
 971                 break;
 972               case FT_SIGNED_SHORT:
 973                 type = init_type (TYPE_CODE_INT,
 974                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 975                                   TYPE_FLAG_SIGNED,
 976                                   "short", objfile);    /* FIXME -fnf */
 977                 break;
 978               case FT_UNSIGNED_SHORT:
 979                 type = init_type (TYPE_CODE_INT,
 980                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 981                                   TYPE_FLAG_UNSIGNED,
 982                                   "unsigned short", objfile);
 983                 break;
 984               case FT_INTEGER:
 985                 type = init_type (TYPE_CODE_INT,
 986                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 987                                   0,
 988                                   "int", objfile);
 989                 break;
 990               case FT_SIGNED_INTEGER:
 991                 type = init_type (TYPE_CODE_INT,
 992                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 993                                   TYPE_FLAG_SIGNED,
 994                                   "int", objfile);      /* FIXME -fnf */
 995                 break;
 996               case FT_UNSIGNED_INTEGER:
 997                 type = init_type (TYPE_CODE_INT,
 998                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 999                                   TYPE_FLAG_UNSIGNED,
1000                                   "unsigned int", objfile);
1001                 break;
1002               case FT_FIXED_DECIMAL:
1003                 type = init_type (TYPE_CODE_INT,
1004                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1005                                   0,
1006                                   "fixed decimal", objfile);
1007                 break;
1008               case FT_LONG:
1009                 type = init_type (TYPE_CODE_INT,
1010                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1011                                   0,
1012                                   "long", objfile);
1013                 break;
1014               case FT_SIGNED_LONG:
1015                 type = init_type (TYPE_CODE_INT,
1016                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1017                                   TYPE_FLAG_SIGNED,
1018                                   "long", objfile);     /* FIXME -fnf */
1019                 break;
1020               case FT_UNSIGNED_LONG:
1021                 type = init_type (TYPE_CODE_INT,
1022                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1023                                   TYPE_FLAG_UNSIGNED,
1024                                   "unsigned long", objfile);
1025                 break;
1026               case FT_LONG_LONG:
1027                 type = init_type (TYPE_CODE_INT,
1028                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1029                                   0,
1030                                   "long long", objfile);
1031                 break;
1032               case FT_SIGNED_LONG_LONG:
1033                 type = init_type (TYPE_CODE_INT,
1034                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1035                                   TYPE_FLAG_SIGNED,
1036                                   "signed long long", objfile);
1037                 break;
1038               case FT_UNSIGNED_LONG_LONG:
1039                 type = init_type (TYPE_CODE_INT,
1040                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1041                                   TYPE_FLAG_UNSIGNED,
1042                                   "unsigned long long", objfile);
1043                 break;
1044               case FT_FLOAT:
1045                 type = init_type (TYPE_CODE_FLT,
1046                                   TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1047                                   0,
1048                                   "float", objfile);
1049                 break;
1050               case FT_DBL_PREC_FLOAT:
1051                 type = init_type (TYPE_CODE_FLT,
1052                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1053                                   0,
1054                                   "double", objfile);
1055                 break;
1056               case FT_FLOAT_DECIMAL:
1057                 type = init_type (TYPE_CODE_FLT,
1058                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1059                                   0,
1060                                   "floating decimal", objfile);
1061                 break;
1062               case FT_EXT_PREC_FLOAT:
1063                 type = init_type (TYPE_CODE_FLT,
1064                                   TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1065                                   0,
1066                                   "long double", objfile);
1067                 break;
1068               case FT_COMPLEX:
1069                 type = init_type (TYPE_CODE_FLT,
1070                                   TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1071                                   0,
1072                                   "complex", objfile);
1073                 break;
1074               case FT_DBL_PREC_COMPLEX:
1075                 type = init_type (TYPE_CODE_FLT,
1076                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1077                                   0,
1078                                   "double complex", objfile);
1079                 break;
1080               case FT_EXT_PREC_COMPLEX:
1081                 type = init_type (TYPE_CODE_FLT,
1082                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1083                                   0,
1084                                   "long double complex", objfile);
1085                 break;
1086             }
1087           /* Install the newly created type in the objfile's fundamental_types
1088              vector. */
1089           *typep = type;
1090         }
1091     }
1092   return (type);
1093 }
1094