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_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    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
 851    of the string pointed to by name in the type_obstack for that objfile,
 852    and initialize the type name to that copy.  There are places (mipsread.c
 853    in particular, where init_type is called with a NULL value for NAME). */
 854
 855 struct type *
 856 init_type (code, length, flags, name, objfile)
 857      enum type_code code;
 858      int length;
 859      int flags;
 860      char *name;
 861      struct objfile *objfile;
 862 {
 863   register struct type *type;
 864
 865   type = alloc_type (objfile);
 866   TYPE_CODE (type) = code;
 867   TYPE_LENGTH (type) = length;
 868   TYPE_FLAGS (type) |= flags;
 869   if ((name != NULL) && (objfile != NULL))
 870     {
 871       TYPE_NAME (type) =
 872         obsavestring (name, strlen (name), &objfile -> type_obstack);
 873     }
 874   else
 875     {
 876       TYPE_NAME (type) = name;
 877     }
 878
 879   /* C++ fancies.  */
 880
 881   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 882     {
 883       INIT_CPLUS_SPECIFIC (type);
 884     }
 885   return (type);
 886 }
 887
 888 /* Look up a fundamental type for the specified objfile.
 889    May need to construct such a type if this is the first use.
 890
 891    Some object file formats (ELF, COFF, etc) do not define fundamental
 892    types such as "int" or "double".  Others (stabs for example), do
 893    define fundamental types.
 894
 895    For the formats which don't provide fundamental types, gdb can create
 896    such types, using defaults reasonable for the current target machine.
 897
 898    FIXME:  Some compilers distinguish explicitly signed integral types
 899    (signed short, signed int, signed long) from "regular" integral types
 900    (short, int, long) in the debugging information.  There is some dis-
 901    agreement as to how useful this feature is.  In particular, gcc does
 902    not support this.  Also, only some debugging formats allow the
 903    distinction to be passed on to a debugger.  For now, we always just
 904    use "short", "int", or "long" as the type name, for both the implicit
 905    and explicitly signed types.  This also makes life easier for the
 906    gdb test suite since we don't have to account for the differences
 907    in output depending upon what the compiler and debugging format
 908    support.  We will probably have to re-examine the issue when gdb
 909    starts taking it's fundamental type information directly from the
 910    debugging information supplied by the compiler.  fnf@cygnus.com */
 911
 912 struct type *
 913 lookup_fundamental_type (objfile, typeid)
 914      struct objfile *objfile;
 915      int typeid;
 916 {
 917   register struct type *type = NULL;
 918   register struct type **typep;
 919   register int nbytes;
 920
 921   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
 922     {
 923       error ("internal error - invalid fundamental type id %d", typeid);
 924     }
 925   else
 926     {
 927       /* If this is the first time we */
 928       if (objfile -> fundamental_types == NULL)
 929         {
 930           nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
 931           objfile -> fundamental_types = (struct type **)
 932             obstack_alloc (&objfile -> type_obstack, nbytes);
 933           memset ((char *)objfile -> fundamental_types, 0, nbytes);
 934         }
 935       typep = objfile -> fundamental_types + typeid;
 936       if ((type = *typep) == NULL)
 937         {
 938           switch (typeid)
 939             {
 940               default:
 941                 error ("internal error: unhandled type id %d", typeid);
 942                 break;
 943               case FT_VOID:
 944                 type = init_type (TYPE_CODE_VOID,
 945                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 946                                   0,
 947                                   "void", objfile);
 948                 break;
 949               case FT_BOOLEAN:
 950                 type = init_type (TYPE_CODE_INT,
 951                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
 952                                   TYPE_FLAG_UNSIGNED,
 953                                   "boolean", objfile);
 954                 break;
 955               case FT_STRING:
 956                 type = init_type (TYPE_CODE_PASCAL_ARRAY,
 957                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 958                                   0,
 959                                   "string", objfile);
 960                 break;
 961               case FT_CHAR:
 962                 type = init_type (TYPE_CODE_INT,
 963                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 964                                   0,
 965                                   "char", objfile);
 966                 break;
 967               case FT_SIGNED_CHAR:
 968                 type = init_type (TYPE_CODE_INT,
 969                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 970                                   TYPE_FLAG_SIGNED,
 971                                   "signed char", objfile);
 972                 break;
 973               case FT_UNSIGNED_CHAR:
 974                 type = init_type (TYPE_CODE_INT,
 975                                   TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 976                                   TYPE_FLAG_UNSIGNED,
 977                                   "unsigned char", objfile);
 978                 break;
 979               case FT_SHORT:
 980                 type = init_type (TYPE_CODE_INT,
 981                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 982                                   0,
 983                                   "short", objfile);
 984                 break;
 985               case FT_SIGNED_SHORT:
 986                 type = init_type (TYPE_CODE_INT,
 987                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 988                                   TYPE_FLAG_SIGNED,
 989                                   "short", objfile);    /* FIXME -fnf */
 990                 break;
 991               case FT_UNSIGNED_SHORT:
 992                 type = init_type (TYPE_CODE_INT,
 993                                   TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 994                                   TYPE_FLAG_UNSIGNED,
 995                                   "unsigned short", objfile);
 996                 break;
 997               case FT_INTEGER:
 998                 type = init_type (TYPE_CODE_INT,
 999                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1000                                   0,
1001                                   "int", objfile);
1002                 break;
1003               case FT_SIGNED_INTEGER:
1004                 type = init_type (TYPE_CODE_INT,
1005                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1006                                   TYPE_FLAG_SIGNED,
1007                                   "int", objfile);      /* FIXME -fnf */
1008                 break;
1009               case FT_UNSIGNED_INTEGER:
1010                 type = init_type (TYPE_CODE_INT,
1011                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1012                                   TYPE_FLAG_UNSIGNED,
1013                                   "unsigned int", objfile);
1014                 break;
1015               case FT_FIXED_DECIMAL:
1016                 type = init_type (TYPE_CODE_INT,
1017                                   TARGET_INT_BIT / TARGET_CHAR_BIT,
1018                                   0,
1019                                   "fixed decimal", objfile);
1020                 break;
1021               case FT_LONG:
1022                 type = init_type (TYPE_CODE_INT,
1023                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1024                                   0,
1025                                   "long", objfile);
1026                 break;
1027               case FT_SIGNED_LONG:
1028                 type = init_type (TYPE_CODE_INT,
1029                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1030                                   TYPE_FLAG_SIGNED,
1031                                   "long", objfile);     /* FIXME -fnf */
1032                 break;
1033               case FT_UNSIGNED_LONG:
1034                 type = init_type (TYPE_CODE_INT,
1035                                   TARGET_LONG_BIT / TARGET_CHAR_BIT,
1036                                   TYPE_FLAG_UNSIGNED,
1037                                   "unsigned long", objfile);
1038                 break;
1039               case FT_LONG_LONG:
1040                 type = init_type (TYPE_CODE_INT,
1041                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1042                                   0,
1043                                   "long long", objfile);
1044                 break;
1045               case FT_SIGNED_LONG_LONG:
1046                 type = init_type (TYPE_CODE_INT,
1047                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1048                                   TYPE_FLAG_SIGNED,
1049                                   "signed long long", objfile);
1050                 break;
1051               case FT_UNSIGNED_LONG_LONG:
1052                 type = init_type (TYPE_CODE_INT,
1053                                   TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1054                                   TYPE_FLAG_UNSIGNED,
1055                                   "unsigned long long", objfile);
1056                 break;
1057               case FT_FLOAT:
1058                 type = init_type (TYPE_CODE_FLT,
1059                                   TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1060                                   0,
1061                                   "float", objfile);
1062                 break;
1063               case FT_DBL_PREC_FLOAT:
1064                 type = init_type (TYPE_CODE_FLT,
1065                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1066                                   0,
1067                                   "double", objfile);
1068                 break;
1069               case FT_FLOAT_DECIMAL:
1070                 type = init_type (TYPE_CODE_FLT,
1071                                   TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1072                                   0,
1073                                   "floating decimal", objfile);
1074                 break;
1075               case FT_EXT_PREC_FLOAT:
1076                 type = init_type (TYPE_CODE_FLT,
1077                                   TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1078                                   0,
1079                                   "long double", objfile);
1080                 break;
1081               case FT_COMPLEX:
1082                 type = init_type (TYPE_CODE_FLT,
1083                                   TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1084                                   0,
1085                                   "complex", objfile);
1086                 break;
1087               case FT_DBL_PREC_COMPLEX:
1088                 type = init_type (TYPE_CODE_FLT,
1089                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1090                                   0,
1091                                   "double complex", objfile);
1092                 break;
1093               case FT_EXT_PREC_COMPLEX:
1094                 type = init_type (TYPE_CODE_FLT,
1095                                   TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1096                                   0,
1097                                   "long double complex", objfile);
1098                 break;
1099             }
1100           /* Install the newly created type in the objfile's fundamental_types
1101              vector. */
1102           *typep = type;
1103         }
1104     }
1105   return (type);
1106 }
1107