/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/gdbtypes.c
Warning:	line 817, column 17 The left operand of '>=' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name gdbtypes.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c
1/* Support routines for manipulating internal types for GDB.
 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
 2004 Free Software Foundation, Inc.
 Contributed by Cygnus Support, using pieces from other GDB modules.

 This file is part of GDB.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */

23#include "defs.h"
24#include "gdb_string.h"
25#include "bfd.h"
26#include "symtab.h"
27#include "symfile.h"
28#include "objfiles.h"
29#include "gdbtypes.h"
30#include "expression.h"
31#include "language.h"
32#include "target.h"
33#include "value.h"
34#include "demangle.h"
35#include "complaints.h"
36#include "gdbcmd.h"
37#include "wrapper.h"
38#include "cp-abi.h"
39#include "gdb_assert.h"

41/* These variables point to the objects
 representing the predefined C data types.  */

44struct type *builtin_type_void;
45struct type *builtin_type_char;
46struct type *builtin_type_true_char;
47struct type *builtin_type_short;
48struct type *builtin_type_int;
49struct type *builtin_type_long;
50struct type *builtin_type_long_long;
51struct type *builtin_type_signed_char;
52struct type *builtin_type_unsigned_char;
53struct type *builtin_type_unsigned_short;
54struct type *builtin_type_unsigned_int;
55struct type *builtin_type_unsigned_long;
56struct type *builtin_type_unsigned_long_long;
57struct type *builtin_type_float;
58struct type *builtin_type_double;
59struct type *builtin_type_long_double;
60struct type *builtin_type_complex;
61struct type *builtin_type_double_complex;
62struct type *builtin_type_string;
63struct type *builtin_type_int0;
64struct type *builtin_type_int8;
65struct type *builtin_type_uint8;
66struct type *builtin_type_int16;
67struct type *builtin_type_uint16;
68struct type *builtin_type_int32;
69struct type *builtin_type_uint32;
70struct type *builtin_type_int64;
71struct type *builtin_type_uint64;
72struct type *builtin_type_int128;
73struct type *builtin_type_uint128;
74struct type *builtin_type_bool;

76/* 128 bit long vector types */
77struct type *builtin_type_v2_double;
78struct type *builtin_type_v4_float;
79struct type *builtin_type_v2_int64;
80struct type *builtin_type_v4_int32;
81struct type *builtin_type_v8_int16;
82struct type *builtin_type_v16_int8;
83/* 64 bit long vector types */
84struct type *builtin_type_v2_float;
85struct type *builtin_type_v2_int32;
86struct type *builtin_type_v4_int16;
87struct type *builtin_type_v8_int8;

89struct type *builtin_type_v4sf;
90struct type *builtin_type_v4si;
91struct type *builtin_type_v16qi;
92struct type *builtin_type_v8qi;
93struct type *builtin_type_v8hi;
94struct type *builtin_type_v4hi;
95struct type *builtin_type_v2si;
96struct type *builtin_type_vec64;
97struct type *builtin_type_vec64i;
98struct type *builtin_type_vec128;
99struct type *builtin_type_vec128i;
100struct type *builtin_type_ieee_single[BFD_ENDIAN_UNKNOWN];
101struct type *builtin_type_ieee_single_big;
102struct type *builtin_type_ieee_single_little;
103struct type *builtin_type_ieee_double[BFD_ENDIAN_UNKNOWN];
104struct type *builtin_type_ieee_double_big;
105struct type *builtin_type_ieee_double_little;
106struct type *builtin_type_ieee_double_littlebyte_bigword;
107struct type *builtin_type_i387_ext;
108struct type *builtin_type_m68881_ext;
109struct type *builtin_type_i960_ext;
110struct type *builtin_type_m88110_ext;
111struct type *builtin_type_m88110_harris_ext;
112struct type *builtin_type_arm_ext[BFD_ENDIAN_UNKNOWN];
113struct type *builtin_type_arm_ext_big;
114struct type *builtin_type_arm_ext_littlebyte_bigword;
115struct type *builtin_type_ia64_spill[BFD_ENDIAN_UNKNOWN];
116struct type *builtin_type_ia64_spill_big;
117struct type *builtin_type_ia64_spill_little;
118struct type *builtin_type_ia64_quad[BFD_ENDIAN_UNKNOWN];
119struct type *builtin_type_ia64_quad_big;
120struct type *builtin_type_ia64_quad_little;
121struct type *builtin_type_void_data_ptr;
122struct type *builtin_type_void_func_ptr;
123struct type *builtin_type_CORE_ADDR;
124struct type *builtin_type_bfd_vma;

126int opaque_type_resolution = 1;
127int overload_debug = 0;

129struct extra
{
  char str[128];
  int len;
};				/* maximum extension is 128! FIXME */

135static void print_bit_vector (B_TYPEunsigned char *, int);
136static void print_arg_types (struct field *, int, int);
137static void dump_fn_fieldlists (struct type *, int);
138static void print_cplus_stuff (struct type *, int);
139static void virtual_base_list_aux (struct type *dclass);


142/* Alloc a new type structure and fill it with some defaults.  If
 OBJFILE is non-NULL, then allocate the space for the type structure
 in that objfile's objfile_obstack.  Otherwise allocate the new type structure
 by xmalloc () (for permanent types).  */

147struct type *
148alloc_type (struct objfile *objfile)
149{
struct type *type;

/* Alloc the structure and start off with all fields zeroed. */

if (objfile == NULL((void*)0))
  {
    type = xmalloc (sizeof (struct type));
    memset (type, 0, sizeof (struct type));
    TYPE_MAIN_TYPE (type)(type)->main_type = xmalloc (sizeof (struct main_type));
  }
else
  {
    type = obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct type))); if (__o->chunk_limit - __o->next_free
 < __len) _obstack_newchunk (__o, __len); ((__o)->next_free
 += (__len)); (void) 0; }); __extension__ ({ struct obstack *
__o1 = (__h); void *value; value = (void *) __o1->object_base
; if (__o1->next_free == value) __o1->maybe_empty_object
 = 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
 > __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); })
	    sizeof (struct type))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct type))); if (__o->chunk_limit - __o->next_free
 < __len) _obstack_newchunk (__o, __len); ((__o)->next_free
 += (__len)); (void) 0; }); __extension__ ({ struct obstack *
__o1 = (__h); void *value; value = (void *) __o1->object_base
; if (__o1->next_free == value) __o1->maybe_empty_object
 = 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
 > __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); });
    memset (type, 0, sizeof (struct type));
    TYPE_MAIN_TYPE (type)(type)->main_type = obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct main_type))); if (__o->chunk_limit - __o->
next_free < __len) _obstack_newchunk (__o, __len); ((__o)->
next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack
 *__o1 = (__h); void *value; value = (void *) __o1->object_base
; if (__o1->next_free == value) __o1->maybe_empty_object
 = 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
 > __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); })
			     sizeof (struct main_type))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(sizeof (struct main_type))); if (__o->chunk_limit - __o->
next_free < __len) _obstack_newchunk (__o, __len); ((__o)->
next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack
 *__o1 = (__h); void *value; value = (void *) __o1->object_base
; if (__o1->next_free == value) __o1->maybe_empty_object
 = 1; __o1->next_free = (((((__o1->next_free) - (char *
) 0)+__o1->alignment_mask) & ~ (__o1->alignment_mask
)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk
 > __o1->chunk_limit - (char *)__o1->chunk) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; value; }); });
    OBJSTAT (objfile, n_types++)(objfile -> stats.n_types++);
  }
memset (TYPE_MAIN_TYPE (type)(type)->main_type, 0, sizeof (struct main_type));

/* Initialize the fields that might not be zero. */

TYPE_CODE (type)(type)->main_type->code = TYPE_CODE_UNDEF;
TYPE_OBJFILE (type)(type)->main_type->objfile = objfile;
TYPE_VPTR_FIELDNO (type)(type)->main_type->vptr_fieldno = -1;
TYPE_CHAIN (type)(type)->chain = type;	/* Chain back to itself.  */

return (type);
179}

181/* Alloc a new type instance structure, fill it with some defaults,
 and point it at OLDTYPE.  Allocate the new type instance from the
 same place as OLDTYPE.  */

185static struct type *
186alloc_type_instance (struct type *oldtype)
187{
struct type *type;

/* Allocate the structure.  */

if (TYPE_OBJFILE (oldtype)(oldtype)->main_type->objfile == NULL((void*)0))
  {
    type = xmalloc (sizeof (struct type));
    memset (type, 0, sizeof (struct type));
  }
else
  {
    type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack,__extension__ ({ struct obstack *__h = (&(oldtype)->main_type
->objfile->objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((sizeof (struct type))); if (__o->
chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); })
	    sizeof (struct type))__extension__ ({ struct obstack *__h = (&(oldtype)->main_type
->objfile->objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((sizeof (struct type))); if (__o->
chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); });
    memset (type, 0, sizeof (struct type));
  }
TYPE_MAIN_TYPE (type)(type)->main_type = TYPE_MAIN_TYPE (oldtype)(oldtype)->main_type;

TYPE_CHAIN (type)(type)->chain = type;	/* Chain back to itself for now.  */

return (type);
208}

210/* Clear all remnants of the previous type at TYPE, in preparation for
 replacing it with something else.  */
212static void
213smash_type (struct type *type)
214{
memset (TYPE_MAIN_TYPE (type)(type)->main_type, 0, sizeof (struct main_type));

/* For now, delete the rings.  */
TYPE_CHAIN (type)(type)->chain = type;

/* For now, leave the pointer/reference types alone.  */
221}

223/* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
 to a pointer to memory where the pointer type should be stored.
 If *TYPEPTR is zero, update it to point to the pointer type we return.
 We allocate new memory if needed.  */

228struct type *
229make_pointer_type (struct type *type, struct type **typeptr)
230{
struct type *ntype;	/* New type */
struct objfile *objfile;

ntype = TYPE_POINTER_TYPE (type)(type)->pointer_type;

if (ntype)
  {
    if (typeptr == 0)
return ntype;		/* Don't care about alloc, and have new type.  */
    else if (*typeptr == 0)
{
 *typeptr = ntype;	/* Tracking alloc, and we have new type.  */
 return ntype;
}
  }

if (typeptr == 0 || *typeptr == 0)	/* We'll need to allocate one.  */
  {
    ntype = alloc_type (TYPE_OBJFILE (type)(type)->main_type->objfile);
    if (typeptr)
*typeptr = ntype;
  }
else
  /* We have storage, but need to reset it.  */
  {
    ntype = *typeptr;
    objfile = TYPE_OBJFILE (ntype)(ntype)->main_type->objfile;
    smash_type (ntype);
    TYPE_OBJFILE (ntype)(ntype)->main_type->objfile = objfile;
  }

TYPE_TARGET_TYPE (ntype)(ntype)->main_type->target_type = type;
TYPE_POINTER_TYPE (type)(type)->pointer_type = ntype;

/* FIXME!  Assume the machine has only one representation for pointers!  */

TYPE_LENGTH (ntype)(ntype)->length = TARGET_PTR_BIT(gdbarch_ptr_bit (current_gdbarch)) / TARGET_CHAR_BIT8;
TYPE_CODE (ntype)(ntype)->main_type->code = TYPE_CODE_PTR;

/* Mark pointers as unsigned.  The target converts between pointers
   and addresses (CORE_ADDRs) using POINTER_TO_ADDRESS() and
   ADDRESS_TO_POINTER(). */
TYPE_FLAGS (ntype)(ntype)->main_type->flags |= TYPE_FLAG_UNSIGNED(1 << 0);

if (!TYPE_POINTER_TYPE (type)(type)->pointer_type)	/* Remember it, if don't have one.  */
  TYPE_POINTER_TYPE (type)(type)->pointer_type = ntype;

return ntype;
279}

281/* Given a type TYPE, return a type of pointers to that type.
 May need to construct such a type if this is the first use.  */

284struct type *
285lookup_pointer_type (struct type *type)
286{
return make_pointer_type (type, (struct type **) 0);
288}

290/* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
 to a pointer to memory where the reference type should be stored.
 If *TYPEPTR is zero, update it to point to the reference type we return.
 We allocate new memory if needed.  */

295struct type *
296make_reference_type (struct type *type, struct type **typeptr)
297{
struct type *ntype;	/* New type */
struct objfile *objfile;

ntype = TYPE_REFERENCE_TYPE (type)(type)->reference_type;

if (ntype)
  {
    if (typeptr == 0)
return ntype;		/* Don't care about alloc, and have new type.  */
    else if (*typeptr == 0)
{
 *typeptr = ntype;	/* Tracking alloc, and we have new type.  */
 return ntype;
}
  }

if (typeptr == 0 || *typeptr == 0)	/* We'll need to allocate one.  */
  {
    ntype = alloc_type (TYPE_OBJFILE (type)(type)->main_type->objfile);
    if (typeptr)
*typeptr = ntype;
  }
else
  /* We have storage, but need to reset it.  */
  {
    ntype = *typeptr;
    objfile = TYPE_OBJFILE (ntype)(ntype)->main_type->objfile;
    smash_type (ntype);
    TYPE_OBJFILE (ntype)(ntype)->main_type->objfile = objfile;
  }

TYPE_TARGET_TYPE (ntype)(ntype)->main_type->target_type = type;
TYPE_REFERENCE_TYPE (type)(type)->reference_type = ntype;

/* FIXME!  Assume the machine has only one representation for references,
   and that it matches the (only) representation for pointers!  */

TYPE_LENGTH (ntype)(ntype)->length = TARGET_PTR_BIT(gdbarch_ptr_bit (current_gdbarch)) / TARGET_CHAR_BIT8;
TYPE_CODE (ntype)(ntype)->main_type->code = TYPE_CODE_REF;

if (!TYPE_REFERENCE_TYPE (type)(type)->reference_type)	/* Remember it, if don't have one.  */
  TYPE_REFERENCE_TYPE (type)(type)->reference_type = ntype;

return ntype;
342}

344/* Same as above, but caller doesn't care about memory allocation details.  */

346struct type *
347lookup_reference_type (struct type *type)
348{
return make_reference_type (type, (struct type **) 0);
350}

352/* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
 to a pointer to memory where the function type should be stored.
 If *TYPEPTR is zero, update it to point to the function type we return.
 We allocate new memory if needed.  */

357struct type *
358make_function_type (struct type *type, struct type **typeptr)
359{
struct type *ntype;	/* New type */
struct objfile *objfile;

if (typeptr == 0 || *typeptr == 0)	/* We'll need to allocate one.  */
  {
    ntype = alloc_type (TYPE_OBJFILE (type)(type)->main_type->objfile);
    if (typeptr)
*typeptr = ntype;
  }
else
  /* We have storage, but need to reset it.  */
  {
    ntype = *typeptr;
    objfile = TYPE_OBJFILE (ntype)(ntype)->main_type->objfile;
    smash_type (ntype);
    TYPE_OBJFILE (ntype)(ntype)->main_type->objfile = objfile;
  }

TYPE_TARGET_TYPE (ntype)(ntype)->main_type->target_type = type;

TYPE_LENGTH (ntype)(ntype)->length = 1;
TYPE_CODE (ntype)(ntype)->main_type->code = TYPE_CODE_FUNC;

return ntype;
384}


387/* Given a type TYPE, return a type of functions that return that type.
 May need to construct such a type if this is the first use.  */

390struct type *
391lookup_function_type (struct type *type)
392{
return make_function_type (type, (struct type **) 0);
394}

396/* Identify address space identifier by name --
 return the integer flag defined in gdbtypes.h.  */
398extern int
399address_space_name_to_int (char *space_identifier)
400{
struct gdbarch *gdbarch = current_gdbarch;
int type_flags;
/* Check for known address space delimiters. */
if (!strcmp (space_identifier, "code"))
  return TYPE_FLAG_CODE_SPACE(1 << 9);
else if (!strcmp (space_identifier, "data"))
  return TYPE_FLAG_DATA_SPACE(1 << 10);
else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
         && gdbarch_address_class_name_to_type_flags (gdbarch,
					space_identifier,
					&type_flags))
  return type_flags;
else
  error ("Unknown address space specifier: \"%s\"", space_identifier);
415}

417/* Identify address space identifier by integer flag as defined in 
 gdbtypes.h -- return the string version of the adress space name. */

420const char *
421address_space_int_to_name (int space_flag)
422{
struct gdbarch *gdbarch = current_gdbarch;
if (space_flag & TYPE_FLAG_CODE_SPACE(1 << 9))
  return "code";
else if (space_flag & TYPE_FLAG_DATA_SPACE(1 << 10))
  return "data";
else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL((1 << 13) | (1 << 14)))
         && gdbarch_address_class_type_flags_to_name_p (gdbarch))
  return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
else
  return NULL((void*)0);
433}

435/* Create a new type with instance flags NEW_FLAGS, based on TYPE.
 If STORAGE is non-NULL, create the new type instance there.  */

438static struct type *
439make_qualified_type (struct type *type, int new_flags,
     struct type *storage)
441{
struct type *ntype;

ntype = type;
do {
  if (TYPE_INSTANCE_FLAGS (ntype)(ntype)->instance_flags == new_flags)
    return ntype;
  ntype = TYPE_CHAIN (ntype)(ntype)->chain;
} while (ntype != type);

/* Create a new type instance.  */
if (storage == NULL((void*)0))
  ntype = alloc_type_instance (type);
else
  {
    ntype = storage;
    TYPE_MAIN_TYPE (ntype)(ntype)->main_type = TYPE_MAIN_TYPE (type)(type)->main_type;
    TYPE_CHAIN (ntype)(ntype)->chain = ntype;
  }

/* Pointers or references to the original type are not relevant to
   the new type.  */
TYPE_POINTER_TYPE (ntype)(ntype)->pointer_type = (struct type *) 0;
TYPE_REFERENCE_TYPE (ntype)(ntype)->reference_type = (struct type *) 0;

/* Chain the new qualified type to the old type.  */
TYPE_CHAIN (ntype)(ntype)->chain = TYPE_CHAIN (type)(type)->chain;
TYPE_CHAIN (type)(type)->chain = ntype;

/* Now set the instance flags and return the new type.  */
TYPE_INSTANCE_FLAGS (ntype)(ntype)->instance_flags = new_flags;

/* Set length of new type to that of the original type.  */
TYPE_LENGTH (ntype)(ntype)->length = TYPE_LENGTH (type)(type)->length;

return ntype;
477}

479/* Make an address-space-delimited variant of a type -- a type that
 is identical to the one supplied except that it has an address
 space attribute attached to it (such as "code" or "data").

 The space attributes "code" and "data" are for Harvard architectures.
 The address space attributes are for architectures which have
 alternately sized pointers or pointers with alternate representations.  */

487struct type *
488make_type_with_address_space (struct type *type, int space_flag)
489{
struct type *ntype;
int new_flags = ((TYPE_INSTANCE_FLAGS (type)(type)->instance_flags
    & ~(TYPE_FLAG_CODE_SPACE(1 << 9) | TYPE_FLAG_DATA_SPACE(1 << 10)
        | TYPE_FLAG_ADDRESS_CLASS_ALL((1 << 13) | (1 << 14))))
   | space_flag);

return make_qualified_type (type, new_flags, NULL((void*)0));
497}

499/* Make a "c-v" variant of a type -- a type that is identical to the
 one supplied except that it may have const or volatile attributes
 CNST is a flag for setting the const attribute
 VOLTL is a flag for setting the volatile attribute
 TYPE is the base type whose variant we are creating.
 TYPEPTR, if nonzero, points
 to a pointer to memory where the reference type should be stored.
 If *TYPEPTR is zero, update it to point to the reference type we return.
 We allocate new memory if needed.  */

509struct type *
510make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
511{
struct type *ntype;	/* New type */
struct type *tmp_type = type;	/* tmp type */
struct objfile *objfile;

int new_flags = (TYPE_INSTANCE_FLAGS (type)(type)->instance_flags
   & ~(TYPE_FLAG_CONST(1 << 5) | TYPE_FLAG_VOLATILE(1 << 6)));

if (cnst)
  new_flags |= TYPE_FLAG_CONST(1 << 5);

if (voltl)
  new_flags |= TYPE_FLAG_VOLATILE(1 << 6);

if (typeptr && *typeptr != NULL((void*)0))
  {
    /* Objfile is per-core-type.  This const-qualified type had best
belong to the same objfile as the type it is qualifying, unless
we are overwriting a stub type, in which case the safest thing
to do is to copy the core type into the new objfile.  */

    gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)((void) (((*typeptr)->main_type->objfile == (type)->
main_type->objfile || ((*typeptr)->main_type->flags &
 (1 << 2))) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 533, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type) || TYPE_STUB (*typeptr)"
), 0)))
  || TYPE_STUB (*typeptr))((void) (((*typeptr)->main_type->objfile == (type)->
main_type->objfile || ((*typeptr)->main_type->flags &
 (1 << 2))) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 533, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type) || TYPE_STUB (*typeptr)"
), 0)));
    if (TYPE_OBJFILE (*typeptr)(*typeptr)->main_type->objfile != TYPE_OBJFILE (type)(type)->main_type->objfile)
{
 TYPE_MAIN_TYPE (*typeptr)(*typeptr)->main_type
   = TYPE_ALLOC (*typeptr, sizeof (struct main_type))((*typeptr)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(*typeptr)->main_type->
objfile -> objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((sizeof (struct main_type))); if (
__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 (sizeof (struct main_type)));
 *TYPE_MAIN_TYPE (*typeptr)(*typeptr)->main_type
   = *TYPE_MAIN_TYPE (type)(type)->main_type;
}
  }

ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL((void*)0));

if (typeptr != NULL((void*)0))
  *typeptr = ntype;

return ntype;
549}

551/* Replace the contents of ntype with the type *type.  This changes the
 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
 the changes are propogated to all types in the TYPE_CHAIN.

 In order to build recursive types, it's inevitable that we'll need
 to update types in place --- but this sort of indiscriminate
 smashing is ugly, and needs to be replaced with something more
 controlled.  TYPE_MAIN_TYPE is a step in this direction; it's not
 clear if more steps are needed.  */
560void
561replace_type (struct type *ntype, struct type *type)
562{
struct type *chain;

*TYPE_MAIN_TYPE (ntype)(ntype)->main_type = *TYPE_MAIN_TYPE (type)(type)->main_type;

/* The type length is not a part of the main type.  Update it for each
   type on the variant chain.  */
chain = ntype;
do {
  /* Assert that this element of the chain has no address-class bits
     set in its flags.  Such type variants might have type lengths
     which are supposed to be different from the non-address-class
     variants.  This assertion shouldn't ever be triggered because
     symbol readers which do construct address-class variants don't
     call replace_type().  */
  gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0)((void) ((((chain)->instance_flags & ((1 << 13) |
 (1 << 14))) == 0) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 577, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_ADDRESS_CLASS_ALL (chain) == 0"
), 0)));

  TYPE_LENGTH (ntype)(ntype)->length = TYPE_LENGTH (type)(type)->length;
  chain = TYPE_CHAIN (chain)(chain)->chain;
} while (ntype != chain);

/* Assert that the two types have equivalent instance qualifiers.
   This should be true for at least all of our debug readers.  */
gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type))((void) (((ntype)->instance_flags == (type)->instance_flags
) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 585, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type)"
), 0)));
586}

588/* Implement direct support for MEMBER_TYPE in GNU C++.
 May need to construct such a type if this is the first use.
 The TYPE is the type of the member.  The DOMAIN is the type
 of the aggregate that the member belongs to.  */

593struct type *
594lookup_member_type (struct type *type, struct type *domain)
595{
struct type *mtype;

mtype = alloc_type (TYPE_OBJFILE (type)(type)->main_type->objfile);
smash_to_member_type (mtype, domain, type);
return (mtype);
601}

603/* Allocate a stub method whose return type is TYPE.  
 This apparently happens for speed of symbol reading, since parsing
 out the arguments to the method is cpu-intensive, the way we are doing
 it.  So, we will fill in arguments later.
 This always returns a fresh type.   */

609struct type *
610allocate_stub_method (struct type *type)
611{
struct type *mtype;

mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB(1 << 2), NULL((void*)0),
     TYPE_OBJFILE (type)(type)->main_type->objfile);
TYPE_TARGET_TYPE (mtype)(mtype)->main_type->target_type = type;
/*  _DOMAIN_TYPE (mtype) = unknown yet */
return (mtype);
619}

621/* Create a range type using either a blank type supplied in RESULT_TYPE,
 or creating a new type, inheriting the objfile from INDEX_TYPE.

 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
 HIGH_BOUND, inclusive.

 FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */

630struct type *
631create_range_type (struct type *result_type, struct type *index_type,
   int low_bound, int high_bound)
633{
if (result_type == NULL((void*)0))
  {
    result_type = alloc_type (TYPE_OBJFILE (index_type)(index_type)->main_type->objfile);
  }
TYPE_CODE (result_type)(result_type)->main_type->code = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (result_type)(result_type)->main_type->target_type = index_type;
if (TYPE_STUB (index_type)((index_type)->main_type->flags & (1 << 2)))
  TYPE_FLAGS (result_type)(result_type)->main_type->flags |= TYPE_FLAG_TARGET_STUB(1 << 3);
else
  TYPE_LENGTH (result_type)(result_type)->length = TYPE_LENGTH (check_typedef (index_type))(check_typedef (index_type))->length;
TYPE_NFIELDS (result_type)(result_type)->main_type->nfields = 2;
TYPE_FIELDS (result_type)(result_type)->main_type->fields = (struct field *)
  TYPE_ALLOC (result_type, 2 * sizeof (struct field))((result_type)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(result_type)->main_type->
objfile -> objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((2 * sizeof (struct field))); if (
__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 (2 * sizeof (struct field)));
memset (TYPE_FIELDS (result_type)(result_type)->main_type->fields, 0, 2 * sizeof (struct field));
TYPE_FIELD_BITPOS (result_type, 0)(((result_type)->main_type->fields[0]).loc.bitpos) = low_bound;
TYPE_FIELD_BITPOS (result_type, 1)(((result_type)->main_type->fields[1]).loc.bitpos) = high_bound;
TYPE_FIELD_TYPE (result_type, 0)(((result_type)->main_type->fields[0]).type) = builtin_type_int;	/* FIXME */
TYPE_FIELD_TYPE (result_type, 1)(((result_type)->main_type->fields[1]).type) = builtin_type_int;	/* FIXME */

if (low_bound >= 0)
  TYPE_FLAGS (result_type)(result_type)->main_type->flags |= TYPE_FLAG_UNSIGNED(1 << 0);

return (result_type);
657}

659/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
 Return 1 of type is a range type, 0 if it is discrete (and bounds
 will fit in LONGEST), or -1 otherwise. */

663int
664get_discrete_bounds (struct type *type, LONGESTlong *lowp, LONGESTlong *highp)
665{
CHECK_TYPEDEF (type)(type) = check_typedef (type);
switch (TYPE_CODE (type)(type)->main_type->code)
  {
  case TYPE_CODE_RANGE:
    *lowp = TYPE_LOW_BOUND (type)(((type)->main_type->fields[0]).loc.bitpos);
    *highp = TYPE_HIGH_BOUND (type)(((type)->main_type->fields[1]).loc.bitpos);
    return 1;
  case TYPE_CODE_ENUM:
    if (TYPE_NFIELDS (type)(type)->main_type->nfields > 0)
{
 /* The enums may not be sorted by value, so search all
    entries */
 int i;

 *lowp = *highp = TYPE_FIELD_BITPOS (type, 0)(((type)->main_type->fields[0]).loc.bitpos);
 for (i = 0; i < TYPE_NFIELDS (type)(type)->main_type->nfields; i++)
   {
     if (TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos) < *lowp)
*lowp = TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos);
     if (TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos) > *highp)
*highp = TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos);
   }

 /* Set unsigned indicator if warranted. */
 if (*lowp >= 0)
   {
     TYPE_FLAGS (type)(type)->main_type->flags |= TYPE_FLAG_UNSIGNED(1 << 0);
   }
}
    else
{
 *lowp = 0;
 *highp = -1;
}
    return 0;
  case TYPE_CODE_BOOL:
    *lowp = 0;
    *highp = 1;
    return 0;
  case TYPE_CODE_INT:
    if (TYPE_LENGTH (type)(type)->length > sizeof (LONGESTlong))	/* Too big */
return -1;
    if (!TYPE_UNSIGNED (type)((type)->main_type->flags & (1 << 0)))
{
 *lowp = -(1 << (TYPE_LENGTH (type)(type)->length * TARGET_CHAR_BIT8 - 1));
 *highp = -*lowp - 1;
 return 0;
}
    /* ... fall through for unsigned ints ... */
  case TYPE_CODE_CHAR:
    *lowp = 0;
    /* This round-about calculation is to avoid shifting by
       TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
       if TYPE_LENGTH (type) == sizeof (LONGEST). */
    *highp = 1 << (TYPE_LENGTH (type)(type)->length * TARGET_CHAR_BIT8 - 1);
    *highp = (*highp - 1) | *highp;
    return 0;
  default:
    return -1;
  }
726}

728/* Create an array type using either a blank type supplied in RESULT_TYPE,
 or creating a new type, inheriting the objfile from RANGE_TYPE.

 Elements will be of type ELEMENT_TYPE, the indices will be of type
 RANGE_TYPE.

 FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */

737struct type *
738create_array_type (struct type *result_type, struct type *element_type,
   struct type *range_type)
740{
LONGESTlong low_bound, high_bound;

if (result_type == NULL((void*)0))
  {
    result_type = alloc_type (TYPE_OBJFILE (range_type)(range_type)->main_type->objfile);
  }
TYPE_CODE (result_type)(result_type)->main_type->code = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type)(result_type)->main_type->target_type = element_type;
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
  low_bound = high_bound = 0;
CHECK_TYPEDEF (element_type)(element_type) = check_typedef (element_type);
TYPE_LENGTH (result_type)(result_type)->length =
  TYPE_LENGTH (element_type)(element_type)->length * (high_bound - low_bound + 1);
TYPE_NFIELDS (result_type)(result_type)->main_type->nfields = 1;
TYPE_FIELDS (result_type)(result_type)->main_type->fields =
  (struct field *) TYPE_ALLOC (result_type, sizeof (struct field))((result_type)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(result_type)->main_type->
objfile -> objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((sizeof (struct field))); if (__o
->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 (sizeof (struct field)));
memset (TYPE_FIELDS (result_type)(result_type)->main_type->fields, 0, sizeof (struct field));
TYPE_FIELD_TYPE (result_type, 0)(((result_type)->main_type->fields[0]).type) = range_type;
TYPE_VPTR_FIELDNO (result_type)(result_type)->main_type->vptr_fieldno = -1;

/* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
if (TYPE_LENGTH (result_type)(result_type)->length == 0)
  TYPE_FLAGS (result_type)(result_type)->main_type->flags |= TYPE_FLAG_TARGET_STUB(1 << 3);

return (result_type);
766}

768/* Create a string type using either a blank type supplied in RESULT_TYPE,
 or creating a new type.  String types are similar enough to array of
 char types that we can use create_array_type to build the basic type
 and then bash it into a string type.

 For fixed length strings, the range type contains 0 as the lower
 bound and the length of the string minus one as the upper bound.

 FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */

779struct type *
780create_string_type (struct type *result_type, struct type *range_type)
781{
struct type *string_char_type;
    
string_char_type = language_string_char_type (current_language,
				current_gdbarch);
result_type = create_array_type (result_type,
		   string_char_type,
		   range_type);
TYPE_CODE (result_type)(result_type)->main_type->code = TYPE_CODE_STRING;
return (result_type);
791}

793struct type *
794create_set_type (struct type *result_type, struct type *domain_type)
795{
LONGESTlong low_bound, high_bound, bit_length;
1
'low_bound' declared without an initial value→
if (result_type == NULL((void*)0))
2
←
Assuming 'result_type' is not equal to NULL→
3
←
Taking false branch→
  {
    result_type = alloc_type (TYPE_OBJFILE (domain_type)(domain_type)->main_type->objfile);
  }
TYPE_CODE (result_type)(result_type)->main_type->code = TYPE_CODE_SET;
TYPE_NFIELDS (result_type)(result_type)->main_type->nfields = 1;
TYPE_FIELDS (result_type)(result_type)->main_type->fields = (struct field *)
  TYPE_ALLOC (result_type, 1 * sizeof (struct field))((result_type)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(result_type)->main_type->
objfile -> objfile_obstack); __extension__ ({ struct obstack
 *__o = (__h); int __len = ((1 * sizeof (struct field))); if (
__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 (1 * sizeof (struct field)));
4
←
Assuming field 'objfile' is equal to null→
5
←
'?' condition is false→
memset (TYPE_FIELDS (result_type)(result_type)->main_type->fields, 0, sizeof (struct field));

if (!TYPE_STUB (domain_type)((domain_type)->main_type->flags & (1 << 2)))
6
←
Assuming the condition is false→
7
←
Taking false branch→
  {
    if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
    bit_length = high_bound - low_bound + 1;
    TYPE_LENGTH (result_type)(result_type)->length
= (bit_length + TARGET_CHAR_BIT8 - 1) / TARGET_CHAR_BIT8;
  }
TYPE_FIELD_TYPE (result_type, 0)(((result_type)->main_type->fields[0]).type) = domain_type;

if (low_bound >= 0)
8
←
The left operand of '>=' is a garbage value
  TYPE_FLAGS (result_type)(result_type)->main_type->flags |= TYPE_FLAG_UNSIGNED(1 << 0);

return (result_type);
821}

823/* Construct and return a type of the form:
struct NAME { ELT_TYPE ELT_NAME[N]; }
 We use these types for SIMD registers.  For example, the type of
 the SSE registers on the late x86-family processors is:
struct __builtin_v4sf { float f[4]; }
 built by the function call:
init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4)
 The type returned is a permanent type, allocated using malloc; it
 doesn't live in any objfile's obstack.  */
832static struct type *
833init_simd_type (char *name,
struct type *elt_type,
char *elt_name,
int n)
837{
struct type *simd_type;
struct type *array_type;

simd_type = init_composite_type (name, TYPE_CODE_STRUCT);
array_type = create_array_type (0, elt_type,
		  create_range_type (0, builtin_type_int,
				     0, n-1));
append_composite_type_field (simd_type, elt_name, array_type);
return simd_type;
847}

849static struct type *
850init_vector_type (struct type *elt_type, int n)
851{
struct type *array_type;

array_type = create_array_type (0, elt_type,
		  create_range_type (0, builtin_type_int,
				     0, n-1));
TYPE_FLAGS (array_type)(array_type)->main_type->flags |= TYPE_FLAG_VECTOR(1 << 12);
return array_type;
859}

861static struct type *
862build_builtin_type_vec64 (void)
863{
/* Construct a type for the 64 bit registers.  The type we're
   building is this: */
866#if 0
union __gdb_builtin_type_vec64
{
  int64_t uint64;
  float v2_float[2];
  int32_t v2_int32[2];
  int16_t v4_int16[4];
  int8_t v8_int8[8];
};
875#endif

struct type *t;

t = init_composite_type ("__gdb_builtin_type_vec64", TYPE_CODE_UNION);
append_composite_type_field (t, "uint64", builtin_type_int64);
append_composite_type_field (t, "v2_float", builtin_type_v2_float);
append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);

TYPE_FLAGS (t)(t)->main_type->flags |= TYPE_FLAG_VECTOR(1 << 12);
TYPE_NAME (t)(t)->main_type->name = "builtin_type_vec64";
return t;
889}

891static struct type *
892build_builtin_type_vec64i (void)
893{
/* Construct a type for the 64 bit registers.  The type we're
   building is this: */
896#if 0
union __gdb_builtin_type_vec64i 
{
  int64_t uint64;
  int32_t v2_int32[2];
  int16_t v4_int16[4];
  int8_t v8_int8[8];
};
904#endif

struct type *t;

t = init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
append_composite_type_field (t, "uint64", builtin_type_int64);
append_composite_type_field (t, "v2_int32", builtin_type_v2_int32);
append_composite_type_field (t, "v4_int16", builtin_type_v4_int16);
append_composite_type_field (t, "v8_int8", builtin_type_v8_int8);

TYPE_FLAGS (t)(t)->main_type->flags |= TYPE_FLAG_VECTOR(1 << 12);
TYPE_NAME (t)(t)->main_type->name = "builtin_type_vec64i";
return t;
917}

919static struct type *
920build_builtin_type_vec128 (void)
921{
/* Construct a type for the 128 bit registers.  The type we're
   building is this: */
924#if 0
union __gdb_builtin_type_vec128 
{
  int128_t uint128;
  float v4_float[4];
  int32_t v4_int32[4];
  int16_t v8_int16[8];
  int8_t v16_int8[16];
};
933#endif

struct type *t;

t = init_composite_type ("__gdb_builtin_type_vec128", TYPE_CODE_UNION);
append_composite_type_field (t, "uint128", builtin_type_int128);
append_composite_type_field (t, "v4_float", builtin_type_v4_float);
append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);

TYPE_FLAGS (t)(t)->main_type->flags |= TYPE_FLAG_VECTOR(1 << 12);
TYPE_NAME (t)(t)->main_type->name = "builtin_type_vec128";
return t;
947}

949static struct type *
950build_builtin_type_vec128i (void)
951{
/* 128-bit Intel SIMD registers */
struct type *t;

t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION);
append_composite_type_field (t, "v4_float", builtin_type_v4_float);
append_composite_type_field (t, "v2_double", builtin_type_v2_double);
append_composite_type_field (t, "v16_int8", builtin_type_v16_int8);
append_composite_type_field (t, "v8_int16", builtin_type_v8_int16);
append_composite_type_field (t, "v4_int32", builtin_type_v4_int32);
append_composite_type_field (t, "v2_int64", builtin_type_v2_int64);
append_composite_type_field (t, "uint128", builtin_type_int128);

TYPE_FLAGS (t)(t)->main_type->flags |= TYPE_FLAG_VECTOR(1 << 12);
TYPE_NAME (t)(t)->main_type->name = "builtin_type_vec128i";
return t;
967}

969/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
 A MEMBER is a wierd thing -- it amounts to a typed offset into
 a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
 include the offset (that's the value of the MEMBER itself), but does
 include the structure type into which it points (for some reason).

 When "smashing" the type, we preserve the objfile that the
 old type pointed to, since we aren't changing where the type is actually
 allocated.  */

979void
980smash_to_member_type (struct type *type, struct type *domain,
      struct type *to_type)
982{
struct objfile *objfile;

objfile = TYPE_OBJFILE (type)(type)->main_type->objfile;

smash_type (type);
TYPE_OBJFILE (type)(type)->main_type->objfile = objfile;
TYPE_TARGET_TYPE (type)(type)->main_type->target_type = to_type;
TYPE_DOMAIN_TYPE (type)(type)->main_type->vptr_basetype = domain;
TYPE_LENGTH (type)(type)->length = 1;	/* In practice, this is never needed.  */
TYPE_CODE (type)(type)->main_type->code = TYPE_CODE_MEMBER;
993}

995/* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
 METHOD just means `function that gets an extra "this" argument'.

 When "smashing" the type, we preserve the objfile that the
 old type pointed to, since we aren't changing where the type is actually
 allocated.  */

1002void
1003smash_to_method_type (struct type *type, struct type *domain,
      struct type *to_type, struct field *args,
      int nargs, int varargs)
1006{
struct objfile *objfile;

objfile = TYPE_OBJFILE (type)(type)->main_type->objfile;

smash_type (type);
TYPE_OBJFILE (type)(type)->main_type->objfile = objfile;
TYPE_TARGET_TYPE (type)(type)->main_type->target_type = to_type;
TYPE_DOMAIN_TYPE (type)(type)->main_type->vptr_basetype = domain;
TYPE_FIELDS (type)(type)->main_type->fields = args;
TYPE_NFIELDS (type)(type)->main_type->nfields = nargs;
if (varargs)
  TYPE_FLAGS (type)(type)->main_type->flags |= TYPE_FLAG_VARARGS(1 << 11);
TYPE_LENGTH (type)(type)->length = 1;	/* In practice, this is never needed.  */
TYPE_CODE (type)(type)->main_type->code = TYPE_CODE_METHOD;
1021}

1023/* Return a typename for a struct/union/enum type without "struct ",
 "union ", or "enum ".  If the type has a NULL name, return NULL.  */

1026char *
1027type_name_no_tag (const struct type *type)
1028{
if (TYPE_TAG_NAME (type)(type)->main_type->tag_name != NULL((void*)0))
  return TYPE_TAG_NAME (type)(type)->main_type->tag_name;

/* Is there code which expects this to return the name if there is no
   tag name?  My guess is that this is mainly used for C++ in cases where
   the two will always be the same.  */
return TYPE_NAME (type)(type)->main_type->name;
1036}

1038/* Lookup a typedef or primitive type named NAME,
 visible in lexical block BLOCK.
 If NOERR is nonzero, return zero if NAME is not suitably defined.  */

1042struct type *
1043lookup_typename (char *name, struct block *block, int noerr)
1044{
struct symbol *sym;
struct type *tmp;

sym = lookup_symbol (name, block, VAR_DOMAIN, 0, (struct symtab **) NULL((void*)0));
if (sym == NULL((void*)0) || SYMBOL_CLASS (sym)(sym)->aclass != LOC_TYPEDEF)
  {
    tmp = language_lookup_primitive_type_by_name (current_language,
				    current_gdbarch,
				    name);
    if (tmp)
{
 return (tmp);
}
    else if (!tmp && noerr)
{
 return (NULL((void*)0));
}
    else
{
 error ("No type named %s.", name);
}
  }
return (SYMBOL_TYPE (sym)(sym)->type);
1068}

1070struct type *
1071lookup_unsigned_typename (char *name)
1072{
char *uns = alloca (strlen (name) + 10)__builtin_alloca(strlen (name) + 10);

strcpy (uns, "unsigned ");
strcpy (uns + 9, name);
return (lookup_typename (uns, (struct block *) NULL((void*)0), 0));
1078}

1080struct type *
1081lookup_signed_typename (char *name)
1082{
struct type *t;
char *uns = alloca (strlen (name) + 8)__builtin_alloca(strlen (name) + 8);

strcpy (uns, "signed ");
strcpy (uns + 7, name);
t = lookup_typename (uns, (struct block *) NULL((void*)0), 1);
/* If we don't find "signed FOO" just try again with plain "FOO". */
if (t != NULL((void*)0))
  return t;
return lookup_typename (name, (struct block *) NULL((void*)0), 0);
1093}

1095/* Lookup a structure type named "struct NAME",
 visible in lexical block BLOCK.  */

1098struct type *
1099lookup_struct (char *name, struct block *block)
1100{
struct symbol *sym;

sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
       (struct symtab **) NULL((void*)0));

if (sym == NULL((void*)0))
  {
    error ("No struct type named %s.", name);
  }
if (TYPE_CODE (SYMBOL_TYPE (sym))((sym)->type)->main_type->code != TYPE_CODE_STRUCT)
  {
    error ("This context has class, union or enum %s, not a struct.", name);
  }
return (SYMBOL_TYPE (sym)(sym)->type);
1115}

1117/* Lookup a union type named "union NAME",
 visible in lexical block BLOCK.  */

1120struct type *
1121lookup_union (char *name, struct block *block)
1122{
struct symbol *sym;
struct type *t;

sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
       (struct symtab **) NULL((void*)0));

if (sym == NULL((void*)0))
  error ("No union type named %s.", name);

t = SYMBOL_TYPE (sym)(sym)->type;

if (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_UNION)
  return (t);

/* C++ unions may come out with TYPE_CODE_CLASS, but we look at
 * a further "declared_type" field to discover it is really a union.
 */
if (HAVE_CPLUS_STRUCT (t)((t)->main_type->type_specific.cplus_stuff != &cplus_struct_default
))
  if (TYPE_DECLARED_TYPE (t)(t)->main_type->type_specific.cplus_stuff->declared_type == DECLARED_TYPE_UNION1)
    return (t);

/* If we get here, it's not a union */
error ("This context has class, struct or enum %s, not a union.", name);
1146}


1149/* Lookup an enum type named "enum NAME",
 visible in lexical block BLOCK.  */

1152struct type *
1153lookup_enum (char *name, struct block *block)
1154{
struct symbol *sym;

sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
       (struct symtab **) NULL((void*)0));
if (sym == NULL((void*)0))
  {
    error ("No enum type named %s.", name);
  }
if (TYPE_CODE (SYMBOL_TYPE (sym))((sym)->type)->main_type->code != TYPE_CODE_ENUM)
  {
    error ("This context has class, struct or union %s, not an enum.", name);
  }
return (SYMBOL_TYPE (sym)(sym)->type);
1168}

1170/* Lookup a template type named "template NAME<TYPE>",
 visible in lexical block BLOCK.  */

1173struct type *
1174lookup_template_type (char *name, struct type *type, struct block *block)
1175{
struct symbol *sym;
char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4)__builtin_alloca(strlen (name) + strlen ((type)->main_type
->name) + 4);
strcpy (nam, name);
strcat (nam, "<");
strcat (nam, TYPE_NAME (type)(type)->main_type->name);
strcat (nam, " >");		/* FIXME, extra space still introduced in gcc? */

sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, (struct symtab **) NULL((void*)0));

if (sym == NULL((void*)0))
  {
    error ("No template type named %s.", name);
  }
if (TYPE_CODE (SYMBOL_TYPE (sym))((sym)->type)->main_type->code != TYPE_CODE_STRUCT)
  {
    error ("This context has class, union or enum %s, not a struct.", name);
  }
return (SYMBOL_TYPE (sym)(sym)->type);
1194}

1196/* Given a type TYPE, lookup the type of the component of type named NAME.  

 TYPE can be either a struct or union, or a pointer or reference to a struct or
 union.  If it is a pointer or reference, its target type is automatically used.
 Thus '.' and '->' are interchangable, as specified for the definitions of the
 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.

 If NOERR is nonzero, return zero if NAME is not suitably defined.
 If NAME is the name of a baseclass type, return that type.  */

1206struct type *
1207lookup_struct_elt_type (struct type *type, char *name, int noerr)
1208{
int i;

for (;;)
  {
    CHECK_TYPEDEF (type)(type) = check_typedef (type);
    if (TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_PTR
 && TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_REF)
break;
    type = TYPE_TARGET_TYPE (type)(type)->main_type->target_type;
  }

if (TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_STRUCT &&
    TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_UNION)
  {
    target_terminal_ours ()(*current_target.to_terminal_ours) ();
    gdb_flush (gdb_stdout);
    fprintf_unfiltered (gdb_stderr, "Type ");
    type_print (type, "", gdb_stderr, -1);
    error (" is not a structure or union type.");
  }

1230#if 0
/* FIXME:  This change put in by Michael seems incorrect for the case where
   the structure tag name is the same as the member name.  I.E. when doing
   "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
   Disabled by fnf. */
{
  char *typename;

  typename = type_name_no_tag (type);
  if (typename != NULL((void*)0) && strcmp (typename, name) == 0)
    return type;
}
1242#endif

for (i = TYPE_NFIELDS (type)(type)->main_type->nfields - 1; i >= TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses; i--)
  {
    char *t_field_name = TYPE_FIELD_NAME (type, i)(((type)->main_type->fields[i]).name);

    if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
 return TYPE_FIELD_TYPE (type, i)(((type)->main_type->fields[i]).type);
}
  }

/* OK, it's not in this class.  Recursively check the baseclasses.  */
for (i = TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses - 1; i >= 0; i--)
  {
    struct type *t;

    t = lookup_struct_elt_type (TYPE_BASECLASS (type, i)(type)->main_type->fields[i].type, name, noerr);
    if (t != NULL((void*)0))
{
 return t;
}
  }

if (noerr)
  {
    return NULL((void*)0);
  }

target_terminal_ours ()(*current_target.to_terminal_ours) ();
gdb_flush (gdb_stdout);
fprintf_unfiltered (gdb_stderr, "Type ");
type_print (type, "", gdb_stderr, -1);
fprintf_unfiltered (gdb_stderr, " has no component named ");
fputs_filtered (name, gdb_stderr);
error (".");
return (struct type *) -1;	/* For lint */
1279}

1281/* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
 valid.  Callers should be aware that in some cases (for example,
 the type or one of its baseclasses is a stub type and we are
 debugging a .o file), this function will not be able to find the virtual
 function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
 will remain NULL.  */

1288void
1289fill_in_vptr_fieldno (struct type *type)
1290{
CHECK_TYPEDEF (type)(type) = check_typedef (type);

if (TYPE_VPTR_FIELDNO (type)(type)->main_type->vptr_fieldno < 0)
  {
    int i;

    /* We must start at zero in case the first (and only) baseclass is
       virtual (and hence we cannot share the table pointer).  */
    for (i = 0; i < TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
{
 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)(type)->main_type->fields[i].type);
 fill_in_vptr_fieldno (baseclass);
 if (TYPE_VPTR_FIELDNO (baseclass)(baseclass)->main_type->vptr_fieldno >= 0)
   {
     TYPE_VPTR_FIELDNO (type)(type)->main_type->vptr_fieldno = TYPE_VPTR_FIELDNO (baseclass)(baseclass)->main_type->vptr_fieldno;
     TYPE_VPTR_BASETYPE (type)(type)->main_type->vptr_basetype = TYPE_VPTR_BASETYPE (baseclass)(baseclass)->main_type->vptr_basetype;
     break;
   }
}
  }
1311}

1313/* Find the method and field indices for the destructor in class type T.
 Return 1 if the destructor was found, otherwise, return 0.  */

1316int
1317get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp)
1318{
int i;

for (i = 0; i < TYPE_NFN_FIELDS (t)(t)->main_type->type_specific.cplus_stuff->nfn_fields; i++)
  {
    int j;
    struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i)(t)->main_type->type_specific.cplus_stuff->fn_fieldlists
[i].fn_fields;

    for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i)(t)->main_type->type_specific.cplus_stuff->fn_fieldlists
[i].length; j++)
{
 if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)(f)[j].physname) != 0)
   {
     *method_indexp = i;
     *field_indexp = j;
     return 1;
   }
}
  }
return 0;
1337}

1339static void
1340stub_noname_complaint (void)
1341{
complaint (&symfile_complaints, "stub type has NULL name");
1343}

1345/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.

 If this is a stubbed struct (i.e. declared as struct foo *), see if
 we can find a full definition in some other file. If so, copy this
 definition, so we can use it in future.  There used to be a comment (but
 not any code) that if we don't find a full definition, we'd set a flag
 so we don't spend time in the future checking the same type.  That would
 be a mistake, though--we might load in more symbols which contain a
 full definition for the type.

 This used to be coded as a macro, but I don't think it is called 
 often enough to merit such treatment.  */

1358/* Find the real type of TYPE.  This function returns the real type, after
 removing all layers of typedefs and completing opaque or stub types.
 Completion changes the TYPE argument, but stripping of typedefs does
 not.  */

1363struct type *
1364check_typedef (struct type *type)
1365{
struct type *orig_type = type;
int is_const, is_volatile;

while (TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_TYPEDEF)
  {
    if (!TYPE_TARGET_TYPE (type)(type)->main_type->target_type)
{
 char *name;
 struct symbol *sym;

 /* It is dangerous to call lookup_symbol if we are currently
    reading a symtab.  Infinite recursion is one danger. */
 if (currently_reading_symtab)
   return type;

 name = type_name_no_tag (type);
 /* FIXME: shouldn't we separately check the TYPE_NAME and the
    TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
    as appropriate?  (this code was written before TYPE_NAME and
    TYPE_TAG_NAME were separate).  */
 if (name == NULL((void*)0))
   {
     stub_noname_complaint ();
     return type;
   }
 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,
	       (struct symtab **) NULL((void*)0));
 if (sym)
   TYPE_TARGET_TYPE (type)(type)->main_type->target_type = SYMBOL_TYPE (sym)(sym)->type;
 else
   TYPE_TARGET_TYPE (type)(type)->main_type->target_type = alloc_type (NULL((void*)0));	/* TYPE_CODE_UNDEF */
}
    type = TYPE_TARGET_TYPE (type)(type)->main_type->target_type;
  }

is_const = TYPE_CONST (type)((type)->instance_flags & (1 << 5));
is_volatile = TYPE_VOLATILE (type)((type)->instance_flags & (1 << 6));

/* If this is a struct/class/union with no fields, then check whether a
   full definition exists somewhere else.  This is for systems where a
   type definition with no fields is issued for such types, instead of
   identifying them as stub types in the first place */

if (TYPE_IS_OPAQUE (type)((((type)->main_type->code == TYPE_CODE_STRUCT) || ((type
)->main_type->code == TYPE_CODE_UNION)) && ((type
)->main_type->nfields == 0) && ((type)->main_type
->type_specific.cplus_stuff && ((type)->main_type
->type_specific.cplus_stuff->nfn_fields == 0))) && opaque_type_resolution && !currently_reading_symtab)
  {
    char *name = type_name_no_tag (type);
    struct type *newtype;
    if (name == NULL((void*)0))
{
 stub_noname_complaint ();
 return type;
}
    newtype = lookup_transparent_type (name);
    if (newtype)
make_cv_type (is_const, is_volatile, newtype, &type);
  }
/* Otherwise, rely on the stub flag being set for opaque/stubbed types */
else if (TYPE_STUB (type)((type)->main_type->flags & (1 << 2)) && !currently_reading_symtab)
  {
    char *name = type_name_no_tag (type);
    /* FIXME: shouldn't we separately check the TYPE_NAME and the
       TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
       as appropriate?  (this code was written before TYPE_NAME and
       TYPE_TAG_NAME were separate).  */
    struct symbol *sym;
    if (name == NULL((void*)0))
{
 stub_noname_complaint ();
 return type;
}
    sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL((void*)0));
    if (sym)
make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym)(sym)->type, &type);
  }

if (TYPE_TARGET_STUB (type)((type)->main_type->flags & (1 << 3)))
  {
    struct type *range_type;
    struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)(type)->main_type->target_type);

    if (TYPE_STUB (target_type)((target_type)->main_type->flags & (1 << 2)) || TYPE_TARGET_STUB (target_type)((target_type)->main_type->flags & (1 << 3)))
{
}
    else if (TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_ARRAY
      && TYPE_NFIELDS (type)(type)->main_type->nfields == 1
      && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))(range_type = (((type)->main_type->fields[0]).type))->
main_type->code
   == TYPE_CODE_RANGE))
{
 /* Now recompute the length of the array type, based on its
    number of elements and the target type's length.  */
 TYPE_LENGTH (type)(type)->length =
   ((TYPE_FIELD_BITPOS (range_type, 1)(((range_type)->main_type->fields[1]).loc.bitpos)
     - TYPE_FIELD_BITPOS (range_type, 0)(((range_type)->main_type->fields[0]).loc.bitpos)
     + 1)
    * TYPE_LENGTH (target_type)(target_type)->length);
 TYPE_FLAGS (type)(type)->main_type->flags &= ~TYPE_FLAG_TARGET_STUB(1 << 3);
}
    else if (TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_RANGE)
{
 TYPE_LENGTH (type)(type)->length = TYPE_LENGTH (target_type)(target_type)->length;
 TYPE_FLAGS (type)(type)->main_type->flags &= ~TYPE_FLAG_TARGET_STUB(1 << 3);
}
  }
/* Cache TYPE_LENGTH for future use. */
TYPE_LENGTH (orig_type)(orig_type)->length = TYPE_LENGTH (type)(type)->length;
return type;
1472}

1474/* Parse a type expression in the string [P..P+LENGTH).  If an error occurs,
 silently return builtin_type_void. */

1477static struct type *
1478safe_parse_type (char *p, int length)
1479{
struct ui_file *saved_gdb_stderr;
struct type *type;

/* Suppress error messages. */
saved_gdb_stderr = gdb_stderr;
gdb_stderr = ui_file_new ();

/* Call parse_and_eval_type() without fear of longjmp()s. */
if (!gdb_parse_and_eval_type (p, length, &type))
  type = builtin_type_void;

/* Stop suppressing error messages. */
ui_file_delete (gdb_stderr);
gdb_stderr = saved_gdb_stderr;

return type;
1496}

1498/* Ugly hack to convert method stubs into method types.

 He ain't kiddin'.  This demangles the name of the method into a string
 including argument types, parses out each argument type, generates
 a string casting a zero to that type, evaluates the string, and stuffs
 the resulting type into an argtype vector!!!  Then it knows the type
 of the whole function (including argument types for overloading),
 which info used to be in the stab's but was removed to hack back
 the space required for them.  */

1508static void
1509check_stub_method (struct type *type, int method_id, int signature_id)
1510{
struct fn_field *f;
char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
char *demangled_name = cplus_demangle (mangled_name,
			 DMGL_PARAMS(1 << 0) | DMGL_ANSI(1 << 1));
char *argtypetext, *p;
int depth = 0, argcount = 1;
struct field *argtypes;
struct type *mtype;

/* Make sure we got back a function string that we can use.  */
if (demangled_name)
  p = strchr (demangled_name, '(');
else
  p = NULL((void*)0);

if (demangled_name == NULL((void*)0) || p == NULL((void*)0))
  error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);

/* Now, read in the parameters that define this type.  */
p += 1;
argtypetext = p;
while (*p)
  {
    if (*p == '(' || *p == '<')
{
 depth += 1;
}
    else if (*p == ')' || *p == '>')
{
 depth -= 1;
}
    else if (*p == ',' && depth == 0)
{
 argcount += 1;
}

    p += 1;
  }

/* If we read one argument and it was ``void'', don't count it.  */
if (strncmp (argtypetext, "(void)", 6) == 0)
  argcount -= 1;

/* We need one extra slot, for the THIS pointer.  */

argtypes = (struct field *)
  TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field))((type)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(type)->main_type->objfile
 -> objfile_obstack); __extension__ ({ struct obstack *__o
 = (__h); int __len = (((argcount + 1) * sizeof (struct field
))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 ((argcount + 1) * sizeof (struct field)));
p = argtypetext;

/* Add THIS pointer for non-static methods.  */
f = TYPE_FN_FIELDLIST1 (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].fn_fields;
if (TYPE_FN_FIELD_STATIC_P (f, signature_id)((f)[signature_id].voffset == 1))
  argcount = 0;
else
  {
    argtypes[0].type = lookup_pointer_type (type);
    argcount = 1;
  }

if (*p != ')')		/* () means no args, skip while */
  {
    depth = 0;
    while (*p)
{
 if (depth <= 0 && (*p == ',' || *p == ')'))
   {
     /* Avoid parsing of ellipsis, they will be handled below.
        Also avoid ``void'' as above.  */
     if (strncmp (argtypetext, "...", p - argtypetext) != 0
  && strncmp (argtypetext, "void", p - argtypetext) != 0)
{
  argtypes[argcount].type =
    safe_parse_type (argtypetext, p - argtypetext);
  argcount += 1;
}
     argtypetext = p + 1;
   }

 if (*p == '(' || *p == '<')
   {
     depth += 1;
   }
 else if (*p == ')' || *p == '>')
   {
     depth -= 1;
   }

 p += 1;
}
  }

TYPE_FN_FIELD_PHYSNAME (f, signature_id)(f)[signature_id].physname = mangled_name;

/* Now update the old "stub" type into a real type.  */
mtype = TYPE_FN_FIELD_TYPE (f, signature_id)(f)[signature_id].type;
TYPE_DOMAIN_TYPE (mtype)(mtype)->main_type->vptr_basetype = type;
TYPE_FIELDS (mtype)(mtype)->main_type->fields = argtypes;
TYPE_NFIELDS (mtype)(mtype)->main_type->nfields = argcount;
TYPE_FLAGS (mtype)(mtype)->main_type->flags &= ~TYPE_FLAG_STUB(1 << 2);
TYPE_FN_FIELD_STUB (f, signature_id)((f)[signature_id].is_stub) = 0;
if (p[-2] == '.')
  TYPE_FLAGS (mtype)(mtype)->main_type->flags |= TYPE_FLAG_VARARGS(1 << 11);

xfree (demangled_name);
1615}

1617/* This is the external interface to check_stub_method, above.  This function
 unstubs all of the signatures for TYPE's METHOD_ID method name.  After
 calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
 and TYPE_FN_FIELDLIST_NAME will be correct.

 This function unfortunately can not die until stabs do.  */

1624void
1625check_stub_method_group (struct type *type, int method_id)
1626{
int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].length;
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].fn_fields;
int j, found_stub = 0;

for (j = 0; j < len; j++)
  if (TYPE_FN_FIELD_STUB (f, j)((f)[j].is_stub))
    {
found_stub = 1;
check_stub_method (type, method_id, j);
    }

/* GNU v3 methods with incorrect names were corrected when we read in
   type information, because it was cheaper to do it then.  The only GNU v2
   methods with incorrect method names are operators and destructors;
   destructors were also corrected when we read in type information.

   Therefore the only thing we need to handle here are v2 operator
   names.  */
if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0)(f)[0].physname, "_Z", 2) != 0)
  {
    int ret;
    char dem_opname[256];

    ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].name,
		   dem_opname, DMGL_ANSI(1 << 1));
    if (!ret)
ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].name,
		     dem_opname, 0);
    if (ret)
TYPE_FN_FIELDLIST_NAME (type, method_id)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_id].name = xstrdup (dem_opname);
  }
1658}

1660const struct cplus_struct_type cplus_struct_default;

1662void
1663allocate_cplus_struct_type (struct type *type)
1664{
if (!HAVE_CPLUS_STRUCT (type)((type)->main_type->type_specific.cplus_stuff != &cplus_struct_default
))
  {
    TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff = (struct cplus_struct_type *)
TYPE_ALLOC (type, sizeof (struct cplus_struct_type))((type)->main_type->objfile != ((void*)0) ? __extension__
 ({ struct obstack *__h = (&(type)->main_type->objfile
 -> objfile_obstack); __extension__ ({ struct obstack *__o
 = (__h); int __len = ((sizeof (struct cplus_struct_type))); if
 (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk
 (__o, __len); ((__o)->next_free += (__len)); (void) 0; })
; __extension__ ({ struct obstack *__o1 = (__h); void *value;
 value = (void *) __o1->object_base; if (__o1->next_free
 == value) __o1->maybe_empty_object = 1; __o1->next_free
 = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask
) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->
next_free - (char *)__o1->chunk > __o1->chunk_limit -
 (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; value; }); }) : xmalloc
 (sizeof (struct cplus_struct_type)));
    *(TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff) = cplus_struct_default;
  }
1671}

1673/* Helper function to initialize the standard scalar types.

 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
 of the string pointed to by name in the objfile_obstack for that objfile,
 and initialize the type name to that copy.  There are places (mipsread.c
 in particular, where init_type is called with a NULL value for NAME). */

1680struct type *
1681init_type (enum type_code code, int length, int flags, char *name,
  struct objfile *objfile)
1683{
struct type *type;

type = alloc_type (objfile);
TYPE_CODE (type)(type)->main_type->code = code;
TYPE_LENGTH (type)(type)->length = length;
TYPE_FLAGS (type)(type)->main_type->flags |= flags;
if ((name != NULL((void*)0)) && (objfile != NULL((void*)0)))
  {
    TYPE_NAME (type)(type)->main_type->name =
obsavestring (name, strlen (name), &objfile->objfile_obstack);
  }
else
  {
    TYPE_NAME (type)(type)->main_type->name = name;
  }

/* C++ fancies.  */

if (name && strcmp (name, "char") == 0)
  TYPE_FLAGS (type)(type)->main_type->flags |= TYPE_FLAG_NOSIGN(1 << 1);

if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
    || code == TYPE_CODE_NAMESPACE)
  {
    INIT_CPLUS_SPECIFIC (type)((type)->main_type->type_specific.cplus_stuff=(struct cplus_struct_type
*)&cplus_struct_default);
  }
return (type);
1711}

1713/* Helper function.  Create an empty composite type.  */

1715struct type *
1716init_composite_type (char *name, enum type_code code)
1717{
struct type *t;
gdb_assert (code == TYPE_CODE_STRUCT((void) ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 1720, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION"
), 0)))
     || code == TYPE_CODE_UNION)((void) ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c"
, 1720, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION"
), 0)));
t = init_type (code, 0, 0, NULL((void*)0), NULL((void*)0));
TYPE_TAG_NAME (t)(t)->main_type->tag_name = name;
return t;
1724}

1726/* Helper function.  Append a field to a composite type.  */

1728void
1729append_composite_type_field (struct type *t, char *name, struct type *field)
1730{
struct field *f;
TYPE_NFIELDS (t)(t)->main_type->nfields = TYPE_NFIELDS (t)(t)->main_type->nfields + 1;
TYPE_FIELDS (t)(t)->main_type->fields = xrealloc (TYPE_FIELDS (t)(t)->main_type->fields,
	      sizeof (struct field) * TYPE_NFIELDS (t)(t)->main_type->nfields);
f = &(TYPE_FIELDS (t)(t)->main_type->fields[TYPE_NFIELDS (t)(t)->main_type->nfields - 1]);
memset (f, 0, sizeof f[0]);
FIELD_TYPE (f[0])((f[0]).type) = field;
FIELD_NAME (f[0])((f[0]).name) = name;
if (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_UNION)
  {
    if (TYPE_LENGTH (t)(t)->length < TYPE_LENGTH (field)(field)->length)
TYPE_LENGTH (t)(t)->length = TYPE_LENGTH (field)(field)->length;
  }
else if (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_STRUCT)
  {
    TYPE_LENGTH (t)(t)->length = TYPE_LENGTH (t)(t)->length + TYPE_LENGTH (field)(field)->length;
    if (TYPE_NFIELDS (t)(t)->main_type->nfields > 1)
{
 FIELD_BITPOS (f[0])((f[0]).loc.bitpos) = (FIELD_BITPOS (f[-1])((f[-1]).loc.bitpos)
		 + TYPE_LENGTH (field)(field)->length * TARGET_CHAR_BIT8);
}
  }
1753}

1755/* Look up a fundamental type for the specified objfile.
 May need to construct such a type if this is the first use.

 Some object file formats (ELF, COFF, etc) do not define fundamental
 types such as "int" or "double".  Others (stabs for example), do
 define fundamental types.

 For the formats which don't provide fundamental types, gdb can create
 such types, using defaults reasonable for the current language and
 the current target machine.

 NOTE:  This routine is obsolescent.  Each debugging format reader
 should manage it's own fundamental types, either creating them from
 suitable defaults or reading them from the debugging information,
 whichever is appropriate.  The DWARF reader has already been
 fixed to do this.  Once the other readers are fixed, this routine
 will go away.  Also note that fundamental types should be managed
 on a compilation unit basis in a multi-language environment, not
 on a linkage unit basis as is done here. */


1776struct type *
1777lookup_fundamental_type (struct objfile *objfile, int typeid)
1778{
struct type **typep;
int nbytes;

if (typeid < 0 || typeid >= FT_NUM_MEMBERS29)
  {
    error ("internal error - invalid fundamental type id %d", typeid);
  }

/* If this is the first time we need a fundamental type for this objfile
   then we need to initialize the vector of type pointers. */

if (objfile->fundamental_types == NULL((void*)0))
  {
    nbytes = FT_NUM_MEMBERS29 * sizeof (struct type *);
    objfile->fundamental_types = (struct type **)
obstack_alloc (&objfile->objfile_obstack, nbytes)__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack
); __extension__ ({ struct obstack *__o = (__h); int __len = (
(nbytes)); if (__o->chunk_limit - __o->next_free < __len
) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len
)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h
); void *value; value = (void *) __o1->object_base; if (__o1
->next_free == value) __o1->maybe_empty_object = 1; __o1
->next_free = (((((__o1->next_free) - (char *) 0)+__o1->
alignment_mask) & ~ (__o1->alignment_mask)) + (char *)
 0); if (__o1->next_free - (char *)__o1->chunk > __o1
->chunk_limit - (char *)__o1->chunk) __o1->next_free
 = __o1->chunk_limit; __o1->object_base = __o1->next_free
; value; }); });
    memset ((char *) objfile->fundamental_types, 0, nbytes);
    OBJSTAT (objfile, n_types += FT_NUM_MEMBERS)(objfile -> stats.n_types += 29);
  }

/* Look for this particular type in the fundamental type vector.  If one is
   not found, create and install one appropriate for the current language. */

typep = objfile->fundamental_types + typeid;
if (*typep == NULL((void*)0))
  {
    *typep = create_fundamental_type (objfile, typeid)(current_language->la_fund_type(objfile, typeid));
  }

return (*typep);
1809}

1811int
1812can_dereference (struct type *t)
1813{
/* FIXME: Should we return true for references as well as pointers?  */
CHECK_TYPEDEF (t)(t) = check_typedef (t);
return
  (t != NULL((void*)0)
   && TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_PTR
   && TYPE_CODE (TYPE_TARGET_TYPE (t))((t)->main_type->target_type)->main_type->code != TYPE_CODE_VOID);
1820}

1822int
1823is_integral_type (struct type *t)
1824{
CHECK_TYPEDEF (t)(t) = check_typedef (t);
return
  ((t != NULL((void*)0))
   && ((TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_INT)
|| (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_ENUM)
|| (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_CHAR)
|| (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_RANGE)
|| (TYPE_CODE (t)(t)->main_type->code == TYPE_CODE_BOOL)));
1833}

1835/* Check whether BASE is an ancestor or base class or DCLASS 
 Return 1 if so, and 0 if not.
 Note: callers may want to check for identity of the types before
 calling this function -- identical types are considered to satisfy
 the ancestor relationship even if they're identical */

1841int
1842is_ancestor (struct type *base, struct type *dclass)
1843{
int i;

CHECK_TYPEDEF (base)(base) = check_typedef (base);
CHECK_TYPEDEF (dclass)(dclass) = check_typedef (dclass);

if (base == dclass)
  return 1;
if (TYPE_NAME (base)(base)->main_type->name && TYPE_NAME (dclass)(dclass)->main_type->name &&
    !strcmp (TYPE_NAME (base)(base)->main_type->name, TYPE_NAME (dclass)(dclass)->main_type->name))
  return 1;

for (i = 0; i < TYPE_N_BASECLASSES (dclass)(dclass)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
  if (is_ancestor (base, TYPE_BASECLASS (dclass, i)(dclass)->main_type->fields[i].type))
    return 1;

return 0;
1860}



1864/* See whether DCLASS has a virtual table.  This routine is aimed at
 the HP/Taligent ANSI C++ runtime model, and may not work with other
 runtime models.  Return 1 => Yes, 0 => No.  */

1868int
1869has_vtable (struct type *dclass)
1870{
/* In the HP ANSI C++ runtime model, a class has a vtable only if it
   has virtual functions or virtual bases.  */

int i;

if (TYPE_CODE (dclass)(dclass)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT)
  return 0;

/* First check for the presence of virtual bases */
if (TYPE_FIELD_VIRTUAL_BITS (dclass)(dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits)
  for (i = 0; i < TYPE_N_BASECLASSES (dclass)(dclass)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
    if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)(((dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits
)[(i)>>3] & (1 << ((i)&7))))
return 1;

/* Next check for virtual functions */
if (TYPE_FN_FIELDLISTS (dclass)(dclass)->main_type->type_specific.cplus_stuff->fn_fieldlists)
  for (i = 0; i < TYPE_NFN_FIELDS (dclass)(dclass)->main_type->type_specific.cplus_stuff->nfn_fields; i++)
    if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0)(((dclass)->main_type->type_specific.cplus_stuff->fn_fieldlists
[i].fn_fields)[0].voffset > 1))
return 1;

/* Recurse on non-virtual bases to see if any of them needs a vtable */
if (TYPE_FIELD_VIRTUAL_BITS (dclass)(dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits)
  for (i = 0; i < TYPE_N_BASECLASSES (dclass)(dclass)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
    if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)(((dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits
)[(i)>>3] & (1 << ((i)&7)))) &&
 (has_vtable (TYPE_FIELD_TYPE (dclass, i)(((dclass)->main_type->fields[i]).type))))
return 1;

/* Well, maybe we don't need a virtual table */
return 0;
1900}

1902/* Return a pointer to the "primary base class" of DCLASS.

 A NULL return indicates that DCLASS has no primary base, or that it
 couldn't be found (insufficient information).

 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
 and may not work with other runtime models.  */

1910struct type *
1911primary_base_class (struct type *dclass)
1912{
/* In HP ANSI C++'s runtime model, a "primary base class" of a class
   is the first directly inherited, non-virtual base class that
   requires a virtual table */

int i;

if (TYPE_CODE (dclass)(dclass)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT)
  return NULL((void*)0);

for (i = 0; i < TYPE_N_BASECLASSES (dclass)(dclass)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
  if (!TYPE_FIELD_VIRTUAL (dclass, i)((dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits
 == ((void*)0) ? 0 : (((dclass)->main_type->type_specific
.cplus_stuff->virtual_field_bits)[((i))>>3] & (1
 << (((i))&7)))) &&
has_vtable (TYPE_FIELD_TYPE (dclass, i)(((dclass)->main_type->fields[i]).type)))
    return TYPE_FIELD_TYPE (dclass, i)(((dclass)->main_type->fields[i]).type);

return NULL((void*)0);
1928}

1930/* Global manipulated by virtual_base_list[_aux]() */

1932static struct vbase *current_vbase_list = NULL((void*)0);

1934/* Return a pointer to a null-terminated list of struct vbase
 items. The vbasetype pointer of each item in the list points to the
 type information for a virtual base of the argument DCLASS.

 Helper function for virtual_base_list(). 
 Note: the list goes backward, right-to-left. virtual_base_list()
 copies the items out in reverse order.  */

1942static void
1943virtual_base_list_aux (struct type *dclass)
1944{
struct vbase *tmp_vbase;
int i;

if (TYPE_CODE (dclass)(dclass)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT)
  return;

for (i = 0; i < TYPE_N_BASECLASSES (dclass)(dclass)->main_type->type_specific.cplus_stuff->n_baseclasses; i++)
  {
    /* Recurse on this ancestor, first */
    virtual_base_list_aux (TYPE_FIELD_TYPE (dclass, i)(((dclass)->main_type->fields[i]).type));

    /* If this current base is itself virtual, add it to the list */
    if (BASETYPE_VIA_VIRTUAL (dclass, i)((dclass)->main_type->type_specific.cplus_stuff->virtual_field_bits
 == ((void*)0) ? 0 : (((dclass)->main_type->type_specific
.cplus_stuff->virtual_field_bits)[((i))>>3] & (1
 << (((i))&7)))))
{
 struct type *basetype = TYPE_FIELD_TYPE (dclass, i)(((dclass)->main_type->fields[i]).type);

 /* Check if base already recorded */
 tmp_vbase = current_vbase_list;
 while (tmp_vbase)
   {
     if (tmp_vbase->vbasetype == basetype)
break;		/* found it */
     tmp_vbase = tmp_vbase->next;
   }

 if (!tmp_vbase)	/* normal exit from loop */
   {
     /* Allocate new item for this virtual base */
     tmp_vbase = (struct vbase *) xmalloc (sizeof (struct vbase));

     /* Stick it on at the end of the list */
     tmp_vbase->vbasetype = basetype;
     tmp_vbase->next = current_vbase_list;
     current_vbase_list = tmp_vbase;
   }
}			/* if virtual */
  }				/* for loop over bases */
1982}


1985/* Compute the list of virtual bases in the right order.  Virtual
 bases are laid out in the object's memory area in order of their
 occurrence in a depth-first, left-to-right search through the
 ancestors.

 Argument DCLASS is the type whose virtual bases are required.
 Return value is the address of a null-terminated array of pointers
 to struct type items.

 This routine is aimed at the HP/Taligent ANSI C++ runtime model,
 and may not work with other runtime models.

 This routine merely hands off the argument to virtual_base_list_aux()
 and then copies the result into an array to save space.  */

2000struct type **
2001virtual_base_list (struct type *dclass)
2002{
struct vbase *tmp_vbase;
struct vbase *tmp_vbase_2;
int i;
int count;
struct type **vbase_array;

current_vbase_list = NULL((void*)0);
virtual_base_list_aux (dclass);

for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL((void*)0); i++, tmp_vbase = tmp_vbase->next)
  /* no body */ ;

count = i;

vbase_array = (struct type **) xmalloc ((count + 1) * sizeof (struct type *));

for (i = count - 1, tmp_vbase = current_vbase_list; i >= 0; i--, tmp_vbase = tmp_vbase->next)
  vbase_array[i] = tmp_vbase->vbasetype;

/* Get rid of constructed chain */
tmp_vbase_2 = tmp_vbase = current_vbase_list;
while (tmp_vbase)
  {
    tmp_vbase = tmp_vbase->next;
    xfree (tmp_vbase_2);
    tmp_vbase_2 = tmp_vbase;
  }

vbase_array[count] = NULL((void*)0);
return vbase_array;
2033}

2035/* Return the length of the virtual base list of the type DCLASS.  */

2037int
2038virtual_base_list_length (struct type *dclass)
2039{
int i;
struct vbase *tmp_vbase;

current_vbase_list = NULL((void*)0);
virtual_base_list_aux (dclass);

for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL((void*)0); i++, tmp_vbase = tmp_vbase->next)
  /* no body */ ;
return i;
2049}

2051/* Return the number of elements of the virtual base list of the type
 DCLASS, ignoring those appearing in the primary base (and its
 primary base, recursively).  */

2055int
2056virtual_base_list_length_skip_primaries (struct type *dclass)
2057{
int i;
struct vbase *tmp_vbase;
struct type *primary;

primary = TYPE_RUNTIME_PTR (dclass)((dclass)->main_type->type_specific.cplus_stuff->runtime_ptr
) ? TYPE_PRIMARY_BASE (dclass)(((dclass)->main_type->type_specific.cplus_stuff->runtime_ptr
)->primary_base) : NULL((void*)0);

if (!primary)
  return virtual_base_list_length (dclass);

current_vbase_list = NULL((void*)0);
virtual_base_list_aux (dclass);

for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL((void*)0); tmp_vbase = tmp_vbase->next)
  {
    if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
continue;
    i++;
  }
return i;
2077}


2080/* Return the index (position) of type BASE, which is a virtual base
 class of DCLASS, in the latter's virtual base list.  A return of -1
 indicates "not found" or a problem.  */

2084int
2085virtual_base_index (struct type *base, struct type *dclass)
2086{
struct type *vbase;
int i;

if ((TYPE_CODE (dclass)(dclass)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT) ||
    (TYPE_CODE (base)(base)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT))
  return -1;

i = 0;
vbase = virtual_base_list (dclass)[0];
while (vbase)
  {
    if (vbase == base)
break;
    vbase = virtual_base_list (dclass)[++i];
  }

return vbase ? i : -1;
2104}



2108/* Return the index (position) of type BASE, which is a virtual base
 class of DCLASS, in the latter's virtual base list. Skip over all
 bases that may appear in the virtual base list of the primary base
 class of DCLASS (recursively).  A return of -1 indicates "not
 found" or a problem.  */

2114int
2115virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
2116{
struct type *vbase;
int i, j;
struct type *primary;

if ((TYPE_CODE (dclass)(dclass)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT) ||
    (TYPE_CODE (base)(base)->main_type->code != TYPE_CODE_CLASSTYPE_CODE_STRUCT))
  return -1;

primary = TYPE_RUNTIME_PTR (dclass)((dclass)->main_type->type_specific.cplus_stuff->runtime_ptr
) ? TYPE_PRIMARY_BASE (dclass)(((dclass)->main_type->type_specific.cplus_stuff->runtime_ptr
)->primary_base) : NULL((void*)0);

j = -1;
i = 0;
vbase = virtual_base_list (dclass)[0];
while (vbase)
  {
    if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
j++;
    if (vbase == base)
break;
    vbase = virtual_base_list (dclass)[++i];
  }

return vbase ? j : -1;
2140}

2142/* Return position of a derived class DCLASS in the list of
* primary bases starting with the remotest ancestor.
* Position returned is 0-based. */

2146int
2147class_index_in_primary_list (struct type *dclass)
2148{
struct type *pbc;		/* primary base class */

/* Simply recurse on primary base */
pbc = TYPE_PRIMARY_BASE (dclass)(((dclass)->main_type->type_specific.cplus_stuff->runtime_ptr
)->primary_base);
if (pbc)
  return 1 + class_index_in_primary_list (pbc);
else
  return 0;
2157}

2159/* Return a count of the number of virtual functions a type has.
* This includes all the virtual functions it inherits from its
* base classes too.
*/

2164/* pai: FIXME This doesn't do the right thing: count redefined virtual
* functions only once (latest redefinition)
*/

2168int
2169count_virtual_fns (struct type *dclass)
2170{
int fn, oi;			/* function and overloaded instance indices */
int vfuncs;			/* count to return */

/* recurse on bases that can share virtual table */
struct type *pbc = primary_base_class (dclass);
if (pbc)
  vfuncs = count_virtual_fns (pbc);
else
  vfuncs = 0;

for (fn = 0; fn < TYPE_NFN_FIELDS (dclass)(dclass)->main_type->type_specific.cplus_stuff->nfn_fields; fn++)
  for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (dclass, fn)(dclass)->main_type->type_specific.cplus_stuff->fn_fieldlists
[fn].length; oi++)
    if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, fn), oi)(((dclass)->main_type->type_specific.cplus_stuff->fn_fieldlists
[fn].fn_fields)[oi].voffset > 1))
vfuncs++;

return vfuncs;
2187}
2188


2191/* Functions for overload resolution begin here */

2193/* Compare two badness vectors A and B and return the result.
* 0 => A and B are identical
* 1 => A and B are incomparable
* 2 => A is better than B
* 3 => A is worse than B */

2199int
2200compare_badness (struct badness_vector *a, struct badness_vector *b)
2201{
int i;
int tmp;
short found_pos = 0;		/* any positives in c? */
short found_neg = 0;		/* any negatives in c? */

/* differing lengths => incomparable */
if (a->length != b->length)
  return 1;

/* Subtract b from a */
for (i = 0; i < a->length; i++)
  {
    tmp = a->rank[i] - b->rank[i];
    if (tmp > 0)
found_pos = 1;
    else if (tmp < 0)
found_neg = 1;
  }

if (found_pos)
  {
    if (found_neg)
return 1;		/* incomparable */
    else
return 3;		/* A > B */
  }
else
  /* no positives */
  {
    if (found_neg)
return 2;		/* A < B */
    else
return 0;		/* A == B */
  }
2236}

2238/* Rank a function by comparing its parameter types (PARMS, length NPARMS),
* to the types of an argument list (ARGS, length NARGS).
* Return a pointer to a badness vector. This has NARGS + 1 entries. */

2242struct badness_vector *
2243rank_function (struct type **parms, int nparms, struct type **args, int nargs)
2244{
int i;
struct badness_vector *bv;
int min_len = nparms < nargs ? nparms : nargs;

bv = xmalloc (sizeof (struct badness_vector));
bv->length = nargs + 1;	/* add 1 for the length-match rank */
bv->rank = xmalloc ((nargs + 1) * sizeof (int));

/* First compare the lengths of the supplied lists.
 * If there is a mismatch, set it to a high value. */

/* pai/1997-06-03 FIXME: when we have debug info about default
 * arguments and ellipsis parameter lists, we should consider those
 * and rank the length-match more finely. */

LENGTH_MATCH (bv)((bv)->rank[0]) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS100 : 0;

/* Now rank all the parameters of the candidate function */
for (i = 1; i <= min_len; i++)
  bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);

/* If more arguments than parameters, add dummy entries */
for (i = min_len + 1; i <= nargs; i++)
  bv->rank[i] = TOO_FEW_PARAMS_BADNESS100;

return bv;
2271}

2273/* Compare the names of two integer types, assuming that any sign
 qualifiers have been checked already.  We do it this way because
 there may be an "int" in the name of one of the types.  */

2277static int
2278integer_types_same_name_p (const char *first, const char *second)
2279{
int first_p, second_p;

/* If both are shorts, return 1; if neither is a short, keep checking.  */
first_p = (strstr (first, "short") != NULL((void*)0));
second_p = (strstr (second, "short") != NULL((void*)0));
if (first_p && second_p)
  return 1;
if (first_p || second_p)
  return 0;

/* Likewise for long.  */
first_p = (strstr (first, "long") != NULL((void*)0));
second_p = (strstr (second, "long") != NULL((void*)0));
if (first_p && second_p)
  return 1;
if (first_p || second_p)
  return 0;

/* Likewise for char.  */
first_p = (strstr (first, "char") != NULL((void*)0));
second_p = (strstr (second, "char") != NULL((void*)0));
if (first_p && second_p)
  return 1;
if (first_p || second_p)
  return 0;

/* They must both be ints.  */
return 1;
2308}

2310/* Compare one type (PARM) for compatibility with another (ARG).
* PARM is intended to be the parameter type of a function; and
* ARG is the supplied argument's type.  This function tests if
* the latter can be converted to the former.
*
* Return 0 if they are identical types;
* Otherwise, return an integer which corresponds to how compatible
* PARM is to ARG. The higher the return value, the worse the match.
* Generally the "bad" conversions are all uniformly assigned a 100 */

2320int
2321rank_one_type (struct type *parm, struct type *arg)
2322{
/* Identical type pointers */
/* However, this still doesn't catch all cases of same type for arg
 * and param. The reason is that builtin types are different from
 * the same ones constructed from the object. */
if (parm == arg)
  return 0;

/* Resolve typedefs */
if (TYPE_CODE (parm)(parm)->main_type->code == TYPE_CODE_TYPEDEF)
  parm = check_typedef (parm);
if (TYPE_CODE (arg)(arg)->main_type->code == TYPE_CODE_TYPEDEF)
  arg = check_typedef (arg);

/*
   Well, damnit, if the names are exactly the same,
   i'll say they are exactly the same. This happens when we generate
   method stubs. The types won't point to the same address, but they
   really are the same.
*/

if (TYPE_NAME (parm)(parm)->main_type->name && TYPE_NAME (arg)(arg)->main_type->name &&
    !strcmp (TYPE_NAME (parm)(parm)->main_type->name, TYPE_NAME (arg)(arg)->main_type->name))
    return 0;

/* Check if identical after resolving typedefs */
if (parm == arg)
  return 0;

/* See through references, since we can almost make non-references
   references. */
if (TYPE_CODE (arg)(arg)->main_type->code == TYPE_CODE_REF)
  return (rank_one_type (parm, TYPE_TARGET_TYPE (arg)(arg)->main_type->target_type)
   + REFERENCE_CONVERSION_BADNESS2);
if (TYPE_CODE (parm)(parm)->main_type->code == TYPE_CODE_REF)
  return (rank_one_type (TYPE_TARGET_TYPE (parm)(parm)->main_type->target_type, arg)
   + REFERENCE_CONVERSION_BADNESS2);
if (overload_debug)
/* Debugging only. */
  fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
      TYPE_NAME (arg)(arg)->main_type->name, TYPE_CODE (arg)(arg)->main_type->code, TYPE_NAME (parm)(parm)->main_type->name, TYPE_CODE (parm)(parm)->main_type->code);

/* x -> y means arg of type x being supplied for parameter of type y */

switch (TYPE_CODE (parm)(parm)->main_type->code)
  {
  case TYPE_CODE_PTR:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_PTR:
 if (TYPE_CODE (TYPE_TARGET_TYPE (parm))((parm)->main_type->target_type)->main_type->code == TYPE_CODE_VOID)
   return VOID_PTR_CONVERSION_BADNESS2;
 else
   return rank_one_type (TYPE_TARGET_TYPE (parm)(parm)->main_type->target_type, TYPE_TARGET_TYPE (arg)(arg)->main_type->target_type);
case TYPE_CODE_ARRAY:
 return rank_one_type (TYPE_TARGET_TYPE (parm)(parm)->main_type->target_type, TYPE_TARGET_TYPE (arg)(arg)->main_type->target_type);
case TYPE_CODE_FUNC:
 return rank_one_type (TYPE_TARGET_TYPE (parm)(parm)->main_type->target_type, arg);
case TYPE_CODE_INT:
case TYPE_CODE_ENUM:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
 return POINTER_CONVERSION_BADNESS2;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
  case TYPE_CODE_ARRAY:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
 return rank_one_type (TYPE_TARGET_TYPE (parm)(parm)->main_type->target_type, TYPE_TARGET_TYPE (arg)(arg)->main_type->target_type);
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
  case TYPE_CODE_FUNC:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_PTR:	/* funcptr -> func */
 return rank_one_type (parm, TYPE_TARGET_TYPE (arg)(arg)->main_type->target_type);
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
  case TYPE_CODE_INT:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_INT:
 if (TYPE_LENGTH (arg)(arg)->length == TYPE_LENGTH (parm)(parm)->length)
   {
     /* Deal with signed, unsigned, and plain chars and
        signed and unsigned ints */
     if (TYPE_NOSIGN (parm)((parm)->main_type->flags & (1 << 1)))
{
  /* This case only for character types */
  if (TYPE_NOSIGN (arg)((arg)->main_type->flags & (1 << 1)))	/* plain char -> plain char */
    return 0;
  else
    return INTEGER_CONVERSION_BADNESS2;	/* signed/unsigned char -> plain char */
}
     else if (TYPE_UNSIGNED (parm)((parm)->main_type->flags & (1 << 0)))
{
  if (TYPE_UNSIGNED (arg)((arg)->main_type->flags & (1 << 0)))
    {
      /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
      if (integer_types_same_name_p (TYPE_NAME (parm)(parm)->main_type->name, TYPE_NAME (arg)(arg)->main_type->name))
	return 0;
      else if (integer_types_same_name_p (TYPE_NAME (arg)(arg)->main_type->name, "int")
	       && integer_types_same_name_p (TYPE_NAME (parm)(parm)->main_type->name, "long"))
	return INTEGER_PROMOTION_BADNESS1;	/* unsigned int -> unsigned long */
      else
	return INTEGER_CONVERSION_BADNESS2;	/* unsigned long -> unsigned int */
    }
  else
    {
      if (integer_types_same_name_p (TYPE_NAME (arg)(arg)->main_type->name, "long")
	  && integer_types_same_name_p (TYPE_NAME (parm)(parm)->main_type->name, "int"))
	return INTEGER_CONVERSION_BADNESS2;	/* signed long -> unsigned int */
      else
	return INTEGER_CONVERSION_BADNESS2;	/* signed int/long -> unsigned int/long */
    }
}
     else if (!TYPE_NOSIGN (arg)((arg)->main_type->flags & (1 << 1)) && !TYPE_UNSIGNED (arg)((arg)->main_type->flags & (1 << 0)))
{
  if (integer_types_same_name_p (TYPE_NAME (parm)(parm)->main_type->name, TYPE_NAME (arg)(arg)->main_type->name))
    return 0;
  else if (integer_types_same_name_p (TYPE_NAME (arg)(arg)->main_type->name, "int")
	   && integer_types_same_name_p (TYPE_NAME (parm)(parm)->main_type->name, "long"))
    return INTEGER_PROMOTION_BADNESS1;
  else
    return INTEGER_CONVERSION_BADNESS2;
}
     else
return INTEGER_CONVERSION_BADNESS2;
   }
 else if (TYPE_LENGTH (arg)(arg)->length < TYPE_LENGTH (parm)(parm)->length)
   return INTEGER_PROMOTION_BADNESS1;
 else
   return INTEGER_CONVERSION_BADNESS2;
case TYPE_CODE_ENUM:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
 return INTEGER_PROMOTION_BADNESS1;
case TYPE_CODE_FLT:
 return INT_FLOAT_CONVERSION_BADNESS2;
case TYPE_CODE_PTR:
 return NS_POINTER_CONVERSION_BADNESS10;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_ENUM:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
 return INTEGER_CONVERSION_BADNESS2;
case TYPE_CODE_FLT:
 return INT_FLOAT_CONVERSION_BADNESS2;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_CHAR:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
 return INTEGER_CONVERSION_BADNESS2;
case TYPE_CODE_FLT:
 return INT_FLOAT_CONVERSION_BADNESS2;
case TYPE_CODE_INT:
 if (TYPE_LENGTH (arg)(arg)->length > TYPE_LENGTH (parm)(parm)->length)
   return INTEGER_CONVERSION_BADNESS2;
 else if (TYPE_LENGTH (arg)(arg)->length < TYPE_LENGTH (parm)(parm)->length)
   return INTEGER_PROMOTION_BADNESS1;
 /* >>> !! else fall through !! <<< */
case TYPE_CODE_CHAR:
 /* Deal with signed, unsigned, and plain chars for C++
    and with int cases falling through from previous case */
 if (TYPE_NOSIGN (parm)((parm)->main_type->flags & (1 << 1)))
   {
     if (TYPE_NOSIGN (arg)((arg)->main_type->flags & (1 << 1)))
return 0;
     else
return INTEGER_CONVERSION_BADNESS2;
   }
 else if (TYPE_UNSIGNED (parm)((parm)->main_type->flags & (1 << 0)))
   {
     if (TYPE_UNSIGNED (arg)((arg)->main_type->flags & (1 << 0)))
return 0;
     else
return INTEGER_PROMOTION_BADNESS1;
   }
 else if (!TYPE_NOSIGN (arg)((arg)->main_type->flags & (1 << 1)) && !TYPE_UNSIGNED (arg)((arg)->main_type->flags & (1 << 0)))
   return 0;
 else
   return INTEGER_CONVERSION_BADNESS2;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_RANGE:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
 return INTEGER_CONVERSION_BADNESS2;
case TYPE_CODE_FLT:
 return INT_FLOAT_CONVERSION_BADNESS2;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_BOOL:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLT:
case TYPE_CODE_PTR:
 return BOOLEAN_CONVERSION_BADNESS2;
case TYPE_CODE_BOOL:
 return 0;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_FLT:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_FLT:
 if (TYPE_LENGTH (arg)(arg)->length < TYPE_LENGTH (parm)(parm)->length)
   return FLOAT_PROMOTION_BADNESS1;
 else if (TYPE_LENGTH (arg)(arg)->length == TYPE_LENGTH (parm)(parm)->length)
   return 0;
 else
   return FLOAT_CONVERSION_BADNESS2;
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
case TYPE_CODE_ENUM:
case TYPE_CODE_RANGE:
case TYPE_CODE_CHAR:
 return INT_FLOAT_CONVERSION_BADNESS2;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_COMPLEX:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{			/* Strictly not needed for C++, but... */
case TYPE_CODE_FLT:
 return FLOAT_PROMOTION_BADNESS1;
case TYPE_CODE_COMPLEX:
 return 0;
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_STRUCT:
    /* currently same as TYPE_CODE_CLASS */
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_STRUCT:
 /* Check for derivation */
 if (is_ancestor (parm, arg))
   return BASE_CONVERSION_BADNESS2;
 /* else fall through */
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_UNION:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
case TYPE_CODE_UNION:
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_MEMBER:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_METHOD:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{

default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_REF:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{

default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}

    break;
  case TYPE_CODE_SET:
    switch (TYPE_CODE (arg)(arg)->main_type->code)
{
 /* Not in C++ */
case TYPE_CODE_SET:
 return rank_one_type (TYPE_FIELD_TYPE (parm, 0)(((parm)->main_type->fields[0]).type), TYPE_FIELD_TYPE (arg, 0)(((arg)->main_type->fields[0]).type));
default:
 return INCOMPATIBLE_TYPE_BADNESS100;
}
    break;
  case TYPE_CODE_VOID:
  default:
    return INCOMPATIBLE_TYPE_BADNESS100;
  }				/* switch (TYPE_CODE (arg)) */
2650}


2653/* End of functions for overload resolution */

2655static void
2656print_bit_vector (B_TYPEunsigned char *bits, int nbits)
2657{
int bitno;

for (bitno = 0; bitno < nbits; bitno++)
  {
    if ((bitno % 8) == 0)
{
 puts_filtered (" ");
}
    if (B_TST (bits, bitno)((bits)[(bitno)>>3] & (1 << ((bitno)&7))))
{
 printf_filtered ("1");
}
    else
{
 printf_filtered ("0");
}
  }
2675}

2677/* Note the first arg should be the "this" pointer, we may not want to
 include it since we may get into a infinitely recursive situation.  */

2680static void
2681print_arg_types (struct field *args, int nargs, int spaces)
2682{
if (args != NULL((void*)0))
  {
    int i;

    for (i = 0; i < nargs; i++)
recursive_dump_type (args[i].type, spaces + 2);
  }
2690}

2692static void
2693dump_fn_fieldlists (struct type *type, int spaces)
2694{
int method_idx;
int overload_idx;
struct fn_field *f;

printfi_filtered (spaces, "fn_fieldlists ");
gdb_print_host_address (TYPE_FN_FIELDLISTS (type)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists, gdb_stdout);
printf_filtered ("\n");
for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type)(type)->main_type->type_specific.cplus_stuff->nfn_fields; method_idx++)
  {
    f = TYPE_FN_FIELDLIST1 (type, method_idx)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_idx].fn_fields;
    printfi_filtered (spaces + 2, "[%d] name '%s' (",
	method_idx,
	TYPE_FN_FIELDLIST_NAME (type, method_idx)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_idx].name);
    gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_idx].name,
	      gdb_stdout);
    printf_filtered (") length %d\n",
       TYPE_FN_FIELDLIST_LENGTH (type, method_idx)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_idx].length);
    for (overload_idx = 0;
  overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx)(type)->main_type->type_specific.cplus_stuff->fn_fieldlists
[method_idx].length;
  overload_idx++)
{
 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
	    overload_idx,
	    TYPE_FN_FIELD_PHYSNAME (f, overload_idx)(f)[overload_idx].physname);
 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx)(f)[overload_idx].physname,
		  gdb_stdout);
 printf_filtered (")\n");
 printfi_filtered (spaces + 8, "type ");
 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx)(f)[overload_idx].type, gdb_stdout);
 printf_filtered ("\n");

 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx)(f)[overload_idx].type,
	       spaces + 8 + 2);

 printfi_filtered (spaces + 8, "args ");
 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx)((f)[overload_idx].type)->main_type->fields, gdb_stdout);
 printf_filtered ("\n");

 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx)((f)[overload_idx].type)->main_type->fields,
	   TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx))((f)[overload_idx].type)->main_type->nfields,
	   spaces);
 printfi_filtered (spaces + 8, "fcontext ");
 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx)((f)[overload_idx].fcontext),
		  gdb_stdout);
 printf_filtered ("\n");

 printfi_filtered (spaces + 8, "is_const %d\n",
	    TYPE_FN_FIELD_CONST (f, overload_idx)((f)[overload_idx].is_const));
 printfi_filtered (spaces + 8, "is_volatile %d\n",
	    TYPE_FN_FIELD_VOLATILE (f, overload_idx)((f)[overload_idx].is_volatile));
 printfi_filtered (spaces + 8, "is_private %d\n",
	    TYPE_FN_FIELD_PRIVATE (f, overload_idx)((f)[overload_idx].is_private));
 printfi_filtered (spaces + 8, "is_protected %d\n",
	    TYPE_FN_FIELD_PROTECTED (f, overload_idx)((f)[overload_idx].is_protected));
 printfi_filtered (spaces + 8, "is_stub %d\n",
	    TYPE_FN_FIELD_STUB (f, overload_idx)((f)[overload_idx].is_stub));
 printfi_filtered (spaces + 8, "voffset %u\n",
	    TYPE_FN_FIELD_VOFFSET (f, overload_idx)((f)[overload_idx].voffset-2));
}
  }
2755}

2757static void
2758print_cplus_stuff (struct type *type, int spaces)
2759{
printfi_filtered (spaces, "n_baseclasses %d\n",
    TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses);
printfi_filtered (spaces, "nfn_fields %d\n",
    TYPE_NFN_FIELDS (type)(type)->main_type->type_specific.cplus_stuff->nfn_fields);
printfi_filtered (spaces, "nfn_fields_total %d\n",
    TYPE_NFN_FIELDS_TOTAL (type)(type)->main_type->type_specific.cplus_stuff->nfn_fields_total);
if (TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses > 0)
  {
    printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
	TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses);
    gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type)(type)->main_type->type_specific.cplus_stuff->virtual_field_bits, gdb_stdout);
    printf_filtered (")");

    print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type)(type)->main_type->type_specific.cplus_stuff->virtual_field_bits,
	TYPE_N_BASECLASSES (type)(type)->main_type->type_specific.cplus_stuff->n_baseclasses);
    puts_filtered ("\n");
  }
if (TYPE_NFIELDS (type)(type)->main_type->nfields > 0)
  {
    if (TYPE_FIELD_PRIVATE_BITS (type)(type)->main_type->type_specific.cplus_stuff->private_field_bits != NULL((void*)0))
{
 printfi_filtered (spaces, "private_field_bits (%d bits at *",
	    TYPE_NFIELDS (type)(type)->main_type->nfields);
 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type)(type)->main_type->type_specific.cplus_stuff->private_field_bits, gdb_stdout);
 printf_filtered (")");
 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type)(type)->main_type->type_specific.cplus_stuff->private_field_bits,
	    TYPE_NFIELDS (type)(type)->main_type->nfields);
 puts_filtered ("\n");
}
    if (TYPE_FIELD_PROTECTED_BITS (type)(type)->main_type->type_specific.cplus_stuff->protected_field_bits != NULL((void*)0))
{
 printfi_filtered (spaces, "protected_field_bits (%d bits at *",
	    TYPE_NFIELDS (type)(type)->main_type->nfields);
 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type)(type)->main_type->type_specific.cplus_stuff->protected_field_bits, gdb_stdout);
 printf_filtered (")");
 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type)(type)->main_type->type_specific.cplus_stuff->protected_field_bits,
	    TYPE_NFIELDS (type)(type)->main_type->nfields);
 puts_filtered ("\n");
}
  }
if (TYPE_NFN_FIELDS (type)(type)->main_type->type_specific.cplus_stuff->nfn_fields > 0)
  {
    dump_fn_fieldlists (type, spaces);
  }
2804}

2806static void
2807print_bound_type (int bt)
2808{
switch (bt)
  {
  case BOUND_CANNOT_BE_DETERMINED:
    printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)");
    break;
  case BOUND_BY_REF_ON_STACK:
    printf_filtered ("(BOUND_BY_REF_ON_STACK)");
    break;
  case BOUND_BY_VALUE_ON_STACK:
    printf_filtered ("(BOUND_BY_VALUE_ON_STACK)");
    break;
  case BOUND_BY_REF_IN_REG:
    printf_filtered ("(BOUND_BY_REF_IN_REG)");
    break;
  case BOUND_BY_VALUE_IN_REG:
    printf_filtered ("(BOUND_BY_VALUE_IN_REG)");
    break;
  case BOUND_SIMPLE:
    printf_filtered ("(BOUND_SIMPLE)");
    break;
  default:
    printf_filtered ("(unknown bound type)");
    break;
  }
2833}

2835static struct obstack dont_print_type_obstack;

2837void
2838recursive_dump_type (struct type *type, int spaces)
2839{
int idx;

if (spaces == 0)
  obstack_begin (&dont_print_type_obstack, 0)_obstack_begin ((&dont_print_type_obstack), (0), 0, (void
 *(*) (long)) xmalloc, (void (*) (void *)) xfree);

if (TYPE_NFIELDS (type)(type)->main_type->nfields > 0
    || (TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff && TYPE_NFN_FIELDS (type)(type)->main_type->type_specific.cplus_stuff->nfn_fields > 0))
  {
    struct type **first_dont_print
    = (struct type **) obstack_base (&dont_print_type_obstack)((&dont_print_type_obstack)->object_base);

    int i = (struct type **) obstack_next_free (&dont_print_type_obstack)((&dont_print_type_obstack)->next_free)
    - first_dont_print;

    while (--i >= 0)
{
 if (type == first_dont_print[i])
   {
     printfi_filtered (spaces, "type node ");
     gdb_print_host_address (type, gdb_stdout);
     printf_filtered (" <same as already seen type>\n");
     return;
   }
}

    obstack_ptr_grow (&dont_print_type_obstack, type)__extension__ ({ struct obstack *__o = (&dont_print_type_obstack
); if (__o->next_free + sizeof (void *) > __o->chunk_limit
) _obstack_newchunk (__o, sizeof (void *)); __extension__ ({ struct
 obstack *__o1 = (__o); *(const void **) __o1->next_free =
 (type); __o1->next_free += sizeof (const void *); (void) 0
; }); });
  }

printfi_filtered (spaces, "type node ");
gdb_print_host_address (type, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "name '%s' (",
    TYPE_NAME (type)(type)->main_type->name ? TYPE_NAME (type)(type)->main_type->name : "<NULL>");
gdb_print_host_address (TYPE_NAME (type)(type)->main_type->name, gdb_stdout);
printf_filtered (")\n");
printfi_filtered (spaces, "tagname '%s' (",
    TYPE_TAG_NAME (type)(type)->main_type->tag_name ? TYPE_TAG_NAME (type)(type)->main_type->tag_name : "<NULL>");
gdb_print_host_address (TYPE_TAG_NAME (type)(type)->main_type->tag_name, gdb_stdout);
printf_filtered (")\n");
printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type)(type)->main_type->code);
switch (TYPE_CODE (type)(type)->main_type->code)
  {
  case TYPE_CODE_UNDEF:
    printf_filtered ("(TYPE_CODE_UNDEF)");
    break;
  case TYPE_CODE_PTR:
    printf_filtered ("(TYPE_CODE_PTR)");
    break;
  case TYPE_CODE_ARRAY:
    printf_filtered ("(TYPE_CODE_ARRAY)");
    break;
  case TYPE_CODE_STRUCT:
    printf_filtered ("(TYPE_CODE_STRUCT)");
    break;
  case TYPE_CODE_UNION:
    printf_filtered ("(TYPE_CODE_UNION)");
    break;
  case TYPE_CODE_ENUM:
    printf_filtered ("(TYPE_CODE_ENUM)");
    break;
  case TYPE_CODE_FUNC:
    printf_filtered ("(TYPE_CODE_FUNC)");
    break;
  case TYPE_CODE_INT:
    printf_filtered ("(TYPE_CODE_INT)");
    break;
  case TYPE_CODE_FLT:
    printf_filtered ("(TYPE_CODE_FLT)");
    break;
  case TYPE_CODE_VOID:
    printf_filtered ("(TYPE_CODE_VOID)");
    break;
  case TYPE_CODE_SET:
    printf_filtered ("(TYPE_CODE_SET)");
    break;
  case TYPE_CODE_RANGE:
    printf_filtered ("(TYPE_CODE_RANGE)");
    break;
  case TYPE_CODE_STRING:
    printf_filtered ("(TYPE_CODE_STRING)");
    break;
  case TYPE_CODE_BITSTRING:
    printf_filtered ("(TYPE_CODE_BITSTRING)");
    break;
  case TYPE_CODE_ERROR:
    printf_filtered ("(TYPE_CODE_ERROR)");
    break;
  case TYPE_CODE_MEMBER:
    printf_filtered ("(TYPE_CODE_MEMBER)");
    break;
  case TYPE_CODE_METHOD:
    printf_filtered ("(TYPE_CODE_METHOD)");
    break;
  case TYPE_CODE_REF:
    printf_filtered ("(TYPE_CODE_REF)");
    break;
  case TYPE_CODE_CHAR:
    printf_filtered ("(TYPE_CODE_CHAR)");
    break;
  case TYPE_CODE_BOOL:
    printf_filtered ("(TYPE_CODE_BOOL)");
    break;
  case TYPE_CODE_COMPLEX:
    printf_filtered ("(TYPE_CODE_COMPLEX)");
    break;
  case TYPE_CODE_TYPEDEF:
    printf_filtered ("(TYPE_CODE_TYPEDEF)");
    break;
  case TYPE_CODE_TEMPLATE:
    printf_filtered ("(TYPE_CODE_TEMPLATE)");
    break;
  case TYPE_CODE_TEMPLATE_ARG:
    printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)");
    break;
  case TYPE_CODE_NAMESPACE:
    printf_filtered ("(TYPE_CODE_NAMESPACE)");
    break;
  default:
    printf_filtered ("(UNKNOWN TYPE CODE)");
    break;
  }
puts_filtered ("\n");
printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)(type)->length);
printfi_filtered (spaces, "upper_bound_type 0x%x ",
    TYPE_ARRAY_UPPER_BOUND_TYPE (type)(type)->main_type->upper_bound_type);
print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type)(type)->main_type->upper_bound_type);
puts_filtered ("\n");
printfi_filtered (spaces, "lower_bound_type 0x%x ",
    TYPE_ARRAY_LOWER_BOUND_TYPE (type)(type)->main_type->lower_bound_type);
print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type)(type)->main_type->lower_bound_type);
puts_filtered ("\n");
printfi_filtered (spaces, "objfile ");
gdb_print_host_address (TYPE_OBJFILE (type)(type)->main_type->objfile, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "target_type ");
gdb_print_host_address (TYPE_TARGET_TYPE (type)(type)->main_type->target_type, gdb_stdout);
printf_filtered ("\n");
if (TYPE_TARGET_TYPE (type)(type)->main_type->target_type != NULL((void*)0))
  {
    recursive_dump_type (TYPE_TARGET_TYPE (type)(type)->main_type->target_type, spaces + 2);
  }
printfi_filtered (spaces, "pointer_type ");
gdb_print_host_address (TYPE_POINTER_TYPE (type)(type)->pointer_type, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "reference_type ");
gdb_print_host_address (TYPE_REFERENCE_TYPE (type)(type)->reference_type, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "type_chain ");
gdb_print_host_address (TYPE_CHAIN (type)(type)->chain, gdb_stdout);
printf_filtered ("\n");
printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type)(type)->instance_flags);
if (TYPE_CONST (type)((type)->instance_flags & (1 << 5)))
  {
    puts_filtered (" TYPE_FLAG_CONST");
  }
if (TYPE_VOLATILE (type)((type)->instance_flags & (1 << 6)))
  {
    puts_filtered (" TYPE_FLAG_VOLATILE");
  }
if (TYPE_CODE_SPACE (type)((type)->instance_flags & (1 << 9)))
  {
    puts_filtered (" TYPE_FLAG_CODE_SPACE");
  }
if (TYPE_DATA_SPACE (type)((type)->instance_flags & (1 << 10)))
  {
    puts_filtered (" TYPE_FLAG_DATA_SPACE");
  }
if (TYPE_ADDRESS_CLASS_1 (type)((type)->instance_flags & (1 << 13)))
  {
    puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
  }
if (TYPE_ADDRESS_CLASS_2 (type)((type)->instance_flags & (1 << 14)))
  {
    puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
  }
puts_filtered ("\n");
printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type)(type)->main_type->flags);
if (TYPE_UNSIGNED (type)((type)->main_type->flags & (1 << 0)))
  {
    puts_filtered (" TYPE_FLAG_UNSIGNED");
  }
if (TYPE_NOSIGN (type)((type)->main_type->flags & (1 << 1)))
  {
    puts_filtered (" TYPE_FLAG_NOSIGN");
  }
if (TYPE_STUB (type)((type)->main_type->flags & (1 << 2)))
  {
    puts_filtered (" TYPE_FLAG_STUB");
  }
if (TYPE_TARGET_STUB (type)((type)->main_type->flags & (1 << 3)))
  {
    puts_filtered (" TYPE_FLAG_TARGET_STUB");
  }
if (TYPE_STATIC (type)((type)->main_type->flags & (1 << 4)))
  {
    puts_filtered (" TYPE_FLAG_STATIC");
  }
if (TYPE_PROTOTYPED (type)((type)->main_type->flags & (1 << 7)))
  {
    puts_filtered (" TYPE_FLAG_PROTOTYPED");
  }
if (TYPE_INCOMPLETE (type)((type)->main_type->flags & (1 << 8)))
  {
    puts_filtered (" TYPE_FLAG_INCOMPLETE");
  }
if (TYPE_VARARGS (type)((type)->main_type->flags & (1 << 11)))
  {
    puts_filtered (" TYPE_FLAG_VARARGS");
  }
/* This is used for things like AltiVec registers on ppc.  Gcc emits
   an attribute for the array type, which tells whether or not we
   have a vector, instead of a regular array.  */
if (TYPE_VECTOR (type)((type)->main_type->flags & (1 << 12)))
  {
    puts_filtered (" TYPE_FLAG_VECTOR");
  }
puts_filtered ("\n");
printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)(type)->main_type->nfields);
gdb_print_host_address (TYPE_FIELDS (type)(type)->main_type->fields, gdb_stdout);
puts_filtered ("\n");
for (idx = 0; idx < TYPE_NFIELDS (type)(type)->main_type->nfields; idx++)
  {
    printfi_filtered (spaces + 2,
	"[%d] bitpos %d bitsize %d type ",
	idx, TYPE_FIELD_BITPOS (type, idx)(((type)->main_type->fields[idx]).loc.bitpos),
	TYPE_FIELD_BITSIZE (type, idx)(((type)->main_type->fields[idx]).bitsize));
    gdb_print_host_address (TYPE_FIELD_TYPE (type, idx)(((type)->main_type->fields[idx]).type), gdb_stdout);
    printf_filtered (" name '%s' (",
       TYPE_FIELD_NAME (type, idx)(((type)->main_type->fields[idx]).name) != NULL((void*)0)
       ? TYPE_FIELD_NAME (type, idx)(((type)->main_type->fields[idx]).name)
       : "<NULL>");
    gdb_print_host_address (TYPE_FIELD_NAME (type, idx)(((type)->main_type->fields[idx]).name), gdb_stdout);
    printf_filtered (")\n");
    if (TYPE_FIELD_TYPE (type, idx)(((type)->main_type->fields[idx]).type) != NULL((void*)0))
{
 recursive_dump_type (TYPE_FIELD_TYPE (type, idx)(((type)->main_type->fields[idx]).type), spaces + 4);
}
  }
printfi_filtered (spaces, "vptr_basetype ");
gdb_print_host_address (TYPE_VPTR_BASETYPE (type)(type)->main_type->vptr_basetype, gdb_stdout);
puts_filtered ("\n");
if (TYPE_VPTR_BASETYPE (type)(type)->main_type->vptr_basetype != NULL((void*)0))
  {
    recursive_dump_type (TYPE_VPTR_BASETYPE (type)(type)->main_type->vptr_basetype, spaces + 2);
  }
printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type)(type)->main_type->vptr_fieldno);
switch (TYPE_CODE (type)(type)->main_type->code)
  {
  case TYPE_CODE_STRUCT:
    printfi_filtered (spaces, "cplus_stuff ");
    gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff, gdb_stdout);
    puts_filtered ("\n");
    print_cplus_stuff (type, spaces);
    break;

  case TYPE_CODE_FLT:
    printfi_filtered (spaces, "floatformat ");
    if (TYPE_FLOATFORMAT (type)(type)->main_type->type_specific.floatformat == NULL((void*)0)
 || TYPE_FLOATFORMAT (type)(type)->main_type->type_specific.floatformat->name == NULL((void*)0))
puts_filtered ("(null)");
    else
puts_filtered (TYPE_FLOATFORMAT (type)(type)->main_type->type_specific.floatformat->name);
    puts_filtered ("\n");
    break;

  default:
    /* We have to pick one of the union types to be able print and test
       the value.  Pick cplus_struct_type, even though we know it isn't
       any particular one. */
    printfi_filtered (spaces, "type_specific ");
    gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff, gdb_stdout);
    if (TYPE_CPLUS_SPECIFIC (type)(type)->main_type->type_specific.cplus_stuff != NULL((void*)0))
{
 printf_filtered (" (unknown data form)");
}
    printf_filtered ("\n");
    break;

  }
if (spaces == 0)
  obstack_free (&dont_print_type_obstack, NULL)__extension__ ({ struct obstack *__o = (&dont_print_type_obstack
); void *__obj = (((void*)0)); if (__obj > (void *)__o->
chunk && __obj < (void *)__o->chunk_limit) __o->
next_free = __o->object_base = __obj; else (obstack_free) (
__o, __obj); });
3121}

3123static void build_gdbtypes (void);
3124static void
3125build_gdbtypes (void)
3126{
builtin_type_void =
  init_type (TYPE_CODE_VOID, 1,
      0,
      "void", (struct objfile *) NULL((void*)0));
builtin_type_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      (TYPE_FLAG_NOSIGN(1 << 1)
              | (TARGET_CHAR_SIGNED(gdbarch_char_signed (current_gdbarch)) ? 0 : TYPE_FLAG_UNSIGNED(1 << 0))),
      "char", (struct objfile *) NULL((void*)0));
builtin_type_true_char =
  init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "true character", (struct objfile *) NULL((void*)0));
builtin_type_signed_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "signed char", (struct objfile *) NULL((void*)0));
builtin_type_unsigned_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned char", (struct objfile *) NULL((void*)0));
builtin_type_short =
  init_type (TYPE_CODE_INT, TARGET_SHORT_BIT(gdbarch_short_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "short", (struct objfile *) NULL((void*)0));
builtin_type_unsigned_short =
  init_type (TYPE_CODE_INT, TARGET_SHORT_BIT(gdbarch_short_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned short", (struct objfile *) NULL((void*)0));
builtin_type_int =
  init_type (TYPE_CODE_INT, TARGET_INT_BIT(gdbarch_int_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "int", (struct objfile *) NULL((void*)0));
builtin_type_unsigned_int =
  init_type (TYPE_CODE_INT, TARGET_INT_BIT(gdbarch_int_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned int", (struct objfile *) NULL((void*)0));
builtin_type_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "long", (struct objfile *) NULL((void*)0));
builtin_type_unsigned_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned long", (struct objfile *) NULL((void*)0));
builtin_type_long_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT(gdbarch_long_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "long long", (struct objfile *) NULL((void*)0));
builtin_type_unsigned_long_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT(gdbarch_long_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned long long", (struct objfile *) NULL((void*)0));
builtin_type_float =
  init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT(gdbarch_float_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "float", (struct objfile *) NULL((void*)0));
3184/* vinschen@redhat.com 2002-02-08:
 The below lines are disabled since they are doing the wrong
 thing for non-multiarch targets.  They are setting the correct
 type of floats for the target but while on multiarch targets
 this is done everytime the architecture changes, it's done on
 non-multiarch targets only on startup, leaving the wrong values
 in even if the architecture changes (eg. from big-endian to
 little-endian).  */
3192#if 0
TYPE_FLOATFORMAT (builtin_type_float)(builtin_type_float)->main_type->type_specific.floatformat = TARGET_FLOAT_FORMAT(gdbarch_float_format (current_gdbarch));
3194#endif
builtin_type_double =
  init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT(gdbarch_double_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "double", (struct objfile *) NULL((void*)0));
3199#if 0
TYPE_FLOATFORMAT (builtin_type_double)(builtin_type_double)->main_type->type_specific.floatformat = TARGET_DOUBLE_FORMAT(gdbarch_double_format (current_gdbarch));
3201#endif
builtin_type_long_double =
  init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT(gdbarch_long_double_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "long double", (struct objfile *) NULL((void*)0));
3206#if 0
TYPE_FLOATFORMAT (builtin_type_long_double)(builtin_type_long_double)->main_type->type_specific.floatformat = TARGET_LONG_DOUBLE_FORMAT(gdbarch_long_double_format (current_gdbarch));
3208#endif
builtin_type_complex =
  init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT(gdbarch_float_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "complex", (struct objfile *) NULL((void*)0));
TYPE_TARGET_TYPE (builtin_type_complex)(builtin_type_complex)->main_type->target_type = builtin_type_float;
builtin_type_double_complex =
  init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT(gdbarch_double_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "double complex", (struct objfile *) NULL((void*)0));
TYPE_TARGET_TYPE (builtin_type_double_complex)(builtin_type_double_complex)->main_type->target_type = builtin_type_double;
builtin_type_string =
  init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "string", (struct objfile *) NULL((void*)0));
builtin_type_bool =
  init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "bool", (struct objfile *) NULL((void*)0));

/* Add user knob for controlling resolution of opaque types */
deprecated_add_show_from_set
  (add_set_cmd ("opaque-type-resolution", class_support, var_boolean, (char *) &opaque_type_resolution,
  "Set resolution of opaque struct/class/union types (if set before loading symbols).",
  &setlist),
   &showlist);
opaque_type_resolution = 1;

/* Build SIMD types.  */
builtin_type_v4sf
  = init_simd_type ("__builtin_v4sf", builtin_type_float, "f", 4);
builtin_type_v4si
  = init_simd_type ("__builtin_v4si", builtin_type_int32, "f", 4);
builtin_type_v16qi
  = init_simd_type ("__builtin_v16qi", builtin_type_int8, "f", 16);
builtin_type_v8qi
  = init_simd_type ("__builtin_v8qi", builtin_type_int8, "f", 8);
builtin_type_v8hi
  = init_simd_type ("__builtin_v8hi", builtin_type_int16, "f", 8);
builtin_type_v4hi
  = init_simd_type ("__builtin_v4hi", builtin_type_int16, "f", 4);
builtin_type_v2si
  = init_simd_type ("__builtin_v2si", builtin_type_int32, "f", 2);

/* 128 bit vectors.  */
builtin_type_v2_double = init_vector_type (builtin_type_double, 2);
builtin_type_v4_float = init_vector_type (builtin_type_float, 4);
builtin_type_v2_int64 = init_vector_type (builtin_type_int64, 2);
builtin_type_v4_int32 = init_vector_type (builtin_type_int32, 4);
builtin_type_v8_int16 = init_vector_type (builtin_type_int16, 8);
builtin_type_v16_int8 = init_vector_type (builtin_type_int8, 16);
/* 64 bit vectors.  */
builtin_type_v2_float = init_vector_type (builtin_type_float, 2);
builtin_type_v2_int32 = init_vector_type (builtin_type_int32, 2);
builtin_type_v4_int16 = init_vector_type (builtin_type_int16, 4);
builtin_type_v8_int8 = init_vector_type (builtin_type_int8, 8);

/* Vector types.  */
builtin_type_vec64 = build_builtin_type_vec64 ();
builtin_type_vec64i = build_builtin_type_vec64i ();
builtin_type_vec128 = build_builtin_type_vec128 ();
builtin_type_vec128i = build_builtin_type_vec128i ();

/* Pointer/Address types. */

/* NOTE: on some targets, addresses and pointers are not necessarily
   the same --- for example, on the D10V, pointers are 16 bits long,
   but addresses are 32 bits long.  See doc/gdbint.texinfo,
   ``Pointers Are Not Always Addresses''.

   The upshot is:
   - gdb's `struct type' always describes the target's
     representation.
   - gdb's `struct value' objects should always hold values in
     target form.
   - gdb's CORE_ADDR values are addresses in the unified virtual
     address space that the assembler and linker work with.  Thus,
     since target_read_memory takes a CORE_ADDR as an argument, it
     can access any memory on the target, even if the processor has
     separate code and data address spaces.

   So, for example:
   - If v is a value holding a D10V code pointer, its contents are
     in target form: a big-endian address left-shifted two bits.
   - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
     sizeof (void *) == 2 on the target.

   In this context, builtin_type_CORE_ADDR is a bit odd: it's a
   target type for a value the target will never see.  It's only
   used to hold the values of (typeless) linker symbols, which are
   indeed in the unified virtual address space.  */
builtin_type_void_data_ptr = make_pointer_type (builtin_type_void, NULL((void*)0));
builtin_type_void_func_ptr
  = lookup_pointer_type (lookup_function_type (builtin_type_void));
builtin_type_CORE_ADDR =
  init_type (TYPE_CODE_INT, TARGET_ADDR_BIT(gdbarch_addr_bit (current_gdbarch)) / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "__CORE_ADDR", (struct objfile *) NULL((void*)0));
builtin_type_bfd_vma =
  init_type (TYPE_CODE_INT, TARGET_BFD_VMA_BIT(gdbarch_bfd_vma_bit (current_gdbarch)) / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "__bfd_vma", (struct objfile *) NULL((void*)0));
3310}

3312static struct gdbarch_data *gdbtypes_data;

3314const struct builtin_type *
3315builtin_type (struct gdbarch *gdbarch)
3316{
return gdbarch_data (gdbarch, gdbtypes_data);
3318}


3321static struct type *
3322build_flt (int bit, char *name, const struct floatformat *floatformat)
3323{
struct type *t;
if (bit <= 0 || floatformat == NULL((void*)0))
  {
    gdb_assert (builtin_type_error != NULL)((void) ((builtin_type_error != ((void*)0)) ? 0 : (internal_error
 ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c", 3327, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "builtin_type_error != NULL"), 0)));
    return builtin_type_error;
  }
t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT8,
 0, name, (struct objfile *) NULL((void*)0));
TYPE_FLOATFORMAT (t)(t)->main_type->type_specific.floatformat = floatformat;
return t;
3334}

3336static struct type *
3337build_complex (int bit, char *name, struct type *target_type)
3338{
struct type *t;
if (bit <= 0 || target_type == builtin_type_error)
  {
    gdb_assert (builtin_type_error != NULL)((void) ((builtin_type_error != ((void*)0)) ? 0 : (internal_error
 ("/usr/src/gnu/usr.bin/binutils/gdb/gdbtypes.c", 3342, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "builtin_type_error != NULL"), 0)));
    return builtin_type_error;
  }
t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT8,
 0, name, (struct objfile *) NULL((void*)0));
TYPE_TARGET_TYPE (t)(t)->main_type->target_type = target_type;
return t;
3349}

3351static void *
3352gdbtypes_post_init (struct gdbarch *gdbarch)
3353{
struct builtin_type *builtin_type
  = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type)((struct builtin_type *) gdbarch_obstack_zalloc ((gdbarch), sizeof
 (struct builtin_type)));

builtin_type->builtin_void =
  init_type (TYPE_CODE_VOID, 1,
      0,
      "void", (struct objfile *) NULL((void*)0));
builtin_type->builtin_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      (TYPE_FLAG_NOSIGN(1 << 1)
              | (TARGET_CHAR_SIGNED(gdbarch_char_signed (current_gdbarch)) ? 0 : TYPE_FLAG_UNSIGNED(1 << 0))),
      "char", (struct objfile *) NULL((void*)0));
builtin_type->builtin_true_char =
  init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "true character", (struct objfile *) NULL((void*)0));
builtin_type->builtin_signed_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "signed char", (struct objfile *) NULL((void*)0));
builtin_type->builtin_unsigned_char =
  init_type (TYPE_CODE_INT, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned char", (struct objfile *) NULL((void*)0));
builtin_type->builtin_short =
  init_type (TYPE_CODE_INT, TARGET_SHORT_BIT(gdbarch_short_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "short", (struct objfile *) NULL((void*)0));
builtin_type->builtin_unsigned_short =
  init_type (TYPE_CODE_INT, TARGET_SHORT_BIT(gdbarch_short_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned short", (struct objfile *) NULL((void*)0));
builtin_type->builtin_int =
  init_type (TYPE_CODE_INT, TARGET_INT_BIT(gdbarch_int_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "int", (struct objfile *) NULL((void*)0));
builtin_type->builtin_unsigned_int =
  init_type (TYPE_CODE_INT, TARGET_INT_BIT(gdbarch_int_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned int", (struct objfile *) NULL((void*)0));
builtin_type->builtin_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "long", (struct objfile *) NULL((void*)0));
builtin_type->builtin_unsigned_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_BIT(gdbarch_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned long", (struct objfile *) NULL((void*)0));
builtin_type->builtin_long_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT(gdbarch_long_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      0,
      "long long", (struct objfile *) NULL((void*)0));
builtin_type->builtin_unsigned_long_long =
  init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT(gdbarch_long_long_bit (current_gdbarch)) / TARGET_CHAR_BIT8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "unsigned long long", (struct objfile *) NULL((void*)0));
builtin_type->builtin_float
  = build_flt (gdbarch_float_bit (gdbarch), "float",
 gdbarch_float_format (gdbarch));
builtin_type->builtin_double
  = build_flt (gdbarch_double_bit (gdbarch), "double",
 gdbarch_double_format (gdbarch));
builtin_type->builtin_long_double
  = build_flt (gdbarch_long_double_bit (gdbarch), "long double",
 gdbarch_long_double_format (gdbarch));
builtin_type->builtin_complex
  = build_complex (gdbarch_float_bit (gdbarch), "complex",
     builtin_type->builtin_float);
builtin_type->builtin_double_complex
  = build_complex (gdbarch_double_bit (gdbarch), "double complex",
     builtin_type->builtin_double);
builtin_type->builtin_string =
  init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "string", (struct objfile *) NULL((void*)0));
builtin_type->builtin_bool =
  init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT8 / TARGET_CHAR_BIT8,
      0,
      "bool", (struct objfile *) NULL((void*)0));

/* Pointer/Address types. */

/* NOTE: on some targets, addresses and pointers are not necessarily
   the same --- for example, on the D10V, pointers are 16 bits long,
   but addresses are 32 bits long.  See doc/gdbint.texinfo,
   ``Pointers Are Not Always Addresses''.

   The upshot is:
   - gdb's `struct type' always describes the target's
     representation.
   - gdb's `struct value' objects should always hold values in
     target form.
   - gdb's CORE_ADDR values are addresses in the unified virtual
     address space that the assembler and linker work with.  Thus,
     since target_read_memory takes a CORE_ADDR as an argument, it
     can access any memory on the target, even if the processor has
     separate code and data address spaces.

   So, for example:
   - If v is a value holding a D10V code pointer, its contents are
     in target form: a big-endian address left-shifted two bits.
   - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
     sizeof (void *) == 2 on the target.

   In this context, builtin_type->CORE_ADDR is a bit odd: it's a
   target type for a value the target will never see.  It's only
   used to hold the values of (typeless) linker symbols, which are
   indeed in the unified virtual address space.  */
builtin_type->builtin_data_ptr
  = make_pointer_type (builtin_type->builtin_void, NULL((void*)0));
builtin_type->builtin_func_ptr
  = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
builtin_type->builtin_core_addr =
  init_type (TYPE_CODE_INT, TARGET_ADDR_BIT(gdbarch_addr_bit (current_gdbarch)) / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "__CORE_ADDR", (struct objfile *) NULL((void*)0));

return builtin_type;
3472}

3474extern void _initialize_gdbtypes (void);
3475void
3476_initialize_gdbtypes (void)
3477{
struct cmd_list_element *c;

builtin_type_int0 =
  init_type (TYPE_CODE_INT, 0 / 8,
      0,
      "int0_t", (struct objfile *) NULL((void*)0));
builtin_type_int8 =
  init_type (TYPE_CODE_INT, 8 / 8,
      0,
      "int8_t", (struct objfile *) NULL((void*)0));
builtin_type_uint8 =
  init_type (TYPE_CODE_INT, 8 / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "uint8_t", (struct objfile *) NULL((void*)0));
builtin_type_int16 =
  init_type (TYPE_CODE_INT, 16 / 8,
      0,
      "int16_t", (struct objfile *) NULL((void*)0));
builtin_type_uint16 =
  init_type (TYPE_CODE_INT, 16 / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "uint16_t", (struct objfile *) NULL((void*)0));
builtin_type_int32 =
  init_type (TYPE_CODE_INT, 32 / 8,
      0,
      "int32_t", (struct objfile *) NULL((void*)0));
builtin_type_uint32 =
  init_type (TYPE_CODE_INT, 32 / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "uint32_t", (struct objfile *) NULL((void*)0));
builtin_type_int64 =
  init_type (TYPE_CODE_INT, 64 / 8,
      0,
      "int64_t", (struct objfile *) NULL((void*)0));
builtin_type_uint64 =
  init_type (TYPE_CODE_INT, 64 / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "uint64_t", (struct objfile *) NULL((void*)0));
builtin_type_int128 =
  init_type (TYPE_CODE_INT, 128 / 8,
      0,
      "int128_t", (struct objfile *) NULL((void*)0));
builtin_type_uint128 =
  init_type (TYPE_CODE_INT, 128 / 8,
      TYPE_FLAG_UNSIGNED(1 << 0),
      "uint128_t", (struct objfile *) NULL((void*)0));

build_gdbtypes ();

gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);

/* FIXME - For the moment, handle types by swapping them in and out.
   Should be using the per-architecture data-pointer and a large
   struct. */
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void)deprecated_register_gdbarch_swap (&(builtin_type_void), sizeof
 ((builtin_type_void)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char)deprecated_register_gdbarch_swap (&(builtin_type_char), sizeof
 ((builtin_type_char)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short)deprecated_register_gdbarch_swap (&(builtin_type_short), sizeof
 ((builtin_type_short)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int)deprecated_register_gdbarch_swap (&(builtin_type_int), sizeof
 ((builtin_type_int)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long)deprecated_register_gdbarch_swap (&(builtin_type_long), sizeof
 ((builtin_type_long)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long)deprecated_register_gdbarch_swap (&(builtin_type_long_long
), sizeof ((builtin_type_long_long)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char)deprecated_register_gdbarch_swap (&(builtin_type_signed_char
), sizeof ((builtin_type_signed_char)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char)deprecated_register_gdbarch_swap (&(builtin_type_unsigned_char
), sizeof ((builtin_type_unsigned_char)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short)deprecated_register_gdbarch_swap (&(builtin_type_unsigned_short
), sizeof ((builtin_type_unsigned_short)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int)deprecated_register_gdbarch_swap (&(builtin_type_unsigned_int
), sizeof ((builtin_type_unsigned_int)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long)deprecated_register_gdbarch_swap (&(builtin_type_unsigned_long
), sizeof ((builtin_type_unsigned_long)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long)deprecated_register_gdbarch_swap (&(builtin_type_unsigned_long_long
), sizeof ((builtin_type_unsigned_long_long)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float)deprecated_register_gdbarch_swap (&(builtin_type_float), sizeof
 ((builtin_type_float)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double)deprecated_register_gdbarch_swap (&(builtin_type_double),
 sizeof ((builtin_type_double)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double)deprecated_register_gdbarch_swap (&(builtin_type_long_double
), sizeof ((builtin_type_long_double)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex)deprecated_register_gdbarch_swap (&(builtin_type_complex)
, sizeof ((builtin_type_complex)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex)deprecated_register_gdbarch_swap (&(builtin_type_double_complex
), sizeof ((builtin_type_double_complex)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string)deprecated_register_gdbarch_swap (&(builtin_type_string),
 sizeof ((builtin_type_string)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf)deprecated_register_gdbarch_swap (&(builtin_type_v4sf), sizeof
 ((builtin_type_v4sf)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si)deprecated_register_gdbarch_swap (&(builtin_type_v4si), sizeof
 ((builtin_type_v4si)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi)deprecated_register_gdbarch_swap (&(builtin_type_v16qi), sizeof
 ((builtin_type_v16qi)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi)deprecated_register_gdbarch_swap (&(builtin_type_v8qi), sizeof
 ((builtin_type_v8qi)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi)deprecated_register_gdbarch_swap (&(builtin_type_v8hi), sizeof
 ((builtin_type_v8hi)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi)deprecated_register_gdbarch_swap (&(builtin_type_v4hi), sizeof
 ((builtin_type_v4hi)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si)deprecated_register_gdbarch_swap (&(builtin_type_v2si), sizeof
 ((builtin_type_v2si)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double)deprecated_register_gdbarch_swap (&(builtin_type_v2_double
), sizeof ((builtin_type_v2_double)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float)deprecated_register_gdbarch_swap (&(builtin_type_v4_float
), sizeof ((builtin_type_v4_float)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64)deprecated_register_gdbarch_swap (&(builtin_type_v2_int64
), sizeof ((builtin_type_v2_int64)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32)deprecated_register_gdbarch_swap (&(builtin_type_v4_int32
), sizeof ((builtin_type_v4_int32)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16)deprecated_register_gdbarch_swap (&(builtin_type_v8_int16
), sizeof ((builtin_type_v8_int16)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8)deprecated_register_gdbarch_swap (&(builtin_type_v16_int8
), sizeof ((builtin_type_v16_int8)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float)deprecated_register_gdbarch_swap (&(builtin_type_v2_float
), sizeof ((builtin_type_v2_float)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32)deprecated_register_gdbarch_swap (&(builtin_type_v2_int32
), sizeof ((builtin_type_v2_int32)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8)deprecated_register_gdbarch_swap (&(builtin_type_v8_int8)
, sizeof ((builtin_type_v8_int8)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16)deprecated_register_gdbarch_swap (&(builtin_type_v4_int16
), sizeof ((builtin_type_v4_int16)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128)deprecated_register_gdbarch_swap (&(builtin_type_vec128),
 sizeof ((builtin_type_vec128)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128i)deprecated_register_gdbarch_swap (&(builtin_type_vec128i)
, sizeof ((builtin_type_vec128i)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr)deprecated_register_gdbarch_swap (&(builtin_type_void_data_ptr
), sizeof ((builtin_type_void_data_ptr)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr)deprecated_register_gdbarch_swap (&(builtin_type_void_func_ptr
), sizeof ((builtin_type_void_func_ptr)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR)deprecated_register_gdbarch_swap (&(builtin_type_CORE_ADDR
), sizeof ((builtin_type_CORE_ADDR)), ((void*)0));
DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma)deprecated_register_gdbarch_swap (&(builtin_type_bfd_vma)
, sizeof ((builtin_type_bfd_vma)), ((void*)0));
deprecated_register_gdbarch_swap (NULL((void*)0), 0, build_gdbtypes);

/* Note: These types do not need to be swapped - they are target
   neutral.  */
builtin_type_ieee_single_big =
  init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8,
      0, "builtin_type_ieee_single_big", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ieee_single_big)(builtin_type_ieee_single_big)->main_type->type_specific
.floatformat = &floatformat_ieee_single_big;
builtin_type_ieee_single_little =
  init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8,
      0, "builtin_type_ieee_single_little", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ieee_single_little)(builtin_type_ieee_single_little)->main_type->type_specific
.floatformat = &floatformat_ieee_single_little;
builtin_type_ieee_single[BFD_ENDIAN_BIG]
  = build_flt (floatformat_ieee_single_big.totalsize,
 "builtin_type_ieee_single_big",
 &floatformat_ieee_single_big);
builtin_type_ieee_single[BFD_ENDIAN_LITTLE]
  = build_flt (floatformat_ieee_single_little.totalsize,
 "builtin_type_ieee_single_little",
 &floatformat_ieee_single_little);
builtin_type_ieee_double_big =
  init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8,
      0, "builtin_type_ieee_double_big", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ieee_double_big)(builtin_type_ieee_double_big)->main_type->type_specific
.floatformat = &floatformat_ieee_double_big;
builtin_type_ieee_double_little =
  init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8,
      0, "builtin_type_ieee_double_little", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ieee_double_little)(builtin_type_ieee_double_little)->main_type->type_specific
.floatformat = &floatformat_ieee_double_little;
builtin_type_ieee_double[BFD_ENDIAN_BIG]
  = build_flt (floatformat_ieee_double_big.totalsize,
 "builtin_type_ieee_double_big",
 &floatformat_ieee_double_big);
builtin_type_ieee_double[BFD_ENDIAN_LITTLE]
  = build_flt (floatformat_ieee_double_little.totalsize,
 "builtin_type_ieee_double_little",
 &floatformat_ieee_double_little);
builtin_type_ieee_double_littlebyte_bigword =
  init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8,
      0, "builtin_type_ieee_double_littlebyte_bigword", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword)(builtin_type_ieee_double_littlebyte_bigword)->main_type->
type_specific.floatformat = &floatformat_ieee_double_littlebyte_bigword;
builtin_type_i387_ext =
  init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8,
      0, "builtin_type_i387_ext", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_i387_ext)(builtin_type_i387_ext)->main_type->type_specific.floatformat = &floatformat_i387_ext;
builtin_type_m68881_ext =
  init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8,
      0, "builtin_type_m68881_ext", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_m68881_ext)(builtin_type_m68881_ext)->main_type->type_specific.floatformat = &floatformat_m68881_ext;
builtin_type_i960_ext =
  init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8,
      0, "builtin_type_i960_ext", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_i960_ext)(builtin_type_i960_ext)->main_type->type_specific.floatformat = &floatformat_i960_ext;
builtin_type_m88110_ext =
  init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8,
      0, "builtin_type_m88110_ext", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_m88110_ext)(builtin_type_m88110_ext)->main_type->type_specific.floatformat = &floatformat_m88110_ext;
builtin_type_m88110_harris_ext =
  init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8,
      0, "builtin_type_m88110_harris_ext", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext)(builtin_type_m88110_harris_ext)->main_type->type_specific
.floatformat = &floatformat_m88110_harris_ext;
builtin_type_arm_ext_big =
  init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8,
      0, "builtin_type_arm_ext_big", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_arm_ext_big)(builtin_type_arm_ext_big)->main_type->type_specific.floatformat = &floatformat_arm_ext_big;
builtin_type_arm_ext_littlebyte_bigword =
  init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8,
      0, "builtin_type_arm_ext_littlebyte_bigword", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword)(builtin_type_arm_ext_littlebyte_bigword)->main_type->type_specific
.floatformat = &floatformat_arm_ext_littlebyte_bigword;
builtin_type_arm_ext[BFD_ENDIAN_BIG]
  = build_flt (floatformat_arm_ext_big.totalsize,
 "builtin_type_arm_ext_big",
 &floatformat_arm_ext_big);
builtin_type_arm_ext[BFD_ENDIAN_LITTLE]
  = build_flt (floatformat_arm_ext_littlebyte_bigword.totalsize,
 "builtin_type_arm_ext_littlebyte_bigword",
 &floatformat_arm_ext_littlebyte_bigword);
builtin_type_ia64_spill_big =
  init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8,
      0, "builtin_type_ia64_spill_big", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ia64_spill_big)(builtin_type_ia64_spill_big)->main_type->type_specific
.floatformat = &floatformat_ia64_spill_big;
builtin_type_ia64_spill_little =
  init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8,
      0, "builtin_type_ia64_spill_little", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ia64_spill_little)(builtin_type_ia64_spill_little)->main_type->type_specific
.floatformat = &floatformat_ia64_spill_little;
builtin_type_ia64_spill[BFD_ENDIAN_BIG]
  = build_flt (floatformat_ia64_spill_big.totalsize,
 "builtin_type_ia64_spill_big",
 &floatformat_ia64_spill_big);
builtin_type_ia64_spill[BFD_ENDIAN_LITTLE]
  = build_flt (floatformat_ia64_spill_little.totalsize,
 "builtin_type_ia64_spill_little",
 &floatformat_ia64_spill_little);
builtin_type_ia64_quad_big =
  init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8,
      0, "builtin_type_ia64_quad_big", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ia64_quad_big)(builtin_type_ia64_quad_big)->main_type->type_specific.
floatformat = &floatformat_ia64_quad_big;
builtin_type_ia64_quad_little =
  init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8,
      0, "builtin_type_ia64_quad_little", NULL((void*)0));
TYPE_FLOATFORMAT (builtin_type_ia64_quad_little)(builtin_type_ia64_quad_little)->main_type->type_specific
.floatformat = &floatformat_ia64_quad_little;
builtin_type_ia64_quad[BFD_ENDIAN_BIG]
  = build_flt (floatformat_ia64_quad_big.totalsize,
 "builtin_type_ia64_quad_big",
 &floatformat_ia64_quad_big);
builtin_type_ia64_quad[BFD_ENDIAN_LITTLE]
  = build_flt (floatformat_ia64_quad_little.totalsize,
 "builtin_type_ia64_quad_little",
 &floatformat_ia64_quad_little);

deprecated_add_show_from_set
  (add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
  "Set debugging of C++ overloading.\n\
3685When enabled, ranking of the functions is displayed.", &setdebuglist),
   &showdebuglist);
3687}