gcc/dwarf2out.c

   1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
   2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003 Free Software Foundation, Inc.
   4    Contributed by Gary Funck (gary@intrepid.com).
   5    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
   6    Extensively modified by Jason Merrill (jason@cygnus.com).
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 2, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to the Free
  22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  23 02111-1307, USA.  */
  24
  25 /* TODO: Emit .debug_line header even when there are no functions, since
  26            the file numbers are used by .debug_info.  Alternately, leave
  27            out locations for types and decls.
  28          Avoid talking about ctors and op= for PODs.
  29          Factor out common prologue sequences into multiple CIEs.  */
  30
  31 /* The first part of this file deals with the DWARF 2 frame unwind
  32    information, which is also used by the GCC efficient exception handling
  33    mechanism.  The second part, controlled only by an #ifdef
  34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  35    information.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "coretypes.h"
  40 #include "tm.h"
  41 #include "tree.h"
  42 #include "flags.h"
  43 #include "real.h"
  44 #include "rtl.h"
  45 #include "hard-reg-set.h"
  46 #include "regs.h"
  47 #include "insn-config.h"
  48 #include "reload.h"
  49 #include "function.h"
  50 #include "output.h"
  51 #include "expr.h"
  52 #include "libfuncs.h"
  53 #include "except.h"
  54 #include "dwarf2.h"
  55 #include "dwarf2out.h"
  56 #include "dwarf2asm.h"
  57 #include "toplev.h"
  58 #include "varray.h"
  59 #include "ggc.h"
  60 #include "md5.h"
  61 #include "tm_p.h"
  62 #include "diagnostic.h"
  63 #include "debug.h"
  64 #include "target.h"
  65 #include "langhooks.h"
  66 #include "hashtab.h"
  67
  68 #ifdef DWARF2_DEBUGGING_INFO
  69 static void dwarf2out_source_line       PARAMS ((unsigned int, const char *));
  70 #endif
  71
  72 /* DWARF2 Abbreviation Glossary:
  73    CFA = Canonical Frame Address
  74            a fixed address on the stack which identifies a call frame.
  75            We define it to be the value of SP just before the call insn.
  76            The CFA register and offset, which may change during the course
  77            of the function, are used to calculate its value at runtime.
  78    CFI = Call Frame Instruction
  79            an instruction for the DWARF2 abstract machine
  80    CIE = Common Information Entry
  81            information describing information common to one or more FDEs
  82    DIE = Debugging Information Entry
  83    FDE = Frame Description Entry
  84            information describing the stack call frame, in particular,
  85            how to restore registers
  86
  87    DW_CFA_... = DWARF2 CFA call frame instruction
  88    DW_TAG_... = DWARF2 DIE tag */
  89
  90 /* Decide whether we want to emit frame unwind information for the current
  91    translation unit.  */
  92
  93 int
  94 dwarf2out_do_frame ()
  95 {
  96   return (write_symbols == DWARF2_DEBUG
  97           || write_symbols == VMS_AND_DWARF2_DEBUG
  98 #ifdef DWARF2_FRAME_INFO
  99           || DWARF2_FRAME_INFO
 100 #endif
 101 #ifdef DWARF2_UNWIND_INFO
 102           || flag_unwind_tables
 103           || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)
 104 #endif
 105           );
 106 }
 107
 108 /* The size of the target's pointer type.  */
 109 #ifndef PTR_SIZE
 110 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 111 #endif
 112
 113 /* Default version of targetm.eh_frame_section.  Note this must appear
 114    outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro
 115    guards.  */
 116
 117 void
 118 default_eh_frame_section ()
 119 {
 120 #ifdef EH_FRAME_SECTION_NAME
 121 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
 122   int fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
 123   int per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
 124   int lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
 125   int flags;
 126
 127   flags = (! flag_pic
 128            || ((fde_encoding & 0x70) != DW_EH_PE_absptr
 129                && (fde_encoding & 0x70) != DW_EH_PE_aligned
 130                && (per_encoding & 0x70) != DW_EH_PE_absptr
 131                && (per_encoding & 0x70) != DW_EH_PE_aligned
 132                && (lsda_encoding & 0x70) != DW_EH_PE_absptr
 133                && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
 134           ? 0 : SECTION_WRITE;
 135   named_section_flags (EH_FRAME_SECTION_NAME, flags);
 136 #else
 137   named_section_flags (EH_FRAME_SECTION_NAME, SECTION_WRITE);
 138 #endif
 139 #else
 140   tree label = get_file_function_name ('F');
 141
 142   data_section ();
 143   ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
 144   (*targetm.asm_out.globalize_label) (asm_out_file, IDENTIFIER_POINTER (label));
 145   ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
 146 #endif
 147 }
 148
 149 /* Array of RTXes referenced by the debugging information, which therefore
 150    must be kept around forever.  */
 151 static GTY(()) varray_type used_rtx_varray;
 152
 153 /* A pointer to the base of a list of incomplete types which might be
 154    completed at some later time.  incomplete_types_list needs to be a VARRAY
 155    because we want to tell the garbage collector about it.  */
 156 static GTY(()) varray_type incomplete_types;
 157
 158 /* A pointer to the base of a table of references to declaration
 159    scopes.  This table is a display which tracks the nesting
 160    of declaration scopes at the current scope and containing
 161    scopes.  This table is used to find the proper place to
 162    define type declaration DIE's.  */
 163 static GTY(()) varray_type decl_scope_table;
 164
 165 /* How to start an assembler comment.  */
 166 #ifndef ASM_COMMENT_START
 167 #define ASM_COMMENT_START ";#"
 168 #endif
 169
 170 typedef struct dw_cfi_struct *dw_cfi_ref;
 171 typedef struct dw_fde_struct *dw_fde_ref;
 172 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 173
 174 /* Call frames are described using a sequence of Call Frame
 175    Information instructions.  The register number, offset
 176    and address fields are provided as possible operands;
 177    their use is selected by the opcode field.  */
 178
 179 enum dw_cfi_oprnd_type {
 180   dw_cfi_oprnd_unused,
 181   dw_cfi_oprnd_reg_num,
 182   dw_cfi_oprnd_offset,
 183   dw_cfi_oprnd_addr,
 184   dw_cfi_oprnd_loc
 185 };
 186
 187 typedef union dw_cfi_oprnd_struct GTY(())
 188 {
 189   unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 190   long int GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 191   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 192   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 193 }
 194 dw_cfi_oprnd;
 195
 196 typedef struct dw_cfi_struct GTY(())
 197 {
 198   dw_cfi_ref dw_cfi_next;
 199   enum dwarf_call_frame_info dw_cfi_opc;
 200   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 201     dw_cfi_oprnd1;
 202   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 203     dw_cfi_oprnd2;
 204 }
 205 dw_cfi_node;
 206
 207 /* This is how we define the location of the CFA. We use to handle it
 208    as REG + OFFSET all the time,  but now it can be more complex.
 209    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 210    Instead of passing around REG and OFFSET, we pass a copy
 211    of this structure.  */
 212 typedef struct cfa_loc GTY(())
 213 {
 214   unsigned long reg;
 215   long offset;
 216   long base_offset;
 217   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 218 } dw_cfa_location;
 219
 220 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 221    refer to a single Common Information Entry (CIE), defined at
 222    the beginning of the .debug_frame section.  This use of a single
 223    CIE obviates the need to keep track of multiple CIE's
 224    in the DWARF generation routines below.  */
 225
 226 typedef struct dw_fde_struct GTY(())
 227 {
 228   const char *dw_fde_begin;
 229   const char *dw_fde_current_label;
 230   const char *dw_fde_end;
 231   dw_cfi_ref dw_fde_cfi;
 232   unsigned funcdef_number;
 233   unsigned all_throwers_are_sibcalls : 1;
 234   unsigned nothrow : 1;
 235   unsigned uses_eh_lsda : 1;
 236 }
 237 dw_fde_node;
 238
 239 /* Maximum size (in bytes) of an artificially generated label.  */
 240 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 241
 242 /* The size of addresses as they appear in the Dwarf 2 data.
 243    Some architectures use word addresses to refer to code locations,
 244    but Dwarf 2 info always uses byte addresses.  On such machines,
 245    Dwarf 2 addresses need to be larger than the architecture's
 246    pointers.  */
 247 #ifndef DWARF2_ADDR_SIZE
 248 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 249 #endif
 250
 251 /* The size in bytes of a DWARF field indicating an offset or length
 252    relative to a debug info section, specified to be 4 bytes in the
 253    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 254    as PTR_SIZE.  */
 255
 256 #ifndef DWARF_OFFSET_SIZE
 257 #define DWARF_OFFSET_SIZE 4
 258 #endif
 259
 260 #define DWARF_VERSION 2
 261
 262 /* Round SIZE up to the nearest BOUNDARY.  */
 263 #define DWARF_ROUND(SIZE,BOUNDARY) \
 264   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 265
 266 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 267 #ifndef DWARF_CIE_DATA_ALIGNMENT
 268 #ifdef STACK_GROWS_DOWNWARD
 269 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 270 #else
 271 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 272 #endif
 273 #endif
 274
 275 /* A pointer to the base of a table that contains frame description
 276    information for each routine.  */
 277 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 278
 279 /* Number of elements currently allocated for fde_table.  */
 280 static unsigned fde_table_allocated;
 281
 282 /* Number of elements in fde_table currently in use.  */
 283 static GTY(()) unsigned fde_table_in_use;
 284
 285 /* Size (in elements) of increments by which we may expand the
 286    fde_table.  */
 287 #define FDE_TABLE_INCREMENT 256
 288
 289 /* A list of call frame insns for the CIE.  */
 290 static GTY(()) dw_cfi_ref cie_cfi_head;
 291
 292 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 293 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 294    attribute that accelerates the lookup of the FDE associated
 295    with the subprogram.  This variable holds the table index of the FDE
 296    associated with the current function (body) definition.  */
 297 static unsigned current_funcdef_fde;
 298 #endif
 299
 300 struct indirect_string_node GTY(())
 301 {
 302   const char *str;
 303   unsigned int refcount;
 304   unsigned int form;
 305   char *label;
 306 };
 307
 308 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 309
 310 static GTY(()) int dw2_string_counter;
 311 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 312
 313 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 314
 315 /* Forward declarations for functions defined in this file.  */
 316
 317 static char *stripattributes            PARAMS ((const char *));
 318 static const char *dwarf_cfi_name       PARAMS ((unsigned));
 319 static dw_cfi_ref new_cfi               PARAMS ((void));
 320 static void add_cfi                     PARAMS ((dw_cfi_ref *, dw_cfi_ref));
 321 static void add_fde_cfi                 PARAMS ((const char *, dw_cfi_ref));
 322 static void lookup_cfa_1                PARAMS ((dw_cfi_ref,
 323                                                  dw_cfa_location *));
 324 static void lookup_cfa                  PARAMS ((dw_cfa_location *));
 325 static void reg_save                    PARAMS ((const char *, unsigned,
 326                                                  unsigned, long));
 327 static void initial_return_save         PARAMS ((rtx));
 328 static long stack_adjust_offset         PARAMS ((rtx));
 329 static void output_cfi                  PARAMS ((dw_cfi_ref, dw_fde_ref, int));
 330 static void output_call_frame_info      PARAMS ((int));
 331 static void dwarf2out_stack_adjust      PARAMS ((rtx));
 332 static void queue_reg_save              PARAMS ((const char *, rtx, long));
 333 static void flush_queued_reg_saves      PARAMS ((void));
 334 static bool clobbers_queued_reg_save    PARAMS ((rtx));
 335 static void dwarf2out_frame_debug_expr  PARAMS ((rtx, const char *));
 336
 337 /* Support for complex CFA locations.  */
 338 static void output_cfa_loc              PARAMS ((dw_cfi_ref));
 339 static void get_cfa_from_loc_descr      PARAMS ((dw_cfa_location *,
 340                                                 struct dw_loc_descr_struct *));
 341 static struct dw_loc_descr_struct *build_cfa_loc
 342                                         PARAMS ((dw_cfa_location *));
 343 static void def_cfa_1                   PARAMS ((const char *,
 344                                                  dw_cfa_location *));
 345
 346 /* How to start an assembler comment.  */
 347 #ifndef ASM_COMMENT_START
 348 #define ASM_COMMENT_START ";#"
 349 #endif
 350
 351 /* Data and reference forms for relocatable data.  */
 352 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 353 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 354
 355 #ifndef DEBUG_FRAME_SECTION
 356 #define DEBUG_FRAME_SECTION     ".debug_frame"
 357 #endif
 358
 359 #ifndef FUNC_BEGIN_LABEL
 360 #define FUNC_BEGIN_LABEL        "LFB"
 361 #endif
 362
 363 #ifndef FUNC_END_LABEL
 364 #define FUNC_END_LABEL          "LFE"
 365 #endif
 366
 367 #define FRAME_BEGIN_LABEL       "Lframe"
 368 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 369 #define CIE_END_LABEL           "LECIE"
 370 #define FDE_LABEL               "LSFDE"
 371 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 372 #define FDE_END_LABEL           "LEFDE"
 373 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 374 #define LINE_NUMBER_END_LABEL   "LELT"
 375 #define LN_PROLOG_AS_LABEL      "LASLTP"
 376 #define LN_PROLOG_END_LABEL     "LELTP"
 377 #define DIE_LABEL_PREFIX        "DW"
 378
 379 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 380    is the column for PC, or the first column after all of the hard
 381    registers.  */
 382 #ifndef DWARF_FRAME_RETURN_COLUMN
 383 #ifdef PC_REGNUM
 384 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 385 #else
 386 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 387 #endif
 388 #endif
 389
 390 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 391    default, we just provide columns for all registers.  */
 392 #ifndef DWARF_FRAME_REGNUM
 393 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 394 #endif
 395
 396 /* The offset from the incoming value of %sp to the top of the stack frame
 397    for the current function.  */
 398 #ifndef INCOMING_FRAME_SP_OFFSET
 399 #define INCOMING_FRAME_SP_OFFSET 0
 400 #endif
 401 \f
 402 /* Hook used by __throw.  */
 403
 404 rtx
 405 expand_builtin_dwarf_fp_regnum ()
 406 {
 407   return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
 408 }
 409
 410 /* Return a pointer to a copy of the section string name S with all
 411    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 412
 413 static inline char *
 414 stripattributes (s)
 415      const char *s;
 416 {
 417   char *stripped = xmalloc (strlen (s) + 2);
 418   char *p = stripped;
 419
 420   *p++ = '*';
 421
 422   while (*s && *s != ',')
 423     *p++ = *s++;
 424
 425   *p = '\0';
 426   return stripped;
 427 }
 428
 429 /* Generate code to initialize the register size table.  */
 430
 431 void
 432 expand_builtin_init_dwarf_reg_sizes (address)
 433      tree address;
 434 {
 435   int i;
 436   enum machine_mode mode = TYPE_MODE (char_type_node);
 437   rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
 438   rtx mem = gen_rtx_MEM (BLKmode, addr);
 439
 440   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 441     if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
 442       {
 443         HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
 444         HOST_WIDE_INT size = GET_MODE_SIZE (reg_raw_mode[i]);
 445
 446         if (offset < 0)
 447           continue;
 448
 449         emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 450       }
 451 }
 452
 453 /* Convert a DWARF call frame info. operation to its string name */
 454
 455 static const char *
 456 dwarf_cfi_name (cfi_opc)
 457      unsigned cfi_opc;
 458 {
 459   switch (cfi_opc)
 460     {
 461     case DW_CFA_advance_loc:
 462       return "DW_CFA_advance_loc";
 463     case DW_CFA_offset:
 464       return "DW_CFA_offset";
 465     case DW_CFA_restore:
 466       return "DW_CFA_restore";
 467     case DW_CFA_nop:
 468       return "DW_CFA_nop";
 469     case DW_CFA_set_loc:
 470       return "DW_CFA_set_loc";
 471     case DW_CFA_advance_loc1:
 472       return "DW_CFA_advance_loc1";
 473     case DW_CFA_advance_loc2:
 474       return "DW_CFA_advance_loc2";
 475     case DW_CFA_advance_loc4:
 476       return "DW_CFA_advance_loc4";
 477     case DW_CFA_offset_extended:
 478       return "DW_CFA_offset_extended";
 479     case DW_CFA_restore_extended:
 480       return "DW_CFA_restore_extended";
 481     case DW_CFA_undefined:
 482       return "DW_CFA_undefined";
 483     case DW_CFA_same_value:
 484       return "DW_CFA_same_value";
 485     case DW_CFA_register:
 486       return "DW_CFA_register";
 487     case DW_CFA_remember_state:
 488       return "DW_CFA_remember_state";
 489     case DW_CFA_restore_state:
 490       return "DW_CFA_restore_state";
 491     case DW_CFA_def_cfa:
 492       return "DW_CFA_def_cfa";
 493     case DW_CFA_def_cfa_register:
 494       return "DW_CFA_def_cfa_register";
 495     case DW_CFA_def_cfa_offset:
 496       return "DW_CFA_def_cfa_offset";
 497
 498     /* DWARF 3 */
 499     case DW_CFA_def_cfa_expression:
 500       return "DW_CFA_def_cfa_expression";
 501     case DW_CFA_expression:
 502       return "DW_CFA_expression";
 503     case DW_CFA_offset_extended_sf:
 504       return "DW_CFA_offset_extended_sf";
 505     case DW_CFA_def_cfa_sf:
 506       return "DW_CFA_def_cfa_sf";
 507     case DW_CFA_def_cfa_offset_sf:
 508       return "DW_CFA_def_cfa_offset_sf";
 509
 510     /* SGI/MIPS specific */
 511     case DW_CFA_MIPS_advance_loc8:
 512       return "DW_CFA_MIPS_advance_loc8";
 513
 514     /* GNU extensions */
 515     case DW_CFA_GNU_window_save:
 516       return "DW_CFA_GNU_window_save";
 517     case DW_CFA_GNU_args_size:
 518       return "DW_CFA_GNU_args_size";
 519     case DW_CFA_GNU_negative_offset_extended:
 520       return "DW_CFA_GNU_negative_offset_extended";
 521
 522     default:
 523       return "DW_CFA_<unknown>";
 524     }
 525 }
 526
 527 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 528
 529 static inline dw_cfi_ref
 530 new_cfi ()
 531 {
 532   dw_cfi_ref cfi = (dw_cfi_ref) ggc_alloc (sizeof (dw_cfi_node));
 533
 534   cfi->dw_cfi_next = NULL;
 535   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 536   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 537
 538   return cfi;
 539 }
 540
 541 /* Add a Call Frame Instruction to list of instructions.  */
 542
 543 static inline void
 544 add_cfi (list_head, cfi)
 545      dw_cfi_ref *list_head;
 546      dw_cfi_ref cfi;
 547 {
 548   dw_cfi_ref *p;
 549
 550   /* Find the end of the chain.  */
 551   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 552     ;
 553
 554   *p = cfi;
 555 }
 556
 557 /* Generate a new label for the CFI info to refer to.  */
 558
 559 char *
 560 dwarf2out_cfi_label ()
 561 {
 562   static char label[20];
 563
 564   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 565   ASM_OUTPUT_LABEL (asm_out_file, label);
 566   return label;
 567 }
 568
 569 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 570    or to the CIE if LABEL is NULL.  */
 571
 572 static void
 573 add_fde_cfi (label, cfi)
 574      const char *label;
 575      dw_cfi_ref cfi;
 576 {
 577   if (label)
 578     {
 579       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 580
 581       if (*label == 0)
 582         label = dwarf2out_cfi_label ();
 583
 584       if (fde->dw_fde_current_label == NULL
 585           || strcmp (label, fde->dw_fde_current_label) != 0)
 586         {
 587           dw_cfi_ref xcfi;
 588
 589           fde->dw_fde_current_label = label = xstrdup (label);
 590
 591           /* Set the location counter to the new label.  */
 592           xcfi = new_cfi ();
 593           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
 594           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 595           add_cfi (&fde->dw_fde_cfi, xcfi);
 596         }
 597
 598       add_cfi (&fde->dw_fde_cfi, cfi);
 599     }
 600
 601   else
 602     add_cfi (&cie_cfi_head, cfi);
 603 }
 604
 605 /* Subroutine of lookup_cfa.  */
 606
 607 static inline void
 608 lookup_cfa_1 (cfi, loc)
 609      dw_cfi_ref cfi;
 610      dw_cfa_location *loc;
 611 {
 612   switch (cfi->dw_cfi_opc)
 613     {
 614     case DW_CFA_def_cfa_offset:
 615       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 616       break;
 617     case DW_CFA_def_cfa_register:
 618       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 619       break;
 620     case DW_CFA_def_cfa:
 621       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 622       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 623       break;
 624     case DW_CFA_def_cfa_expression:
 625       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 626       break;
 627     default:
 628       break;
 629     }
 630 }
 631
 632 /* Find the previous value for the CFA.  */
 633
 634 static void
 635 lookup_cfa (loc)
 636      dw_cfa_location *loc;
 637 {
 638   dw_cfi_ref cfi;
 639
 640   loc->reg = (unsigned long) -1;
 641   loc->offset = 0;
 642   loc->indirect = 0;
 643   loc->base_offset = 0;
 644
 645   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 646     lookup_cfa_1 (cfi, loc);
 647
 648   if (fde_table_in_use)
 649     {
 650       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 651       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 652         lookup_cfa_1 (cfi, loc);
 653     }
 654 }
 655
 656 /* The current rule for calculating the DWARF2 canonical frame address.  */
 657 static dw_cfa_location cfa;
 658
 659 /* The register used for saving registers to the stack, and its offset
 660    from the CFA.  */
 661 static dw_cfa_location cfa_store;
 662
 663 /* The running total of the size of arguments pushed onto the stack.  */
 664 static long args_size;
 665
 666 /* The last args_size we actually output.  */
 667 static long old_args_size;
 668
 669 /* Entry point to update the canonical frame address (CFA).
 670    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 671    calculated from REG+OFFSET.  */
 672
 673 void
 674 dwarf2out_def_cfa (label, reg, offset)
 675      const char *label;
 676      unsigned reg;
 677      long offset;
 678 {
 679   dw_cfa_location loc;
 680   loc.indirect = 0;
 681   loc.base_offset = 0;
 682   loc.reg = reg;
 683   loc.offset = offset;
 684   def_cfa_1 (label, &loc);
 685 }
 686
 687 /* This routine does the actual work.  The CFA is now calculated from
 688    the dw_cfa_location structure.  */
 689
 690 static void
 691 def_cfa_1 (label, loc_p)
 692      const char *label;
 693      dw_cfa_location *loc_p;
 694 {
 695   dw_cfi_ref cfi;
 696   dw_cfa_location old_cfa, loc;
 697
 698   cfa = *loc_p;
 699   loc = *loc_p;
 700
 701   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 702     cfa_store.offset = loc.offset;
 703
 704   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 705   lookup_cfa (&old_cfa);
 706
 707   /* If nothing changed, no need to issue any call frame instructions.  */
 708   if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset
 709       && loc.indirect == old_cfa.indirect
 710       && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset))
 711     return;
 712
 713   cfi = new_cfi ();
 714
 715   if (loc.reg == old_cfa.reg && !loc.indirect)
 716     {
 717       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
 718          indicating the CFA register did not change but the offset
 719          did.  */
 720       cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 721       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 722     }
 723
 724 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 725   else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1
 726            && !loc.indirect)
 727     {
 728       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 729          indicating the CFA register has changed to <register> but the
 730          offset has not changed.  */
 731       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 732       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 733     }
 734 #endif
 735
 736   else if (loc.indirect == 0)
 737     {
 738       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 739          indicating the CFA register has changed to <register> with
 740          the specified offset.  */
 741       cfi->dw_cfi_opc = DW_CFA_def_cfa;
 742       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 743       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 744     }
 745   else
 746     {
 747       /* Construct a DW_CFA_def_cfa_expression instruction to
 748          calculate the CFA using a full location expression since no
 749          register-offset pair is available.  */
 750       struct dw_loc_descr_struct *loc_list;
 751
 752       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 753       loc_list = build_cfa_loc (&loc);
 754       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 755     }
 756
 757   add_fde_cfi (label, cfi);
 758 }
 759
 760 /* Add the CFI for saving a register.  REG is the CFA column number.
 761    LABEL is passed to add_fde_cfi.
 762    If SREG is -1, the register is saved at OFFSET from the CFA;
 763    otherwise it is saved in SREG.  */
 764
 765 static void
 766 reg_save (label, reg, sreg, offset)
 767      const char *label;
 768      unsigned reg;
 769      unsigned sreg;
 770      long offset;
 771 {
 772   dw_cfi_ref cfi = new_cfi ();
 773
 774   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 775
 776   /* The following comparison is correct. -1 is used to indicate that
 777      the value isn't a register number.  */
 778   if (sreg == (unsigned int) -1)
 779     {
 780       if (reg & ~0x3f)
 781         /* The register number won't fit in 6 bits, so we have to use
 782            the long form.  */
 783         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 784       else
 785         cfi->dw_cfi_opc = DW_CFA_offset;
 786
 787 #ifdef ENABLE_CHECKING
 788       {
 789         /* If we get an offset that is not a multiple of
 790            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 791            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 792            description.  */
 793         long check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 794
 795         if (check_offset * DWARF_CIE_DATA_ALIGNMENT != offset)
 796           abort ();
 797       }
 798 #endif
 799       offset /= DWARF_CIE_DATA_ALIGNMENT;
 800       if (offset < 0)
 801         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 802
 803       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 804     }
 805   else if (sreg == reg)
 806     /* We could emit a DW_CFA_same_value in this case, but don't bother.  */
 807     return;
 808   else
 809     {
 810       cfi->dw_cfi_opc = DW_CFA_register;
 811       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 812     }
 813
 814   add_fde_cfi (label, cfi);
 815 }
 816
 817 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 818    This CFI tells the unwinder that it needs to restore the window registers
 819    from the previous frame's window save area.
 820
 821    ??? Perhaps we should note in the CIE where windows are saved (instead of
 822    assuming 0(cfa)) and what registers are in the window.  */
 823
 824 void
 825 dwarf2out_window_save (label)
 826      const char *label;
 827 {
 828   dw_cfi_ref cfi = new_cfi ();
 829
 830   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 831   add_fde_cfi (label, cfi);
 832 }
 833
 834 /* Add a CFI to update the running total of the size of arguments
 835    pushed onto the stack.  */
 836
 837 void
 838 dwarf2out_args_size (label, size)
 839      const char *label;
 840      long size;
 841 {
 842   dw_cfi_ref cfi;
 843
 844   if (size == old_args_size)
 845     return;
 846
 847   old_args_size = size;
 848
 849   cfi = new_cfi ();
 850   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 851   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 852   add_fde_cfi (label, cfi);
 853 }
 854
 855 /* Entry point for saving a register to the stack.  REG is the GCC register
 856    number.  LABEL and OFFSET are passed to reg_save.  */
 857
 858 void
 859 dwarf2out_reg_save (label, reg, offset)
 860      const char *label;
 861      unsigned reg;
 862      long offset;
 863 {
 864   reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
 865 }
 866
 867 /* Entry point for saving the return address in the stack.
 868    LABEL and OFFSET are passed to reg_save.  */
 869
 870 void
 871 dwarf2out_return_save (label, offset)
 872      const char *label;
 873      long offset;
 874 {
 875   reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
 876 }
 877
 878 /* Entry point for saving the return address in a register.
 879    LABEL and SREG are passed to reg_save.  */
 880
 881 void
 882 dwarf2out_return_reg (label, sreg)
 883      const char *label;
 884      unsigned sreg;
 885 {
 886   reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
 887 }
 888
 889 /* Record the initial position of the return address.  RTL is
 890    INCOMING_RETURN_ADDR_RTX.  */
 891
 892 static void
 893 initial_return_save (rtl)
 894      rtx rtl;
 895 {
 896   unsigned int reg = (unsigned int) -1;
 897   HOST_WIDE_INT offset = 0;
 898
 899   switch (GET_CODE (rtl))
 900     {
 901     case REG:
 902       /* RA is in a register.  */
 903       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 904       break;
 905
 906     case MEM:
 907       /* RA is on the stack.  */
 908       rtl = XEXP (rtl, 0);
 909       switch (GET_CODE (rtl))
 910         {
 911         case REG:
 912           if (REGNO (rtl) != STACK_POINTER_REGNUM)
 913             abort ();
 914           offset = 0;
 915           break;
 916
 917         case PLUS:
 918           if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
 919             abort ();
 920           offset = INTVAL (XEXP (rtl, 1));
 921           break;
 922
 923         case MINUS:
 924           if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
 925             abort ();
 926           offset = -INTVAL (XEXP (rtl, 1));
 927           break;
 928
 929         default:
 930           abort ();
 931         }
 932
 933       break;
 934
 935     case PLUS:
 936       /* The return address is at some offset from any value we can
 937          actually load.  For instance, on the SPARC it is in %i7+8. Just
 938          ignore the offset for now; it doesn't matter for unwinding frames.  */
 939       if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
 940         abort ();
 941       initial_return_save (XEXP (rtl, 0));
 942       return;
 943
 944     default:
 945       abort ();
 946     }
 947
 948   reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
 949 }
 950
 951 /* Given a SET, calculate the amount of stack adjustment it
 952    contains.  */
 953
 954 static long
 955 stack_adjust_offset (pattern)
 956      rtx pattern;
 957 {
 958   rtx src = SET_SRC (pattern);
 959   rtx dest = SET_DEST (pattern);
 960   HOST_WIDE_INT offset = 0;
 961   enum rtx_code code;
 962
 963   if (dest == stack_pointer_rtx)
 964     {
 965       /* (set (reg sp) (plus (reg sp) (const_int))) */
 966       code = GET_CODE (src);
 967       if (! (code == PLUS || code == MINUS)
 968           || XEXP (src, 0) != stack_pointer_rtx
 969           || GET_CODE (XEXP (src, 1)) != CONST_INT)
 970         return 0;
 971
 972       offset = INTVAL (XEXP (src, 1));
 973       if (code == PLUS)
 974         offset = -offset;
 975     }
 976   else if (GET_CODE (dest) == MEM)
 977     {
 978       /* (set (mem (pre_dec (reg sp))) (foo)) */
 979       src = XEXP (dest, 0);
 980       code = GET_CODE (src);
 981
 982       switch (code)
 983         {
 984         case PRE_MODIFY:
 985         case POST_MODIFY:
 986           if (XEXP (src, 0) == stack_pointer_rtx)
 987             {
 988               rtx val = XEXP (XEXP (src, 1), 1);
 989               /* We handle only adjustments by constant amount.  */
 990               if (GET_CODE (XEXP (src, 1)) != PLUS ||
 991                   GET_CODE (val) != CONST_INT)
 992                 abort ();
 993               offset = -INTVAL (val);
 994               break;
 995             }
 996           return 0;
 997
 998         case PRE_DEC:
 999         case POST_DEC:
1000           if (XEXP (src, 0) == stack_pointer_rtx)
1001             {
1002               offset = GET_MODE_SIZE (GET_MODE (dest));
1003               break;
1004             }
1005           return 0;
1006
1007         case PRE_INC:
1008         case POST_INC:
1009           if (XEXP (src, 0) == stack_pointer_rtx)
1010             {
1011               offset = -GET_MODE_SIZE (GET_MODE (dest));
1012               break;
1013             }
1014           return 0;
1015
1016         default:
1017           return 0;
1018         }
1019     }
1020   else
1021     return 0;
1022
1023   return offset;
1024 }
1025
1026 /* Check INSN to see if it looks like a push or a stack adjustment, and
1027    make a note of it if it does.  EH uses this information to find out how
1028    much extra space it needs to pop off the stack.  */
1029
1030 static void
1031 dwarf2out_stack_adjust (insn)
1032      rtx insn;
1033 {
1034   HOST_WIDE_INT offset;
1035   const char *label;
1036   int i;
1037
1038   if (!flag_asynchronous_unwind_tables && GET_CODE (insn) == CALL_INSN)
1039     {
1040       /* Extract the size of the args from the CALL rtx itself.  */
1041       insn = PATTERN (insn);
1042       if (GET_CODE (insn) == PARALLEL)
1043         insn = XVECEXP (insn, 0, 0);
1044       if (GET_CODE (insn) == SET)
1045         insn = SET_SRC (insn);
1046       if (GET_CODE (insn) != CALL)
1047         abort ();
1048
1049       dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1050       return;
1051     }
1052
1053   /* If only calls can throw, and we have a frame pointer,
1054      save up adjustments until we see the CALL_INSN.  */
1055   else if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1056     return;
1057
1058   if (GET_CODE (insn) == BARRIER)
1059     {
1060       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1061          the compiler will have already emitted a stack adjustment, but
1062          doesn't bother for calls to noreturn functions.  */
1063 #ifdef STACK_GROWS_DOWNWARD
1064       offset = -args_size;
1065 #else
1066       offset = args_size;
1067 #endif
1068     }
1069   else if (GET_CODE (PATTERN (insn)) == SET)
1070     offset = stack_adjust_offset (PATTERN (insn));
1071   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1072            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1073     {
1074       /* There may be stack adjustments inside compound insns.  Search
1075          for them.  */
1076       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1077         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1078           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1079     }
1080   else
1081     return;
1082
1083   if (offset == 0)
1084     return;
1085
1086   if (cfa.reg == STACK_POINTER_REGNUM)
1087     cfa.offset += offset;
1088
1089 #ifndef STACK_GROWS_DOWNWARD
1090   offset = -offset;
1091 #endif
1092
1093   args_size += offset;
1094   if (args_size < 0)
1095     args_size = 0;
1096
1097   label = dwarf2out_cfi_label ();
1098   def_cfa_1 (label, &cfa);
1099   dwarf2out_args_size (label, args_size);
1100 }
1101
1102 #endif
1103
1104 /* We delay emitting a register save until either (a) we reach the end
1105    of the prologue or (b) the register is clobbered.  This clusters
1106    register saves so that there are fewer pc advances.  */
1107
1108 struct queued_reg_save GTY(())
1109 {
1110   struct queued_reg_save *next;
1111   rtx reg;
1112   long cfa_offset;
1113 };
1114
1115 static GTY(()) struct queued_reg_save *queued_reg_saves;
1116
1117 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1118 static const char *last_reg_save_label;
1119
1120 static void
1121 queue_reg_save (label, reg, offset)
1122      const char *label;
1123      rtx reg;
1124      long offset;
1125 {
1126   struct queued_reg_save *q = ggc_alloc (sizeof (*q));
1127
1128   q->next = queued_reg_saves;
1129   q->reg = reg;
1130   q->cfa_offset = offset;
1131   queued_reg_saves = q;
1132
1133   last_reg_save_label = label;
1134 }
1135
1136 static void
1137 flush_queued_reg_saves ()
1138 {
1139   struct queued_reg_save *q, *next;
1140
1141   for (q = queued_reg_saves; q; q = next)
1142     {
1143       dwarf2out_reg_save (last_reg_save_label, REGNO (q->reg), q->cfa_offset);
1144       next = q->next;
1145     }
1146
1147   queued_reg_saves = NULL;
1148   last_reg_save_label = NULL;
1149 }
1150
1151 static bool
1152 clobbers_queued_reg_save (insn)
1153      rtx insn;
1154 {
1155   struct queued_reg_save *q;
1156
1157   for (q = queued_reg_saves; q; q = q->next)
1158     if (modified_in_p (q->reg, insn))
1159       return true;
1160
1161   return false;
1162 }
1163
1164
1165 /* A temporary register holding an integral value used in adjusting SP
1166    or setting up the store_reg.  The "offset" field holds the integer
1167    value, not an offset.  */
1168 static dw_cfa_location cfa_temp;
1169
1170 /* Record call frame debugging information for an expression EXPR,
1171    which either sets SP or FP (adjusting how we calculate the frame
1172    address) or saves a register to the stack.  LABEL indicates the
1173    address of EXPR.
1174
1175    This function encodes a state machine mapping rtxes to actions on
1176    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1177    users need not read the source code.
1178
1179   The High-Level Picture
1180
1181   Changes in the register we use to calculate the CFA: Currently we
1182   assume that if you copy the CFA register into another register, we
1183   should take the other one as the new CFA register; this seems to
1184   work pretty well.  If it's wrong for some target, it's simple
1185   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1186
1187   Changes in the register we use for saving registers to the stack:
1188   This is usually SP, but not always.  Again, we deduce that if you
1189   copy SP into another register (and SP is not the CFA register),
1190   then the new register is the one we will be using for register
1191   saves.  This also seems to work.
1192
1193   Register saves: There's not much guesswork about this one; if
1194   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1195   register save, and the register used to calculate the destination
1196   had better be the one we think we're using for this purpose.
1197
1198   Except: If the register being saved is the CFA register, and the
1199   offset is nonzero, we are saving the CFA, so we assume we have to
1200   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1201   the intent is to save the value of SP from the previous frame.
1202
1203   Invariants / Summaries of Rules
1204
1205   cfa          current rule for calculating the CFA.  It usually
1206                consists of a register and an offset.
1207   cfa_store    register used by prologue code to save things to the stack
1208                cfa_store.offset is the offset from the value of
1209                cfa_store.reg to the actual CFA
1210   cfa_temp     register holding an integral value.  cfa_temp.offset
1211                stores the value, which will be used to adjust the
1212                stack pointer.  cfa_temp is also used like cfa_store,
1213                to track stores to the stack via fp or a temp reg.
1214
1215   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1216                with cfa.reg as the first operand changes the cfa.reg and its
1217                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1218                cfa_temp.offset.
1219
1220   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1221                expression yielding a constant.  This sets cfa_temp.reg
1222                and cfa_temp.offset.
1223
1224   Rule 5:      Create a new register cfa_store used to save items to the
1225                stack.
1226
1227   Rules 10-14: Save a register to the stack.  Define offset as the
1228                difference of the original location and cfa_store's
1229                location (or cfa_temp's location if cfa_temp is used).
1230
1231   The Rules
1232
1233   "{a,b}" indicates a choice of a xor b.
1234   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1235
1236   Rule 1:
1237   (set <reg1> <reg2>:cfa.reg)
1238   effects: cfa.reg = <reg1>
1239            cfa.offset unchanged
1240            cfa_temp.reg = <reg1>
1241            cfa_temp.offset = cfa.offset
1242
1243   Rule 2:
1244   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1245                               {<const_int>,<reg>:cfa_temp.reg}))
1246   effects: cfa.reg = sp if fp used
1247            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1248            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1249              if cfa_store.reg==sp
1250
1251   Rule 3:
1252   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1253   effects: cfa.reg = fp
1254            cfa_offset += +/- <const_int>
1255
1256   Rule 4:
1257   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1258   constraints: <reg1> != fp
1259                <reg1> != sp
1260   effects: cfa.reg = <reg1>
1261            cfa_temp.reg = <reg1>
1262            cfa_temp.offset = cfa.offset
1263
1264   Rule 5:
1265   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1266   constraints: <reg1> != fp
1267                <reg1> != sp
1268   effects: cfa_store.reg = <reg1>
1269            cfa_store.offset = cfa.offset - cfa_temp.offset
1270
1271   Rule 6:
1272   (set <reg> <const_int>)
1273   effects: cfa_temp.reg = <reg>
1274            cfa_temp.offset = <const_int>
1275
1276   Rule 7:
1277   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1278   effects: cfa_temp.reg = <reg1>
1279            cfa_temp.offset |= <const_int>
1280
1281   Rule 8:
1282   (set <reg> (high <exp>))
1283   effects: none
1284
1285   Rule 9:
1286   (set <reg> (lo_sum <exp> <const_int>))
1287   effects: cfa_temp.reg = <reg>
1288            cfa_temp.offset = <const_int>
1289
1290   Rule 10:
1291   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1292   effects: cfa_store.offset -= <const_int>
1293            cfa.offset = cfa_store.offset if cfa.reg == sp
1294            cfa.reg = sp
1295            cfa.base_offset = -cfa_store.offset
1296
1297   Rule 11:
1298   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1299   effects: cfa_store.offset += -/+ mode_size(mem)
1300            cfa.offset = cfa_store.offset if cfa.reg == sp
1301            cfa.reg = sp
1302            cfa.base_offset = -cfa_store.offset
1303
1304   Rule 12:
1305   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1306
1307        <reg2>)
1308   effects: cfa.reg = <reg1>
1309            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1310
1311   Rule 13:
1312   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1313   effects: cfa.reg = <reg1>
1314            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1315
1316   Rule 14:
1317   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1318   effects: cfa.reg = <reg1>
1319            cfa.base_offset = -cfa_temp.offset
1320            cfa_temp.offset -= mode_size(mem)  */
1321
1322 static void
1323 dwarf2out_frame_debug_expr (expr, label)
1324      rtx expr;
1325      const char *label;
1326 {
1327   rtx src, dest;
1328   HOST_WIDE_INT offset;
1329
1330   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1331      the PARALLEL independently. The first element is always processed if
1332      it is a SET. This is for backward compatibility.   Other elements
1333      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1334      flag is set in them.  */
1335   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1336     {
1337       int par_index;
1338       int limit = XVECLEN (expr, 0);
1339
1340       for (par_index = 0; par_index < limit; par_index++)
1341         if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1342             && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1343                 || par_index == 0))
1344           dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1345
1346       return;
1347     }
1348
1349   if (GET_CODE (expr) != SET)
1350     abort ();
1351
1352   src = SET_SRC (expr);
1353   dest = SET_DEST (expr);
1354
1355   switch (GET_CODE (dest))
1356     {
1357     case REG:
1358       /* Rule 1 */
1359       /* Update the CFA rule wrt SP or FP.  Make sure src is
1360          relative to the current CFA register.  */
1361       switch (GET_CODE (src))
1362         {
1363           /* Setting FP from SP.  */
1364         case REG:
1365           if (cfa.reg == (unsigned) REGNO (src))
1366             /* OK.  */
1367             ;
1368           else
1369             abort ();
1370
1371           /* We used to require that dest be either SP or FP, but the
1372              ARM copies SP to a temporary register, and from there to
1373              FP.  So we just rely on the backends to only set
1374              RTX_FRAME_RELATED_P on appropriate insns.  */
1375           cfa.reg = REGNO (dest);
1376           cfa_temp.reg = cfa.reg;
1377           cfa_temp.offset = cfa.offset;
1378           break;
1379
1380         case PLUS:
1381         case MINUS:
1382         case LO_SUM:
1383           if (dest == stack_pointer_rtx)
1384             {
1385               /* Rule 2 */
1386               /* Adjusting SP.  */
1387               switch (GET_CODE (XEXP (src, 1)))
1388                 {
1389                 case CONST_INT:
1390                   offset = INTVAL (XEXP (src, 1));
1391                   break;
1392                 case REG:
1393                   if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp.reg)
1394                     abort ();
1395                   offset = cfa_temp.offset;
1396                   break;
1397                 default:
1398                   abort ();
1399                 }
1400
1401               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1402                 {
1403                   /* Restoring SP from FP in the epilogue.  */
1404                   if (cfa.reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1405                     abort ();
1406                   cfa.reg = STACK_POINTER_REGNUM;
1407                 }
1408               else if (GET_CODE (src) == LO_SUM)
1409                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1410                 ;
1411               else if (XEXP (src, 0) != stack_pointer_rtx)
1412                 abort ();
1413
1414               if (GET_CODE (src) != MINUS)
1415                 offset = -offset;
1416               if (cfa.reg == STACK_POINTER_REGNUM)
1417                 cfa.offset += offset;
1418               if (cfa_store.reg == STACK_POINTER_REGNUM)
1419                 cfa_store.offset += offset;
1420             }
1421           else if (dest == hard_frame_pointer_rtx)
1422             {
1423               /* Rule 3 */
1424               /* Either setting the FP from an offset of the SP,
1425                  or adjusting the FP */
1426               if (! frame_pointer_needed)
1427                 abort ();
1428
1429               if (GET_CODE (XEXP (src, 0)) == REG
1430                   && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1431                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1432                 {
1433                   offset = INTVAL (XEXP (src, 1));
1434                   if (GET_CODE (src) != MINUS)
1435                     offset = -offset;
1436                   cfa.offset += offset;
1437                   cfa.reg = HARD_FRAME_POINTER_REGNUM;
1438                 }
1439               else
1440                 abort ();
1441             }
1442           else
1443             {
1444               if (GET_CODE (src) == MINUS)
1445                 abort ();
1446
1447               /* Rule 4 */
1448               if (GET_CODE (XEXP (src, 0)) == REG
1449                   && REGNO (XEXP (src, 0)) == cfa.reg
1450                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1451                 {
1452                   /* Setting a temporary CFA register that will be copied
1453                      into the FP later on.  */
1454                   offset = - INTVAL (XEXP (src, 1));
1455                   cfa.offset += offset;
1456                   cfa.reg = REGNO (dest);
1457                   /* Or used to save regs to the stack.  */
1458                   cfa_temp.reg = cfa.reg;
1459                   cfa_temp.offset = cfa.offset;
1460                 }
1461
1462               /* Rule 5 */
1463               else if (GET_CODE (XEXP (src, 0)) == REG
1464                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1465                        && XEXP (src, 1) == stack_pointer_rtx)
1466                 {
1467                   /* Setting a scratch register that we will use instead
1468                      of SP for saving registers to the stack.  */
1469                   if (cfa.reg != STACK_POINTER_REGNUM)
1470                     abort ();
1471                   cfa_store.reg = REGNO (dest);
1472                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1473                 }
1474
1475               /* Rule 9 */
1476               else if (GET_CODE (src) == LO_SUM
1477                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1478                 {
1479                   cfa_temp.reg = REGNO (dest);
1480                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1481                 }
1482               else
1483                 abort ();
1484             }
1485           break;
1486
1487           /* Rule 6 */
1488         case CONST_INT:
1489           cfa_temp.reg = REGNO (dest);
1490           cfa_temp.offset = INTVAL (src);
1491           break;
1492
1493           /* Rule 7 */
1494         case IOR:
1495           if (GET_CODE (XEXP (src, 0)) != REG
1496               || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp.reg
1497               || GET_CODE (XEXP (src, 1)) != CONST_INT)
1498             abort ();
1499
1500           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1501             cfa_temp.reg = REGNO (dest);
1502           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1503           break;
1504
1505           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1506              which will fill in all of the bits.  */
1507           /* Rule 8 */
1508         case HIGH:
1509           break;
1510
1511         default:
1512           abort ();
1513         }
1514
1515       def_cfa_1 (label, &cfa);
1516       break;
1517
1518     case MEM:
1519       if (GET_CODE (src) != REG)
1520         abort ();
1521
1522       /* Saving a register to the stack.  Make sure dest is relative to the
1523          CFA register.  */
1524       switch (GET_CODE (XEXP (dest, 0)))
1525         {
1526           /* Rule 10 */
1527           /* With a push.  */
1528         case PRE_MODIFY:
1529           /* We can't handle variable size modifications.  */
1530           if (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) != CONST_INT)
1531             abort ();
1532           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1533
1534           if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1535               || cfa_store.reg != STACK_POINTER_REGNUM)
1536             abort ();
1537
1538           cfa_store.offset += offset;
1539           if (cfa.reg == STACK_POINTER_REGNUM)
1540             cfa.offset = cfa_store.offset;
1541
1542           offset = -cfa_store.offset;
1543           break;
1544
1545           /* Rule 11 */
1546         case PRE_INC:
1547         case PRE_DEC:
1548           offset = GET_MODE_SIZE (GET_MODE (dest));
1549           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1550             offset = -offset;
1551
1552           if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1553               || cfa_store.reg != STACK_POINTER_REGNUM)
1554             abort ();
1555
1556           cfa_store.offset += offset;
1557           if (cfa.reg == STACK_POINTER_REGNUM)
1558             cfa.offset = cfa_store.offset;
1559
1560           offset = -cfa_store.offset;
1561           break;
1562
1563           /* Rule 12 */
1564           /* With an offset.  */
1565         case PLUS:
1566         case MINUS:
1567         case LO_SUM:
1568           if (GET_CODE (XEXP (XEXP (dest, 0), 1)) != CONST_INT)
1569             abort ();
1570           offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1571           if (GET_CODE (XEXP (dest, 0)) == MINUS)
1572             offset = -offset;
1573
1574           if (cfa_store.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1575             offset -= cfa_store.offset;
1576           else if (cfa_temp.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1577             offset -= cfa_temp.offset;
1578           else
1579             abort ();
1580           break;
1581
1582           /* Rule 13 */
1583           /* Without an offset.  */
1584         case REG:
1585           if (cfa_store.reg == (unsigned) REGNO (XEXP (dest, 0)))
1586             offset = -cfa_store.offset;
1587           else if (cfa_temp.reg == (unsigned) REGNO (XEXP (dest, 0)))
1588             offset = -cfa_temp.offset;
1589           else
1590             abort ();
1591           break;
1592
1593           /* Rule 14 */
1594         case POST_INC:
1595           if (cfa_temp.reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1596             abort ();
1597           offset = -cfa_temp.offset;
1598           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1599           break;
1600
1601         default:
1602           abort ();
1603         }
1604
1605       if (REGNO (src) != STACK_POINTER_REGNUM
1606           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1607           && (unsigned) REGNO (src) == cfa.reg)
1608         {
1609           /* We're storing the current CFA reg into the stack.  */
1610
1611           if (cfa.offset == 0)
1612             {
1613               /* If the source register is exactly the CFA, assume
1614                  we're saving SP like any other register; this happens
1615                  on the ARM.  */
1616               def_cfa_1 (label, &cfa);
1617               queue_reg_save (label, stack_pointer_rtx, offset);
1618               break;
1619             }
1620           else
1621             {
1622               /* Otherwise, we'll need to look in the stack to
1623                  calculate the CFA.  */
1624               rtx x = XEXP (dest, 0);
1625
1626               if (GET_CODE (x) != REG)
1627                 x = XEXP (x, 0);
1628               if (GET_CODE (x) != REG)
1629                 abort ();
1630
1631               cfa.reg = REGNO (x);
1632               cfa.base_offset = offset;
1633               cfa.indirect = 1;
1634               def_cfa_1 (label, &cfa);
1635               break;
1636             }
1637         }
1638
1639       def_cfa_1 (label, &cfa);
1640       queue_reg_save (label, src, offset);
1641       break;
1642
1643     default:
1644       abort ();
1645     }
1646 }
1647
1648 /* Record call frame debugging information for INSN, which either
1649    sets SP or FP (adjusting how we calculate the frame address) or saves a
1650    register to the stack.  If INSN is NULL_RTX, initialize our state.  */
1651
1652 void
1653 dwarf2out_frame_debug (insn)
1654      rtx insn;
1655 {
1656   const char *label;
1657   rtx src;
1658
1659   if (insn == NULL_RTX)
1660     {
1661       /* Flush any queued register saves.  */
1662       flush_queued_reg_saves ();
1663
1664       /* Set up state for generating call frame debug info.  */
1665       lookup_cfa (&cfa);
1666       if (cfa.reg != (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1667         abort ();
1668
1669       cfa.reg = STACK_POINTER_REGNUM;
1670       cfa_store = cfa;
1671       cfa_temp.reg = -1;
1672       cfa_temp.offset = 0;
1673       return;
1674     }
1675
1676   if (GET_CODE (insn) != INSN || clobbers_queued_reg_save (insn))
1677     flush_queued_reg_saves ();
1678
1679   if (! RTX_FRAME_RELATED_P (insn))
1680     {
1681       if (!ACCUMULATE_OUTGOING_ARGS)
1682         dwarf2out_stack_adjust (insn);
1683
1684       return;
1685     }
1686
1687   label = dwarf2out_cfi_label ();
1688   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1689   if (src)
1690     insn = XEXP (src, 0);
1691   else
1692     insn = PATTERN (insn);
1693
1694   dwarf2out_frame_debug_expr (insn, label);
1695 }
1696
1697 #endif
1698
1699 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1700 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1701    PARAMS ((enum dwarf_call_frame_info cfi));
1702
1703 static enum dw_cfi_oprnd_type
1704 dw_cfi_oprnd1_desc (cfi)
1705      enum dwarf_call_frame_info cfi;
1706 {
1707   switch (cfi)
1708     {
1709     case DW_CFA_nop:
1710     case DW_CFA_GNU_window_save:
1711       return dw_cfi_oprnd_unused;
1712
1713     case DW_CFA_set_loc:
1714     case DW_CFA_advance_loc1:
1715     case DW_CFA_advance_loc2:
1716     case DW_CFA_advance_loc4:
1717     case DW_CFA_MIPS_advance_loc8:
1718       return dw_cfi_oprnd_addr;
1719
1720     case DW_CFA_offset:
1721     case DW_CFA_offset_extended:
1722     case DW_CFA_def_cfa:
1723     case DW_CFA_offset_extended_sf:
1724     case DW_CFA_def_cfa_sf:
1725     case DW_CFA_restore_extended:
1726     case DW_CFA_undefined:
1727     case DW_CFA_same_value:
1728     case DW_CFA_def_cfa_register:
1729     case DW_CFA_register:
1730       return dw_cfi_oprnd_reg_num;
1731
1732     case DW_CFA_def_cfa_offset:
1733     case DW_CFA_GNU_args_size:
1734     case DW_CFA_def_cfa_offset_sf:
1735       return dw_cfi_oprnd_offset;
1736
1737     case DW_CFA_def_cfa_expression:
1738     case DW_CFA_expression:
1739       return dw_cfi_oprnd_loc;
1740
1741     default:
1742       abort ();
1743     }
1744 }
1745
1746 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1747 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1748    PARAMS ((enum dwarf_call_frame_info cfi));
1749
1750 static enum dw_cfi_oprnd_type
1751 dw_cfi_oprnd2_desc (cfi)
1752      enum dwarf_call_frame_info cfi;
1753 {
1754   switch (cfi)
1755     {
1756     case DW_CFA_def_cfa:
1757     case DW_CFA_def_cfa_sf:
1758     case DW_CFA_offset:
1759     case DW_CFA_offset_extended_sf:
1760     case DW_CFA_offset_extended:
1761       return dw_cfi_oprnd_offset;
1762
1763     case DW_CFA_register:
1764       return dw_cfi_oprnd_reg_num;
1765
1766     default:
1767       return dw_cfi_oprnd_unused;
1768     }
1769 }
1770
1771 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1772
1773 /* Output a Call Frame Information opcode and its operand(s).  */
1774
1775 static void
1776 output_cfi (cfi, fde, for_eh)
1777      dw_cfi_ref cfi;
1778      dw_fde_ref fde;
1779      int for_eh;
1780 {
1781   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1782     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1783                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
1784                          "DW_CFA_advance_loc 0x%lx",
1785                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
1786   else if (cfi->dw_cfi_opc == DW_CFA_offset)
1787     {
1788       dw2_asm_output_data (1, (cfi->dw_cfi_opc
1789                                | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)),
1790                            "DW_CFA_offset, column 0x%lx",
1791                            cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1792       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1793     }
1794   else if (cfi->dw_cfi_opc == DW_CFA_restore)
1795     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1796                              | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)),
1797                          "DW_CFA_restore, column 0x%lx",
1798                          cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1799   else
1800     {
1801       dw2_asm_output_data (1, cfi->dw_cfi_opc,
1802                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
1803
1804       switch (cfi->dw_cfi_opc)
1805         {
1806         case DW_CFA_set_loc:
1807           if (for_eh)
1808             dw2_asm_output_encoded_addr_rtx (
1809                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1810                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
1811                 NULL);
1812           else
1813             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
1814                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
1815           break;
1816
1817         case DW_CFA_advance_loc1:
1818           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1819                                 fde->dw_fde_current_label, NULL);
1820           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1821           break;
1822
1823         case DW_CFA_advance_loc2:
1824           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1825                                 fde->dw_fde_current_label, NULL);
1826           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1827           break;
1828
1829         case DW_CFA_advance_loc4:
1830           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1831                                 fde->dw_fde_current_label, NULL);
1832           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1833           break;
1834
1835         case DW_CFA_MIPS_advance_loc8:
1836           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1837                                 fde->dw_fde_current_label, NULL);
1838           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1839           break;
1840
1841         case DW_CFA_offset_extended:
1842         case DW_CFA_def_cfa:
1843           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1844                                        NULL);
1845           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1846           break;
1847
1848         case DW_CFA_offset_extended_sf:
1849         case DW_CFA_def_cfa_sf:
1850           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1851                                        NULL);
1852           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1853           break;
1854
1855         case DW_CFA_restore_extended:
1856         case DW_CFA_undefined:
1857         case DW_CFA_same_value:
1858         case DW_CFA_def_cfa_register:
1859           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1860                                        NULL);
1861           break;
1862
1863         case DW_CFA_register:
1864           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1865                                        NULL);
1866           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num,
1867                                        NULL);
1868           break;
1869
1870         case DW_CFA_def_cfa_offset:
1871         case DW_CFA_GNU_args_size:
1872           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
1873           break;
1874
1875         case DW_CFA_def_cfa_offset_sf:
1876           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
1877           break;
1878
1879         case DW_CFA_GNU_window_save:
1880           break;
1881
1882         case DW_CFA_def_cfa_expression:
1883         case DW_CFA_expression:
1884           output_cfa_loc (cfi);
1885           break;
1886
1887         case DW_CFA_GNU_negative_offset_extended:
1888           /* Obsoleted by DW_CFA_offset_extended_sf.  */
1889           abort ();
1890
1891         default:
1892           break;
1893         }
1894     }
1895 }
1896
1897 /* Output the call frame information used to used to record information
1898    that relates to calculating the frame pointer, and records the
1899    location of saved registers.  */
1900
1901 static void
1902 output_call_frame_info (for_eh)
1903      int for_eh;
1904 {
1905   unsigned int i;
1906   dw_fde_ref fde;
1907   dw_cfi_ref cfi;
1908   char l1[20], l2[20], section_start_label[20];
1909   int any_lsda_needed = 0;
1910   char augmentation[6];
1911   int augmentation_size;
1912   int fde_encoding = DW_EH_PE_absptr;
1913   int per_encoding = DW_EH_PE_absptr;
1914   int lsda_encoding = DW_EH_PE_absptr;
1915
1916   /* Don't emit a CIE if there won't be any FDEs.  */
1917   if (fde_table_in_use == 0)
1918     return;
1919
1920   /* If we don't have any functions we'll want to unwind out of, don't emit any
1921      EH unwind information.  */
1922   if (for_eh)
1923     {
1924       int any_eh_needed = flag_asynchronous_unwind_tables;
1925
1926       for (i = 0; i < fde_table_in_use; i++)
1927         if (fde_table[i].uses_eh_lsda)
1928           any_eh_needed = any_lsda_needed = 1;
1929         else if (! fde_table[i].nothrow)
1930           any_eh_needed = 1;
1931
1932       if (! any_eh_needed)
1933         return;
1934     }
1935
1936   /* We're going to be generating comments, so turn on app.  */
1937   if (flag_debug_asm)
1938     app_enable ();
1939
1940   if (for_eh)
1941     (*targetm.asm_out.eh_frame_section) ();
1942   else
1943     named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
1944
1945   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
1946   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
1947
1948   /* Output the CIE.  */
1949   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1950   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1951   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
1952                         "Length of Common Information Entry");
1953   ASM_OUTPUT_LABEL (asm_out_file, l1);
1954
1955   /* Now that the CIE pointer is PC-relative for EH,
1956      use 0 to identify the CIE.  */
1957   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
1958                        (for_eh ? 0 : DW_CIE_ID),
1959                        "CIE Identifier Tag");
1960
1961   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
1962
1963   augmentation[0] = 0;
1964   augmentation_size = 0;
1965   if (for_eh)
1966     {
1967       char *p;
1968
1969       /* Augmentation:
1970          z      Indicates that a uleb128 is present to size the
1971                 augmentation section.
1972          L      Indicates the encoding (and thus presence) of
1973                 an LSDA pointer in the FDE augmentation.
1974          R      Indicates a non-default pointer encoding for
1975                 FDE code pointers.
1976          P      Indicates the presence of an encoding + language
1977                 personality routine in the CIE augmentation.  */
1978
1979       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
1980       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
1981       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1982
1983       p = augmentation + 1;
1984       if (eh_personality_libfunc)
1985         {
1986           *p++ = 'P';
1987           augmentation_size += 1 + size_of_encoded_value (per_encoding);
1988         }
1989       if (any_lsda_needed)
1990         {
1991           *p++ = 'L';
1992           augmentation_size += 1;
1993         }
1994       if (fde_encoding != DW_EH_PE_absptr)
1995         {
1996           *p++ = 'R';
1997           augmentation_size += 1;
1998         }
1999       if (p > augmentation + 1)
2000         {
2001           augmentation[0] = 'z';
2002           *p = '\0';
2003         }
2004
2005       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2006       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2007         {
2008           int offset = (  4             /* Length */
2009                         + 4             /* CIE Id */
2010                         + 1             /* CIE version */
2011                         + strlen (augmentation) + 1     /* Augmentation */
2012                         + size_of_uleb128 (1)           /* Code alignment */
2013                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2014                         + 1             /* RA column */
2015                         + 1             /* Augmentation size */
2016                         + 1             /* Personality encoding */ );
2017           int pad = -offset & (PTR_SIZE - 1);
2018
2019           augmentation_size += pad;
2020
2021           /* Augmentations should be small, so there's scarce need to
2022              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2023           if (size_of_uleb128 (augmentation_size) != 1)
2024             abort ();
2025         }
2026     }
2027
2028   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2029   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2030   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2031                                "CIE Data Alignment Factor");
2032   dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column");
2033
2034   if (augmentation[0])
2035     {
2036       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2037       if (eh_personality_libfunc)
2038         {
2039           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2040                                eh_data_format_name (per_encoding));
2041           dw2_asm_output_encoded_addr_rtx (per_encoding,
2042                                            eh_personality_libfunc, NULL);
2043         }
2044
2045       if (any_lsda_needed)
2046         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2047                              eh_data_format_name (lsda_encoding));
2048
2049       if (fde_encoding != DW_EH_PE_absptr)
2050         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2051                              eh_data_format_name (fde_encoding));
2052     }
2053
2054   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2055     output_cfi (cfi, NULL, for_eh);
2056
2057   /* Pad the CIE out to an address sized boundary.  */
2058   ASM_OUTPUT_ALIGN (asm_out_file,
2059                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2060   ASM_OUTPUT_LABEL (asm_out_file, l2);
2061
2062   /* Loop through all of the FDE's.  */
2063   for (i = 0; i < fde_table_in_use; i++)
2064     {
2065       fde = &fde_table[i];
2066
2067       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2068       if (!flag_asynchronous_unwind_tables && for_eh
2069           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2070           && !fde->uses_eh_lsda)
2071         continue;
2072
2073       (*targetm.asm_out.internal_label) (asm_out_file, FDE_LABEL, for_eh + i * 2);
2074       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2075       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2076       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2077                             "FDE Length");
2078       ASM_OUTPUT_LABEL (asm_out_file, l1);
2079
2080       if (for_eh)
2081         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2082       else
2083         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2084                                "FDE CIE offset");
2085
2086       if (for_eh)
2087         {
2088           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2089                    gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin),
2090                    "FDE initial location");
2091           dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2092                                 fde->dw_fde_end, fde->dw_fde_begin,
2093                                 "FDE address range");
2094         }
2095       else
2096         {
2097           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2098                                "FDE initial location");
2099           dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2100                                 fde->dw_fde_end, fde->dw_fde_begin,
2101                                 "FDE address range");
2102         }
2103
2104       if (augmentation[0])
2105         {
2106           if (any_lsda_needed)
2107             {
2108               int size = size_of_encoded_value (lsda_encoding);
2109
2110               if (lsda_encoding == DW_EH_PE_aligned)
2111                 {
2112                   int offset = (  4             /* Length */
2113                                 + 4             /* CIE offset */
2114                                 + 2 * size_of_encoded_value (fde_encoding)
2115                                 + 1             /* Augmentation size */ );
2116                   int pad = -offset & (PTR_SIZE - 1);
2117
2118                   size += pad;
2119                   if (size_of_uleb128 (size) != 1)
2120                     abort ();
2121                 }
2122
2123               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2124
2125               if (fde->uses_eh_lsda)
2126                 {
2127                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2128                                                fde->funcdef_number);
2129                   dw2_asm_output_encoded_addr_rtx (
2130                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2131                         "Language Specific Data Area");
2132                 }
2133               else
2134                 {
2135                   if (lsda_encoding == DW_EH_PE_aligned)
2136                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2137                   dw2_asm_output_data
2138                     (size_of_encoded_value (lsda_encoding), 0,
2139                      "Language Specific Data Area (none)");
2140                 }
2141             }
2142           else
2143             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2144         }
2145
2146       /* Loop through the Call Frame Instructions associated with
2147          this FDE.  */
2148       fde->dw_fde_current_label = fde->dw_fde_begin;
2149       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2150         output_cfi (cfi, fde, for_eh);
2151
2152       /* Pad the FDE out to an address sized boundary.  */
2153       ASM_OUTPUT_ALIGN (asm_out_file,
2154                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2155       ASM_OUTPUT_LABEL (asm_out_file, l2);
2156     }
2157
2158   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2159     dw2_asm_output_data (4, 0, "End of Table");
2160 #ifdef MIPS_DEBUGGING_INFO
2161   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2162      get a value of 0.  Putting .align 0 after the label fixes it.  */
2163   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2164 #endif
2165
2166   /* Turn off app to make assembly quicker.  */
2167   if (flag_debug_asm)
2168     app_disable ();
2169 }
2170
2171 /* Output a marker (i.e. a label) for the beginning of a function, before
2172    the prologue.  */
2173
2174 void
2175 dwarf2out_begin_prologue (line, file)
2176      unsigned int line ATTRIBUTE_UNUSED;
2177      const char *file ATTRIBUTE_UNUSED;
2178 {
2179   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2180   dw_fde_ref fde;
2181
2182   current_function_func_begin_label = 0;
2183
2184 #ifdef IA64_UNWIND_INFO
2185   /* ??? current_function_func_begin_label is also used by except.c
2186      for call-site information.  We must emit this label if it might
2187      be used.  */
2188   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2189       && ! dwarf2out_do_frame ())
2190     return;
2191 #else
2192   if (! dwarf2out_do_frame ())
2193     return;
2194 #endif
2195
2196   function_section (current_function_decl);
2197   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2198                                current_function_funcdef_no);
2199   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2200                           current_function_funcdef_no);
2201   current_function_func_begin_label = get_identifier (label);
2202
2203 #ifdef IA64_UNWIND_INFO
2204   /* We can elide the fde allocation if we're not emitting debug info.  */
2205   if (! dwarf2out_do_frame ())
2206     return;
2207 #endif
2208
2209   /* Expand the fde table if necessary.  */
2210   if (fde_table_in_use == fde_table_allocated)
2211     {
2212       fde_table_allocated += FDE_TABLE_INCREMENT;
2213       fde_table = ggc_realloc (fde_table,
2214                                fde_table_allocated * sizeof (dw_fde_node));
2215       memset (fde_table + fde_table_in_use, 0,
2216               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2217     }
2218
2219   /* Record the FDE associated with this function.  */
2220   current_funcdef_fde = fde_table_in_use;
2221
2222   /* Add the new FDE at the end of the fde_table.  */
2223   fde = &fde_table[fde_table_in_use++];
2224   fde->dw_fde_begin = xstrdup (label);
2225   fde->dw_fde_current_label = NULL;
2226   fde->dw_fde_end = NULL;
2227   fde->dw_fde_cfi = NULL;
2228   fde->funcdef_number = current_function_funcdef_no;
2229   fde->nothrow = current_function_nothrow;
2230   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2231   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2232
2233   args_size = old_args_size = 0;
2234
2235   /* We only want to output line number information for the genuine dwarf2
2236      prologue case, not the eh frame case.  */
2237 #ifdef DWARF2_DEBUGGING_INFO
2238   if (file)
2239     dwarf2out_source_line (line, file);
2240 #endif
2241 }
2242
2243 /* Output a marker (i.e. a label) for the absolute end of the generated code
2244    for a function definition.  This gets called *after* the epilogue code has
2245    been generated.  */
2246
2247 void
2248 dwarf2out_end_epilogue (line, file)
2249      unsigned int line ATTRIBUTE_UNUSED;
2250      const char *file ATTRIBUTE_UNUSED;
2251 {
2252   dw_fde_ref fde;
2253   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2254
2255   /* Output a label to mark the endpoint of the code generated for this
2256      function.  */
2257   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2258                                current_function_funcdef_no);
2259   ASM_OUTPUT_LABEL (asm_out_file, label);
2260   fde = &fde_table[fde_table_in_use - 1];
2261   fde->dw_fde_end = xstrdup (label);
2262 }
2263
2264 void
2265 dwarf2out_frame_init ()
2266 {
2267   /* Allocate the initial hunk of the fde_table.  */
2268   fde_table = (dw_fde_ref) ggc_alloc_cleared (FDE_TABLE_INCREMENT
2269                                               * sizeof (dw_fde_node));
2270   fde_table_allocated = FDE_TABLE_INCREMENT;
2271   fde_table_in_use = 0;
2272
2273   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2274      sake of lookup_cfa.  */
2275
2276 #ifdef DWARF2_UNWIND_INFO
2277   /* On entry, the Canonical Frame Address is at SP.  */
2278   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2279   initial_return_save (INCOMING_RETURN_ADDR_RTX);
2280 #endif
2281 }
2282
2283 void
2284 dwarf2out_frame_finish ()
2285 {
2286   /* Output call frame information.  */
2287   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
2288     output_call_frame_info (0);
2289
2290   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2291     output_call_frame_info (1);
2292 }
2293 #endif
2294 \f
2295 /* And now, the subset of the debugging information support code necessary
2296    for emitting location expressions.  */
2297
2298 /* We need some way to distinguish DW_OP_addr with a direct symbol
2299    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2300 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2301
2302
2303 typedef struct dw_val_struct *dw_val_ref;
2304 typedef struct die_struct *dw_die_ref;
2305 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2306 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2307
2308 /* Each DIE may have a series of attribute/value pairs.  Values
2309    can take on several forms.  The forms that are used in this
2310    implementation are listed below.  */
2311
2312 enum dw_val_class
2313 {
2314   dw_val_class_addr,
2315   dw_val_class_offset,
2316   dw_val_class_loc,
2317   dw_val_class_loc_list,
2318   dw_val_class_range_list,
2319   dw_val_class_const,
2320   dw_val_class_unsigned_const,
2321   dw_val_class_long_long,
2322   dw_val_class_float,
2323   dw_val_class_flag,
2324   dw_val_class_die_ref,
2325   dw_val_class_fde_ref,
2326   dw_val_class_lbl_id,
2327   dw_val_class_lbl_offset,
2328   dw_val_class_str
2329 };
2330
2331 /* Describe a double word constant value.  */
2332 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2333
2334 typedef struct dw_long_long_struct GTY(())
2335 {
2336   unsigned long hi;
2337   unsigned long low;
2338 }
2339 dw_long_long_const;
2340
2341 /* Describe a floating point constant value.  */
2342
2343 typedef struct dw_fp_struct GTY(())
2344 {
2345   long * GTY((length ("%h.length"))) array;
2346   unsigned length;
2347 }
2348 dw_float_const;
2349
2350 /* The dw_val_node describes an attribute's value, as it is
2351    represented internally.  */
2352
2353 typedef struct dw_val_struct GTY(())
2354 {
2355   enum dw_val_class val_class;
2356   union dw_val_struct_union
2357     {
2358       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2359       long unsigned GTY ((tag ("dw_val_class_offset"))) val_offset;
2360       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2361       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2362       long int GTY ((default (""))) val_int;
2363       long unsigned GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2364       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2365       dw_float_const GTY ((tag ("dw_val_class_float"))) val_float;
2366       struct dw_val_die_union
2367         {
2368           dw_die_ref die;
2369           int external;
2370         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2371       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2372       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2373       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2374       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2375     }
2376   GTY ((desc ("%1.val_class"))) v;
2377 }
2378 dw_val_node;
2379
2380 /* Locations in memory are described using a sequence of stack machine
2381    operations.  */
2382
2383 typedef struct dw_loc_descr_struct GTY(())
2384 {
2385   dw_loc_descr_ref dw_loc_next;
2386   enum dwarf_location_atom dw_loc_opc;
2387   dw_val_node dw_loc_oprnd1;
2388   dw_val_node dw_loc_oprnd2;
2389   int dw_loc_addr;
2390 }
2391 dw_loc_descr_node;
2392
2393 /* Location lists are ranges + location descriptions for that range,
2394    so you can track variables that are in different places over
2395    their entire life.  */
2396 typedef struct dw_loc_list_struct GTY(())
2397 {
2398   dw_loc_list_ref dw_loc_next;
2399   const char *begin; /* Label for begin address of range */
2400   const char *end;  /* Label for end address of range */
2401   char *ll_symbol; /* Label for beginning of location list.
2402                       Only on head of list */
2403   const char *section; /* Section this loclist is relative to */
2404   dw_loc_descr_ref expr;
2405 } dw_loc_list_node;
2406
2407 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2408
2409 static const char *dwarf_stack_op_name  PARAMS ((unsigned));
2410 static dw_loc_descr_ref new_loc_descr   PARAMS ((enum dwarf_location_atom,
2411                                                  unsigned long,
2412                                                  unsigned long));
2413 static void add_loc_descr               PARAMS ((dw_loc_descr_ref *,
2414                                                  dw_loc_descr_ref));
2415 static unsigned long size_of_loc_descr  PARAMS ((dw_loc_descr_ref));
2416 static unsigned long size_of_locs       PARAMS ((dw_loc_descr_ref));
2417 static void output_loc_operands         PARAMS ((dw_loc_descr_ref));
2418 static void output_loc_sequence         PARAMS ((dw_loc_descr_ref));
2419
2420 /* Convert a DWARF stack opcode into its string name.  */
2421
2422 static const char *
2423 dwarf_stack_op_name (op)
2424      unsigned op;
2425 {
2426   switch (op)
2427     {
2428     case DW_OP_addr:
2429     case INTERNAL_DW_OP_tls_addr:
2430       return "DW_OP_addr";
2431     case DW_OP_deref:
2432       return "DW_OP_deref";
2433     case DW_OP_const1u:
2434       return "DW_OP_const1u";
2435     case DW_OP_const1s:
2436       return "DW_OP_const1s";
2437     case DW_OP_const2u:
2438       return "DW_OP_const2u";
2439     case DW_OP_const2s:
2440       return "DW_OP_const2s";
2441     case DW_OP_const4u:
2442       return "DW_OP_const4u";
2443     case DW_OP_const4s:
2444       return "DW_OP_const4s";
2445     case DW_OP_const8u:
2446       return "DW_OP_const8u";
2447     case DW_OP_const8s:
2448       return "DW_OP_const8s";
2449     case DW_OP_constu:
2450       return "DW_OP_constu";
2451     case DW_OP_consts:
2452       return "DW_OP_consts";
2453     case DW_OP_dup:
2454       return "DW_OP_dup";
2455     case DW_OP_drop:
2456       return "DW_OP_drop";
2457     case DW_OP_over:
2458       return "DW_OP_over";
2459     case DW_OP_pick:
2460       return "DW_OP_pick";
2461     case DW_OP_swap:
2462       return "DW_OP_swap";
2463     case DW_OP_rot:
2464       return "DW_OP_rot";
2465     case DW_OP_xderef:
2466       return "DW_OP_xderef";
2467     case DW_OP_abs:
2468       return "DW_OP_abs";
2469     case DW_OP_and:
2470       return "DW_OP_and";
2471     case DW_OP_div:
2472       return "DW_OP_div";
2473     case DW_OP_minus:
2474       return "DW_OP_minus";
2475     case DW_OP_mod:
2476       return "DW_OP_mod";
2477     case DW_OP_mul:
2478       return "DW_OP_mul";
2479     case DW_OP_neg:
2480       return "DW_OP_neg";
2481     case DW_OP_not:
2482       return "DW_OP_not";
2483     case DW_OP_or:
2484       return "DW_OP_or";
2485     case DW_OP_plus:
2486       return "DW_OP_plus";
2487     case DW_OP_plus_uconst:
2488       return "DW_OP_plus_uconst";
2489     case DW_OP_shl:
2490       return "DW_OP_shl";
2491     case DW_OP_shr:
2492       return "DW_OP_shr";
2493     case DW_OP_shra:
2494       return "DW_OP_shra";
2495     case DW_OP_xor:
2496       return "DW_OP_xor";
2497     case DW_OP_bra:
2498       return "DW_OP_bra";
2499     case DW_OP_eq:
2500       return "DW_OP_eq";
2501     case DW_OP_ge:
2502       return "DW_OP_ge";
2503     case DW_OP_gt:
2504       return "DW_OP_gt";
2505     case DW_OP_le:
2506       return "DW_OP_le";
2507     case DW_OP_lt:
2508       return "DW_OP_lt";
2509     case DW_OP_ne:
2510       return "DW_OP_ne";
2511     case DW_OP_skip:
2512       return "DW_OP_skip";
2513     case DW_OP_lit0:
2514       return "DW_OP_lit0";
2515     case DW_OP_lit1:
2516       return "DW_OP_lit1";
2517     case DW_OP_lit2:
2518       return "DW_OP_lit2";
2519     case DW_OP_lit3:
2520       return "DW_OP_lit3";
2521     case DW_OP_lit4:
2522       return "DW_OP_lit4";
2523     case DW_OP_lit5:
2524       return "DW_OP_lit5";
2525     case DW_OP_lit6:
2526       return "DW_OP_lit6";
2527     case DW_OP_lit7:
2528       return "DW_OP_lit7";
2529     case DW_OP_lit8:
2530       return "DW_OP_lit8";
2531     case DW_OP_lit9:
2532       return "DW_OP_lit9";
2533     case DW_OP_lit10:
2534       return "DW_OP_lit10";
2535     case DW_OP_lit11:
2536       return "DW_OP_lit11";
2537     case DW_OP_lit12:
2538       return "DW_OP_lit12";
2539     case DW_OP_lit13:
2540       return "DW_OP_lit13";
2541     case DW_OP_lit14:
2542       return "DW_OP_lit14";
2543     case DW_OP_lit15:
2544       return "DW_OP_lit15";
2545     case DW_OP_lit16:
2546       return "DW_OP_lit16";
2547     case DW_OP_lit17:
2548       return "DW_OP_lit17";
2549     case DW_OP_lit18:
2550       return "DW_OP_lit18";
2551     case DW_OP_lit19:
2552       return "DW_OP_lit19";
2553     case DW_OP_lit20:
2554       return "DW_OP_lit20";
2555     case DW_OP_lit21:
2556       return "DW_OP_lit21";
2557     case DW_OP_lit22:
2558       return "DW_OP_lit22";
2559     case DW_OP_lit23:
2560       return "DW_OP_lit23";
2561     case DW_OP_lit24:
2562       return "DW_OP_lit24";
2563     case DW_OP_lit25:
2564       return "DW_OP_lit25";
2565     case DW_OP_lit26:
2566       return "DW_OP_lit26";
2567     case DW_OP_lit27:
2568       return "DW_OP_lit27";
2569     case DW_OP_lit28:
2570       return "DW_OP_lit28";
2571     case DW_OP_lit29:
2572       return "DW_OP_lit29";
2573     case DW_OP_lit30:
2574       return "DW_OP_lit30";
2575     case DW_OP_lit31:
2576       return "DW_OP_lit31";
2577     case DW_OP_reg0:
2578       return "DW_OP_reg0";
2579     case DW_OP_reg1:
2580       return "DW_OP_reg1";
2581     case DW_OP_reg2:
2582       return "DW_OP_reg2";
2583     case DW_OP_reg3:
2584       return "DW_OP_reg3";
2585     case DW_OP_reg4:
2586       return "DW_OP_reg4";
2587     case DW_OP_reg5:
2588       return "DW_OP_reg5";
2589     case DW_OP_reg6:
2590       return "DW_OP_reg6";
2591     case DW_OP_reg7:
2592       return "DW_OP_reg7";
2593     case DW_OP_reg8:
2594       return "DW_OP_reg8";
2595     case DW_OP_reg9:
2596       return "DW_OP_reg9";
2597     case DW_OP_reg10:
2598       return "DW_OP_reg10";
2599     case DW_OP_reg11:
2600       return "DW_OP_reg11";
2601     case DW_OP_reg12:
2602       return "DW_OP_reg12";
2603     case DW_OP_reg13:
2604       return "DW_OP_reg13";
2605     case DW_OP_reg14:
2606       return "DW_OP_reg14";
2607     case DW_OP_reg15:
2608       return "DW_OP_reg15";
2609     case DW_OP_reg16:
2610       return "DW_OP_reg16";
2611     case DW_OP_reg17:
2612       return "DW_OP_reg17";
2613     case DW_OP_reg18:
2614       return "DW_OP_reg18";
2615     case DW_OP_reg19:
2616       return "DW_OP_reg19";
2617     case DW_OP_reg20:
2618       return "DW_OP_reg20";
2619     case DW_OP_reg21:
2620       return "DW_OP_reg21";
2621     case DW_OP_reg22:
2622       return "DW_OP_reg22";
2623     case DW_OP_reg23:
2624       return "DW_OP_reg23";
2625     case DW_OP_reg24:
2626       return "DW_OP_reg24";
2627     case DW_OP_reg25:
2628       return "DW_OP_reg25";
2629     case DW_OP_reg26:
2630       return "DW_OP_reg26";
2631     case DW_OP_reg27:
2632       return "DW_OP_reg27";
2633     case DW_OP_reg28:
2634       return "DW_OP_reg28";
2635     case DW_OP_reg29:
2636       return "DW_OP_reg29";
2637     case DW_OP_reg30:
2638       return "DW_OP_reg30";
2639     case DW_OP_reg31:
2640       return "DW_OP_reg31";
2641     case DW_OP_breg0:
2642       return "DW_OP_breg0";
2643     case DW_OP_breg1:
2644       return "DW_OP_breg1";
2645     case DW_OP_breg2:
2646       return "DW_OP_breg2";
2647     case DW_OP_breg3:
2648       return "DW_OP_breg3";
2649     case DW_OP_breg4:
2650       return "DW_OP_breg4";
2651     case DW_OP_breg5:
2652       return "DW_OP_breg5";
2653     case DW_OP_breg6:
2654       return "DW_OP_breg6";
2655     case DW_OP_breg7:
2656       return "DW_OP_breg7";
2657     case DW_OP_breg8:
2658       return "DW_OP_breg8";
2659     case DW_OP_breg9:
2660       return "DW_OP_breg9";
2661     case DW_OP_breg10:
2662       return "DW_OP_breg10";
2663     case DW_OP_breg11:
2664       return "DW_OP_breg11";
2665     case DW_OP_breg12:
2666       return "DW_OP_breg12";
2667     case DW_OP_breg13:
2668       return "DW_OP_breg13";
2669     case DW_OP_breg14:
2670       return "DW_OP_breg14";
2671     case DW_OP_breg15:
2672       return "DW_OP_breg15";
2673     case DW_OP_breg16:
2674       return "DW_OP_breg16";
2675     case DW_OP_breg17:
2676       return "DW_OP_breg17";
2677     case DW_OP_breg18:
2678       return "DW_OP_breg18";
2679     case DW_OP_breg19:
2680       return "DW_OP_breg19";
2681     case DW_OP_breg20:
2682       return "DW_OP_breg20";
2683     case DW_OP_breg21:
2684       return "DW_OP_breg21";
2685     case DW_OP_breg22:
2686       return "DW_OP_breg22";
2687     case DW_OP_breg23:
2688       return "DW_OP_breg23";
2689     case DW_OP_breg24:
2690       return "DW_OP_breg24";
2691     case DW_OP_breg25:
2692       return "DW_OP_breg25";
2693     case DW_OP_breg26:
2694       return "DW_OP_breg26";
2695     case DW_OP_breg27:
2696       return "DW_OP_breg27";
2697     case DW_OP_breg28:
2698       return "DW_OP_breg28";
2699     case DW_OP_breg29:
2700       return "DW_OP_breg29";
2701     case DW_OP_breg30:
2702       return "DW_OP_breg30";
2703     case DW_OP_breg31:
2704       return "DW_OP_breg31";
2705     case DW_OP_regx:
2706       return "DW_OP_regx";
2707     case DW_OP_fbreg:
2708       return "DW_OP_fbreg";
2709     case DW_OP_bregx:
2710       return "DW_OP_bregx";
2711     case DW_OP_piece:
2712       return "DW_OP_piece";
2713     case DW_OP_deref_size:
2714       return "DW_OP_deref_size";
2715     case DW_OP_xderef_size:
2716       return "DW_OP_xderef_size";
2717     case DW_OP_nop:
2718       return "DW_OP_nop";
2719     case DW_OP_push_object_address:
2720       return "DW_OP_push_object_address";
2721     case DW_OP_call2:
2722       return "DW_OP_call2";
2723     case DW_OP_call4:
2724       return "DW_OP_call4";
2725     case DW_OP_call_ref:
2726       return "DW_OP_call_ref";
2727     case DW_OP_GNU_push_tls_address:
2728       return "DW_OP_GNU_push_tls_address";
2729     default:
2730       return "OP_<unknown>";
2731     }
2732 }
2733
2734 /* Return a pointer to a newly allocated location description.  Location
2735    descriptions are simple expression terms that can be strung
2736    together to form more complicated location (address) descriptions.  */
2737
2738 static inline dw_loc_descr_ref
2739 new_loc_descr (op, oprnd1, oprnd2)
2740      enum dwarf_location_atom op;
2741      unsigned long oprnd1;
2742      unsigned long oprnd2;
2743 {
2744   dw_loc_descr_ref descr
2745     = (dw_loc_descr_ref) ggc_alloc_cleared (sizeof (dw_loc_descr_node));
2746
2747   descr->dw_loc_opc = op;
2748   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2749   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2750   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2751   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2752
2753   return descr;
2754 }
2755
2756
2757 /* Add a location description term to a location description expression.  */
2758
2759 static inline void
2760 add_loc_descr (list_head, descr)
2761      dw_loc_descr_ref *list_head;
2762      dw_loc_descr_ref descr;
2763 {
2764   dw_loc_descr_ref *d;
2765
2766   /* Find the end of the chain.  */
2767   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
2768     ;
2769
2770   *d = descr;
2771 }
2772
2773 /* Return the size of a location descriptor.  */
2774
2775 static unsigned long
2776 size_of_loc_descr (loc)
2777      dw_loc_descr_ref loc;
2778 {
2779   unsigned long size = 1;
2780
2781   switch (loc->dw_loc_opc)
2782     {
2783     case DW_OP_addr:
2784     case INTERNAL_DW_OP_tls_addr:
2785       size += DWARF2_ADDR_SIZE;
2786       break;
2787     case DW_OP_const1u:
2788     case DW_OP_const1s:
2789       size += 1;
2790       break;
2791     case DW_OP_const2u:
2792     case DW_OP_const2s:
2793       size += 2;
2794       break;
2795     case DW_OP_const4u:
2796     case DW_OP_const4s:
2797       size += 4;
2798       break;
2799     case DW_OP_const8u:
2800     case DW_OP_const8s:
2801       size += 8;
2802       break;
2803     case DW_OP_constu:
2804       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2805       break;
2806     case DW_OP_consts:
2807       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2808       break;
2809     case DW_OP_pick:
2810       size += 1;
2811       break;
2812     case DW_OP_plus_uconst:
2813       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2814       break;
2815     case DW_OP_skip:
2816     case DW_OP_bra:
2817       size += 2;
2818       break;
2819     case DW_OP_breg0:
2820     case DW_OP_breg1:
2821     case DW_OP_breg2:
2822     case DW_OP_breg3:
2823     case DW_OP_breg4:
2824     case DW_OP_breg5:
2825     case DW_OP_breg6:
2826     case DW_OP_breg7:
2827     case DW_OP_breg8:
2828     case DW_OP_breg9:
2829     case DW_OP_breg10:
2830     case DW_OP_breg11:
2831     case DW_OP_breg12:
2832     case DW_OP_breg13:
2833     case DW_OP_breg14:
2834     case DW_OP_breg15:
2835     case DW_OP_breg16:
2836     case DW_OP_breg17:
2837     case DW_OP_breg18:
2838     case DW_OP_breg19:
2839     case DW_OP_breg20:
2840     case DW_OP_breg21:
2841     case DW_OP_breg22:
2842     case DW_OP_breg23:
2843     case DW_OP_breg24:
2844     case DW_OP_breg25:
2845     case DW_OP_breg26:
2846     case DW_OP_breg27:
2847     case DW_OP_breg28:
2848     case DW_OP_breg29:
2849     case DW_OP_breg30:
2850     case DW_OP_breg31:
2851       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2852       break;
2853     case DW_OP_regx:
2854       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2855       break;
2856     case DW_OP_fbreg:
2857       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2858       break;
2859     case DW_OP_bregx:
2860       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2861       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
2862       break;
2863     case DW_OP_piece:
2864       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2865       break;
2866     case DW_OP_deref_size:
2867     case DW_OP_xderef_size:
2868       size += 1;
2869       break;
2870     case DW_OP_call2:
2871       size += 2;
2872       break;
2873     case DW_OP_call4:
2874       size += 4;
2875       break;
2876     case DW_OP_call_ref:
2877       size += DWARF2_ADDR_SIZE;
2878       break;
2879     default:
2880       break;
2881     }
2882
2883   return size;
2884 }
2885
2886 /* Return the size of a series of location descriptors.  */
2887
2888 static unsigned long
2889 size_of_locs (loc)
2890      dw_loc_descr_ref loc;
2891 {
2892   unsigned long size;
2893
2894   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
2895     {
2896       loc->dw_loc_addr = size;
2897       size += size_of_loc_descr (loc);
2898     }
2899
2900   return size;
2901 }
2902
2903 /* Output location description stack opcode's operands (if any).  */
2904
2905 static void
2906 output_loc_operands (loc)
2907      dw_loc_descr_ref loc;
2908 {
2909   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2910   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2911
2912   switch (loc->dw_loc_opc)
2913     {
2914 #ifdef DWARF2_DEBUGGING_INFO
2915     case DW_OP_addr:
2916       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2917       break;
2918     case DW_OP_const2u:
2919     case DW_OP_const2s:
2920       dw2_asm_output_data (2, val1->v.val_int, NULL);
2921       break;
2922     case DW_OP_const4u:
2923     case DW_OP_const4s:
2924       dw2_asm_output_data (4, val1->v.val_int, NULL);
2925       break;
2926     case DW_OP_const8u:
2927     case DW_OP_const8s:
2928       if (HOST_BITS_PER_LONG < 64)
2929         abort ();
2930       dw2_asm_output_data (8, val1->v.val_int, NULL);
2931       break;
2932     case DW_OP_skip:
2933     case DW_OP_bra:
2934       {
2935         int offset;
2936
2937         if (val1->val_class == dw_val_class_loc)
2938           offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2939         else
2940           abort ();
2941
2942         dw2_asm_output_data (2, offset, NULL);
2943       }
2944       break;
2945 #else
2946     case DW_OP_addr:
2947     case DW_OP_const2u:
2948     case DW_OP_const2s:
2949     case DW_OP_const4u:
2950     case DW_OP_const4s:
2951     case DW_OP_const8u:
2952     case DW_OP_const8s:
2953     case DW_OP_skip:
2954     case DW_OP_bra:
2955       /* We currently don't make any attempt to make sure these are
2956          aligned properly like we do for the main unwind info, so
2957          don't support emitting things larger than a byte if we're
2958          only doing unwinding.  */
2959       abort ();
2960 #endif
2961     case DW_OP_const1u:
2962     case DW_OP_const1s:
2963       dw2_asm_output_data (1, val1->v.val_int, NULL);
2964       break;
2965     case DW_OP_constu:
2966       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2967       break;
2968     case DW_OP_consts:
2969       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2970       break;
2971     case DW_OP_pick:
2972       dw2_asm_output_data (1, val1->v.val_int, NULL);
2973       break;
2974     case DW_OP_plus_uconst:
2975       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2976       break;
2977     case DW_OP_breg0:
2978     case DW_OP_breg1:
2979     case DW_OP_breg2:
2980     case DW_OP_breg3:
2981     case DW_OP_breg4:
2982     case DW_OP_breg5:
2983     case DW_OP_breg6:
2984     case DW_OP_breg7:
2985     case DW_OP_breg8:
2986     case DW_OP_breg9:
2987     case DW_OP_breg10:
2988     case DW_OP_breg11:
2989     case DW_OP_breg12:
2990     case DW_OP_breg13:
2991     case DW_OP_breg14:
2992     case DW_OP_breg15:
2993     case DW_OP_breg16:
2994     case DW_OP_breg17:
2995     case DW_OP_breg18:
2996     case DW_OP_breg19:
2997     case DW_OP_breg20:
2998     case DW_OP_breg21:
2999     case DW_OP_breg22:
3000     case DW_OP_breg23:
3001     case DW_OP_breg24:
3002     case DW_OP_breg25:
3003     case DW_OP_breg26:
3004     case DW_OP_breg27:
3005     case DW_OP_breg28:
3006     case DW_OP_breg29:
3007     case DW_OP_breg30:
3008     case DW_OP_breg31:
3009       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3010       break;
3011     case DW_OP_regx:
3012       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3013       break;
3014     case DW_OP_fbreg:
3015       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3016       break;
3017     case DW_OP_bregx:
3018       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3019       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3020       break;
3021     case DW_OP_piece:
3022       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3023       break;
3024     case DW_OP_deref_size:
3025     case DW_OP_xderef_size:
3026       dw2_asm_output_data (1, val1->v.val_int, NULL);
3027       break;
3028
3029     case INTERNAL_DW_OP_tls_addr:
3030 #ifdef ASM_OUTPUT_DWARF_DTPREL
3031       ASM_OUTPUT_DWARF_DTPREL (asm_out_file, DWARF2_ADDR_SIZE,
3032                                val1->v.val_addr);
3033       fputc ('\n', asm_out_file);
3034 #else
3035       abort ();
3036 #endif
3037       break;
3038
3039     default:
3040       /* Other codes have no operands.  */
3041       break;
3042     }
3043 }
3044
3045 /* Output a sequence of location operations.  */
3046
3047 static void
3048 output_loc_sequence (loc)
3049      dw_loc_descr_ref loc;
3050 {
3051   for (; loc != NULL; loc = loc->dw_loc_next)
3052     {
3053       /* Output the opcode.  */
3054       dw2_asm_output_data (1, loc->dw_loc_opc,
3055                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3056
3057       /* Output the operand(s) (if any).  */
3058       output_loc_operands (loc);
3059     }
3060 }
3061
3062 /* This routine will generate the correct assembly data for a location
3063    description based on a cfi entry with a complex address.  */
3064
3065 static void
3066 output_cfa_loc (cfi)
3067      dw_cfi_ref cfi;
3068 {
3069   dw_loc_descr_ref loc;
3070   unsigned long size;
3071
3072   /* Output the size of the block.  */
3073   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3074   size = size_of_locs (loc);
3075   dw2_asm_output_data_uleb128 (size, NULL);
3076
3077   /* Now output the operations themselves.  */
3078   output_loc_sequence (loc);
3079 }
3080
3081 /* This function builds a dwarf location descriptor sequence from
3082    a dw_cfa_location.  */
3083
3084 static struct dw_loc_descr_struct *
3085 build_cfa_loc (cfa)
3086      dw_cfa_location *cfa;
3087 {
3088   struct dw_loc_descr_struct *head, *tmp;
3089
3090   if (cfa->indirect == 0)
3091     abort ();
3092
3093   if (cfa->base_offset)
3094     {
3095       if (cfa->reg <= 31)
3096         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3097       else
3098         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3099     }
3100   else if (cfa->reg <= 31)
3101     head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3102   else
3103     head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3104
3105   head->dw_loc_oprnd1.val_class = dw_val_class_const;
3106   tmp = new_loc_descr (DW_OP_deref, 0, 0);
3107   add_loc_descr (&head, tmp);
3108   if (cfa->offset != 0)
3109     {
3110       tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3111       add_loc_descr (&head, tmp);
3112     }
3113
3114   return head;
3115 }
3116
3117 /* This function fills in aa dw_cfa_location structure from a dwarf location
3118    descriptor sequence.  */
3119
3120 static void
3121 get_cfa_from_loc_descr (cfa, loc)
3122      dw_cfa_location *cfa;
3123      struct dw_loc_descr_struct *loc;
3124 {
3125   struct dw_loc_descr_struct *ptr;
3126   cfa->offset = 0;
3127   cfa->base_offset = 0;
3128   cfa->indirect = 0;
3129   cfa->reg = -1;
3130
3131   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3132     {
3133       enum dwarf_location_atom op = ptr->dw_loc_opc;
3134
3135       switch (op)
3136         {
3137         case DW_OP_reg0:
3138         case DW_OP_reg1:
3139         case DW_OP_reg2:
3140         case DW_OP_reg3:
3141         case DW_OP_reg4:
3142         case DW_OP_reg5:
3143         case DW_OP_reg6:
3144         case DW_OP_reg7:
3145         case DW_OP_reg8:
3146         case DW_OP_reg9:
3147         case DW_OP_reg10:
3148         case DW_OP_reg11:
3149         case DW_OP_reg12:
3150         case DW_OP_reg13:
3151         case DW_OP_reg14:
3152         case DW_OP_reg15:
3153         case DW_OP_reg16:
3154         case DW_OP_reg17:
3155         case DW_OP_reg18:
3156         case DW_OP_reg19:
3157         case DW_OP_reg20:
3158         case DW_OP_reg21:
3159         case DW_OP_reg22:
3160         case DW_OP_reg23:
3161         case DW_OP_reg24:
3162         case DW_OP_reg25:
3163         case DW_OP_reg26:
3164         case DW_OP_reg27:
3165         case DW_OP_reg28:
3166         case DW_OP_reg29:
3167         case DW_OP_reg30:
3168         case DW_OP_reg31:
3169           cfa->reg = op - DW_OP_reg0;
3170           break;
3171         case DW_OP_regx:
3172           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3173           break;
3174         case DW_OP_breg0:
3175         case DW_OP_breg1:
3176         case DW_OP_breg2:
3177         case DW_OP_breg3:
3178         case DW_OP_breg4:
3179         case DW_OP_breg5:
3180         case DW_OP_breg6:
3181         case DW_OP_breg7:
3182         case DW_OP_breg8:
3183         case DW_OP_breg9:
3184         case DW_OP_breg10:
3185         case DW_OP_breg11:
3186         case DW_OP_breg12:
3187         case DW_OP_breg13:
3188         case DW_OP_breg14:
3189         case DW_OP_breg15:
3190         case DW_OP_breg16:
3191         case DW_OP_breg17:
3192         case DW_OP_breg18:
3193         case DW_OP_breg19:
3194         case DW_OP_breg20:
3195         case DW_OP_breg21:
3196         case DW_OP_breg22:
3197         case DW_OP_breg23:
3198         case DW_OP_breg24:
3199         case DW_OP_breg25:
3200         case DW_OP_breg26:
3201         case DW_OP_breg27:
3202         case DW_OP_breg28:
3203         case DW_OP_breg29:
3204         case DW_OP_breg30:
3205         case DW_OP_breg31:
3206           cfa->reg = op - DW_OP_breg0;
3207           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3208           break;
3209         case DW_OP_bregx:
3210           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3211           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3212           break;
3213         case DW_OP_deref:
3214           cfa->indirect = 1;
3215           break;
3216         case DW_OP_plus_uconst:
3217           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3218           break;
3219         default:
3220           internal_error ("DW_LOC_OP %s not implemented\n",
3221                           dwarf_stack_op_name (ptr->dw_loc_opc));
3222         }
3223     }
3224 }
3225 #endif /* .debug_frame support */
3226 \f
3227 /* And now, the support for symbolic debugging information.  */
3228 #ifdef DWARF2_DEBUGGING_INFO
3229
3230 /* .debug_str support.  */
3231 static int output_indirect_string       PARAMS ((void **, void *));
3232
3233 static void dwarf2out_init              PARAMS ((const char *));
3234 static void dwarf2out_finish            PARAMS ((const char *));
3235 static void dwarf2out_define            PARAMS ((unsigned int, const char *));
3236 static void dwarf2out_undef             PARAMS ((unsigned int, const char *));
3237 static void dwarf2out_start_source_file PARAMS ((unsigned, const char *));
3238 static void dwarf2out_end_source_file   PARAMS ((unsigned));
3239 static void dwarf2out_begin_block       PARAMS ((unsigned, unsigned));
3240 static void dwarf2out_end_block         PARAMS ((unsigned, unsigned));
3241 static bool dwarf2out_ignore_block      PARAMS ((tree));
3242 static void dwarf2out_global_decl       PARAMS ((tree));
3243 static void dwarf2out_abstract_function PARAMS ((tree));
3244
3245 /* The debug hooks structure.  */
3246
3247 const struct gcc_debug_hooks dwarf2_debug_hooks =
3248 {
3249   dwarf2out_init,
3250   dwarf2out_finish,
3251   dwarf2out_define,
3252   dwarf2out_undef,
3253   dwarf2out_start_source_file,
3254   dwarf2out_end_source_file,
3255   dwarf2out_begin_block,
3256   dwarf2out_end_block,
3257   dwarf2out_ignore_block,
3258   dwarf2out_source_line,
3259   dwarf2out_begin_prologue,
3260   debug_nothing_int_charstar,   /* end_prologue */
3261   dwarf2out_end_epilogue,
3262   debug_nothing_tree,           /* begin_function */
3263   debug_nothing_int,            /* end_function */
3264   dwarf2out_decl,               /* function_decl */
3265   dwarf2out_global_decl,
3266   debug_nothing_tree,           /* deferred_inline_function */
3267   /* The DWARF 2 backend tries to reduce debugging bloat by not
3268      emitting the abstract description of inline functions until
3269      something tries to reference them.  */
3270   dwarf2out_abstract_function,  /* outlining_inline_function */
3271   debug_nothing_rtx             /* label */
3272 };
3273 #endif
3274 \f
3275 /* NOTE: In the comments in this file, many references are made to
3276    "Debugging Information Entries".  This term is abbreviated as `DIE'
3277    throughout the remainder of this file.  */
3278
3279 /* An internal representation of the DWARF output is built, and then
3280    walked to generate the DWARF debugging info.  The walk of the internal
3281    representation is done after the entire program has been compiled.
3282    The types below are used to describe the internal representation.  */
3283
3284 /* Various DIE's use offsets relative to the beginning of the
3285    .debug_info section to refer to each other.  */
3286
3287 typedef long int dw_offset;
3288
3289 /* Define typedefs here to avoid circular dependencies.  */
3290
3291 typedef struct dw_attr_struct *dw_attr_ref;
3292 typedef struct dw_line_info_struct *dw_line_info_ref;
3293 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3294 typedef struct pubname_struct *pubname_ref;
3295 typedef struct dw_ranges_struct *dw_ranges_ref;
3296
3297 /* Each entry in the line_info_table maintains the file and
3298    line number associated with the label generated for that
3299    entry.  The label gives the PC value associated with
3300    the line number entry.  */
3301
3302 typedef struct dw_line_info_struct GTY(())
3303 {
3304   unsigned long dw_file_num;
3305   unsigned long dw_line_num;
3306 }
3307 dw_line_info_entry;
3308
3309 /* Line information for functions in separate sections; each one gets its
3310    own sequence.  */
3311 typedef struct dw_separate_line_info_struct GTY(())
3312 {
3313   unsigned long dw_file_num;
3314   unsigned long dw_line_num;
3315   unsigned long function;
3316 }
3317 dw_separate_line_info_entry;
3318
3319 /* Each DIE attribute has a field specifying the attribute kind,
3320    a link to the next attribute in the chain, and an attribute value.
3321    Attributes are typically linked below the DIE they modify.  */
3322
3323 typedef struct dw_attr_struct GTY(())
3324 {
3325   enum dwarf_attribute dw_attr;
3326   dw_attr_ref dw_attr_next;
3327   dw_val_node dw_attr_val;
3328 }
3329 dw_attr_node;
3330
3331 /* The Debugging Information Entry (DIE) structure */
3332
3333 typedef struct die_struct GTY(())
3334 {
3335   enum dwarf_tag die_tag;
3336   char *die_symbol;
3337   dw_attr_ref die_attr;
3338   dw_die_ref die_parent;
3339   dw_die_ref die_child;
3340   dw_die_ref die_sib;
3341   dw_offset die_offset;
3342   unsigned long die_abbrev;
3343   int die_mark;
3344 }
3345 die_node;
3346
3347 /* The pubname structure */
3348
3349 typedef struct pubname_struct GTY(())
3350 {
3351   dw_die_ref die;
3352   char *name;
3353 }
3354 pubname_entry;
3355
3356 struct dw_ranges_struct GTY(())
3357 {
3358   int block_num;
3359 };
3360
3361 /* The limbo die list structure.  */
3362 typedef struct limbo_die_struct GTY(())
3363 {
3364   dw_die_ref die;
3365   tree created_for;
3366   struct limbo_die_struct *next;
3367 }
3368 limbo_die_node;
3369
3370 /* How to start an assembler comment.  */
3371 #ifndef ASM_COMMENT_START
3372 #define ASM_COMMENT_START ";#"
3373 #endif
3374
3375 /* Define a macro which returns nonzero for a TYPE_DECL which was
3376    implicitly generated for a tagged type.
3377
3378    Note that unlike the gcc front end (which generates a NULL named
3379    TYPE_DECL node for each complete tagged type, each array type, and
3380    each function type node created) the g++ front end generates a
3381    _named_ TYPE_DECL node for each tagged type node created.
3382    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3383    generate a DW_TAG_typedef DIE for them.  */
3384
3385 #define TYPE_DECL_IS_STUB(decl)                         \
3386   (DECL_NAME (decl) == NULL_TREE                        \
3387    || (DECL_ARTIFICIAL (decl)                           \
3388        && is_tagged_type (TREE_TYPE (decl))             \
3389        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3390            /* This is necessary for stub decls that     \
3391               appear in nested inline functions.  */    \
3392            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3393                && (decl_ultimate_origin (decl)          \
3394                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3395
3396 /* Information concerning the compilation unit's programming
3397    language, and compiler version.  */
3398
3399 /* Fixed size portion of the DWARF compilation unit header.  */
3400 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
3401
3402 /* Fixed size portion of public names info.  */
3403 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3404
3405 /* Fixed size portion of the address range info.  */
3406 #define DWARF_ARANGES_HEADER_SIZE                                       \
3407   (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, DWARF2_ADDR_SIZE * 2)        \
3408    - DWARF_OFFSET_SIZE)
3409
3410 /* Size of padding portion in the address range info.  It must be
3411    aligned to twice the pointer size.  */
3412 #define DWARF_ARANGES_PAD_SIZE \
3413   (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, DWARF2_ADDR_SIZE * 2) \
3414    - (2 * DWARF_OFFSET_SIZE + 4))
3415
3416 /* Use assembler line directives if available.  */
3417 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3418 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3419 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3420 #else
3421 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3422 #endif
3423 #endif
3424
3425 /* Minimum line offset in a special line info. opcode.
3426    This value was chosen to give a reasonable range of values.  */
3427 #define DWARF_LINE_BASE  -10
3428
3429 /* First special line opcode - leave room for the standard opcodes.  */
3430 #define DWARF_LINE_OPCODE_BASE  10
3431
3432 /* Range of line offsets in a special line info. opcode.  */
3433 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3434
3435 /* Flag that indicates the initial value of the is_stmt_start flag.
3436    In the present implementation, we do not mark any lines as
3437    the beginning of a source statement, because that information
3438    is not made available by the GCC front-end.  */
3439 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3440
3441 #ifdef DWARF2_DEBUGGING_INFO
3442 /* This location is used by calc_die_sizes() to keep track
3443    the offset of each DIE within the .debug_info section.  */
3444 static unsigned long next_die_offset;
3445 #endif
3446
3447 /* Record the root of the DIE's built for the current compilation unit.  */
3448 static GTY(()) dw_die_ref comp_unit_die;
3449
3450 #ifdef DWARF2_DEBUGGING_INFO
3451 /* We need special handling in dwarf2out_start_source_file if it is
3452    first one.  */
3453 static int is_main_source;
3454 #endif
3455
3456 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3457 static GTY(()) limbo_die_node *limbo_die_list;
3458
3459 /* Filenames referenced by this compilation unit.  */
3460 static GTY(()) varray_type file_table;
3461 static GTY(()) varray_type file_table_emitted;
3462 static GTY(()) size_t file_table_last_lookup_index;
3463
3464 /* A pointer to the base of a table of references to DIE's that describe
3465    declarations.  The table is indexed by DECL_UID() which is a unique
3466    number identifying each decl.  */
3467 static GTY((length ("decl_die_table_allocated"))) dw_die_ref *decl_die_table;
3468
3469 /* Number of elements currently allocated for the decl_die_table.  */
3470 static unsigned decl_die_table_allocated;
3471
3472 #ifdef DWARF2_DEBUGGING_INFO
3473 /* Number of elements in decl_die_table currently in use.  */
3474 static unsigned decl_die_table_in_use;
3475 #endif
3476
3477 /* Size (in elements) of increments by which we may expand the
3478    decl_die_table.  */
3479 #define DECL_DIE_TABLE_INCREMENT 256
3480
3481 /* A pointer to the base of a list of references to DIE's that
3482    are uniquely identified by their tag, presence/absence of
3483    children DIE's, and list of attribute/value pairs.  */
3484 static GTY((length ("abbrev_die_table_allocated")))
3485   dw_die_ref *abbrev_die_table;
3486
3487 /* Number of elements currently allocated for abbrev_die_table.  */
3488 static unsigned abbrev_die_table_allocated;
3489
3490 #ifdef DWARF2_DEBUGGING_INFO
3491 /* Number of elements in type_die_table currently in use.  */
3492 static unsigned abbrev_die_table_in_use;
3493 #endif
3494
3495 /* Size (in elements) of increments by which we may expand the
3496    abbrev_die_table.  */
3497 #define ABBREV_DIE_TABLE_INCREMENT 256
3498
3499 /* A pointer to the base of a table that contains line information
3500    for each source code line in .text in the compilation unit.  */
3501 static GTY((length ("line_info_table_allocated")))
3502      dw_line_info_ref line_info_table;
3503
3504 /* Number of elements currently allocated for line_info_table.  */
3505 static unsigned line_info_table_allocated;
3506
3507 #ifdef DWARF2_DEBUGGING_INFO
3508 /* Number of elements in line_info_table currently in use.  */
3509 static unsigned line_info_table_in_use;
3510 #endif
3511
3512 /* A pointer to the base of a table that contains line information
3513    for each source code line outside of .text in the compilation unit.  */
3514 static GTY ((length ("separate_line_info_table_allocated")))
3515      dw_separate_line_info_ref separate_line_info_table;
3516
3517 /* Number of elements currently allocated for separate_line_info_table.  */
3518 static unsigned separate_line_info_table_allocated;
3519
3520 #ifdef DWARF2_DEBUGGING_INFO
3521 /* Number of elements in separate_line_info_table currently in use.  */
3522 static unsigned separate_line_info_table_in_use;
3523 #endif
3524
3525 /* Size (in elements) of increments by which we may expand the
3526    line_info_table.  */
3527 #define LINE_INFO_TABLE_INCREMENT 1024
3528
3529 /* A pointer to the base of a table that contains a list of publicly
3530    accessible names.  */
3531 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3532
3533 /* Number of elements currently allocated for pubname_table.  */
3534 static unsigned pubname_table_allocated;
3535
3536 #ifdef DWARF2_DEBUGGING_INFO
3537 /* Number of elements in pubname_table currently in use.  */
3538 static unsigned pubname_table_in_use;
3539 #endif
3540
3541 /* Size (in elements) of increments by which we may expand the
3542    pubname_table.  */
3543 #define PUBNAME_TABLE_INCREMENT 64
3544
3545 /* Array of dies for which we should generate .debug_arange info.  */
3546 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3547
3548 /* Number of elements currently allocated for arange_table.  */
3549 static unsigned arange_table_allocated;
3550
3551 #ifdef DWARF2_DEBUGGING_INFO
3552 /* Number of elements in arange_table currently in use.  */
3553 static unsigned arange_table_in_use;
3554 #endif
3555
3556 /* Size (in elements) of increments by which we may expand the
3557    arange_table.  */
3558 #define ARANGE_TABLE_INCREMENT 64
3559
3560 /* Array of dies for which we should generate .debug_ranges info.  */
3561 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3562
3563 /* Number of elements currently allocated for ranges_table.  */
3564 static unsigned ranges_table_allocated;
3565
3566 #ifdef DWARF2_DEBUGGING_INFO
3567 /* Number of elements in ranges_table currently in use.  */
3568 static unsigned ranges_table_in_use;
3569
3570 /* Size (in elements) of increments by which we may expand the
3571    ranges_table.  */
3572 #define RANGES_TABLE_INCREMENT 64
3573
3574 /* Whether we have location lists that need outputting */
3575 static unsigned have_location_lists;
3576
3577 /* Record whether the function being analyzed contains inlined functions.  */
3578 static int current_function_has_inlines;
3579 #endif
3580 #if 0 && defined (MIPS_DEBUGGING_INFO)
3581 static int comp_unit_has_inlines;
3582 #endif
3583
3584 #ifdef DWARF2_DEBUGGING_INFO
3585
3586 /* Forward declarations for functions defined in this file.  */
3587
3588 static int is_pseudo_reg                PARAMS ((rtx));
3589 static tree type_main_variant           PARAMS ((tree));
3590 static int is_tagged_type               PARAMS ((tree));
3591 static const char *dwarf_tag_name       PARAMS ((unsigned));
3592 static const char *dwarf_attr_name      PARAMS ((unsigned));
3593 static const char *dwarf_form_name      PARAMS ((unsigned));
3594 #if 0
3595 static const char *dwarf_type_encoding_name PARAMS ((unsigned));
3596 #endif
3597 static tree decl_ultimate_origin        PARAMS ((tree));
3598 static tree block_ultimate_origin       PARAMS ((tree));
3599 static tree decl_class_context          PARAMS ((tree));
3600 static void add_dwarf_attr              PARAMS ((dw_die_ref, dw_attr_ref));
3601 static inline enum dw_val_class AT_class        PARAMS ((dw_attr_ref));
3602 static void add_AT_flag                 PARAMS ((dw_die_ref,
3603                                                  enum dwarf_attribute,
3604                                                  unsigned));
3605 static inline unsigned AT_flag          PARAMS ((dw_attr_ref));
3606 static void add_AT_int                  PARAMS ((dw_die_ref,
3607                                                  enum dwarf_attribute, long));
3608 static inline long int AT_int           PARAMS ((dw_attr_ref));
3609 static void add_AT_unsigned             PARAMS ((dw_die_ref,
3610                                                  enum dwarf_attribute,
3611                                                  unsigned long));
3612 static inline unsigned long             AT_unsigned PARAMS ((dw_attr_ref));
3613 static void add_AT_long_long            PARAMS ((dw_die_ref,
3614                                                  enum dwarf_attribute,
3615                                                  unsigned long,
3616                                                  unsigned long));
3617 static void add_AT_float                PARAMS ((dw_die_ref,
3618                                                  enum dwarf_attribute,
3619                                                  unsigned, long *));
3620 static hashval_t debug_str_do_hash      PARAMS ((const void *));
3621 static int debug_str_eq                 PARAMS ((const void *, const void *));
3622 static void add_AT_string               PARAMS ((dw_die_ref,
3623                                                  enum dwarf_attribute,
3624                                                  const char *));
3625 static inline const char *AT_string     PARAMS ((dw_attr_ref));
3626 static int AT_string_form               PARAMS ((dw_attr_ref));
3627 static void add_AT_die_ref              PARAMS ((dw_die_ref,
3628                                                  enum dwarf_attribute,
3629                                                  dw_die_ref));
3630 static inline dw_die_ref AT_ref         PARAMS ((dw_attr_ref));
3631 static inline int AT_ref_external       PARAMS ((dw_attr_ref));
3632 static inline void set_AT_ref_external  PARAMS ((dw_attr_ref, int));
3633 static void add_AT_fde_ref              PARAMS ((dw_die_ref,
3634                                                  enum dwarf_attribute,
3635                                                  unsigned));
3636 static void add_AT_loc                  PARAMS ((dw_die_ref,
3637                                                  enum dwarf_attribute,
3638                                                  dw_loc_descr_ref));
3639 static inline dw_loc_descr_ref AT_loc   PARAMS ((dw_attr_ref));
3640 static void add_AT_loc_list             PARAMS ((dw_die_ref,
3641                                                  enum dwarf_attribute,
3642                                                  dw_loc_list_ref));
3643 static inline dw_loc_list_ref AT_loc_list PARAMS ((dw_attr_ref));
3644 static void add_AT_addr                 PARAMS ((dw_die_ref,
3645                                                  enum dwarf_attribute,
3646                                                  rtx));
3647 static inline rtx AT_addr               PARAMS ((dw_attr_ref));
3648 static void add_AT_lbl_id               PARAMS ((dw_die_ref,
3649                                                  enum dwarf_attribute,
3650                                                  const char *));
3651 static void add_AT_lbl_offset           PARAMS ((dw_die_ref,
3652                                                  enum dwarf_attribute,
3653                                                  const char *));
3654 static void add_AT_offset               PARAMS ((dw_die_ref,
3655                                                  enum dwarf_attribute,
3656                                                  unsigned long));
3657 static void add_AT_range_list           PARAMS ((dw_die_ref,
3658                                                  enum dwarf_attribute,
3659                                                  unsigned long));
3660 static inline const char *AT_lbl        PARAMS ((dw_attr_ref));
3661 static dw_attr_ref get_AT               PARAMS ((dw_die_ref,
3662                                                  enum dwarf_attribute));
3663 static const char *get_AT_low_pc        PARAMS ((dw_die_ref));
3664 static const char *get_AT_hi_pc         PARAMS ((dw_die_ref));
3665 static const char *get_AT_string        PARAMS ((dw_die_ref,
3666                                                  enum dwarf_attribute));
3667 static int get_AT_flag                  PARAMS ((dw_die_ref,
3668                                                  enum dwarf_attribute));
3669 static unsigned get_AT_unsigned         PARAMS ((dw_die_ref,
3670                                                  enum dwarf_attribute));
3671 static inline dw_die_ref get_AT_ref     PARAMS ((dw_die_ref,
3672                                                  enum dwarf_attribute));
3673 static int is_c_family                  PARAMS ((void));
3674 static int is_cxx                       PARAMS ((void));
3675 static int is_java                      PARAMS ((void));
3676 static int is_fortran                   PARAMS ((void));
3677 static void remove_AT                   PARAMS ((dw_die_ref,
3678                                                  enum dwarf_attribute));
3679 static inline void free_die             PARAMS ((dw_die_ref));
3680 static void remove_children             PARAMS ((dw_die_ref));
3681 static void add_child_die               PARAMS ((dw_die_ref, dw_die_ref));
3682 static dw_die_ref new_die               PARAMS ((enum dwarf_tag, dw_die_ref,
3683                                                  tree));
3684 static dw_die_ref lookup_type_die       PARAMS ((tree));
3685 static void equate_type_number_to_die   PARAMS ((tree, dw_die_ref));
3686 static dw_die_ref lookup_decl_die       PARAMS ((tree));
3687 static void equate_decl_number_to_die   PARAMS ((tree, dw_die_ref));
3688 static void print_spaces                PARAMS ((FILE *));
3689 static void print_die                   PARAMS ((dw_die_ref, FILE *));
3690 static void print_dwarf_line_table      PARAMS ((FILE *));
3691 static void reverse_die_lists           PARAMS ((dw_die_ref));
3692 static void reverse_all_dies            PARAMS ((dw_die_ref));
3693 static dw_die_ref push_new_compile_unit PARAMS ((dw_die_ref, dw_die_ref));
3694 static dw_die_ref pop_compile_unit      PARAMS ((dw_die_ref));
3695 static void loc_checksum                PARAMS ((dw_loc_descr_ref,
3696                                                  struct md5_ctx *));
3697 static void attr_checksum               PARAMS ((dw_attr_ref,
3698                                                  struct md5_ctx *,
3699                                                  int *));
3700 static void die_checksum                PARAMS ((dw_die_ref,
3701                                                  struct md5_ctx *,
3702                                                  int *));
3703 static int same_loc_p                   PARAMS ((dw_loc_descr_ref,
3704                                                  dw_loc_descr_ref, int *));
3705 static int same_dw_val_p                PARAMS ((dw_val_node *, dw_val_node *,
3706                                                  int *));
3707 static int same_attr_p                  PARAMS ((dw_attr_ref, dw_attr_ref, int *));
3708 static int same_die_p                   PARAMS ((dw_die_ref, dw_die_ref, int *));
3709 static int same_die_p_wrap              PARAMS ((dw_die_ref, dw_die_ref));
3710 static void compute_section_prefix      PARAMS ((dw_die_ref));
3711 static int is_type_die                  PARAMS ((dw_die_ref));
3712 static int is_comdat_die                PARAMS ((dw_die_ref));
3713 static int is_symbol_die                PARAMS ((dw_die_ref));
3714 static void assign_symbol_names         PARAMS ((dw_die_ref));
3715 static void break_out_includes          PARAMS ((dw_die_ref));
3716 static hashval_t htab_cu_hash           PARAMS ((const void *));
3717 static int htab_cu_eq                   PARAMS ((const void *, const void *));
3718 static void htab_cu_del                 PARAMS ((void *));
3719 static int check_duplicate_cu           PARAMS ((dw_die_ref, htab_t, unsigned *));
3720 static void record_comdat_symbol_number PARAMS ((dw_die_ref, htab_t, unsigned));
3721 static void add_sibling_attributes      PARAMS ((dw_die_ref));
3722 static void build_abbrev_table          PARAMS ((dw_die_ref));
3723 static void output_location_lists       PARAMS ((dw_die_ref));
3724 static int constant_size                PARAMS ((long unsigned));
3725 static unsigned long size_of_die        PARAMS ((dw_die_ref));
3726 static void calc_die_sizes              PARAMS ((dw_die_ref));
3727 static void mark_dies                   PARAMS ((dw_die_ref));
3728 static void unmark_dies                 PARAMS ((dw_die_ref));
3729 static void unmark_all_dies             PARAMS ((dw_die_ref));
3730 static unsigned long size_of_pubnames   PARAMS ((void));
3731 static unsigned long size_of_aranges    PARAMS ((void));
3732 static enum dwarf_form value_format     PARAMS ((dw_attr_ref));
3733 static void output_value_format         PARAMS ((dw_attr_ref));
3734 static void output_abbrev_section       PARAMS ((void));
3735 static void output_die_symbol           PARAMS ((dw_die_ref));
3736 static void output_die                  PARAMS ((dw_die_ref));
3737 static void output_compilation_unit_header PARAMS ((void));
3738 static void output_comp_unit            PARAMS ((dw_die_ref, int));
3739 static const char *dwarf2_name          PARAMS ((tree, int));
3740 static void add_pubname                 PARAMS ((tree, dw_die_ref));
3741 static void output_pubnames             PARAMS ((void));
3742 static void add_arange                  PARAMS ((tree, dw_die_ref));
3743 static void output_aranges              PARAMS ((void));
3744 static unsigned int add_ranges          PARAMS ((tree));
3745 static void output_ranges               PARAMS ((void));
3746 static void output_line_info            PARAMS ((void));
3747 static void output_file_names           PARAMS ((void));
3748 static dw_die_ref base_type_die         PARAMS ((tree));
3749 static tree root_type                   PARAMS ((tree));
3750 static int is_base_type                 PARAMS ((tree));
3751 static dw_die_ref modified_type_die     PARAMS ((tree, int, int, dw_die_ref));
3752 static int type_is_enum                 PARAMS ((tree));
3753 static unsigned int reg_number          PARAMS ((rtx));
3754 static dw_loc_descr_ref reg_loc_descriptor PARAMS ((rtx));
3755 static dw_loc_descr_ref int_loc_descriptor PARAMS ((HOST_WIDE_INT));
3756 static dw_loc_descr_ref based_loc_descr PARAMS ((unsigned, long));
3757 static int is_based_loc                 PARAMS ((rtx));
3758 static dw_loc_descr_ref mem_loc_descriptor PARAMS ((rtx, enum machine_mode mode));
3759 static dw_loc_descr_ref concat_loc_descriptor PARAMS ((rtx, rtx));
3760 static dw_loc_descr_ref loc_descriptor  PARAMS ((rtx));
3761 static dw_loc_descr_ref loc_descriptor_from_tree PARAMS ((tree, int));
3762 static HOST_WIDE_INT ceiling            PARAMS ((HOST_WIDE_INT, unsigned int));
3763 static tree field_type                  PARAMS ((tree));
3764 static unsigned int simple_type_align_in_bits PARAMS ((tree));
3765 static unsigned int simple_decl_align_in_bits PARAMS ((tree));
3766 static unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
3767 static HOST_WIDE_INT field_byte_offset  PARAMS ((tree));
3768 static void add_AT_location_description PARAMS ((dw_die_ref,
3769                                                  enum dwarf_attribute,
3770                                                  dw_loc_descr_ref));
3771 static void add_data_member_location_attribute PARAMS ((dw_die_ref, tree));
3772 static void add_const_value_attribute   PARAMS ((dw_die_ref, rtx));
3773 static rtx rtl_for_decl_location        PARAMS ((tree));
3774 static void add_location_or_const_value_attribute PARAMS ((dw_die_ref, tree));
3775 static void tree_add_const_value_attribute PARAMS ((dw_die_ref, tree));
3776 static void add_name_attribute          PARAMS ((dw_die_ref, const char *));
3777 static void add_comp_dir_attribute      PARAMS ((dw_die_ref));
3778 static void add_bound_info              PARAMS ((dw_die_ref,
3779                                                  enum dwarf_attribute, tree));
3780 static void add_subscript_info          PARAMS ((dw_die_ref, tree));
3781 static void add_byte_size_attribute     PARAMS ((dw_die_ref, tree));
3782 static void add_bit_offset_attribute    PARAMS ((dw_die_ref, tree));
3783 static void add_bit_size_attribute      PARAMS ((dw_die_ref, tree));
3784 static void add_prototyped_attribute    PARAMS ((dw_die_ref, tree));
3785 static void add_abstract_origin_attribute PARAMS ((dw_die_ref, tree));
3786 static void add_pure_or_virtual_attribute PARAMS ((dw_die_ref, tree));
3787 static void add_src_coords_attributes   PARAMS ((dw_die_ref, tree));
3788 static void add_name_and_src_coords_attributes PARAMS ((dw_die_ref, tree));
3789 static void push_decl_scope             PARAMS ((tree));
3790 static void pop_decl_scope              PARAMS ((void));
3791 static dw_die_ref scope_die_for         PARAMS ((tree, dw_die_ref));
3792 static inline int local_scope_p         PARAMS ((dw_die_ref));
3793 static inline int class_scope_p         PARAMS ((dw_die_ref));
3794 static void add_type_attribute          PARAMS ((dw_die_ref, tree, int, int,
3795                                                  dw_die_ref));
3796 static const char *type_tag             PARAMS ((tree));
3797 static tree member_declared_type        PARAMS ((tree));
3798 #if 0
3799 static const char *decl_start_label     PARAMS ((tree));
3800 #endif
3801 static void gen_array_type_die          PARAMS ((tree, dw_die_ref));
3802 static void gen_set_type_die            PARAMS ((tree, dw_die_ref));
3803 #if 0
3804 static void gen_entry_point_die         PARAMS ((tree, dw_die_ref));
3805 #endif
3806 static void gen_inlined_enumeration_type_die PARAMS ((tree, dw_die_ref));
3807 static void gen_inlined_structure_type_die PARAMS ((tree, dw_die_ref));
3808 static void gen_inlined_union_type_die  PARAMS ((tree, dw_die_ref));
3809 static void gen_enumeration_type_die    PARAMS ((tree, dw_die_ref));
3810 static dw_die_ref gen_formal_parameter_die PARAMS ((tree, dw_die_ref));
3811 static void gen_unspecified_parameters_die PARAMS ((tree, dw_die_ref));
3812 static void gen_formal_types_die        PARAMS ((tree, dw_die_ref));
3813 static void gen_subprogram_die          PARAMS ((tree, dw_die_ref));
3814 static void gen_variable_die            PARAMS ((tree, dw_die_ref));
3815 static void gen_label_die               PARAMS ((tree, dw_die_ref));
3816 static void gen_lexical_block_die       PARAMS ((tree, dw_die_ref, int));
3817 static void gen_inlined_subroutine_die  PARAMS ((tree, dw_die_ref, int));
3818 static void gen_field_die               PARAMS ((tree, dw_die_ref));
3819 static void gen_ptr_to_mbr_type_die     PARAMS ((tree, dw_die_ref));
3820 static dw_die_ref gen_compile_unit_die  PARAMS ((const char *));
3821 static void gen_string_type_die         PARAMS ((tree, dw_die_ref));
3822 static void gen_inheritance_die         PARAMS ((tree, tree, dw_die_ref));
3823 static void gen_member_die              PARAMS ((tree, dw_die_ref));
3824 static void gen_struct_or_union_type_die PARAMS ((tree, dw_die_ref));
3825 static void gen_subroutine_type_die     PARAMS ((tree, dw_die_ref));
3826 static void gen_typedef_die             PARAMS ((tree, dw_die_ref));
3827 static void gen_type_die                PARAMS ((tree, dw_die_ref));
3828 static void gen_tagged_type_instantiation_die PARAMS ((tree, dw_die_ref));
3829 static void gen_block_die               PARAMS ((tree, dw_die_ref, int));
3830 static void decls_for_scope             PARAMS ((tree, dw_die_ref, int));
3831 static int is_redundant_typedef         PARAMS ((tree));
3832 static void gen_decl_die                PARAMS ((tree, dw_die_ref));
3833 static unsigned lookup_filename         PARAMS ((const char *));
3834 static void init_file_table             PARAMS ((void));
3835 static void retry_incomplete_types      PARAMS ((void));
3836 static void gen_type_die_for_member     PARAMS ((tree, tree, dw_die_ref));
3837 static void splice_child_die            PARAMS ((dw_die_ref, dw_die_ref));
3838 static int file_info_cmp                PARAMS ((const void *, const void *));
3839 static dw_loc_list_ref new_loc_list     PARAMS ((dw_loc_descr_ref,
3840                                                  const char *, const char *,
3841                                                  const char *, unsigned));
3842 static void add_loc_descr_to_loc_list   PARAMS ((dw_loc_list_ref *,
3843                                                  dw_loc_descr_ref,
3844                                                  const char *, const char *, const char *));
3845 static void output_loc_list             PARAMS ((dw_loc_list_ref));
3846 static char *gen_internal_sym           PARAMS ((const char *));
3847
3848 static void prune_unmark_dies           PARAMS ((dw_die_ref));
3849 static void prune_unused_types_mark     PARAMS ((dw_die_ref, int));
3850 static void prune_unused_types_walk     PARAMS ((dw_die_ref));
3851 static void prune_unused_types_walk_attribs PARAMS ((dw_die_ref));
3852 static void prune_unused_types_prune    PARAMS ((dw_die_ref));
3853 static void prune_unused_types          PARAMS ((void));
3854 static int maybe_emit_file              PARAMS ((int));
3855
3856 /* Section names used to hold DWARF debugging information.  */
3857 #ifndef DEBUG_INFO_SECTION
3858 #define DEBUG_INFO_SECTION      ".debug_info"
3859 #endif
3860 #ifndef DEBUG_ABBREV_SECTION
3861 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3862 #endif
3863 #ifndef DEBUG_ARANGES_SECTION
3864 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3865 #endif
3866 #ifndef DEBUG_MACINFO_SECTION
3867 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3868 #endif
3869 #ifndef DEBUG_LINE_SECTION
3870 #define DEBUG_LINE_SECTION      ".debug_line"
3871 #endif
3872 #ifndef DEBUG_LOC_SECTION
3873 #define DEBUG_LOC_SECTION       ".debug_loc"
3874 #endif
3875 #ifndef DEBUG_PUBNAMES_SECTION
3876 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3877 #endif
3878 #ifndef DEBUG_STR_SECTION
3879 #define DEBUG_STR_SECTION       ".debug_str"
3880 #endif
3881 #ifndef DEBUG_RANGES_SECTION
3882 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3883 #endif
3884
3885 /* Standard ELF section names for compiled code and data.  */
3886 #ifndef TEXT_SECTION_NAME
3887 #define TEXT_SECTION_NAME       ".text"
3888 #endif
3889
3890 /* Section flags for .debug_str section.  */
3891 #ifdef HAVE_GAS_SHF_MERGE
3892 #define DEBUG_STR_SECTION_FLAGS \
3893   (SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1)
3894 #else
3895 #define DEBUG_STR_SECTION_FLAGS SECTION_DEBUG
3896 #endif
3897
3898 /* Labels we insert at beginning sections we can reference instead of
3899    the section names themselves.  */
3900
3901 #ifndef TEXT_SECTION_LABEL
3902 #define TEXT_SECTION_LABEL              "Ltext"
3903 #endif
3904 #ifndef DEBUG_LINE_SECTION_LABEL
3905 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
3906 #endif
3907 #ifndef DEBUG_INFO_SECTION_LABEL
3908 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
3909 #endif
3910 #ifndef DEBUG_ABBREV_SECTION_LABEL
3911 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
3912 #endif
3913 #ifndef DEBUG_LOC_SECTION_LABEL
3914 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
3915 #endif
3916 #ifndef DEBUG_RANGES_SECTION_LABEL
3917 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
3918 #endif
3919 #ifndef DEBUG_MACINFO_SECTION_LABEL
3920 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
3921 #endif
3922
3923 /* Definitions of defaults for formats and names of various special
3924    (artificial) labels which may be generated within this file (when the -g
3925    options is used and DWARF_DEBUGGING_INFO is in effect.
3926    If necessary, these may be overridden from within the tm.h file, but
3927    typically, overriding these defaults is unnecessary.  */
3928
3929 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3930 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3931 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3932 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3933 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3934 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3935 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3936 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3937
3938 #ifndef TEXT_END_LABEL
3939 #define TEXT_END_LABEL          "Letext"
3940 #endif
3941 #ifndef BLOCK_BEGIN_LABEL
3942 #define BLOCK_BEGIN_LABEL       "LBB"
3943 #endif
3944 #ifndef BLOCK_END_LABEL
3945 #define BLOCK_END_LABEL         "LBE"
3946 #endif
3947 #ifndef LINE_CODE_LABEL
3948 #define LINE_CODE_LABEL         "LM"
3949 #endif
3950 #ifndef SEPARATE_LINE_CODE_LABEL
3951 #define SEPARATE_LINE_CODE_LABEL        "LSM"
3952 #endif
3953 \f
3954 /* We allow a language front-end to designate a function that is to be
3955    called to "demangle" any name before it it put into a DIE.  */
3956
3957 static const char *(*demangle_name_func) PARAMS ((const char *));
3958
3959 void
3960 dwarf2out_set_demangle_name_func (func)
3961      const char *(*func) PARAMS ((const char *));
3962 {
3963   demangle_name_func = func;
3964 }
3965
3966 /* Test if rtl node points to a pseudo register.  */
3967
3968 static inline int
3969 is_pseudo_reg (rtl)
3970      rtx rtl;
3971 {
3972   return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3973           || (GET_CODE (rtl) == SUBREG
3974               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3975 }
3976
3977 /* Return a reference to a type, with its const and volatile qualifiers
3978    removed.  */
3979
3980 static inline tree
3981 type_main_variant (type)
3982      tree type;
3983 {
3984   type = TYPE_MAIN_VARIANT (type);
3985
3986   /* ??? There really should be only one main variant among any group of
3987      variants of a given type (and all of the MAIN_VARIANT values for all
3988      members of the group should point to that one type) but sometimes the C
3989      front-end messes this up for array types, so we work around that bug
3990      here.  */
3991   if (TREE_CODE (type) == ARRAY_TYPE)
3992     while (type != TYPE_MAIN_VARIANT (type))
3993       type = TYPE_MAIN_VARIANT (type);
3994
3995   return type;
3996 }
3997
3998 /* Return nonzero if the given type node represents a tagged type.  */
3999
4000 static inline int
4001 is_tagged_type (type)
4002      tree type;
4003 {
4004   enum tree_code code = TREE_CODE (type);
4005
4006   return (code == RECORD_TYPE || code == UNION_TYPE
4007           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4008 }
4009
4010 /* Convert a DIE tag into its string name.  */
4011
4012 static const char *
4013 dwarf_tag_name (tag)
4014      unsigned tag;
4015 {
4016   switch (tag)
4017     {
4018     case DW_TAG_padding:
4019       return "DW_TAG_padding";
4020     case DW_TAG_array_type:
4021       return "DW_TAG_array_type";
4022     case DW_TAG_class_type:
4023       return "DW_TAG_class_type";
4024     case DW_TAG_entry_point:
4025       return "DW_TAG_entry_point";
4026     case DW_TAG_enumeration_type:
4027       return "DW_TAG_enumeration_type";
4028     case DW_TAG_formal_parameter:
4029       return "DW_TAG_formal_parameter";
4030     case DW_TAG_imported_declaration:
4031       return "DW_TAG_imported_declaration";
4032     case DW_TAG_label:
4033       return "DW_TAG_label";
4034     case DW_TAG_lexical_block:
4035       return "DW_TAG_lexical_block";
4036     case DW_TAG_member:
4037       return "DW_TAG_member";
4038     case DW_TAG_pointer_type:
4039       return "DW_TAG_pointer_type";
4040     case DW_TAG_reference_type:
4041       return "DW_TAG_reference_type";
4042     case DW_TAG_compile_unit:
4043       return "DW_TAG_compile_unit";
4044     case DW_TAG_string_type:
4045       return "DW_TAG_string_type";
4046     case DW_TAG_structure_type:
4047       return "DW_TAG_structure_type";
4048     case DW_TAG_subroutine_type:
4049       return "DW_TAG_subroutine_type";
4050     case DW_TAG_typedef:
4051       return "DW_TAG_typedef";
4052     case DW_TAG_union_type:
4053       return "DW_TAG_union_type";
4054     case DW_TAG_unspecified_parameters:
4055       return "DW_TAG_unspecified_parameters";
4056     case DW_TAG_variant:
4057       return "DW_TAG_variant";
4058     case DW_TAG_common_block:
4059       return "DW_TAG_common_block";
4060     case DW_TAG_common_inclusion:
4061       return "DW_TAG_common_inclusion";
4062     case DW_TAG_inheritance:
4063       return "DW_TAG_inheritance";
4064     case DW_TAG_inlined_subroutine:
4065       return "DW_TAG_inlined_subroutine";
4066     case DW_TAG_module:
4067       return "DW_TAG_module";
4068     case DW_TAG_ptr_to_member_type:
4069       return "DW_TAG_ptr_to_member_type";
4070     case DW_TAG_set_type:
4071       return "DW_TAG_set_type";
4072     case DW_TAG_subrange_type:
4073       return "DW_TAG_subrange_type";
4074     case DW_TAG_with_stmt:
4075       return "DW_TAG_with_stmt";
4076     case DW_TAG_access_declaration:
4077       return "DW_TAG_access_declaration";
4078     case DW_TAG_base_type:
4079       return "DW_TAG_base_type";
4080     case DW_TAG_catch_block:
4081       return "DW_TAG_catch_block";
4082     case DW_TAG_const_type:
4083       return "DW_TAG_const_type";
4084     case DW_TAG_constant:
4085       return "DW_TAG_constant";
4086     case DW_TAG_enumerator:
4087       return "DW_TAG_enumerator";
4088     case DW_TAG_file_type:
4089       return "DW_TAG_file_type";
4090     case DW_TAG_friend:
4091       return "DW_TAG_friend";
4092     case DW_TAG_namelist:
4093       return "DW_TAG_namelist";
4094     case DW_TAG_namelist_item:
4095       return "DW_TAG_namelist_item";
4096     case DW_TAG_packed_type:
4097       return "DW_TAG_packed_type";
4098     case DW_TAG_subprogram:
4099       return "DW_TAG_subprogram";
4100     case DW_TAG_template_type_param:
4101       return "DW_TAG_template_type_param";
4102     case DW_TAG_template_value_param:
4103       return "DW_TAG_template_value_param";
4104     case DW_TAG_thrown_type:
4105       return "DW_TAG_thrown_type";
4106     case DW_TAG_try_block:
4107       return "DW_TAG_try_block";
4108     case DW_TAG_variant_part:
4109       return "DW_TAG_variant_part";
4110     case DW_TAG_variable:
4111       return "DW_TAG_variable";
4112     case DW_TAG_volatile_type:
4113       return "DW_TAG_volatile_type";
4114     case DW_TAG_MIPS_loop:
4115       return "DW_TAG_MIPS_loop";
4116     case DW_TAG_format_label:
4117       return "DW_TAG_format_label";
4118     case DW_TAG_function_template:
4119       return "DW_TAG_function_template";
4120     case DW_TAG_class_template:
4121       return "DW_TAG_class_template";
4122     case DW_TAG_GNU_BINCL:
4123       return "DW_TAG_GNU_BINCL";
4124     case DW_TAG_GNU_EINCL:
4125       return "DW_TAG_GNU_EINCL";
4126     default:
4127       return "DW_TAG_<unknown>";
4128     }
4129 }
4130
4131 /* Convert a DWARF attribute code into its string name.  */
4132
4133 static const char *
4134 dwarf_attr_name (attr)
4135      unsigned attr;
4136 {
4137   switch (attr)
4138     {
4139     case DW_AT_sibling:
4140       return "DW_AT_sibling";
4141     case DW_AT_location:
4142       return "DW_AT_location";
4143     case DW_AT_name:
4144       return "DW_AT_name";
4145     case DW_AT_ordering:
4146       return "DW_AT_ordering";
4147     case DW_AT_subscr_data:
4148       return "DW_AT_subscr_data";
4149     case DW_AT_byte_size:
4150       return "DW_AT_byte_size";
4151     case DW_AT_bit_offset:
4152       return "DW_AT_bit_offset";
4153     case DW_AT_bit_size:
4154       return "DW_AT_bit_size";
4155     case DW_AT_element_list:
4156       return "DW_AT_element_list";
4157     case DW_AT_stmt_list:
4158       return "DW_AT_stmt_list";
4159     case DW_AT_low_pc:
4160       return "DW_AT_low_pc";
4161     case DW_AT_high_pc:
4162       return "DW_AT_high_pc";
4163     case DW_AT_language:
4164       return "DW_AT_language";
4165     case DW_AT_member:
4166       return "DW_AT_member";
4167     case DW_AT_discr:
4168       return "DW_AT_discr";
4169     case DW_AT_discr_value:
4170       return "DW_AT_discr_value";
4171     case DW_AT_visibility:
4172       return "DW_AT_visibility";
4173     case DW_AT_import:
4174       return "DW_AT_import";
4175     case DW_AT_string_length:
4176       return "DW_AT_string_length";
4177     case DW_AT_common_reference:
4178       return "DW_AT_common_reference";
4179     case DW_AT_comp_dir:
4180       return "DW_AT_comp_dir";
4181     case DW_AT_const_value:
4182       return "DW_AT_const_value";
4183     case DW_AT_containing_type:
4184       return "DW_AT_containing_type";
4185     case DW_AT_default_value:
4186       return "DW_AT_default_value";
4187     case DW_AT_inline:
4188       return "DW_AT_inline";
4189     case DW_AT_is_optional:
4190       return "DW_AT_is_optional";
4191     case DW_AT_lower_bound:
4192       return "DW_AT_lower_bound";
4193     case DW_AT_producer:
4194       return "DW_AT_producer";
4195     case DW_AT_prototyped:
4196       return "DW_AT_prototyped";
4197     case DW_AT_return_addr:
4198       return "DW_AT_return_addr";
4199     case DW_AT_start_scope:
4200       return "DW_AT_start_scope";
4201     case DW_AT_stride_size:
4202       return "DW_AT_stride_size";
4203     case DW_AT_upper_bound:
4204       return "DW_AT_upper_bound";
4205     case DW_AT_abstract_origin:
4206       return "DW_AT_abstract_origin";
4207     case DW_AT_accessibility:
4208       return "DW_AT_accessibility";
4209     case DW_AT_address_class:
4210       return "DW_AT_address_class";
4211     case DW_AT_artificial:
4212       return "DW_AT_artificial";
4213     case DW_AT_base_types:
4214       return "DW_AT_base_types";
4215     case DW_AT_calling_convention:
4216       return "DW_AT_calling_convention";
4217     case DW_AT_count:
4218       return "DW_AT_count";
4219     case DW_AT_data_member_location:
4220       return "DW_AT_data_member_location";
4221     case DW_AT_decl_column:
4222       return "DW_AT_decl_column";
4223     case DW_AT_decl_file:
4224       return "DW_AT_decl_file";
4225     case DW_AT_decl_line:
4226       return "DW_AT_decl_line";
4227     case DW_AT_declaration:
4228       return "DW_AT_declaration";
4229     case DW_AT_discr_list:
4230       return "DW_AT_discr_list";
4231     case DW_AT_encoding:
4232       return "DW_AT_encoding";
4233     case DW_AT_external:
4234       return "DW_AT_external";
4235     case DW_AT_frame_base:
4236       return "DW_AT_frame_base";
4237     case DW_AT_friend:
4238       return "DW_AT_friend";
4239     case DW_AT_identifier_case:
4240       return "DW_AT_identifier_case";
4241     case DW_AT_macro_info:
4242       return "DW_AT_macro_info";
4243     case DW_AT_namelist_items:
4244       return "DW_AT_namelist_items";
4245     case DW_AT_priority:
4246       return "DW_AT_priority";
4247     case DW_AT_segment:
4248       return "DW_AT_segment";
4249     case DW_AT_specification:
4250       return "DW_AT_specification";
4251     case DW_AT_static_link:
4252       return "DW_AT_static_link";
4253     case DW_AT_type:
4254       return "DW_AT_type";
4255     case DW_AT_use_location:
4256       return "DW_AT_use_location";
4257     case DW_AT_variable_parameter:
4258       return "DW_AT_variable_parameter";
4259     case DW_AT_virtuality:
4260       return "DW_AT_virtuality";
4261     case DW_AT_vtable_elem_location:
4262       return "DW_AT_vtable_elem_location";
4263
4264     case DW_AT_allocated:
4265       return "DW_AT_allocated";
4266     case DW_AT_associated:
4267       return "DW_AT_associated";
4268     case DW_AT_data_location:
4269       return "DW_AT_data_location";
4270     case DW_AT_stride:
4271       return "DW_AT_stride";
4272     case DW_AT_entry_pc:
4273       return "DW_AT_entry_pc";
4274     case DW_AT_use_UTF8:
4275       return "DW_AT_use_UTF8";
4276     case DW_AT_extension:
4277       return "DW_AT_extension";
4278     case DW_AT_ranges:
4279       return "DW_AT_ranges";
4280     case DW_AT_trampoline:
4281       return "DW_AT_trampoline";
4282     case DW_AT_call_column:
4283       return "DW_AT_call_column";
4284     case DW_AT_call_file:
4285       return "DW_AT_call_file";
4286     case DW_AT_call_line:
4287       return "DW_AT_call_line";
4288
4289     case DW_AT_MIPS_fde:
4290       return "DW_AT_MIPS_fde";
4291     case DW_AT_MIPS_loop_begin:
4292       return "DW_AT_MIPS_loop_begin";
4293     case DW_AT_MIPS_tail_loop_begin:
4294       return "DW_AT_MIPS_tail_loop_begin";
4295     case DW_AT_MIPS_epilog_begin:
4296       return "DW_AT_MIPS_epilog_begin";
4297     case DW_AT_MIPS_loop_unroll_factor:
4298       return "DW_AT_MIPS_loop_unroll_factor";
4299     case DW_AT_MIPS_software_pipeline_depth:
4300       return "DW_AT_MIPS_software_pipeline_depth";
4301     case DW_AT_MIPS_linkage_name:
4302       return "DW_AT_MIPS_linkage_name";
4303     case DW_AT_MIPS_stride:
4304       return "DW_AT_MIPS_stride";
4305     case DW_AT_MIPS_abstract_name:
4306       return "DW_AT_MIPS_abstract_name";
4307     case DW_AT_MIPS_clone_origin:
4308       return "DW_AT_MIPS_clone_origin";
4309     case DW_AT_MIPS_has_inlines:
4310       return "DW_AT_MIPS_has_inlines";
4311
4312     case DW_AT_sf_names:
4313       return "DW_AT_sf_names";
4314     case DW_AT_src_info:
4315       return "DW_AT_src_info";
4316     case DW_AT_mac_info:
4317       return "DW_AT_mac_info";
4318     case DW_AT_src_coords:
4319       return "DW_AT_src_coords";
4320     case DW_AT_body_begin:
4321       return "DW_AT_body_begin";
4322     case DW_AT_body_end:
4323       return "DW_AT_body_end";
4324     case DW_AT_GNU_vector:
4325       return "DW_AT_GNU_vector";
4326
4327     case DW_AT_VMS_rtnbeg_pd_address:
4328       return "DW_AT_VMS_rtnbeg_pd_address";
4329
4330     default:
4331       return "DW_AT_<unknown>";
4332     }
4333 }
4334
4335 /* Convert a DWARF value form code into its string name.  */
4336
4337 static const char *
4338 dwarf_form_name (form)
4339      unsigned form;
4340 {
4341   switch (form)
4342     {
4343     case DW_FORM_addr:
4344       return "DW_FORM_addr";
4345     case DW_FORM_block2:
4346       return "DW_FORM_block2";
4347     case DW_FORM_block4:
4348       return "DW_FORM_block4";
4349     case DW_FORM_data2:
4350       return "DW_FORM_data2";
4351     case DW_FORM_data4:
4352       return "DW_FORM_data4";
4353     case DW_FORM_data8:
4354       return "DW_FORM_data8";
4355     case DW_FORM_string:
4356       return "DW_FORM_string";
4357     case DW_FORM_block:
4358       return "DW_FORM_block";
4359     case DW_FORM_block1:
4360       return "DW_FORM_block1";
4361     case DW_FORM_data1:
4362       return "DW_FORM_data1";
4363     case DW_FORM_flag:
4364       return "DW_FORM_flag";
4365     case DW_FORM_sdata:
4366       return "DW_FORM_sdata";
4367     case DW_FORM_strp:
4368       return "DW_FORM_strp";
4369     case DW_FORM_udata:
4370       return "DW_FORM_udata";
4371     case DW_FORM_ref_addr:
4372       return "DW_FORM_ref_addr";
4373     case DW_FORM_ref1:
4374       return "DW_FORM_ref1";
4375     case DW_FORM_ref2:
4376       return "DW_FORM_ref2";
4377     case DW_FORM_ref4:
4378       return "DW_FORM_ref4";
4379     case DW_FORM_ref8:
4380       return "DW_FORM_ref8";
4381     case DW_FORM_ref_udata:
4382       return "DW_FORM_ref_udata";
4383     case DW_FORM_indirect:
4384       return "DW_FORM_indirect";
4385     default:
4386       return "DW_FORM_<unknown>";
4387     }
4388 }
4389
4390 /* Convert a DWARF type code into its string name.  */
4391
4392 #if 0
4393 static const char *
4394 dwarf_type_encoding_name (enc)
4395      unsigned enc;
4396 {
4397   switch (enc)
4398     {
4399     case DW_ATE_address:
4400       return "DW_ATE_address";
4401     case DW_ATE_boolean:
4402       return "DW_ATE_boolean";
4403     case DW_ATE_complex_float:
4404       return "DW_ATE_complex_float";
4405     case DW_ATE_float:
4406       return "DW_ATE_float";
4407     case DW_ATE_signed:
4408       return "DW_ATE_signed";
4409     case DW_ATE_signed_char:
4410       return "DW_ATE_signed_char";
4411     case DW_ATE_unsigned:
4412       return "DW_ATE_unsigned";
4413     case DW_ATE_unsigned_char:
4414       return "DW_ATE_unsigned_char";
4415     default:
4416       return "DW_ATE_<unknown>";
4417     }
4418 }
4419 #endif
4420 \f
4421 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4422    instance of an inlined instance of a decl which is local to an inline
4423    function, so we have to trace all of the way back through the origin chain
4424    to find out what sort of node actually served as the original seed for the
4425    given block.  */
4426
4427 static tree
4428 decl_ultimate_origin (decl)
4429      tree decl;
4430 {
4431   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4432      nodes in the function to point to themselves; ignore that if
4433      we're trying to output the abstract instance of this function.  */
4434   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4435     return NULL_TREE;
4436
4437 #ifdef ENABLE_CHECKING
4438   if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
4439     /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4440        most distant ancestor, this should never happen.  */
4441     abort ();
4442 #endif
4443
4444   return DECL_ABSTRACT_ORIGIN (decl);
4445 }
4446
4447 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4448    instance of an inlined instance of a block which is local to an inline
4449    function, so we have to trace all of the way back through the origin chain
4450    to find out what sort of node actually served as the original seed for the
4451    given block.  */
4452
4453 static tree
4454 block_ultimate_origin (block)
4455      tree block;
4456 {
4457   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4458
4459   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4460      nodes in the function to point to themselves; ignore that if
4461      we're trying to output the abstract instance of this function.  */
4462   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4463     return NULL_TREE;
4464
4465   if (immediate_origin == NULL_TREE)
4466     return NULL_TREE;
4467   else
4468     {
4469       tree ret_val;
4470       tree lookahead = immediate_origin;
4471
4472       do
4473         {
4474           ret_val = lookahead;
4475           lookahead = (TREE_CODE (ret_val) == BLOCK
4476                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4477         }
4478       while (lookahead != NULL && lookahead != ret_val);
4479
4480       return ret_val;
4481     }
4482 }
4483
4484 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4485    of a virtual function may refer to a base class, so we check the 'this'
4486    parameter.  */
4487
4488 static tree
4489 decl_class_context (decl)
4490      tree decl;
4491 {
4492   tree context = NULL_TREE;
4493
4494   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4495     context = DECL_CONTEXT (decl);
4496   else
4497     context = TYPE_MAIN_VARIANT
4498       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4499
4500   if (context && !TYPE_P (context))
4501     context = NULL_TREE;
4502
4503   return context;
4504 }
4505 \f
4506 /* Add an attribute/value pair to a DIE.  We build the lists up in reverse
4507    addition order, and correct that in reverse_all_dies.  */
4508
4509 static inline void
4510 add_dwarf_attr (die, attr)
4511      dw_die_ref die;
4512      dw_attr_ref attr;
4513 {
4514   if (die != NULL && attr != NULL)
4515     {
4516       attr->dw_attr_next = die->die_attr;
4517       die->die_attr = attr;
4518     }
4519 }
4520
4521 static inline enum dw_val_class
4522 AT_class (a)
4523      dw_attr_ref a;
4524 {
4525   return a->dw_attr_val.val_class;
4526 }
4527
4528 /* Add a flag value attribute to a DIE.  */
4529
4530 static inline void
4531 add_AT_flag (die, attr_kind, flag)
4532      dw_die_ref die;
4533      enum dwarf_attribute attr_kind;
4534      unsigned flag;
4535 {
4536   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4537
4538   attr->dw_attr_next = NULL;
4539   attr->dw_attr = attr_kind;
4540   attr->dw_attr_val.val_class = dw_val_class_flag;
4541   attr->dw_attr_val.v.val_flag = flag;
4542   add_dwarf_attr (die, attr);
4543 }
4544
4545 static inline unsigned
4546 AT_flag (a)
4547      dw_attr_ref a;
4548 {
4549   if (a && AT_class (a) == dw_val_class_flag)
4550     return a->dw_attr_val.v.val_flag;
4551
4552   abort ();
4553 }
4554
4555 /* Add a signed integer attribute value to a DIE.  */
4556
4557 static inline void
4558 add_AT_int (die, attr_kind, int_val)
4559      dw_die_ref die;
4560      enum dwarf_attribute attr_kind;
4561      long int int_val;
4562 {
4563   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4564
4565   attr->dw_attr_next = NULL;
4566   attr->dw_attr = attr_kind;
4567   attr->dw_attr_val.val_class = dw_val_class_const;
4568   attr->dw_attr_val.v.val_int = int_val;
4569   add_dwarf_attr (die, attr);
4570 }
4571
4572 static inline long int
4573 AT_int (a)
4574      dw_attr_ref a;
4575 {
4576   if (a && AT_class (a) == dw_val_class_const)
4577     return a->dw_attr_val.v.val_int;
4578
4579   abort ();
4580 }
4581
4582 /* Add an unsigned integer attribute value to a DIE.  */
4583
4584 static inline void
4585 add_AT_unsigned (die, attr_kind, unsigned_val)
4586      dw_die_ref die;
4587      enum dwarf_attribute attr_kind;
4588      unsigned long unsigned_val;
4589 {
4590   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4591
4592   attr->dw_attr_next = NULL;
4593   attr->dw_attr = attr_kind;
4594   attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4595   attr->dw_attr_val.v.val_unsigned = unsigned_val;
4596   add_dwarf_attr (die, attr);
4597 }
4598
4599 static inline unsigned long
4600 AT_unsigned (a)
4601      dw_attr_ref a;
4602 {
4603   if (a && AT_class (a) == dw_val_class_unsigned_const)
4604     return a->dw_attr_val.v.val_unsigned;
4605
4606   abort ();
4607 }
4608
4609 /* Add an unsigned double integer attribute value to a DIE.  */
4610
4611 static inline void
4612 add_AT_long_long (die, attr_kind, val_hi, val_low)
4613      dw_die_ref die;
4614      enum dwarf_attribute attr_kind;
4615      unsigned long val_hi;
4616      unsigned long val_low;
4617 {
4618   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4619
4620   attr->dw_attr_next = NULL;
4621   attr->dw_attr = attr_kind;
4622   attr->dw_attr_val.val_class = dw_val_class_long_long;
4623   attr->dw_attr_val.v.val_long_long.hi = val_hi;
4624   attr->dw_attr_val.v.val_long_long.low = val_low;
4625   add_dwarf_attr (die, attr);
4626 }
4627
4628 /* Add a floating point attribute value to a DIE and return it.  */
4629
4630 static inline void
4631 add_AT_float (die, attr_kind, length, array)
4632      dw_die_ref die;
4633      enum dwarf_attribute attr_kind;
4634      unsigned length;
4635      long *array;
4636 {
4637   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4638
4639   attr->dw_attr_next = NULL;
4640   attr->dw_attr = attr_kind;
4641   attr->dw_attr_val.val_class = dw_val_class_float;
4642   attr->dw_attr_val.v.val_float.length = length;
4643   attr->dw_attr_val.v.val_float.array = array;
4644   add_dwarf_attr (die, attr);
4645 }
4646
4647 /* Hash and equality functions for debug_str_hash.  */
4648
4649 static hashval_t
4650 debug_str_do_hash (x)
4651      const void * x;
4652 {
4653   return htab_hash_string (((const struct indirect_string_node *)x)->str);
4654 }
4655
4656 static int
4657 debug_str_eq (x1, x2)
4658      const void * x1;
4659      const void * x2;
4660 {
4661   return strcmp ((((const struct indirect_string_node *)x1)->str),
4662                  (const char *)x2) == 0;
4663 }
4664
4665 /* Add a string attribute value to a DIE.  */
4666
4667 static inline void
4668 add_AT_string (die, attr_kind, str)
4669      dw_die_ref die;
4670      enum dwarf_attribute attr_kind;
4671      const char *str;
4672 {
4673   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4674   struct indirect_string_node *node;
4675   PTR *slot;
4676
4677   if (! debug_str_hash)
4678     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4679                                       debug_str_eq, NULL);
4680
4681   slot = htab_find_slot_with_hash (debug_str_hash, str,
4682                                    htab_hash_string (str), INSERT);
4683   if (*slot == NULL)
4684     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4685   node = (struct indirect_string_node *) *slot;
4686   node->str = ggc_alloc_string (str, -1);
4687   node->refcount++;
4688
4689   attr->dw_attr_next = NULL;
4690   attr->dw_attr = attr_kind;
4691   attr->dw_attr_val.val_class = dw_val_class_str;
4692   attr->dw_attr_val.v.val_str = node;
4693   add_dwarf_attr (die, attr);
4694 }
4695
4696 static inline const char *
4697 AT_string (a)
4698      dw_attr_ref a;
4699 {
4700   if (a && AT_class (a) == dw_val_class_str)
4701     return a->dw_attr_val.v.val_str->str;
4702
4703   abort ();
4704 }
4705
4706 /* Find out whether a string should be output inline in DIE
4707    or out-of-line in .debug_str section.  */
4708
4709 static int
4710 AT_string_form (a)
4711      dw_attr_ref a;
4712 {
4713   if (a && AT_class (a) == dw_val_class_str)
4714     {
4715       struct indirect_string_node *node;
4716       unsigned int len;
4717       char label[32];
4718
4719       node = a->dw_attr_val.v.val_str;
4720       if (node->form)
4721         return node->form;
4722
4723       len = strlen (node->str) + 1;
4724
4725       /* If the string is shorter or equal to the size of the reference, it is
4726          always better to put it inline.  */
4727       if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4728         return node->form = DW_FORM_string;
4729
4730       /* If we cannot expect the linker to merge strings in .debug_str
4731          section, only put it into .debug_str if it is worth even in this
4732          single module.  */
4733       if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
4734           && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
4735         return node->form = DW_FORM_string;
4736
4737       ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4738       ++dw2_string_counter;
4739       node->label = xstrdup (label);
4740
4741       return node->form = DW_FORM_strp;
4742     }
4743
4744   abort ();
4745 }
4746
4747 /* Add a DIE reference attribute value to a DIE.  */
4748
4749 static inline void
4750 add_AT_die_ref (die, attr_kind, targ_die)
4751      dw_die_ref die;
4752      enum dwarf_attribute attr_kind;
4753      dw_die_ref targ_die;
4754 {
4755   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4756
4757   attr->dw_attr_next = NULL;
4758   attr->dw_attr = attr_kind;
4759   attr->dw_attr_val.val_class = dw_val_class_die_ref;
4760   attr->dw_attr_val.v.val_die_ref.die = targ_die;
4761   attr->dw_attr_val.v.val_die_ref.external = 0;
4762   add_dwarf_attr (die, attr);
4763 }
4764
4765 static inline dw_die_ref
4766 AT_ref (a)
4767      dw_attr_ref a;
4768 {
4769   if (a && AT_class (a) == dw_val_class_die_ref)
4770     return a->dw_attr_val.v.val_die_ref.die;
4771
4772   abort ();
4773 }
4774
4775 static inline int
4776 AT_ref_external (a)
4777      dw_attr_ref a;
4778 {
4779   if (a && AT_class (a) == dw_val_class_die_ref)
4780     return a->dw_attr_val.v.val_die_ref.external;
4781
4782   return 0;
4783 }
4784
4785 static inline void
4786 set_AT_ref_external (a, i)
4787      dw_attr_ref a;
4788      int i;
4789 {
4790   if (a && AT_class (a) == dw_val_class_die_ref)
4791     a->dw_attr_val.v.val_die_ref.external = i;
4792   else
4793     abort ();
4794 }
4795
4796 /* Add an FDE reference attribute value to a DIE.  */
4797
4798 static inline void
4799 add_AT_fde_ref (die, attr_kind, targ_fde)
4800      dw_die_ref die;
4801      enum dwarf_attribute attr_kind;
4802      unsigned targ_fde;
4803 {
4804   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4805
4806   attr->dw_attr_next = NULL;
4807   attr->dw_attr = attr_kind;
4808   attr->dw_attr_val.val_class = dw_val_class_fde_ref;
4809   attr->dw_attr_val.v.val_fde_index = targ_fde;
4810   add_dwarf_attr (die, attr);
4811 }
4812
4813 /* Add a location description attribute value to a DIE.  */
4814
4815 static inline void
4816 add_AT_loc (die, attr_kind, loc)
4817      dw_die_ref die;
4818      enum dwarf_attribute attr_kind;
4819      dw_loc_descr_ref loc;
4820 {
4821   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4822
4823   attr->dw_attr_next = NULL;
4824   attr->dw_attr = attr_kind;
4825   attr->dw_attr_val.val_class = dw_val_class_loc;
4826   attr->dw_attr_val.v.val_loc = loc;
4827   add_dwarf_attr (die, attr);
4828 }
4829
4830 static inline dw_loc_descr_ref
4831 AT_loc (a)
4832      dw_attr_ref a;
4833 {
4834   if (a && AT_class (a) == dw_val_class_loc)
4835     return a->dw_attr_val.v.val_loc;
4836
4837   abort ();
4838 }
4839
4840 static inline void
4841 add_AT_loc_list (die, attr_kind, loc_list)
4842      dw_die_ref die;
4843      enum dwarf_attribute attr_kind;
4844      dw_loc_list_ref loc_list;
4845 {
4846   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4847
4848   attr->dw_attr_next = NULL;
4849   attr->dw_attr = attr_kind;
4850   attr->dw_attr_val.val_class = dw_val_class_loc_list;
4851   attr->dw_attr_val.v.val_loc_list = loc_list;
4852   add_dwarf_attr (die, attr);
4853   have_location_lists = 1;
4854 }
4855
4856 static inline dw_loc_list_ref
4857 AT_loc_list (a)
4858      dw_attr_ref a;
4859 {
4860   if (a && AT_class (a) == dw_val_class_loc_list)
4861     return a->dw_attr_val.v.val_loc_list;
4862
4863   abort ();
4864 }
4865
4866 /* Add an address constant attribute value to a DIE.  */
4867
4868 static inline void
4869 add_AT_addr (die, attr_kind, addr)
4870      dw_die_ref die;
4871      enum dwarf_attribute attr_kind;
4872      rtx addr;
4873 {
4874   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4875
4876   attr->dw_attr_next = NULL;
4877   attr->dw_attr = attr_kind;
4878   attr->dw_attr_val.val_class = dw_val_class_addr;
4879   attr->dw_attr_val.v.val_addr = addr;
4880   add_dwarf_attr (die, attr);
4881 }
4882
4883 static inline rtx
4884 AT_addr (a)
4885      dw_attr_ref a;
4886 {
4887   if (a && AT_class (a) == dw_val_class_addr)
4888     return a->dw_attr_val.v.val_addr;
4889
4890   abort ();
4891 }
4892
4893 /* Add a label identifier attribute value to a DIE.  */
4894
4895 static inline void
4896 add_AT_lbl_id (die, attr_kind, lbl_id)
4897      dw_die_ref die;
4898      enum dwarf_attribute attr_kind;
4899      const char *lbl_id;
4900 {
4901   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4902
4903   attr->dw_attr_next = NULL;
4904   attr->dw_attr = attr_kind;
4905   attr->dw_attr_val.val_class = dw_val_class_lbl_id;
4906   attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4907   add_dwarf_attr (die, attr);
4908 }
4909
4910 /* Add a section offset attribute value to a DIE.  */
4911
4912 static inline void
4913 add_AT_lbl_offset (die, attr_kind, label)
4914      dw_die_ref die;
4915      enum dwarf_attribute attr_kind;
4916      const char *label;
4917 {
4918   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4919
4920   attr->dw_attr_next = NULL;
4921   attr->dw_attr = attr_kind;
4922   attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
4923   attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
4924   add_dwarf_attr (die, attr);
4925 }
4926
4927 /* Add an offset attribute value to a DIE.  */
4928
4929 static inline void
4930 add_AT_offset (die, attr_kind, offset)
4931      dw_die_ref die;
4932      enum dwarf_attribute attr_kind;
4933      unsigned long offset;
4934 {
4935   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4936
4937   attr->dw_attr_next = NULL;
4938   attr->dw_attr = attr_kind;
4939   attr->dw_attr_val.val_class = dw_val_class_offset;
4940   attr->dw_attr_val.v.val_offset = offset;
4941   add_dwarf_attr (die, attr);
4942 }
4943
4944 /* Add an range_list attribute value to a DIE.  */
4945
4946 static void
4947 add_AT_range_list (die, attr_kind, offset)
4948      dw_die_ref die;
4949      enum dwarf_attribute attr_kind;
4950      unsigned long offset;
4951 {
4952   dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
4953
4954   attr->dw_attr_next = NULL;
4955   attr->dw_attr = attr_kind;
4956   attr->dw_attr_val.val_class = dw_val_class_range_list;
4957   attr->dw_attr_val.v.val_offset = offset;
4958   add_dwarf_attr (die, attr);
4959 }
4960
4961 static inline const char *
4962 AT_lbl (a)
4963      dw_attr_ref a;
4964 {
4965   if (a && (AT_class (a) == dw_val_class_lbl_id
4966             || AT_class (a) == dw_val_class_lbl_offset))
4967     return a->dw_attr_val.v.val_lbl_id;
4968
4969   abort ();
4970 }
4971
4972 /* Get the attribute of type attr_kind.  */
4973
4974 static inline dw_attr_ref
4975 get_AT (die, attr_kind)
4976      dw_die_ref die;
4977      enum dwarf_attribute attr_kind;
4978 {
4979   dw_attr_ref a;
4980   dw_die_ref spec = NULL;
4981
4982   if (die != NULL)
4983     {
4984       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4985         if (a->dw_attr == attr_kind)
4986           return a;
4987         else if (a->dw_attr == DW_AT_specification
4988                  || a->dw_attr == DW_AT_abstract_origin)
4989           spec = AT_ref (a);
4990
4991       if (spec)
4992         return get_AT (spec, attr_kind);
4993     }
4994
4995   return NULL;
4996 }
4997
4998 /* Return the "low pc" attribute value, typically associated with a subprogram
4999    DIE.  Return null if the "low pc" attribute is either not present, or if it
5000    cannot be represented as an assembler label identifier.  */
5001
5002 static inline const char *
5003 get_AT_low_pc (die)
5004      dw_die_ref die;
5005 {
5006   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5007
5008   return a ? AT_lbl (a) : NULL;
5009 }
5010
5011 /* Return the "high pc" attribute value, typically associated with a subprogram
5012    DIE.  Return null if the "high pc" attribute is either not present, or if it
5013    cannot be represented as an assembler label identifier.  */
5014
5015 static inline const char *
5016 get_AT_hi_pc (die)
5017      dw_die_ref die;
5018 {
5019   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5020
5021   return a ? AT_lbl (a) : NULL;
5022 }
5023
5024 /* Return the value of the string attribute designated by ATTR_KIND, or
5025    NULL if it is not present.  */
5026
5027 static inline const char *
5028 get_AT_string (die, attr_kind)
5029      dw_die_ref die;
5030      enum dwarf_attribute attr_kind;
5031 {
5032   dw_attr_ref a = get_AT (die, attr_kind);
5033
5034   return a ? AT_string (a) : NULL;
5035 }
5036
5037 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5038    if it is not present.  */
5039
5040 static inline int
5041 get_AT_flag (die, attr_kind)
5042      dw_die_ref die;
5043      enum dwarf_attribute attr_kind;
5044 {
5045   dw_attr_ref a = get_AT (die, attr_kind);
5046
5047   return a ? AT_flag (a) : 0;
5048 }
5049
5050 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5051    if it is not present.  */
5052
5053 static inline unsigned
5054 get_AT_unsigned (die, attr_kind)
5055      dw_die_ref die;
5056      enum dwarf_attribute attr_kind;
5057 {
5058   dw_attr_ref a = get_AT (die, attr_kind);
5059
5060   return a ? AT_unsigned (a) : 0;
5061 }
5062
5063 static inline dw_die_ref
5064 get_AT_ref (die, attr_kind)
5065      dw_die_ref die;
5066      enum dwarf_attribute attr_kind;
5067 {
5068   dw_attr_ref a = get_AT (die, attr_kind);
5069
5070   return a ? AT_ref (a) : NULL;
5071 }
5072
5073 static inline int
5074 is_c_family ()
5075 {
5076   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5077
5078   return (lang == DW_LANG_C || lang == DW_LANG_C89
5079           || lang == DW_LANG_C_plus_plus);
5080 }
5081
5082 static inline int
5083 is_cxx ()
5084 {
5085   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5086           == DW_LANG_C_plus_plus);
5087 }
5088
5089 static inline int
5090 is_fortran ()
5091 {
5092   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5093
5094   return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
5095 }
5096
5097 static inline int
5098 is_java ()
5099 {
5100   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5101
5102   return (lang == DW_LANG_Java);
5103 }
5104
5105 /* Free up the memory used by A.  */
5106
5107 static inline void free_AT PARAMS ((dw_attr_ref));
5108 static inline void
5109 free_AT (a)
5110      dw_attr_ref a;
5111 {
5112   if (AT_class (a) == dw_val_class_str)
5113     if (a->dw_attr_val.v.val_str->refcount)
5114       a->dw_attr_val.v.val_str->refcount--;
5115 }
5116
5117 /* Remove the specified attribute if present.  */
5118
5119 static void
5120 remove_AT (die, attr_kind)
5121      dw_die_ref die;
5122      enum dwarf_attribute attr_kind;
5123 {
5124   dw_attr_ref *p;
5125   dw_attr_ref removed = NULL;
5126
5127   if (die != NULL)
5128     {
5129       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5130         if ((*p)->dw_attr == attr_kind)
5131           {
5132             removed = *p;
5133             *p = (*p)->dw_attr_next;
5134             break;
5135           }
5136
5137       if (removed != 0)
5138         free_AT (removed);
5139     }
5140 }
5141
5142 /* Free up the memory used by DIE.  */
5143
5144 static inline void
5145 free_die (die)
5146      dw_die_ref die;
5147 {
5148   remove_children (die);
5149 }
5150
5151 /* Discard the children of this DIE.  */
5152
5153 static void
5154 remove_children (die)
5155      dw_die_ref die;
5156 {
5157   dw_die_ref child_die = die->die_child;
5158
5159   die->die_child = NULL;
5160
5161   while (child_die != NULL)
5162     {
5163       dw_die_ref tmp_die = child_die;
5164       dw_attr_ref a;
5165
5166       child_die = child_die->die_sib;
5167
5168       for (a = tmp_die->die_attr; a != NULL;)
5169         {
5170           dw_attr_ref tmp_a = a;
5171
5172           a = a->dw_attr_next;
5173           free_AT (tmp_a);
5174         }
5175
5176       free_die (tmp_die);
5177     }
5178 }
5179
5180 /* Add a child DIE below its parent.  We build the lists up in reverse
5181    addition order, and correct that in reverse_all_dies.  */
5182
5183 static inline void
5184 add_child_die (die, child_die)
5185      dw_die_ref die;
5186      dw_die_ref child_die;
5187 {
5188   if (die != NULL && child_die != NULL)
5189     {
5190       if (die == child_die)
5191         abort ();
5192
5193       child_die->die_parent = die;
5194       child_die->die_sib = die->die_child;
5195       die->die_child = child_die;
5196     }
5197 }
5198
5199 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5200    is the specification, to the front of PARENT's list of children.  */
5201
5202 static void
5203 splice_child_die (parent, child)
5204      dw_die_ref parent, child;
5205 {
5206   dw_die_ref *p;
5207
5208   /* We want the declaration DIE from inside the class, not the
5209      specification DIE at toplevel.  */
5210   if (child->die_parent != parent)
5211     {
5212       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5213
5214       if (tmp)
5215         child = tmp;
5216     }
5217
5218   if (child->die_parent != parent
5219       && child->die_parent != get_AT_ref (parent, DW_AT_specification))
5220     abort ();
5221
5222   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5223     if (*p == child)
5224       {
5225         *p = child->die_sib;
5226         break;
5227       }
5228
5229   child->die_parent = parent;
5230   child->die_sib = parent->die_child;
5231   parent->die_child = child;
5232 }
5233
5234 /* Return a pointer to a newly created DIE node.  */
5235
5236 static inline dw_die_ref
5237 new_die (tag_value, parent_die, t)
5238      enum dwarf_tag tag_value;
5239      dw_die_ref parent_die;
5240      tree t;
5241 {
5242   dw_die_ref die = (dw_die_ref) ggc_alloc_cleared (sizeof (die_node));
5243
5244   die->die_tag = tag_value;
5245
5246   if (parent_die != NULL)
5247     add_child_die (parent_die, die);
5248   else
5249     {
5250       limbo_die_node *limbo_node;
5251
5252       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5253       limbo_node->die = die;
5254       limbo_node->created_for = t;
5255       limbo_node->next = limbo_die_list;
5256       limbo_die_list = limbo_node;
5257     }
5258
5259   return die;
5260 }
5261
5262 /* Return the DIE associated with the given type specifier.  */
5263
5264 static inline dw_die_ref
5265 lookup_type_die (type)
5266      tree type;
5267 {
5268   return TYPE_SYMTAB_DIE (type);
5269 }
5270
5271 /* Equate a DIE to a given type specifier.  */
5272
5273 static inline void
5274 equate_type_number_to_die (type, type_die)
5275      tree type;
5276      dw_die_ref type_die;
5277 {
5278   TYPE_SYMTAB_DIE (type) = type_die;
5279 }
5280
5281 /* Return the DIE associated with a given declaration.  */
5282
5283 static inline dw_die_ref
5284 lookup_decl_die (decl)
5285      tree decl;
5286 {
5287   unsigned decl_id = DECL_UID (decl);
5288
5289   return (decl_id < decl_die_table_in_use ? decl_die_table[decl_id] : NULL);
5290 }
5291
5292 /* Equate a DIE to a particular declaration.  */
5293
5294 static void
5295 equate_decl_number_to_die (decl, decl_die)
5296      tree decl;
5297      dw_die_ref decl_die;
5298 {
5299   unsigned int decl_id = DECL_UID (decl);
5300   unsigned int num_allocated;
5301
5302   if (decl_id >= decl_die_table_allocated)
5303     {
5304       num_allocated
5305         = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
5306            / DECL_DIE_TABLE_INCREMENT)
5307           * DECL_DIE_TABLE_INCREMENT;
5308
5309       decl_die_table = ggc_realloc (decl_die_table,
5310                                     sizeof (dw_die_ref) * num_allocated);
5311
5312       memset ((char *) &decl_die_table[decl_die_table_allocated], 0,
5313              (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
5314       decl_die_table_allocated = num_allocated;
5315     }
5316
5317   if (decl_id >= decl_die_table_in_use)
5318     decl_die_table_in_use = (decl_id + 1);
5319
5320   decl_die_table[decl_id] = decl_die;
5321 }
5322 \f
5323 /* Keep track of the number of spaces used to indent the
5324    output of the debugging routines that print the structure of
5325    the DIE internal representation.  */
5326 static int print_indent;
5327
5328 /* Indent the line the number of spaces given by print_indent.  */
5329
5330 static inline void
5331 print_spaces (outfile)
5332      FILE *outfile;
5333 {
5334   fprintf (outfile, "%*s", print_indent, "");
5335 }
5336
5337 /* Print the information associated with a given DIE, and its children.
5338    This routine is a debugging aid only.  */
5339
5340 static void
5341 print_die (die, outfile)
5342      dw_die_ref die;
5343      FILE *outfile;
5344 {
5345   dw_attr_ref a;
5346   dw_die_ref c;
5347
5348   print_spaces (outfile);
5349   fprintf (outfile, "DIE %4lu: %s\n",
5350            die->die_offset, dwarf_tag_name (die->die_tag));
5351   print_spaces (outfile);
5352   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5353   fprintf (outfile, " offset: %lu\n", die->die_offset);
5354
5355   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5356     {
5357       print_spaces (outfile);
5358       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5359
5360       switch (AT_class (a))
5361         {
5362         case dw_val_class_addr:
5363           fprintf (outfile, "address");
5364           break;
5365         case dw_val_class_offset:
5366           fprintf (outfile, "offset");
5367           break;
5368         case dw_val_class_loc:
5369           fprintf (outfile, "location descriptor");
5370           break;
5371         case dw_val_class_loc_list:
5372           fprintf (outfile, "location list -> label:%s",
5373                    AT_loc_list (a)->ll_symbol);
5374           break;
5375         case dw_val_class_range_list:
5376           fprintf (outfile, "range list");
5377           break;
5378         case dw_val_class_const:
5379           fprintf (outfile, "%ld", AT_int (a));
5380           break;
5381         case dw_val_class_unsigned_const:
5382           fprintf (outfile, "%lu", AT_unsigned (a));
5383           break;
5384         case dw_val_class_long_long:
5385           fprintf (outfile, "constant (%lu,%lu)",
5386                    a->dw_attr_val.v.val_long_long.hi,
5387                    a->dw_attr_val.v.val_long_long.low);
5388           break;
5389         case dw_val_class_float:
5390           fprintf (outfile, "floating-point constant");
5391           break;
5392         case dw_val_class_flag:
5393           fprintf (outfile, "%u", AT_flag (a));
5394           break;
5395         case dw_val_class_die_ref:
5396           if (AT_ref (a) != NULL)
5397             {
5398               if (AT_ref (a)->die_symbol)
5399                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5400               else
5401                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5402             }
5403           else
5404             fprintf (outfile, "die -> <null>");
5405           break;
5406         case dw_val_class_lbl_id:
5407         case dw_val_class_lbl_offset:
5408           fprintf (outfile, "label: %s", AT_lbl (a));
5409           break;
5410         case dw_val_class_str:
5411           if (AT_string (a) != NULL)
5412             fprintf (outfile, "\"%s\"", AT_string (a));
5413           else
5414             fprintf (outfile, "<null>");
5415           break;
5416         default:
5417           break;
5418         }
5419
5420       fprintf (outfile, "\n");
5421     }
5422
5423   if (die->die_child != NULL)
5424     {
5425       print_indent += 4;
5426       for (c = die->die_child; c != NULL; c = c->die_sib)
5427         print_die (c, outfile);
5428
5429       print_indent -= 4;
5430     }
5431   if (print_indent == 0)
5432     fprintf (outfile, "\n");
5433 }
5434
5435 /* Print the contents of the source code line number correspondence table.
5436    This routine is a debugging aid only.  */
5437
5438 static void
5439 print_dwarf_line_table (outfile)
5440      FILE *outfile;
5441 {
5442   unsigned i;
5443   dw_line_info_ref line_info;
5444
5445   fprintf (outfile, "\n\nDWARF source line information\n");
5446   for (i = 1; i < line_info_table_in_use; i++)
5447     {
5448       line_info = &line_info_table[i];
5449       fprintf (outfile, "%5d: ", i);
5450       fprintf (outfile, "%-20s",
5451                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5452       fprintf (outfile, "%6ld", line_info->dw_line_num);
5453       fprintf (outfile, "\n");
5454     }
5455
5456   fprintf (outfile, "\n\n");
5457 }
5458
5459 /* Print the information collected for a given DIE.  */
5460
5461 void
5462 debug_dwarf_die (die)
5463      dw_die_ref die;
5464 {
5465   print_die (die, stderr);
5466 }
5467
5468 /* Print all DWARF information collected for the compilation unit.
5469    This routine is a debugging aid only.  */
5470
5471 void
5472 debug_dwarf ()
5473 {
5474   print_indent = 0;
5475   print_die (comp_unit_die, stderr);
5476   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5477     print_dwarf_line_table (stderr);
5478 }
5479 \f
5480 /* We build up the lists of children and attributes by pushing new ones
5481    onto the beginning of the list.  Reverse the lists for DIE so that
5482    they are in order of addition.  */
5483
5484 static void
5485 reverse_die_lists (die)
5486      dw_die_ref die;
5487 {
5488   dw_die_ref c, cp, cn;
5489   dw_attr_ref a, ap, an;
5490
5491   for (a = die->die_attr, ap = 0; a; a = an)
5492     {
5493       an = a->dw_attr_next;
5494       a->dw_attr_next = ap;
5495       ap = a;
5496     }
5497
5498   die->die_attr = ap;
5499
5500   for (c = die->die_child, cp = 0; c; c = cn)
5501     {
5502       cn = c->die_sib;
5503       c->die_sib = cp;
5504       cp = c;
5505     }
5506
5507   die->die_child = cp;
5508 }
5509
5510 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5511    reverse all dies in add_sibling_attributes, which runs through all the dies,
5512    it would reverse all the dies.  Now, however, since we don't call
5513    reverse_die_lists in add_sibling_attributes, we need a routine to
5514    recursively reverse all the dies. This is that routine.  */
5515
5516 static void
5517 reverse_all_dies (die)
5518      dw_die_ref die;
5519 {
5520   dw_die_ref c;
5521
5522   reverse_die_lists (die);
5523
5524   for (c = die->die_child; c; c = c->die_sib)
5525     reverse_all_dies (c);
5526 }
5527
5528 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5529    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5530    DIE that marks the start of the DIEs for this include file.  */
5531
5532 static dw_die_ref
5533 push_new_compile_unit (old_unit, bincl_die)
5534      dw_die_ref old_unit, bincl_die;
5535 {
5536   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5537   dw_die_ref new_unit = gen_compile_unit_die (filename);
5538
5539   new_unit->die_sib = old_unit;
5540   return new_unit;
5541 }
5542
5543 /* Close an include-file CU and reopen the enclosing one.  */
5544
5545 static dw_die_ref
5546 pop_compile_unit (old_unit)
5547      dw_die_ref old_unit;
5548 {
5549   dw_die_ref new_unit = old_unit->die_sib;
5550
5551   old_unit->die_sib = NULL;
5552   return new_unit;
5553 }
5554
5555 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5556 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5557
5558 /* Calculate the checksum of a location expression.  */
5559
5560 static inline void
5561 loc_checksum (loc, ctx)
5562      dw_loc_descr_ref loc;
5563      struct md5_ctx *ctx;
5564 {
5565   CHECKSUM (loc->dw_loc_opc);
5566   CHECKSUM (loc->dw_loc_oprnd1);
5567   CHECKSUM (loc->dw_loc_oprnd2);
5568 }
5569
5570 /* Calculate the checksum of an attribute.  */
5571
5572 static void
5573 attr_checksum (at, ctx, mark)
5574      dw_attr_ref at;
5575      struct md5_ctx *ctx;
5576      int *mark;
5577 {
5578   dw_loc_descr_ref loc;
5579   rtx r;
5580
5581   CHECKSUM (at->dw_attr);
5582
5583   /* We don't care about differences in file numbering.  */
5584   if (at->dw_attr == DW_AT_decl_file
5585       /* Or that this was compiled with a different compiler snapshot; if
5586          the output is the same, that's what matters.  */
5587       || at->dw_attr == DW_AT_producer)
5588     return;
5589
5590   switch (AT_class (at))
5591     {
5592     case dw_val_class_const:
5593       CHECKSUM (at->dw_attr_val.v.val_int);
5594       break;
5595     case dw_val_class_unsigned_const:
5596       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5597       break;
5598     case dw_val_class_long_long:
5599       CHECKSUM (at->dw_attr_val.v.val_long_long);
5600       break;
5601     case dw_val_class_float:
5602       CHECKSUM (at->dw_attr_val.v.val_float);
5603       break;
5604     case dw_val_class_flag:
5605       CHECKSUM (at->dw_attr_val.v.val_flag);
5606       break;
5607     case dw_val_class_str:
5608       CHECKSUM_STRING (AT_string (at));
5609       break;
5610
5611     case dw_val_class_addr:
5612       r = AT_addr (at);
5613       switch (GET_CODE (r))
5614         {
5615         case SYMBOL_REF:
5616           CHECKSUM_STRING (XSTR (r, 0));
5617           break;
5618
5619         default:
5620           abort ();
5621         }
5622       break;
5623
5624     case dw_val_class_offset:
5625       CHECKSUM (at->dw_attr_val.v.val_offset);
5626       break;
5627
5628     case dw_val_class_loc:
5629       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5630         loc_checksum (loc, ctx);
5631       break;
5632
5633     case dw_val_class_die_ref:
5634       die_checksum (AT_ref (at), ctx, mark);
5635       break;
5636
5637     case dw_val_class_fde_ref:
5638     case dw_val_class_lbl_id:
5639     case dw_val_class_lbl_offset:
5640       break;
5641
5642     default:
5643       break;
5644     }
5645 }
5646
5647 /* Calculate the checksum of a DIE.  */
5648
5649 static void
5650 die_checksum (die, ctx, mark)
5651      dw_die_ref die;
5652      struct md5_ctx *ctx;
5653      int *mark;
5654 {
5655   dw_die_ref c;
5656   dw_attr_ref a;
5657
5658   /* To avoid infinite recursion.  */
5659   if (die->die_mark)
5660     {
5661       CHECKSUM (die->die_mark);
5662       return;
5663     }
5664   die->die_mark = ++(*mark);
5665
5666   CHECKSUM (die->die_tag);
5667
5668   for (a = die->die_attr; a; a = a->dw_attr_next)
5669     attr_checksum (a, ctx, mark);
5670
5671   for (c = die->die_child; c; c = c->die_sib)
5672     die_checksum (c, ctx, mark);
5673 }
5674
5675 #undef CHECKSUM
5676 #undef CHECKSUM_STRING
5677
5678 /* Do the location expressions look same?  */
5679 static inline int
5680 same_loc_p (loc1, loc2, mark)
5681      dw_loc_descr_ref loc1;
5682      dw_loc_descr_ref loc2;
5683      int *mark;
5684 {
5685   return loc1->dw_loc_opc == loc2->dw_loc_opc
5686          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5687          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5688 }
5689
5690 /* Do the values look the same?  */
5691 static int
5692 same_dw_val_p (v1, v2, mark)
5693      dw_val_node *v1;
5694      dw_val_node *v2;
5695      int *mark;
5696 {
5697   dw_loc_descr_ref loc1, loc2;
5698   rtx r1, r2;
5699   unsigned i;
5700
5701   if (v1->val_class != v2->val_class)
5702     return 0;
5703
5704   switch (v1->val_class)
5705     {
5706     case dw_val_class_const:
5707       return v1->v.val_int == v2->v.val_int;
5708     case dw_val_class_unsigned_const:
5709       return v1->v.val_unsigned == v2->v.val_unsigned;
5710     case dw_val_class_long_long:
5711       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5712              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5713     case dw_val_class_float:
5714       if (v1->v.val_float.length != v2->v.val_float.length)
5715         return 0;
5716       for (i = 0; i < v1->v.val_float.length; i++)
5717         if (v1->v.val_float.array[i] != v2->v.val_float.array[i])
5718           return 0;
5719       return 1;
5720     case dw_val_class_flag:
5721       return v1->v.val_flag == v2->v.val_flag;
5722     case dw_val_class_str:
5723       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
5724
5725     case dw_val_class_addr:
5726       r1 = v1->v.val_addr;
5727       r2 = v2->v.val_addr;
5728       if (GET_CODE (r1) != GET_CODE (r2))
5729         return 0;
5730       switch (GET_CODE (r1))
5731         {
5732         case SYMBOL_REF:
5733           return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
5734
5735         default:
5736           abort ();
5737         }
5738
5739     case dw_val_class_offset:
5740       return v1->v.val_offset == v2->v.val_offset;
5741
5742     case dw_val_class_loc:
5743       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
5744            loc1 && loc2;
5745            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
5746         if (!same_loc_p (loc1, loc2, mark))
5747           return 0;
5748       return !loc1 && !loc2;
5749
5750     case dw_val_class_die_ref:
5751       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
5752
5753     case dw_val_class_fde_ref:
5754     case dw_val_class_lbl_id:
5755     case dw_val_class_lbl_offset:
5756       return 1;
5757
5758     default:
5759       return 1;
5760     }
5761 }
5762
5763 /* Do the attributes look the same?  */
5764
5765 static int
5766 same_attr_p (at1, at2, mark)
5767      dw_attr_ref at1;
5768      dw_attr_ref at2;
5769      int *mark;
5770 {
5771   if (at1->dw_attr != at2->dw_attr)
5772     return 0;
5773
5774   /* We don't care about differences in file numbering.  */
5775   if (at1->dw_attr == DW_AT_decl_file
5776       /* Or that this was compiled with a different compiler snapshot; if
5777          the output is the same, that's what matters.  */
5778       || at1->dw_attr == DW_AT_producer)
5779     return 1;
5780
5781   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
5782 }
5783
5784 /* Do the dies look the same?  */
5785
5786 static int
5787 same_die_p (die1, die2, mark)
5788      dw_die_ref die1;
5789      dw_die_ref die2;
5790      int *mark;
5791 {
5792   dw_die_ref c1, c2;
5793   dw_attr_ref a1, a2;
5794
5795   /* To avoid infinite recursion.  */
5796   if (die1->die_mark)
5797     return die1->die_mark == die2->die_mark;
5798   die1->die_mark = die2->die_mark = ++(*mark);
5799
5800   if (die1->die_tag != die2->die_tag)
5801     return 0;
5802
5803   for (a1 = die1->die_attr, a2 = die2->die_attr;
5804        a1 && a2;
5805        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
5806     if (!same_attr_p (a1, a2, mark))
5807       return 0;
5808   if (a1 || a2)
5809     return 0;
5810
5811   for (c1 = die1->die_child, c2 = die2->die_child;
5812        c1 && c2;
5813        c1 = c1->die_sib, c2 = c2->die_sib)
5814     if (!same_die_p (c1, c2, mark))
5815       return 0;
5816   if (c1 || c2)
5817     return 0;
5818
5819   return 1;
5820 }
5821
5822 /* Do the dies look the same?  Wrapper around same_die_p.  */
5823
5824 static int
5825 same_die_p_wrap (die1, die2)
5826      dw_die_ref die1;
5827      dw_die_ref die2;
5828 {
5829   int mark = 0;
5830   int ret = same_die_p (die1, die2, &mark);
5831
5832   unmark_all_dies (die1);
5833   unmark_all_dies (die2);
5834
5835   return ret;
5836 }
5837
5838 /* The prefix to attach to symbols on DIEs in the current comdat debug
5839    info section.  */
5840 static char *comdat_symbol_id;
5841
5842 /* The index of the current symbol within the current comdat CU.  */
5843 static unsigned int comdat_symbol_number;
5844
5845 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5846    children, and set comdat_symbol_id accordingly.  */
5847
5848 static void
5849 compute_section_prefix (unit_die)
5850      dw_die_ref unit_die;
5851 {
5852   const char *die_name = get_AT_string (unit_die, DW_AT_name);
5853   const char *base = die_name ? lbasename (die_name) : "anonymous";
5854   char *name = (char *) alloca (strlen (base) + 64);
5855   char *p;
5856   int i, mark;
5857   unsigned char checksum[16];
5858   struct md5_ctx ctx;
5859
5860   /* Compute the checksum of the DIE, then append part of it as hex digits to
5861      the name filename of the unit.  */
5862
5863   md5_init_ctx (&ctx);
5864   mark = 0;
5865   die_checksum (unit_die, &ctx, &mark);
5866   unmark_all_dies (unit_die);
5867   md5_finish_ctx (&ctx, checksum);
5868
5869   sprintf (name, "%s.", base);
5870   clean_symbol_name (name);
5871
5872   p = name + strlen (name);
5873   for (i = 0; i < 4; i++)
5874     {
5875       sprintf (p, "%.2x", checksum[i]);
5876       p += 2;
5877     }
5878
5879   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
5880   comdat_symbol_number = 0;
5881 }
5882
5883 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
5884
5885 static int
5886 is_type_die (die)
5887      dw_die_ref die;
5888 {
5889   switch (die->die_tag)
5890     {
5891     case DW_TAG_array_type:
5892     case DW_TAG_class_type:
5893     case DW_TAG_enumeration_type:
5894     case DW_TAG_pointer_type:
5895     case DW_TAG_reference_type:
5896     case DW_TAG_string_type:
5897     case DW_TAG_structure_type:
5898     case DW_TAG_subroutine_type:
5899     case DW_TAG_union_type:
5900     case DW_TAG_ptr_to_member_type:
5901     case DW_TAG_set_type:
5902     case DW_TAG_subrange_type:
5903     case DW_TAG_base_type:
5904     case DW_TAG_const_type:
5905     case DW_TAG_file_type:
5906     case DW_TAG_packed_type:
5907     case DW_TAG_volatile_type:
5908     case DW_TAG_typedef:
5909       return 1;
5910     default:
5911       return 0;
5912     }
5913 }
5914
5915 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
5916    Basically, we want to choose the bits that are likely to be shared between
5917    compilations (types) and leave out the bits that are specific to individual
5918    compilations (functions).  */
5919
5920 static int
5921 is_comdat_die (c)
5922      dw_die_ref c;
5923 {
5924   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
5925      we do for stabs.  The advantage is a greater likelihood of sharing between
5926      objects that don't include headers in the same order (and therefore would
5927      put the base types in a different comdat).  jason 8/28/00 */
5928
5929   if (c->die_tag == DW_TAG_base_type)
5930     return 0;
5931
5932   if (c->die_tag == DW_TAG_pointer_type
5933       || c->die_tag == DW_TAG_reference_type
5934       || c->die_tag == DW_TAG_const_type
5935       || c->die_tag == DW_TAG_volatile_type)
5936     {
5937       dw_die_ref t = get_AT_ref (c, DW_AT_type);
5938
5939       return t ? is_comdat_die (t) : 0;
5940     }
5941
5942   return is_type_die (c);
5943 }
5944
5945 /* Returns 1 iff C is the sort of DIE that might be referred to from another
5946    compilation unit.  */
5947
5948 static int
5949 is_symbol_die (c)
5950      dw_die_ref c;
5951 {
5952   return (is_type_die (c)
5953           || (get_AT (c, DW_AT_declaration)
5954               && !get_AT (c, DW_AT_specification)));
5955 }
5956
5957 static char *
5958 gen_internal_sym (prefix)
5959      const char *prefix;
5960 {
5961   char buf[256];
5962   static int label_num;
5963
5964   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
5965   return xstrdup (buf);
5966 }
5967
5968 /* Assign symbols to all worthy DIEs under DIE.  */
5969
5970 static void
5971 assign_symbol_names (die)
5972      dw_die_ref die;
5973 {
5974   dw_die_ref c;
5975
5976   if (is_symbol_die (die))
5977     {
5978       if (comdat_symbol_id)
5979         {
5980           char *p = alloca (strlen (comdat_symbol_id) + 64);
5981
5982           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
5983                    comdat_symbol_id, comdat_symbol_number++);
5984           die->die_symbol = xstrdup (p);
5985         }
5986       else
5987         die->die_symbol = gen_internal_sym ("LDIE");
5988     }
5989
5990   for (c = die->die_child; c != NULL; c = c->die_sib)
5991     assign_symbol_names (c);
5992 }
5993
5994 struct cu_hash_table_entry
5995 {
5996   dw_die_ref cu;
5997   unsigned min_comdat_num, max_comdat_num;
5998   struct cu_hash_table_entry *next;
5999 };
6000
6001 /* Routines to manipulate hash table of CUs.  */
6002 static hashval_t
6003 htab_cu_hash (of)
6004      const void *of;
6005 {
6006   const struct cu_hash_table_entry *entry = of;
6007
6008   return htab_hash_string (entry->cu->die_symbol);
6009 }
6010
6011 static int
6012 htab_cu_eq (of1, of2)
6013      const void *of1;
6014      const void *of2;
6015 {
6016   const struct cu_hash_table_entry *entry1 = of1;
6017   const struct die_struct *entry2 = of2;
6018
6019   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6020 }
6021
6022 static void
6023 htab_cu_del (what)
6024      void *what;
6025 {
6026   struct cu_hash_table_entry *next, *entry = what;
6027
6028   while (entry)
6029     {
6030       next = entry->next;
6031       free (entry);
6032       entry = next;
6033     }
6034 }
6035
6036 /* Check whether we have already seen this CU and set up SYM_NUM
6037    accordingly.  */
6038 static int
6039 check_duplicate_cu (cu, htable, sym_num)
6040      dw_die_ref cu;
6041      htab_t htable;
6042      unsigned *sym_num;
6043 {
6044   struct cu_hash_table_entry dummy;
6045   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6046
6047   dummy.max_comdat_num = 0;
6048
6049   slot = (struct cu_hash_table_entry **)
6050     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6051         INSERT);
6052   entry = *slot;
6053
6054   for (; entry; last = entry, entry = entry->next)
6055     {
6056       if (same_die_p_wrap (cu, entry->cu))
6057         break;
6058     }
6059
6060   if (entry)
6061     {
6062       *sym_num = entry->min_comdat_num;
6063       return 1;
6064     }
6065
6066   entry = xcalloc (1, sizeof (struct cu_hash_table_entry));
6067   entry->cu = cu;
6068   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6069   entry->next = *slot;
6070   *slot = entry;
6071
6072   return 0;
6073 }
6074
6075 /* Record SYM_NUM to record of CU in HTABLE.  */
6076 static void
6077 record_comdat_symbol_number (cu, htable, sym_num)
6078      dw_die_ref cu;
6079      htab_t htable;
6080      unsigned sym_num;
6081 {
6082   struct cu_hash_table_entry **slot, *entry;
6083
6084   slot = (struct cu_hash_table_entry **)
6085     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6086         NO_INSERT);
6087   entry = *slot;
6088
6089   entry->max_comdat_num = sym_num;
6090 }
6091
6092 /* Traverse the DIE (which is always comp_unit_die), and set up
6093    additional compilation units for each of the include files we see
6094    bracketed by BINCL/EINCL.  */
6095
6096 static void
6097 break_out_includes (die)
6098      dw_die_ref die;
6099 {
6100   dw_die_ref *ptr;
6101   dw_die_ref unit = NULL;
6102   limbo_die_node *node, **pnode;
6103   htab_t cu_hash_table;
6104
6105   for (ptr = &(die->die_child); *ptr;)
6106     {
6107       dw_die_ref c = *ptr;
6108
6109       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6110           || (unit && is_comdat_die (c)))
6111         {
6112           /* This DIE is for a secondary CU; remove it from the main one.  */
6113           *ptr = c->die_sib;
6114
6115           if (c->die_tag == DW_TAG_GNU_BINCL)
6116             {
6117               unit = push_new_compile_unit (unit, c);
6118               free_die (c);
6119             }
6120           else if (c->die_tag == DW_TAG_GNU_EINCL)
6121             {
6122               unit = pop_compile_unit (unit);
6123               free_die (c);
6124             }
6125           else
6126             add_child_die (unit, c);
6127         }
6128       else
6129         {
6130           /* Leave this DIE in the main CU.  */
6131           ptr = &(c->die_sib);
6132           continue;
6133         }
6134     }
6135
6136 #if 0
6137   /* We can only use this in debugging, since the frontend doesn't check
6138      to make sure that we leave every include file we enter.  */
6139   if (unit != NULL)
6140     abort ();
6141 #endif
6142
6143   assign_symbol_names (die);
6144   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6145   for (node = limbo_die_list, pnode = &limbo_die_list;
6146        node;
6147        node = node->next)
6148     {
6149       int is_dupl;
6150
6151       compute_section_prefix (node->die);
6152       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6153                         &comdat_symbol_number);
6154       assign_symbol_names (node->die);
6155       if (is_dupl)
6156         *pnode = node->next;
6157       else
6158         {
6159           pnode = &node->next;
6160           record_comdat_symbol_number (node->die, cu_hash_table,
6161                 comdat_symbol_number);
6162         }
6163     }
6164   htab_delete (cu_hash_table);
6165 }
6166
6167 /* Traverse the DIE and add a sibling attribute if it may have the
6168    effect of speeding up access to siblings.  To save some space,
6169    avoid generating sibling attributes for DIE's without children.  */
6170
6171 static void
6172 add_sibling_attributes (die)
6173      dw_die_ref die;
6174 {
6175   dw_die_ref c;
6176
6177   if (die->die_tag != DW_TAG_compile_unit
6178       && die->die_sib && die->die_child != NULL)
6179     /* Add the sibling link to the front of the attribute list.  */
6180     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6181
6182   for (c = die->die_child; c != NULL; c = c->die_sib)
6183     add_sibling_attributes (c);
6184 }
6185
6186 /* Output all location lists for the DIE and its children.  */
6187
6188 static void
6189 output_location_lists (die)
6190      dw_die_ref die;
6191 {
6192   dw_die_ref c;
6193   dw_attr_ref d_attr;
6194
6195   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6196     if (AT_class (d_attr) == dw_val_class_loc_list)
6197       output_loc_list (AT_loc_list (d_attr));
6198
6199   for (c = die->die_child; c != NULL; c = c->die_sib)
6200     output_location_lists (c);
6201
6202 }
6203
6204 /* The format of each DIE (and its attribute value pairs) is encoded in an
6205    abbreviation table.  This routine builds the abbreviation table and assigns
6206    a unique abbreviation id for each abbreviation entry.  The children of each
6207    die are visited recursively.  */
6208
6209 static void
6210 build_abbrev_table (die)
6211      dw_die_ref die;
6212 {
6213   unsigned long abbrev_id;
6214   unsigned int n_alloc;
6215   dw_die_ref c;
6216   dw_attr_ref d_attr, a_attr;
6217
6218   /* Scan the DIE references, and mark as external any that refer to
6219      DIEs from other CUs (i.e. those which are not marked).  */
6220   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6221     if (AT_class (d_attr) == dw_val_class_die_ref
6222         && AT_ref (d_attr)->die_mark == 0)
6223       {
6224         if (AT_ref (d_attr)->die_symbol == 0)
6225           abort ();
6226
6227         set_AT_ref_external (d_attr, 1);
6228       }
6229
6230   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6231     {
6232       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6233
6234       if (abbrev->die_tag == die->die_tag)
6235         {
6236           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6237             {
6238               a_attr = abbrev->die_attr;
6239               d_attr = die->die_attr;
6240
6241               while (a_attr != NULL && d_attr != NULL)
6242                 {
6243                   if ((a_attr->dw_attr != d_attr->dw_attr)
6244                       || (value_format (a_attr) != value_format (d_attr)))
6245                     break;
6246
6247                   a_attr = a_attr->dw_attr_next;
6248                   d_attr = d_attr->dw_attr_next;
6249                 }
6250
6251               if (a_attr == NULL && d_attr == NULL)
6252                 break;
6253             }
6254         }
6255     }
6256
6257   if (abbrev_id >= abbrev_die_table_in_use)
6258     {
6259       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6260         {
6261           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6262           abbrev_die_table = ggc_realloc (abbrev_die_table,
6263                                           sizeof (dw_die_ref) * n_alloc);
6264
6265           memset ((char *) &abbrev_die_table[abbrev_die_table_allocated], 0,
6266                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6267           abbrev_die_table_allocated = n_alloc;
6268         }
6269
6270       ++abbrev_die_table_in_use;
6271       abbrev_die_table[abbrev_id] = die;
6272     }
6273
6274   die->die_abbrev = abbrev_id;
6275   for (c = die->die_child; c != NULL; c = c->die_sib)
6276     build_abbrev_table (c);
6277 }
6278 \f
6279 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6280
6281 static int
6282 constant_size (value)
6283      long unsigned value;
6284 {
6285   int log;
6286
6287   if (value == 0)
6288     log = 0;
6289   else
6290     log = floor_log2 (value);
6291
6292   log = log / 8;
6293   log = 1 << (floor_log2 (log) + 1);
6294
6295   return log;
6296 }
6297
6298 /* Return the size of a DIE as it is represented in the
6299    .debug_info section.  */
6300
6301 static unsigned long
6302 size_of_die (die)
6303      dw_die_ref die;
6304 {
6305   unsigned long size = 0;
6306   dw_attr_ref a;
6307
6308   size += size_of_uleb128 (die->die_abbrev);
6309   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6310     {
6311       switch (AT_class (a))
6312         {
6313         case dw_val_class_addr:
6314           size += DWARF2_ADDR_SIZE;
6315           break;
6316         case dw_val_class_offset:
6317           size += DWARF_OFFSET_SIZE;
6318           break;
6319         case dw_val_class_loc:
6320           {
6321             unsigned long lsize = size_of_locs (AT_loc (a));
6322
6323             /* Block length.  */
6324             size += constant_size (lsize);
6325             size += lsize;
6326           }
6327           break;
6328         case dw_val_class_loc_list:
6329           size += DWARF_OFFSET_SIZE;
6330           break;
6331         case dw_val_class_range_list:
6332           size += DWARF_OFFSET_SIZE;
6333           break;
6334         case dw_val_class_const:
6335           size += size_of_sleb128 (AT_int (a));
6336           break;
6337         case dw_val_class_unsigned_const:
6338           size += constant_size (AT_unsigned (a));
6339           break;
6340         case dw_val_class_long_long:
6341           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6342           break;
6343         case dw_val_class_float:
6344           size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
6345           break;
6346         case dw_val_class_flag:
6347           size += 1;
6348           break;
6349         case dw_val_class_die_ref:
6350           size += DWARF_OFFSET_SIZE;
6351           break;
6352         case dw_val_class_fde_ref:
6353           size += DWARF_OFFSET_SIZE;
6354           break;
6355         case dw_val_class_lbl_id:
6356           size += DWARF2_ADDR_SIZE;
6357           break;
6358         case dw_val_class_lbl_offset:
6359           size += DWARF_OFFSET_SIZE;
6360           break;
6361         case dw_val_class_str:
6362           if (AT_string_form (a) == DW_FORM_strp)
6363             size += DWARF_OFFSET_SIZE;
6364           else
6365             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6366           break;
6367         default:
6368           abort ();
6369         }
6370     }
6371
6372   return size;
6373 }
6374
6375 /* Size the debugging information associated with a given DIE.  Visits the
6376    DIE's children recursively.  Updates the global variable next_die_offset, on
6377    each time through.  Uses the current value of next_die_offset to update the
6378    die_offset field in each DIE.  */
6379
6380 static void
6381 calc_die_sizes (die)
6382      dw_die_ref die;
6383 {
6384   dw_die_ref c;
6385
6386   die->die_offset = next_die_offset;
6387   next_die_offset += size_of_die (die);
6388
6389   for (c = die->die_child; c != NULL; c = c->die_sib)
6390     calc_die_sizes (c);
6391
6392   if (die->die_child != NULL)
6393     /* Count the null byte used to terminate sibling lists.  */
6394     next_die_offset += 1;
6395 }
6396
6397 /* Set the marks for a die and its children.  We do this so
6398    that we know whether or not a reference needs to use FORM_ref_addr; only
6399    DIEs in the same CU will be marked.  We used to clear out the offset
6400    and use that as the flag, but ran into ordering problems.  */
6401
6402 static void
6403 mark_dies (die)
6404      dw_die_ref die;
6405 {
6406   dw_die_ref c;
6407
6408   if (die->die_mark)
6409     abort ();
6410
6411   die->die_mark = 1;
6412   for (c = die->die_child; c; c = c->die_sib)
6413     mark_dies (c);
6414 }
6415
6416 /* Clear the marks for a die and its children.  */
6417
6418 static void
6419 unmark_dies (die)
6420      dw_die_ref die;
6421 {
6422   dw_die_ref c;
6423
6424   if (!die->die_mark)
6425     abort ();
6426
6427   die->die_mark = 0;
6428   for (c = die->die_child; c; c = c->die_sib)
6429     unmark_dies (c);
6430 }
6431
6432 /* Clear the marks for a die, its children and referred dies.  */
6433
6434 static void
6435 unmark_all_dies (die)
6436      dw_die_ref die;
6437 {
6438   dw_die_ref c;
6439   dw_attr_ref a;
6440
6441   if (!die->die_mark)
6442     return;
6443   die->die_mark = 0;
6444
6445   for (c = die->die_child; c; c = c->die_sib)
6446     unmark_all_dies (c);
6447
6448   for (a = die->die_attr; a; a = a->dw_attr_next)
6449     if (AT_class (a) == dw_val_class_die_ref)
6450       unmark_all_dies (AT_ref (a));
6451 }
6452
6453 /* Return the size of the .debug_pubnames table  generated for the
6454    compilation unit.  */
6455
6456 static unsigned long
6457 size_of_pubnames ()
6458 {
6459   unsigned long size;
6460   unsigned i;
6461
6462   size = DWARF_PUBNAMES_HEADER_SIZE;
6463   for (i = 0; i < pubname_table_in_use; i++)
6464     {
6465       pubname_ref p = &pubname_table[i];
6466       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6467     }
6468
6469   size += DWARF_OFFSET_SIZE;
6470   return size;
6471 }
6472
6473 /* Return the size of the information in the .debug_aranges section.  */
6474
6475 static unsigned long
6476 size_of_aranges ()
6477 {
6478   unsigned long size;
6479
6480   size = DWARF_ARANGES_HEADER_SIZE;
6481
6482   /* Count the address/length pair for this compilation unit.  */
6483   size += 2 * DWARF2_ADDR_SIZE;
6484   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6485
6486   /* Count the two zero words used to terminated the address range table.  */
6487   size += 2 * DWARF2_ADDR_SIZE;
6488   return size;
6489 }
6490 \f
6491 /* Select the encoding of an attribute value.  */
6492
6493 static enum dwarf_form
6494 value_format (a)
6495      dw_attr_ref a;
6496 {
6497   switch (a->dw_attr_val.val_class)
6498     {
6499     case dw_val_class_addr:
6500       return DW_FORM_addr;
6501     case dw_val_class_range_list:
6502     case dw_val_class_offset:
6503       if (DWARF_OFFSET_SIZE == 4)
6504         return DW_FORM_data4;
6505       if (DWARF_OFFSET_SIZE == 8)
6506         return DW_FORM_data8;
6507       abort ();
6508     case dw_val_class_loc_list:
6509       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6510          .debug_loc section */
6511       return DW_FORM_data4;
6512     case dw_val_class_loc:
6513       switch (constant_size (size_of_locs (AT_loc (a))))
6514         {
6515         case 1:
6516           return DW_FORM_block1;
6517         case 2:
6518           return DW_FORM_block2;
6519         default:
6520           abort ();
6521         }
6522     case dw_val_class_const:
6523       return DW_FORM_sdata;
6524     case dw_val_class_unsigned_const:
6525       switch (constant_size (AT_unsigned (a)))
6526         {
6527         case 1:
6528           return DW_FORM_data1;
6529         case 2:
6530           return DW_FORM_data2;
6531         case 4:
6532           return DW_FORM_data4;
6533         case 8:
6534           return DW_FORM_data8;
6535         default:
6536           abort ();
6537         }
6538     case dw_val_class_long_long:
6539       return DW_FORM_block1;
6540     case dw_val_class_float:
6541       return DW_FORM_block1;
6542     case dw_val_class_flag:
6543       return DW_FORM_flag;
6544     case dw_val_class_die_ref:
6545       if (AT_ref_external (a))
6546         return DW_FORM_ref_addr;
6547       else
6548         return DW_FORM_ref;
6549     case dw_val_class_fde_ref:
6550       return DW_FORM_data;
6551     case dw_val_class_lbl_id:
6552       return DW_FORM_addr;
6553     case dw_val_class_lbl_offset:
6554       return DW_FORM_data;
6555     case dw_val_class_str:
6556       return AT_string_form (a);
6557
6558     default:
6559       abort ();
6560     }
6561 }
6562
6563 /* Output the encoding of an attribute value.  */
6564
6565 static void
6566 output_value_format (a)
6567      dw_attr_ref a;
6568 {
6569   enum dwarf_form form = value_format (a);
6570
6571   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6572 }
6573
6574 /* Output the .debug_abbrev section which defines the DIE abbreviation
6575    table.  */
6576
6577 static void
6578 output_abbrev_section ()
6579 {
6580   unsigned long abbrev_id;
6581
6582   dw_attr_ref a_attr;
6583
6584   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6585     {
6586       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6587
6588       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6589       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6590                                    dwarf_tag_name (abbrev->die_tag));
6591
6592       if (abbrev->die_child != NULL)
6593         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6594       else
6595         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6596
6597       for (a_attr = abbrev->die_attr; a_attr != NULL;
6598            a_attr = a_attr->dw_attr_next)
6599         {
6600           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6601                                        dwarf_attr_name (a_attr->dw_attr));
6602           output_value_format (a_attr);
6603         }
6604
6605       dw2_asm_output_data (1, 0, NULL);
6606       dw2_asm_output_data (1, 0, NULL);
6607     }
6608
6609   /* Terminate the table.  */
6610   dw2_asm_output_data (1, 0, NULL);
6611 }
6612
6613 /* Output a symbol we can use to refer to this DIE from another CU.  */
6614
6615 static inline void
6616 output_die_symbol (die)
6617      dw_die_ref die;
6618 {
6619   char *sym = die->die_symbol;
6620
6621   if (sym == 0)
6622     return;
6623
6624   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6625     /* We make these global, not weak; if the target doesn't support
6626        .linkonce, it doesn't support combining the sections, so debugging
6627        will break.  */
6628     (*targetm.asm_out.globalize_label) (asm_out_file, sym);
6629
6630   ASM_OUTPUT_LABEL (asm_out_file, sym);
6631 }
6632
6633 /* Return a new location list, given the begin and end range, and the
6634    expression. gensym tells us whether to generate a new internal symbol for
6635    this location list node, which is done for the head of the list only.  */
6636
6637 static inline dw_loc_list_ref
6638 new_loc_list (expr, begin, end, section, gensym)
6639      dw_loc_descr_ref expr;
6640      const char *begin;
6641      const char *end;
6642      const char *section;
6643      unsigned gensym;
6644 {
6645   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6646
6647   retlist->begin = begin;
6648   retlist->end = end;
6649   retlist->expr = expr;
6650   retlist->section = section;
6651   if (gensym)
6652     retlist->ll_symbol = gen_internal_sym ("LLST");
6653
6654   return retlist;
6655 }
6656
6657 /* Add a location description expression to a location list */
6658
6659 static inline void
6660 add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
6661      dw_loc_list_ref *list_head;
6662      dw_loc_descr_ref descr;
6663      const char *begin;
6664      const char *end;
6665      const char *section;
6666 {
6667   dw_loc_list_ref *d;
6668
6669   /* Find the end of the chain.  */
6670   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6671     ;
6672
6673   /* Add a new location list node to the list */
6674   *d = new_loc_list (descr, begin, end, section, 0);
6675 }
6676
6677 /* Output the location list given to us */
6678
6679 static void
6680 output_loc_list (list_head)
6681      dw_loc_list_ref list_head;
6682 {
6683   dw_loc_list_ref curr = list_head;
6684
6685   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6686
6687   /* ??? This shouldn't be needed now that we've forced the
6688      compilation unit base address to zero when there is code
6689      in more than one section.  */
6690   if (strcmp (curr->section, ".text") == 0)
6691     {
6692       /* dw2_asm_output_data will mask off any extra bits in the ~0.  */
6693       dw2_asm_output_data (DWARF2_ADDR_SIZE, ~(unsigned HOST_WIDE_INT) 0,
6694                            "Location list base address specifier fake entry");
6695       dw2_asm_output_offset (DWARF2_ADDR_SIZE, curr->section,
6696                              "Location list base address specifier base");
6697     }
6698
6699   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6700     {
6701       unsigned long size;
6702
6703       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6704                             "Location list begin address (%s)",
6705                             list_head->ll_symbol);
6706       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6707                             "Location list end address (%s)",
6708                             list_head->ll_symbol);
6709       size = size_of_locs (curr->expr);
6710
6711       /* Output the block length for this list of location operations.  */
6712       if (size > 0xffff)
6713         abort ();
6714       dw2_asm_output_data (2, size, "%s", "Location expression size");
6715
6716       output_loc_sequence (curr->expr);
6717     }
6718
6719   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6720                        "Location list terminator begin (%s)",
6721                        list_head->ll_symbol);
6722   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6723                        "Location list terminator end (%s)",
6724                        list_head->ll_symbol);
6725 }
6726
6727 /* Output the DIE and its attributes.  Called recursively to generate
6728    the definitions of each child DIE.  */
6729
6730 static void
6731 output_die (die)
6732      dw_die_ref die;
6733 {
6734   dw_attr_ref a;
6735   dw_die_ref c;
6736   unsigned long size;
6737
6738   /* If someone in another CU might refer to us, set up a symbol for
6739      them to point to.  */
6740   if (die->die_symbol)
6741     output_die_symbol (die);
6742
6743   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6744                                die->die_offset, dwarf_tag_name (die->die_tag));
6745
6746   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6747     {
6748       const char *name = dwarf_attr_name (a->dw_attr);
6749
6750       switch (AT_class (a))
6751         {
6752         case dw_val_class_addr:
6753           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
6754           break;
6755
6756         case dw_val_class_offset:
6757           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
6758                                "%s", name);
6759           break;
6760
6761         case dw_val_class_range_list:
6762           {
6763             char *p = strchr (ranges_section_label, '\0');
6764
6765             sprintf (p, "+0x%lx", a->dw_attr_val.v.val_offset);
6766             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
6767                                    "%s", name);
6768             *p = '\0';
6769           }
6770           break;
6771
6772         case dw_val_class_loc:
6773           size = size_of_locs (AT_loc (a));
6774
6775           /* Output the block length for this list of location operations.  */
6776           dw2_asm_output_data (constant_size (size), size, "%s", name);
6777
6778           output_loc_sequence (AT_loc (a));
6779           break;
6780
6781         case dw_val_class_const:
6782           /* ??? It would be slightly more efficient to use a scheme like is
6783              used for unsigned constants below, but gdb 4.x does not sign
6784              extend.  Gdb 5.x does sign extend.  */
6785           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
6786           break;
6787
6788         case dw_val_class_unsigned_const:
6789           dw2_asm_output_data (constant_size (AT_unsigned (a)),
6790                                AT_unsigned (a), "%s", name);
6791           break;
6792
6793         case dw_val_class_long_long:
6794           {
6795             unsigned HOST_WIDE_INT first, second;
6796
6797             dw2_asm_output_data (1,
6798                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6799                                  "%s", name);
6800
6801             if (WORDS_BIG_ENDIAN)
6802               {
6803                 first = a->dw_attr_val.v.val_long_long.hi;
6804                 second = a->dw_attr_val.v.val_long_long.low;
6805               }
6806             else
6807               {
6808                 first = a->dw_attr_val.v.val_long_long.low;
6809                 second = a->dw_attr_val.v.val_long_long.hi;
6810               }
6811
6812             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6813                                  first, "long long constant");
6814             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6815                                  second, NULL);
6816           }
6817           break;
6818
6819         case dw_val_class_float:
6820           {
6821             unsigned int i;
6822
6823             dw2_asm_output_data (1, a->dw_attr_val.v.val_float.length * 4,
6824                                  "%s", name);
6825
6826             for (i = 0; i < a->dw_attr_val.v.val_float.length; i++)
6827               dw2_asm_output_data (4, a->dw_attr_val.v.val_float.array[i],
6828                                    "fp constant word %u", i);
6829             break;
6830           }
6831
6832         case dw_val_class_flag:
6833           dw2_asm_output_data (1, AT_flag (a), "%s", name);
6834           break;
6835
6836         case dw_val_class_loc_list:
6837           {
6838             char *sym = AT_loc_list (a)->ll_symbol;
6839
6840             if (sym == 0)
6841               abort ();
6842             dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym,
6843                                   loc_section_label, "%s", name);
6844           }
6845           break;
6846
6847         case dw_val_class_die_ref:
6848           if (AT_ref_external (a))
6849             {
6850               char *sym = AT_ref (a)->die_symbol;
6851
6852               if (sym == 0)
6853                 abort ();
6854               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
6855             }
6856           else if (AT_ref (a)->die_offset == 0)
6857             abort ();
6858           else
6859             dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
6860                                  "%s", name);
6861           break;
6862
6863         case dw_val_class_fde_ref:
6864           {
6865             char l1[20];
6866
6867             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
6868                                          a->dw_attr_val.v.val_fde_index * 2);
6869             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
6870           }
6871           break;
6872
6873         case dw_val_class_lbl_id:
6874           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
6875           break;
6876
6877         case dw_val_class_lbl_offset:
6878           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
6879           break;
6880
6881         case dw_val_class_str:
6882           if (AT_string_form (a) == DW_FORM_strp)
6883             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
6884                                    a->dw_attr_val.v.val_str->label,
6885                                    "%s: \"%s\"", name, AT_string (a));
6886           else
6887             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
6888           break;
6889
6890         default:
6891           abort ();
6892         }
6893     }
6894
6895   for (c = die->die_child; c != NULL; c = c->die_sib)
6896     output_die (c);
6897
6898   /* Add null byte to terminate sibling list.  */
6899   if (die->die_child != NULL)
6900     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6901                          die->die_offset);
6902 }
6903
6904 /* Output the compilation unit that appears at the beginning of the
6905    .debug_info section, and precedes the DIE descriptions.  */
6906
6907 static void
6908 output_compilation_unit_header ()
6909 {
6910   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset - DWARF_OFFSET_SIZE,
6911                        "Length of Compilation Unit Info");
6912   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
6913   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
6914                          "Offset Into Abbrev. Section");
6915   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
6916 }
6917
6918 /* Output the compilation unit DIE and its children.  */
6919
6920 static void
6921 output_comp_unit (die, output_if_empty)
6922      dw_die_ref die;
6923      int output_if_empty;
6924 {
6925   const char *secname;
6926   char *oldsym, *tmp;
6927
6928   /* Unless we are outputting main CU, we may throw away empty ones.  */
6929   if (!output_if_empty && die->die_child == NULL)
6930     return;
6931
6932   /* Even if there are no children of this DIE, we must output the information
6933      about the compilation unit.  Otherwise, on an empty translation unit, we
6934      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
6935      will then complain when examining the file.  First mark all the DIEs in
6936      this CU so we know which get local refs.  */
6937   mark_dies (die);
6938
6939   build_abbrev_table (die);
6940
6941   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
6942   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
6943   calc_die_sizes (die);
6944
6945   oldsym = die->die_symbol;
6946   if (oldsym)
6947     {
6948       tmp = (char *) alloca (strlen (oldsym) + 24);
6949
6950       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
6951       secname = tmp;
6952       die->die_symbol = NULL;
6953     }
6954   else
6955     secname = (const char *) DEBUG_INFO_SECTION;
6956
6957   /* Output debugging information.  */
6958   named_section_flags (secname, SECTION_DEBUG);
6959   output_compilation_unit_header ();
6960   output_die (die);
6961
6962   /* Leave the marks on the main CU, so we can check them in
6963      output_pubnames.  */
6964   if (oldsym)
6965     {
6966       unmark_dies (die);
6967       die->die_symbol = oldsym;
6968     }
6969 }
6970
6971 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
6972    output of lang_hooks.decl_printable_name for C++ looks like
6973    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
6974
6975 static const char *
6976 dwarf2_name (decl, scope)
6977      tree decl;
6978      int scope;
6979 {
6980   return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0);
6981 }
6982
6983 /* Add a new entry to .debug_pubnames if appropriate.  */
6984
6985 static void
6986 add_pubname (decl, die)
6987      tree decl;
6988      dw_die_ref die;
6989 {
6990   pubname_ref p;
6991
6992   if (! TREE_PUBLIC (decl))
6993     return;
6994
6995   if (pubname_table_in_use == pubname_table_allocated)
6996     {
6997       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
6998       pubname_table
6999         = (pubname_ref) ggc_realloc (pubname_table,
7000                                      (pubname_table_allocated
7001                                       * sizeof (pubname_entry)));
7002       memset (pubname_table + pubname_table_in_use, 0,
7003               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7004     }
7005
7006   p = &pubname_table[pubname_table_in_use++];
7007   p->die = die;
7008   p->name = xstrdup (dwarf2_name (decl, 1));
7009 }
7010
7011 /* Output the public names table used to speed up access to externally
7012    visible names.  For now, only generate entries for externally
7013    visible procedures.  */
7014
7015 static void
7016 output_pubnames ()
7017 {
7018   unsigned i;
7019   unsigned long pubnames_length = size_of_pubnames ();
7020
7021   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7022                        "Length of Public Names Info");
7023   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7024   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7025                          "Offset of Compilation Unit Info");
7026   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7027                        "Compilation Unit Length");
7028
7029   for (i = 0; i < pubname_table_in_use; i++)
7030     {
7031       pubname_ref pub = &pubname_table[i];
7032
7033       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7034       if (pub->die->die_mark == 0)
7035         abort ();
7036
7037       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7038                            "DIE offset");
7039
7040       dw2_asm_output_nstring (pub->name, -1, "external name");
7041     }
7042
7043   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7044 }
7045
7046 /* Add a new entry to .debug_aranges if appropriate.  */
7047
7048 static void
7049 add_arange (decl, die)
7050      tree decl;
7051      dw_die_ref die;
7052 {
7053   if (! DECL_SECTION_NAME (decl))
7054     return;
7055
7056   if (arange_table_in_use == arange_table_allocated)
7057     {
7058       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7059       arange_table = ggc_realloc (arange_table,
7060                                   (arange_table_allocated
7061                                    * sizeof (dw_die_ref)));
7062       memset (arange_table + arange_table_in_use, 0,
7063               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7064     }
7065
7066   arange_table[arange_table_in_use++] = die;
7067 }
7068
7069 /* Output the information that goes into the .debug_aranges table.
7070    Namely, define the beginning and ending address range of the
7071    text section generated for this compilation unit.  */
7072
7073 static void
7074 output_aranges ()
7075 {
7076   unsigned i;
7077   unsigned long aranges_length = size_of_aranges ();
7078
7079   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7080                        "Length of Address Ranges Info");
7081   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7082   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7083                          "Offset of Compilation Unit Info");
7084   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7085   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7086
7087   /* We need to align to twice the pointer size here.  */
7088   if (DWARF_ARANGES_PAD_SIZE)
7089     {
7090       /* Pad using a 2 byte words so that padding is correct for any
7091          pointer size.  */
7092       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7093                            2 * DWARF2_ADDR_SIZE);
7094       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7095         dw2_asm_output_data (2, 0, NULL);
7096     }
7097
7098   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7099   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7100                         text_section_label, "Length");
7101
7102   for (i = 0; i < arange_table_in_use; i++)
7103     {
7104       dw_die_ref die = arange_table[i];
7105
7106       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7107       if (die->die_mark == 0)
7108         abort ();
7109
7110       if (die->die_tag == DW_TAG_subprogram)
7111         {
7112           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7113                                "Address");
7114           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7115                                 get_AT_low_pc (die), "Length");
7116         }
7117       else
7118         {
7119           /* A static variable; extract the symbol from DW_AT_location.
7120              Note that this code isn't currently hit, as we only emit
7121              aranges for functions (jason 9/23/99).  */
7122           dw_attr_ref a = get_AT (die, DW_AT_location);
7123           dw_loc_descr_ref loc;
7124
7125           if (! a || AT_class (a) != dw_val_class_loc)
7126             abort ();
7127
7128           loc = AT_loc (a);
7129           if (loc->dw_loc_opc != DW_OP_addr)
7130             abort ();
7131
7132           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7133                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7134           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7135                                get_AT_unsigned (die, DW_AT_byte_size),
7136                                "Length");
7137         }
7138     }
7139
7140   /* Output the terminator words.  */
7141   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7142   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7143 }
7144
7145 /* Add a new entry to .debug_ranges.  Return the offset at which it
7146    was placed.  */
7147
7148 static unsigned int
7149 add_ranges (block)
7150      tree block;
7151 {
7152   unsigned int in_use = ranges_table_in_use;
7153
7154   if (in_use == ranges_table_allocated)
7155     {
7156       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7157       ranges_table = (dw_ranges_ref)
7158         ggc_realloc (ranges_table, (ranges_table_allocated
7159                                     * sizeof (struct dw_ranges_struct)));
7160       memset (ranges_table + ranges_table_in_use, 0,
7161               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7162     }
7163
7164   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7165   ranges_table_in_use = in_use + 1;
7166
7167   return in_use * 2 * DWARF2_ADDR_SIZE;
7168 }
7169
7170 static void
7171 output_ranges ()
7172 {
7173   unsigned i;
7174   static const char *const start_fmt = "Offset 0x%x";
7175   const char *fmt = start_fmt;
7176
7177   for (i = 0; i < ranges_table_in_use; i++)
7178     {
7179       int block_num = ranges_table[i].block_num;
7180
7181       if (block_num)
7182         {
7183           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7184           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7185
7186           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7187           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7188
7189           /* If all code is in the text section, then the compilation
7190              unit base address defaults to DW_AT_low_pc, which is the
7191              base of the text section.  */
7192           if (separate_line_info_table_in_use == 0)
7193             {
7194               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7195                                     text_section_label,
7196                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7197               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7198                                     text_section_label, NULL);
7199             }
7200
7201           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7202              compilation unit base address to zero, which allows us to
7203              use absolute addresses, and not worry about whether the
7204              target supports cross-section arithmetic.  */
7205           else
7206             {
7207               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7208                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7209               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7210             }
7211
7212           fmt = NULL;
7213         }
7214       else
7215         {
7216           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7217           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7218           fmt = start_fmt;
7219         }
7220     }
7221 }
7222
7223 /* Data structure containing information about input files.  */
7224 struct file_info
7225 {
7226   char *path;           /* Complete file name.  */
7227   char *fname;          /* File name part.  */
7228   int length;           /* Length of entire string.  */
7229   int file_idx;         /* Index in input file table.  */
7230   int dir_idx;          /* Index in directory table.  */
7231 };
7232
7233 /* Data structure containing information about directories with source
7234    files.  */
7235 struct dir_info
7236 {
7237   char *path;           /* Path including directory name.  */
7238   int length;           /* Path length.  */
7239   int prefix;           /* Index of directory entry which is a prefix.  */
7240   int count;            /* Number of files in this directory.  */
7241   int dir_idx;          /* Index of directory used as base.  */
7242   int used;             /* Used in the end?  */
7243 };
7244
7245 /* Callback function for file_info comparison.  We sort by looking at
7246    the directories in the path.  */
7247
7248 static int
7249 file_info_cmp (p1, p2)
7250      const void *p1;
7251      const void *p2;
7252 {
7253   const struct file_info *s1 = p1;
7254   const struct file_info *s2 = p2;
7255   unsigned char *cp1;
7256   unsigned char *cp2;
7257
7258   /* Take care of file names without directories.  We need to make sure that
7259      we return consistent values to qsort since some will get confused if
7260      we return the same value when identical operands are passed in opposite
7261      orders.  So if neither has a directory, return 0 and otherwise return
7262      1 or -1 depending on which one has the directory.  */
7263   if ((s1->path == s1->fname || s2->path == s2->fname))
7264     return (s2->path == s2->fname) - (s1->path == s1->fname);
7265
7266   cp1 = (unsigned char *) s1->path;
7267   cp2 = (unsigned char *) s2->path;
7268
7269   while (1)
7270     {
7271       ++cp1;
7272       ++cp2;
7273       /* Reached the end of the first path?  If so, handle like above.  */
7274       if ((cp1 == (unsigned char *) s1->fname)
7275           || (cp2 == (unsigned char *) s2->fname))
7276         return ((cp2 == (unsigned char *) s2->fname)
7277                 - (cp1 == (unsigned char *) s1->fname));
7278
7279       /* Character of current path component the same?  */
7280       else if (*cp1 != *cp2)
7281         return *cp1 - *cp2;
7282     }
7283 }
7284
7285 /* Output the directory table and the file name table.  We try to minimize
7286    the total amount of memory needed.  A heuristic is used to avoid large
7287    slowdowns with many input files.  */
7288
7289 static void
7290 output_file_names ()
7291 {
7292   struct file_info *files;
7293   struct dir_info *dirs;
7294   int *saved;
7295   int *savehere;
7296   int *backmap;
7297   size_t ndirs;
7298   int idx_offset;
7299   size_t i;
7300   int idx;
7301
7302   /* Handle the case where file_table is empty.  */
7303   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7304     {
7305       dw2_asm_output_data (1, 0, "End directory table");
7306       dw2_asm_output_data (1, 0, "End file name table");
7307       return;
7308     }
7309
7310   /* Allocate the various arrays we need.  */
7311   files = (struct file_info *) alloca (VARRAY_ACTIVE_SIZE (file_table)
7312                                        * sizeof (struct file_info));
7313   dirs = (struct dir_info *) alloca (VARRAY_ACTIVE_SIZE (file_table)
7314                                      * sizeof (struct dir_info));
7315
7316   /* Sort the file names.  */
7317   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7318     {
7319       char *f;
7320
7321       /* Skip all leading "./".  */
7322       f = VARRAY_CHAR_PTR (file_table, i);
7323       while (f[0] == '.' && f[1] == '/')
7324         f += 2;
7325
7326       /* Create a new array entry.  */
7327       files[i].path = f;
7328       files[i].length = strlen (f);
7329       files[i].file_idx = i;
7330
7331       /* Search for the file name part.  */
7332       f = strrchr (f, '/');
7333       files[i].fname = f == NULL ? files[i].path : f + 1;
7334     }
7335
7336   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7337          sizeof (files[0]), file_info_cmp);
7338
7339   /* Find all the different directories used.  */
7340   dirs[0].path = files[1].path;
7341   dirs[0].length = files[1].fname - files[1].path;
7342   dirs[0].prefix = -1;
7343   dirs[0].count = 1;
7344   dirs[0].dir_idx = 0;
7345   dirs[0].used = 0;
7346   files[1].dir_idx = 0;
7347   ndirs = 1;
7348
7349   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7350     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7351         && memcmp (dirs[ndirs - 1].path, files[i].path,
7352                    dirs[ndirs - 1].length) == 0)
7353       {
7354         /* Same directory as last entry.  */
7355         files[i].dir_idx = ndirs - 1;
7356         ++dirs[ndirs - 1].count;
7357       }
7358     else
7359       {
7360         size_t j;
7361
7362         /* This is a new directory.  */
7363         dirs[ndirs].path = files[i].path;
7364         dirs[ndirs].length = files[i].fname - files[i].path;
7365         dirs[ndirs].count = 1;
7366         dirs[ndirs].dir_idx = ndirs;
7367         dirs[ndirs].used = 0;
7368         files[i].dir_idx = ndirs;
7369
7370         /* Search for a prefix.  */
7371         dirs[ndirs].prefix = -1;
7372         for (j = 0; j < ndirs; j++)
7373           if (dirs[j].length < dirs[ndirs].length
7374               && dirs[j].length > 1
7375               && (dirs[ndirs].prefix == -1
7376                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7377               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7378             dirs[ndirs].prefix = j;
7379
7380         ++ndirs;
7381       }
7382
7383   /* Now to the actual work.  We have to find a subset of the directories which
7384      allow expressing the file name using references to the directory table
7385      with the least amount of characters.  We do not do an exhaustive search
7386      where we would have to check out every combination of every single
7387      possible prefix.  Instead we use a heuristic which provides nearly optimal
7388      results in most cases and never is much off.  */
7389   saved = (int *) alloca (ndirs * sizeof (int));
7390   savehere = (int *) alloca (ndirs * sizeof (int));
7391
7392   memset (saved, '\0', ndirs * sizeof (saved[0]));
7393   for (i = 0; i < ndirs; i++)
7394     {
7395       size_t j;
7396       int total;
7397
7398       /* We can always save some space for the current directory.  But this
7399          does not mean it will be enough to justify adding the directory.  */
7400       savehere[i] = dirs[i].length;
7401       total = (savehere[i] - saved[i]) * dirs[i].count;
7402
7403       for (j = i + 1; j < ndirs; j++)
7404         {
7405           savehere[j] = 0;
7406           if (saved[j] < dirs[i].length)
7407             {
7408               /* Determine whether the dirs[i] path is a prefix of the
7409                  dirs[j] path.  */
7410               int k;
7411
7412               k = dirs[j].prefix;
7413               while (k != -1 && k != (int) i)
7414                 k = dirs[k].prefix;
7415
7416               if (k == (int) i)
7417                 {
7418                   /* Yes it is.  We can possibly safe some memory but
7419                      writing the filenames in dirs[j] relative to
7420                      dirs[i].  */
7421                   savehere[j] = dirs[i].length;
7422                   total += (savehere[j] - saved[j]) * dirs[j].count;
7423                 }
7424             }
7425         }
7426
7427       /* Check whether we can safe enough to justify adding the dirs[i]
7428          directory.  */
7429       if (total > dirs[i].length + 1)
7430         {
7431           /* It's worthwhile adding.  */
7432           for (j = i; j < ndirs; j++)
7433             if (savehere[j] > 0)
7434               {
7435                 /* Remember how much we saved for this directory so far.  */
7436                 saved[j] = savehere[j];
7437
7438                 /* Remember the prefix directory.  */
7439                 dirs[j].dir_idx = i;
7440               }
7441         }
7442     }
7443
7444   /* We have to emit them in the order they appear in the file_table array
7445      since the index is used in the debug info generation.  To do this
7446      efficiently we generate a back-mapping of the indices first.  */
7447   backmap = (int *) alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7448   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7449     {
7450       backmap[files[i].file_idx] = i;
7451
7452       /* Mark this directory as used.  */
7453       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7454     }
7455
7456   /* That was it.  We are ready to emit the information.  First emit the
7457      directory name table.  We have to make sure the first actually emitted
7458      directory name has index one; zero is reserved for the current working
7459      directory.  Make sure we do not confuse these indices with the one for the
7460      constructed table (even though most of the time they are identical).  */
7461   idx = 1;
7462   idx_offset = dirs[0].length > 0 ? 1 : 0;
7463   for (i = 1 - idx_offset; i < ndirs; i++)
7464     if (dirs[i].used != 0)
7465       {
7466         dirs[i].used = idx++;
7467         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7468                                 "Directory Entry: 0x%x", dirs[i].used);
7469       }
7470
7471   dw2_asm_output_data (1, 0, "End directory table");
7472
7473   /* Correct the index for the current working directory entry if it
7474      exists.  */
7475   if (idx_offset == 0)
7476     dirs[0].used = 0;
7477
7478   /* Now write all the file names.  */
7479   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7480     {
7481       int file_idx = backmap[i];
7482       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7483
7484       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7485                               "File Entry: 0x%x", i);
7486
7487       /* Include directory index.  */
7488       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7489
7490       /* Modification time.  */
7491       dw2_asm_output_data_uleb128 (0, NULL);
7492
7493       /* File length in bytes.  */
7494       dw2_asm_output_data_uleb128 (0, NULL);
7495     }
7496
7497   dw2_asm_output_data (1, 0, "End file name table");
7498 }
7499
7500
7501 /* Output the source line number correspondence information.  This
7502    information goes into the .debug_line section.  */
7503
7504 static void
7505 output_line_info ()
7506 {
7507   char l1[20], l2[20], p1[20], p2[20];
7508   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7509   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7510   unsigned opc;
7511   unsigned n_op_args;
7512   unsigned long lt_index;
7513   unsigned long current_line;
7514   long line_offset;
7515   long line_delta;
7516   unsigned long current_file;
7517   unsigned long function;
7518
7519   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7520   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7521   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7522   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7523
7524   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7525                         "Length of Source Line Info");
7526   ASM_OUTPUT_LABEL (asm_out_file, l1);
7527
7528   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7529   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7530   ASM_OUTPUT_LABEL (asm_out_file, p1);
7531
7532   /* Define the architecture-dependent minimum instruction length (in
7533    bytes).  In this implementation of DWARF, this field is used for
7534    information purposes only.  Since GCC generates assembly language,
7535    we have no a priori knowledge of how many instruction bytes are
7536    generated for each source line, and therefore can use only the
7537    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7538    commands.  Accordingly, we fix this as `1', which is "correct
7539    enough" for all architectures, and don't let the target override.  */
7540   dw2_asm_output_data (1, 1,
7541                        "Minimum Instruction Length");
7542
7543   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7544                        "Default is_stmt_start flag");
7545   dw2_asm_output_data (1, DWARF_LINE_BASE,
7546                        "Line Base Value (Special Opcodes)");
7547   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7548                        "Line Range Value (Special Opcodes)");
7549   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7550                        "Special Opcode Base");
7551
7552   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7553     {
7554       switch (opc)
7555         {
7556         case DW_LNS_advance_pc:
7557         case DW_LNS_advance_line:
7558         case DW_LNS_set_file:
7559         case DW_LNS_set_column:
7560         case DW_LNS_fixed_advance_pc:
7561           n_op_args = 1;
7562           break;
7563         default:
7564           n_op_args = 0;
7565           break;
7566         }
7567
7568       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7569                            opc, n_op_args);
7570     }
7571
7572   /* Write out the information about the files we use.  */
7573   output_file_names ();
7574   ASM_OUTPUT_LABEL (asm_out_file, p2);
7575
7576   /* We used to set the address register to the first location in the text
7577      section here, but that didn't accomplish anything since we already
7578      have a line note for the opening brace of the first function.  */
7579
7580   /* Generate the line number to PC correspondence table, encoded as
7581      a series of state machine operations.  */
7582   current_file = 1;
7583   current_line = 1;
7584   strcpy (prev_line_label, text_section_label);
7585   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7586     {
7587       dw_line_info_ref line_info = &line_info_table[lt_index];
7588
7589 #if 0
7590       /* Disable this optimization for now; GDB wants to see two line notes
7591          at the beginning of a function so it can find the end of the
7592          prologue.  */
7593
7594       /* Don't emit anything for redundant notes.  Just updating the
7595          address doesn't accomplish anything, because we already assume
7596          that anything after the last address is this line.  */
7597       if (line_info->dw_line_num == current_line
7598           && line_info->dw_file_num == current_file)
7599         continue;
7600 #endif
7601
7602       /* Emit debug info for the address of the current line.
7603
7604          Unfortunately, we have little choice here currently, and must always
7605          use the most general form.  GCC does not know the address delta
7606          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7607          attributes which will give an upper bound on the address range.  We
7608          could perhaps use length attributes to determine when it is safe to
7609          use DW_LNS_fixed_advance_pc.  */
7610
7611       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7612       if (0)
7613         {
7614           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7615           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7616                                "DW_LNS_fixed_advance_pc");
7617           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7618         }
7619       else
7620         {
7621           /* This can handle any delta.  This takes
7622              4+DWARF2_ADDR_SIZE bytes.  */
7623           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7624           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7625           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7626           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7627         }
7628
7629       strcpy (prev_line_label, line_label);
7630
7631       /* Emit debug info for the source file of the current line, if
7632          different from the previous line.  */
7633       if (line_info->dw_file_num != current_file)
7634         {
7635           current_file = line_info->dw_file_num;
7636           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7637           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7638                                        VARRAY_CHAR_PTR (file_table,
7639                                                         current_file));
7640         }
7641
7642       /* Emit debug info for the current line number, choosing the encoding
7643          that uses the least amount of space.  */
7644       if (line_info->dw_line_num != current_line)
7645         {
7646           line_offset = line_info->dw_line_num - current_line;
7647           line_delta = line_offset - DWARF_LINE_BASE;
7648           current_line = line_info->dw_line_num;
7649           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7650             /* This can handle deltas from -10 to 234, using the current
7651                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7652                takes 1 byte.  */
7653             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7654                                  "line %lu", current_line);
7655           else
7656             {
7657               /* This can handle any delta.  This takes at least 4 bytes,
7658                  depending on the value being encoded.  */
7659               dw2_asm_output_data (1, DW_LNS_advance_line,
7660                                    "advance to line %lu", current_line);
7661               dw2_asm_output_data_sleb128 (line_offset, NULL);
7662               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7663             }
7664         }
7665       else
7666         /* We still need to start a new row, so output a copy insn.  */
7667         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7668     }
7669
7670   /* Emit debug info for the address of the end of the function.  */
7671   if (0)
7672     {
7673       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7674                            "DW_LNS_fixed_advance_pc");
7675       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7676     }
7677   else
7678     {
7679       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7680       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7681       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7682       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7683     }
7684
7685   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7686   dw2_asm_output_data_uleb128 (1, NULL);
7687   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7688
7689   function = 0;
7690   current_file = 1;
7691   current_line = 1;
7692   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7693     {
7694       dw_separate_line_info_ref line_info
7695         = &separate_line_info_table[lt_index];
7696
7697 #if 0
7698       /* Don't emit anything for redundant notes.  */
7699       if (line_info->dw_line_num == current_line
7700           && line_info->dw_file_num == current_file
7701           && line_info->function == function)
7702         goto cont;
7703 #endif
7704
7705       /* Emit debug info for the address of the current line.  If this is
7706          a new function, or the first line of a function, then we need
7707          to handle it differently.  */
7708       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7709                                    lt_index);
7710       if (function != line_info->function)
7711         {
7712           function = line_info->function;
7713
7714           /* Set the address register to the first line in the function */
7715           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7716           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7717           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7718           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7719         }
7720       else
7721         {
7722           /* ??? See the DW_LNS_advance_pc comment above.  */
7723           if (0)
7724             {
7725               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7726                                    "DW_LNS_fixed_advance_pc");
7727               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7728             }
7729           else
7730             {
7731               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7732               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7733               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7734               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7735             }
7736         }
7737
7738       strcpy (prev_line_label, line_label);
7739
7740       /* Emit debug info for the source file of the current line, if
7741          different from the previous line.  */
7742       if (line_info->dw_file_num != current_file)
7743         {
7744           current_file = line_info->dw_file_num;
7745           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7746           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7747                                        VARRAY_CHAR_PTR (file_table,
7748                                                         current_file));
7749         }
7750
7751       /* Emit debug info for the current line number, choosing the encoding
7752          that uses the least amount of space.  */
7753       if (line_info->dw_line_num != current_line)
7754         {
7755           line_offset = line_info->dw_line_num - current_line;
7756           line_delta = line_offset - DWARF_LINE_BASE;
7757           current_line = line_info->dw_line_num;
7758           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7759             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7760                                  "line %lu", current_line);
7761           else
7762             {
7763               dw2_asm_output_data (1, DW_LNS_advance_line,
7764                                    "advance to line %lu", current_line);
7765               dw2_asm_output_data_sleb128 (line_offset, NULL);
7766               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7767             }
7768         }
7769       else
7770         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7771
7772 #if 0
7773     cont:
7774 #endif
7775
7776       lt_index++;
7777
7778       /* If we're done with a function, end its sequence.  */
7779       if (lt_index == separate_line_info_table_in_use
7780           || separate_line_info_table[lt_index].function != function)
7781         {
7782           current_file = 1;
7783           current_line = 1;
7784
7785           /* Emit debug info for the address of the end of the function.  */
7786           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
7787           if (0)
7788             {
7789               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7790                                    "DW_LNS_fixed_advance_pc");
7791               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7792             }
7793           else
7794             {
7795               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7796               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7797               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7798               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7799             }
7800
7801           /* Output the marker for the end of this sequence.  */
7802           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7803           dw2_asm_output_data_uleb128 (1, NULL);
7804           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7805         }
7806     }
7807
7808   /* Output the marker for the end of the line number info.  */
7809   ASM_OUTPUT_LABEL (asm_out_file, l2);
7810 }
7811 \f
7812 /* Given a pointer to a tree node for some base type, return a pointer to
7813    a DIE that describes the given type.
7814
7815    This routine must only be called for GCC type nodes that correspond to
7816    Dwarf base (fundamental) types.  */
7817
7818 static dw_die_ref
7819 base_type_die (type)
7820      tree type;
7821 {
7822   dw_die_ref base_type_result;
7823   const char *type_name;
7824   enum dwarf_type encoding;
7825   tree name = TYPE_NAME (type);
7826
7827   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
7828     return 0;
7829
7830   if (name)
7831     {
7832       if (TREE_CODE (name) == TYPE_DECL)
7833         name = DECL_NAME (name);
7834
7835       type_name = IDENTIFIER_POINTER (name);
7836     }
7837   else
7838     type_name = "__unknown__";
7839
7840   switch (TREE_CODE (type))
7841     {
7842     case INTEGER_TYPE:
7843       /* Carefully distinguish the C character types, without messing
7844          up if the language is not C. Note that we check only for the names
7845          that contain spaces; other names might occur by coincidence in other
7846          languages.  */
7847       if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
7848              && (type == char_type_node
7849                  || ! strcmp (type_name, "signed char")
7850                  || ! strcmp (type_name, "unsigned char"))))
7851         {
7852           if (TREE_UNSIGNED (type))
7853             encoding = DW_ATE_unsigned;
7854           else
7855             encoding = DW_ATE_signed;
7856           break;
7857         }
7858       /* else fall through.  */
7859
7860     case CHAR_TYPE:
7861       /* GNU Pascal/Ada CHAR type.  Not used in C.  */
7862       if (TREE_UNSIGNED (type))
7863         encoding = DW_ATE_unsigned_char;
7864       else
7865         encoding = DW_ATE_signed_char;
7866       break;
7867
7868     case REAL_TYPE:
7869       encoding = DW_ATE_float;
7870       break;
7871
7872       /* Dwarf2 doesn't know anything about complex ints, so use
7873          a user defined type for it.  */
7874     case COMPLEX_TYPE:
7875       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
7876         encoding = DW_ATE_complex_float;
7877       else
7878         encoding = DW_ATE_lo_user;
7879       break;
7880
7881     case BOOLEAN_TYPE:
7882       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
7883       encoding = DW_ATE_boolean;
7884       break;
7885
7886     default:
7887       /* No other TREE_CODEs are Dwarf fundamental types.  */
7888       abort ();
7889     }
7890
7891   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
7892   if (demangle_name_func)
7893     type_name = (*demangle_name_func) (type_name);
7894
7895   add_AT_string (base_type_result, DW_AT_name, type_name);
7896   add_AT_unsigned (base_type_result, DW_AT_byte_size,
7897                    int_size_in_bytes (type));
7898   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
7899
7900   return base_type_result;
7901 }
7902
7903 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7904    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
7905    a given type is generally the same as the given type, except that if the
7906    given type is a pointer or reference type, then the root type of the given
7907    type is the root type of the "basis" type for the pointer or reference
7908    type.  (This definition of the "root" type is recursive.) Also, the root
7909    type of a `const' qualified type or a `volatile' qualified type is the
7910    root type of the given type without the qualifiers.  */
7911
7912 static tree
7913 root_type (type)
7914      tree type;
7915 {
7916   if (TREE_CODE (type) == ERROR_MARK)
7917     return error_mark_node;
7918
7919   switch (TREE_CODE (type))
7920     {
7921     case ERROR_MARK:
7922       return error_mark_node;
7923
7924     case POINTER_TYPE:
7925     case REFERENCE_TYPE:
7926       return type_main_variant (root_type (TREE_TYPE (type)));
7927
7928     default:
7929       return type_main_variant (type);
7930     }
7931 }
7932
7933 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7934    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
7935
7936 static inline int
7937 is_base_type (type)
7938      tree type;
7939 {
7940   switch (TREE_CODE (type))
7941     {
7942     case ERROR_MARK:
7943     case VOID_TYPE:
7944     case INTEGER_TYPE:
7945     case REAL_TYPE:
7946     case COMPLEX_TYPE:
7947     case BOOLEAN_TYPE:
7948     case CHAR_TYPE:
7949       return 1;
7950
7951     case SET_TYPE:
7952     case ARRAY_TYPE:
7953     case RECORD_TYPE:
7954     case UNION_TYPE:
7955     case QUAL_UNION_TYPE:
7956     case ENUMERAL_TYPE:
7957     case FUNCTION_TYPE:
7958     case METHOD_TYPE:
7959     case POINTER_TYPE:
7960     case REFERENCE_TYPE:
7961     case FILE_TYPE:
7962     case OFFSET_TYPE:
7963     case LANG_TYPE:
7964     case VECTOR_TYPE:
7965       return 0;
7966
7967     default:
7968       abort ();
7969     }
7970
7971   return 0;
7972 }
7973
7974 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
7975    node, return the size in bits for the type if it is a constant, or else
7976    return the alignment for the type if the type's size is not constant, or
7977    else return BITS_PER_WORD if the type actually turns out to be an
7978    ERROR_MARK node.  */
7979
7980 static inline unsigned HOST_WIDE_INT
7981 simple_type_size_in_bits (type)
7982      tree type;
7983 {
7984
7985   if (TREE_CODE (type) == ERROR_MARK)
7986     return BITS_PER_WORD;
7987   else if (TYPE_SIZE (type) == NULL_TREE)
7988     return 0;
7989   else if (host_integerp (TYPE_SIZE (type), 1))
7990     return tree_low_cst (TYPE_SIZE (type), 1);
7991   else
7992     return TYPE_ALIGN (type);
7993 }
7994
7995 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
7996    entry that chains various modifiers in front of the given type.  */
7997
7998 static dw_die_ref
7999 modified_type_die (type, is_const_type, is_volatile_type, context_die)
8000      tree type;
8001      int is_const_type;
8002      int is_volatile_type;
8003      dw_die_ref context_die;
8004 {
8005   enum tree_code code = TREE_CODE (type);
8006   dw_die_ref mod_type_die = NULL;
8007   dw_die_ref sub_die = NULL;
8008   tree item_type = NULL;
8009
8010   if (code != ERROR_MARK)
8011     {
8012       tree qualified_type;
8013
8014       /* See if we already have the appropriately qualified variant of
8015          this type.  */
8016       qualified_type
8017         = get_qualified_type (type,
8018                               ((is_const_type ? TYPE_QUAL_CONST : 0)
8019                                | (is_volatile_type
8020                                   ? TYPE_QUAL_VOLATILE : 0)));
8021
8022       /* If we do, then we can just use its DIE, if it exists.  */
8023       if (qualified_type)
8024         {
8025           mod_type_die = lookup_type_die (qualified_type);
8026           if (mod_type_die)
8027             return mod_type_die;
8028         }
8029
8030       /* Handle C typedef types.  */
8031       if (qualified_type && TYPE_NAME (qualified_type)
8032           && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
8033           && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
8034         {
8035           tree type_name = TYPE_NAME (qualified_type);
8036           tree dtype = TREE_TYPE (type_name);
8037
8038           if (qualified_type == dtype)
8039             {
8040               /* For a named type, use the typedef.  */
8041               gen_type_die (qualified_type, context_die);
8042               mod_type_die = lookup_type_die (qualified_type);
8043             }
8044           else if (is_const_type < TYPE_READONLY (dtype)
8045                    || is_volatile_type < TYPE_VOLATILE (dtype))
8046             /* cv-unqualified version of named type.  Just use the unnamed
8047                type to which it refers.  */
8048             mod_type_die
8049               = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
8050                                    is_const_type, is_volatile_type,
8051                                    context_die);
8052
8053           /* Else cv-qualified version of named type; fall through.  */
8054         }
8055
8056       if (mod_type_die)
8057         /* OK.  */
8058         ;
8059       else if (is_const_type)
8060         {
8061           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8062           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8063         }
8064       else if (is_volatile_type)
8065         {
8066           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8067           sub_die = modified_type_die (type, 0, 0, context_die);
8068         }
8069       else if (code == POINTER_TYPE)
8070         {
8071           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8072           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8073                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8074 #if 0
8075           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8076 #endif
8077           item_type = TREE_TYPE (type);
8078         }
8079       else if (code == REFERENCE_TYPE)
8080         {
8081           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8082           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8083                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8084 #if 0
8085           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8086 #endif
8087           item_type = TREE_TYPE (type);
8088         }
8089       else if (is_base_type (type))
8090         mod_type_die = base_type_die (type);
8091       else
8092         {
8093           gen_type_die (type, context_die);
8094
8095           /* We have to get the type_main_variant here (and pass that to the
8096              `lookup_type_die' routine) because the ..._TYPE node we have
8097              might simply be a *copy* of some original type node (where the
8098              copy was created to help us keep track of typedef names) and
8099              that copy might have a different TYPE_UID from the original
8100              ..._TYPE node.  */
8101           if (TREE_CODE (type) != VECTOR_TYPE)
8102             mod_type_die = lookup_type_die (type_main_variant (type));
8103           else
8104             /* Vectors have the debugging information in the type,
8105                not the main variant.  */
8106             mod_type_die = lookup_type_die (type);
8107           if (mod_type_die == NULL)
8108             abort ();
8109         }
8110
8111       /* We want to equate the qualified type to the die below.  */
8112       type = qualified_type;
8113     }
8114
8115   if (type)
8116     equate_type_number_to_die (type, mod_type_die);
8117   if (item_type)
8118     /* We must do this after the equate_type_number_to_die call, in case
8119        this is a recursive type.  This ensures that the modified_type_die
8120        recursion will terminate even if the type is recursive.  Recursive
8121        types are possible in Ada.  */
8122     sub_die = modified_type_die (item_type,
8123                                  TYPE_READONLY (item_type),
8124                                  TYPE_VOLATILE (item_type),
8125                                  context_die);
8126
8127   if (sub_die != NULL)
8128     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8129
8130   return mod_type_die;
8131 }
8132
8133 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8134    an enumerated type.  */
8135
8136 static inline int
8137 type_is_enum (type)
8138      tree type;
8139 {
8140   return TREE_CODE (type) == ENUMERAL_TYPE;
8141 }
8142
8143 /* Return the register number described by a given RTL node.  */
8144
8145 static unsigned int
8146 reg_number (rtl)
8147      rtx rtl;
8148 {
8149   unsigned regno = REGNO (rtl);
8150
8151   if (regno >= FIRST_PSEUDO_REGISTER)
8152     abort ();
8153
8154   return DBX_REGISTER_NUMBER (regno);
8155 }
8156
8157 /* Return a location descriptor that designates a machine register or
8158    zero if there is no such.  */
8159
8160 static dw_loc_descr_ref
8161 reg_loc_descriptor (rtl)
8162      rtx rtl;
8163 {
8164   dw_loc_descr_ref loc_result = NULL;
8165   unsigned reg;
8166
8167   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8168     return 0;
8169
8170   reg = reg_number (rtl);
8171   if (reg <= 31)
8172     loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
8173   else
8174     loc_result = new_loc_descr (DW_OP_regx, reg, 0);
8175
8176   return loc_result;
8177 }
8178
8179 /* Return a location descriptor that designates a constant.  */
8180
8181 static dw_loc_descr_ref
8182 int_loc_descriptor (i)
8183      HOST_WIDE_INT i;
8184 {
8185   enum dwarf_location_atom op;
8186
8187   /* Pick the smallest representation of a constant, rather than just
8188      defaulting to the LEB encoding.  */
8189   if (i >= 0)
8190     {
8191       if (i <= 31)
8192         op = DW_OP_lit0 + i;
8193       else if (i <= 0xff)
8194         op = DW_OP_const1u;
8195       else if (i <= 0xffff)
8196         op = DW_OP_const2u;
8197       else if (HOST_BITS_PER_WIDE_INT == 32
8198                || i <= 0xffffffff)
8199         op = DW_OP_const4u;
8200       else
8201         op = DW_OP_constu;
8202     }
8203   else
8204     {
8205       if (i >= -0x80)
8206         op = DW_OP_const1s;
8207       else if (i >= -0x8000)
8208         op = DW_OP_const2s;
8209       else if (HOST_BITS_PER_WIDE_INT == 32
8210                || i >= -0x80000000)
8211         op = DW_OP_const4s;
8212       else
8213         op = DW_OP_consts;
8214     }
8215
8216   return new_loc_descr (op, i, 0);
8217 }
8218
8219 /* Return a location descriptor that designates a base+offset location.  */
8220
8221 static dw_loc_descr_ref
8222 based_loc_descr (reg, offset)
8223      unsigned reg;
8224      long int offset;
8225 {
8226   dw_loc_descr_ref loc_result;
8227   /* For the "frame base", we use the frame pointer or stack pointer
8228      registers, since the RTL for local variables is relative to one of
8229      them.  */
8230   unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
8231                                          ? HARD_FRAME_POINTER_REGNUM
8232                                          : STACK_POINTER_REGNUM);
8233
8234   if (reg == fp_reg)
8235     loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
8236   else if (reg <= 31)
8237     loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
8238   else
8239     loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
8240
8241   return loc_result;
8242 }
8243
8244 /* Return true if this RTL expression describes a base+offset calculation.  */
8245
8246 static inline int
8247 is_based_loc (rtl)
8248      rtx rtl;
8249 {
8250   return (GET_CODE (rtl) == PLUS
8251           && ((GET_CODE (XEXP (rtl, 0)) == REG
8252                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8253                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8254 }
8255
8256 /* The following routine converts the RTL for a variable or parameter
8257    (resident in memory) into an equivalent Dwarf representation of a
8258    mechanism for getting the address of that same variable onto the top of a
8259    hypothetical "address evaluation" stack.
8260
8261    When creating memory location descriptors, we are effectively transforming
8262    the RTL for a memory-resident object into its Dwarf postfix expression
8263    equivalent.  This routine recursively descends an RTL tree, turning
8264    it into Dwarf postfix code as it goes.
8265
8266    MODE is the mode of the memory reference, needed to handle some
8267    autoincrement addressing modes.
8268
8269    Return 0 if we can't represent the location.  */
8270
8271 static dw_loc_descr_ref
8272 mem_loc_descriptor (rtl, mode)
8273      rtx rtl;
8274      enum machine_mode mode;
8275 {
8276   dw_loc_descr_ref mem_loc_result = NULL;
8277
8278   /* Note that for a dynamically sized array, the location we will generate a
8279      description of here will be the lowest numbered location which is
8280      actually within the array.  That's *not* necessarily the same as the
8281      zeroth element of the array.  */
8282
8283   rtl = (*targetm.delegitimize_address) (rtl);
8284
8285   switch (GET_CODE (rtl))
8286     {
8287     case POST_INC:
8288     case POST_DEC:
8289     case POST_MODIFY:
8290       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8291          just fall into the SUBREG code.  */
8292
8293       /* ... fall through ...  */
8294
8295     case SUBREG:
8296       /* The case of a subreg may arise when we have a local (register)
8297          variable or a formal (register) parameter which doesn't quite fill
8298          up an entire register.  For now, just assume that it is
8299          legitimate to make the Dwarf info refer to the whole register which
8300          contains the given subreg.  */
8301       rtl = SUBREG_REG (rtl);
8302
8303       /* ... fall through ...  */
8304
8305     case REG:
8306       /* Whenever a register number forms a part of the description of the
8307          method for calculating the (dynamic) address of a memory resident
8308          object, DWARF rules require the register number be referred to as
8309          a "base register".  This distinction is not based in any way upon
8310          what category of register the hardware believes the given register
8311          belongs to.  This is strictly DWARF terminology we're dealing with
8312          here. Note that in cases where the location of a memory-resident
8313          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8314          OP_CONST (0)) the actual DWARF location descriptor that we generate
8315          may just be OP_BASEREG (basereg).  This may look deceptively like
8316          the object in question was allocated to a register (rather than in
8317          memory) so DWARF consumers need to be aware of the subtle
8318          distinction between OP_REG and OP_BASEREG.  */
8319       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8320         mem_loc_result = based_loc_descr (reg_number (rtl), 0);
8321       break;
8322
8323     case MEM:
8324       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8325       if (mem_loc_result != 0)
8326         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8327       break;
8328
8329     case LABEL_REF:
8330       /* Some ports can transform a symbol ref into a label ref, because
8331          the symbol ref is too far away and has to be dumped into a constant
8332          pool.  */
8333     case CONST:
8334     case SYMBOL_REF:
8335       /* Alternatively, the symbol in the constant pool might be referenced
8336          by a different symbol.  */
8337       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8338         {
8339           bool marked;
8340           rtx tmp = get_pool_constant_mark (rtl, &marked);
8341
8342           if (GET_CODE (tmp) == SYMBOL_REF)
8343             {
8344               rtl = tmp;
8345               if (CONSTANT_POOL_ADDRESS_P (tmp))
8346                 get_pool_constant_mark (tmp, &marked);
8347               else
8348                 marked = true;
8349             }
8350
8351           /* If all references to this pool constant were optimized away,
8352              it was not output and thus we can't represent it.
8353              FIXME: might try to use DW_OP_const_value here, though
8354              DW_OP_piece complicates it.  */
8355           if (!marked)
8356             return 0;
8357         }
8358
8359       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8360       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8361       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8362       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
8363       break;
8364
8365     case PRE_MODIFY:
8366       /* Extract the PLUS expression nested inside and fall into
8367          PLUS code below.  */
8368       rtl = XEXP (rtl, 1);
8369       goto plus;
8370
8371     case PRE_INC:
8372     case PRE_DEC:
8373       /* Turn these into a PLUS expression and fall into the PLUS code
8374          below.  */
8375       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8376                           GEN_INT (GET_CODE (rtl) == PRE_INC
8377                                    ? GET_MODE_UNIT_SIZE (mode)
8378                                    : -GET_MODE_UNIT_SIZE (mode)));
8379
8380       /* ... fall through ...  */
8381
8382     case PLUS:
8383     plus:
8384       if (is_based_loc (rtl))
8385         mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
8386                                           INTVAL (XEXP (rtl, 1)));
8387       else
8388         {
8389           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8390           if (mem_loc_result == 0)
8391             break;
8392
8393           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8394               && INTVAL (XEXP (rtl, 1)) >= 0)
8395             add_loc_descr (&mem_loc_result,
8396                            new_loc_descr (DW_OP_plus_uconst,
8397                                           INTVAL (XEXP (rtl, 1)), 0));
8398           else
8399             {
8400               add_loc_descr (&mem_loc_result,
8401                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8402               add_loc_descr (&mem_loc_result,
8403                              new_loc_descr (DW_OP_plus, 0, 0));
8404             }
8405         }
8406       break;
8407
8408     case MULT:
8409       {
8410         /* If a pseudo-reg is optimized away, it is possible for it to
8411            be replaced with a MEM containing a multiply.  */
8412         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8413         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8414
8415         if (op0 == 0 || op1 == 0)
8416           break;
8417
8418         mem_loc_result = op0;
8419         add_loc_descr (&mem_loc_result, op1);
8420         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
8421         break;
8422       }
8423
8424     case CONST_INT:
8425       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8426       break;
8427
8428     case ADDRESSOF:
8429       /* If this is a MEM, return its address.  Otherwise, we can't
8430          represent this.  */
8431       if (GET_CODE (XEXP (rtl, 0)) == MEM)
8432         return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode);
8433       else
8434         return 0;
8435
8436     default:
8437       abort ();
8438     }
8439
8440   return mem_loc_result;
8441 }
8442
8443 /* Return a descriptor that describes the concatenation of two locations.
8444    This is typically a complex variable.  */
8445
8446 static dw_loc_descr_ref
8447 concat_loc_descriptor (x0, x1)
8448      rtx x0, x1;
8449 {
8450   dw_loc_descr_ref cc_loc_result = NULL;
8451   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8452   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8453
8454   if (x0_ref == 0 || x1_ref == 0)
8455     return 0;
8456
8457   cc_loc_result = x0_ref;
8458   add_loc_descr (&cc_loc_result,
8459                  new_loc_descr (DW_OP_piece,
8460                                 GET_MODE_SIZE (GET_MODE (x0)), 0));
8461
8462   add_loc_descr (&cc_loc_result, x1_ref);
8463   add_loc_descr (&cc_loc_result,
8464                  new_loc_descr (DW_OP_piece,
8465                                 GET_MODE_SIZE (GET_MODE (x1)), 0));
8466
8467   return cc_loc_result;
8468 }
8469
8470 /* Output a proper Dwarf location descriptor for a variable or parameter
8471    which is either allocated in a register or in a memory location.  For a
8472    register, we just generate an OP_REG and the register number.  For a
8473    memory location we provide a Dwarf postfix expression describing how to
8474    generate the (dynamic) address of the object onto the address stack.
8475
8476    If we don't know how to describe it, return 0.  */
8477
8478 static dw_loc_descr_ref
8479 loc_descriptor (rtl)
8480      rtx rtl;
8481 {
8482   dw_loc_descr_ref loc_result = NULL;
8483
8484   switch (GET_CODE (rtl))
8485     {
8486     case SUBREG:
8487       /* The case of a subreg may arise when we have a local (register)
8488          variable or a formal (register) parameter which doesn't quite fill
8489          up an entire register.  For now, just assume that it is
8490          legitimate to make the Dwarf info refer to the whole register which
8491          contains the given subreg.  */
8492       rtl = SUBREG_REG (rtl);
8493
8494       /* ... fall through ...  */
8495
8496     case REG:
8497       loc_result = reg_loc_descriptor (rtl);
8498       break;
8499
8500     case MEM:
8501       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8502       break;
8503
8504     case CONCAT:
8505       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8506       break;
8507
8508     default:
8509       abort ();
8510     }
8511
8512   return loc_result;
8513 }
8514
8515 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8516    up particularly with variable length arrays.  If ADDRESSP is nonzero, we are
8517    looking for an address.  Otherwise, we return a value.  If we can't make a
8518    descriptor, return 0.  */
8519
8520 static dw_loc_descr_ref
8521 loc_descriptor_from_tree (loc, addressp)
8522      tree loc;
8523      int addressp;
8524 {
8525   dw_loc_descr_ref ret, ret1;
8526   int indirect_p = 0;
8527   int unsignedp = TREE_UNSIGNED (TREE_TYPE (loc));
8528   enum dwarf_location_atom op;
8529
8530   /* ??? Most of the time we do not take proper care for sign/zero
8531      extending the values properly.  Hopefully this won't be a real
8532      problem...  */
8533
8534   switch (TREE_CODE (loc))
8535     {
8536     case ERROR_MARK:
8537       return 0;
8538
8539     case WITH_RECORD_EXPR:
8540     case PLACEHOLDER_EXPR:
8541       /* This case involves extracting fields from an object to determine the
8542          position of other fields.  We don't try to encode this here.  The
8543          only user of this is Ada, which encodes the needed information using
8544          the names of types.  */
8545       return 0;
8546
8547     case CALL_EXPR:
8548       return 0;
8549
8550     case ADDR_EXPR:
8551       /* We can support this only if we can look through conversions and
8552          find an INDIRECT_EXPR.  */
8553       for (loc = TREE_OPERAND (loc, 0);
8554            TREE_CODE (loc) == CONVERT_EXPR || TREE_CODE (loc) == NOP_EXPR
8555            || TREE_CODE (loc) == NON_LVALUE_EXPR
8556            || TREE_CODE (loc) == VIEW_CONVERT_EXPR
8557            || TREE_CODE (loc) == SAVE_EXPR;
8558            loc = TREE_OPERAND (loc, 0))
8559         ;
8560
8561        return (TREE_CODE (loc) == INDIRECT_REF
8562                ? loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp)
8563                : 0);
8564
8565     case VAR_DECL:
8566       if (DECL_THREAD_LOCAL (loc))
8567         {
8568           rtx rtl;
8569
8570 #ifndef ASM_OUTPUT_DWARF_DTPREL
8571           /* If this is not defined, we have no way to emit the data.  */
8572           return 0;
8573 #endif
8574
8575           /* The way DW_OP_GNU_push_tls_address is specified, we can only
8576              look up addresses of objects in the current module.  */
8577           if (DECL_EXTERNAL (loc))
8578             return 0;
8579
8580           rtl = rtl_for_decl_location (loc);
8581           if (rtl == NULL_RTX)
8582             return 0;
8583
8584           if (GET_CODE (rtl) != MEM)
8585             return 0;
8586           rtl = XEXP (rtl, 0);
8587           if (! CONSTANT_P (rtl))
8588             return 0;
8589
8590           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
8591           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8592           ret->dw_loc_oprnd1.v.val_addr = rtl;
8593
8594           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
8595           add_loc_descr (&ret, ret1);
8596
8597           indirect_p = 1;
8598           break;
8599         }
8600       /* FALLTHRU */
8601
8602     case PARM_DECL:
8603       {
8604         rtx rtl = rtl_for_decl_location (loc);
8605
8606         if (rtl == NULL_RTX)
8607           return 0;
8608         else if (CONSTANT_P (rtl))
8609           {
8610             ret = new_loc_descr (DW_OP_addr, 0, 0);
8611             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8612             ret->dw_loc_oprnd1.v.val_addr = rtl;
8613             indirect_p = 1;
8614           }
8615         else
8616           {
8617             enum machine_mode mode = GET_MODE (rtl);
8618
8619             if (GET_CODE (rtl) == MEM)
8620               {
8621                 indirect_p = 1;
8622                 rtl = XEXP (rtl, 0);
8623               }
8624
8625             ret = mem_loc_descriptor (rtl, mode);
8626           }
8627       }
8628       break;
8629
8630     case INDIRECT_REF:
8631       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8632       indirect_p = 1;
8633       break;
8634
8635     case COMPOUND_EXPR:
8636       return loc_descriptor_from_tree (TREE_OPERAND (loc, 1), addressp);
8637
8638     case NOP_EXPR:
8639     case CONVERT_EXPR:
8640     case NON_LVALUE_EXPR:
8641     case VIEW_CONVERT_EXPR:
8642     case SAVE_EXPR:
8643       return loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp);
8644
8645     case COMPONENT_REF:
8646     case BIT_FIELD_REF:
8647     case ARRAY_REF:
8648     case ARRAY_RANGE_REF:
8649       {
8650         tree obj, offset;
8651         HOST_WIDE_INT bitsize, bitpos, bytepos;
8652         enum machine_mode mode;
8653         int volatilep;
8654
8655         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
8656                                    &unsignedp, &volatilep);
8657
8658         if (obj == loc)
8659           return 0;
8660
8661         ret = loc_descriptor_from_tree (obj, 1);
8662         if (ret == 0
8663             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
8664           return 0;
8665
8666         if (offset != NULL_TREE)
8667           {
8668             /* Variable offset.  */
8669             add_loc_descr (&ret, loc_descriptor_from_tree (offset, 0));
8670             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8671           }
8672
8673         if (!addressp)
8674           indirect_p = 1;
8675
8676         bytepos = bitpos / BITS_PER_UNIT;
8677         if (bytepos > 0)
8678           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
8679         else if (bytepos < 0)
8680           {
8681             add_loc_descr (&ret, int_loc_descriptor (bytepos));
8682             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8683           }
8684         break;
8685       }
8686
8687     case INTEGER_CST:
8688       if (host_integerp (loc, 0))
8689         ret = int_loc_descriptor (tree_low_cst (loc, 0));
8690       else
8691         return 0;
8692       break;
8693
8694     case TRUTH_AND_EXPR:
8695     case TRUTH_ANDIF_EXPR:
8696     case BIT_AND_EXPR:
8697       op = DW_OP_and;
8698       goto do_binop;
8699
8700     case TRUTH_XOR_EXPR:
8701     case BIT_XOR_EXPR:
8702       op = DW_OP_xor;
8703       goto do_binop;
8704
8705     case TRUTH_OR_EXPR:
8706     case TRUTH_ORIF_EXPR:
8707     case BIT_IOR_EXPR:
8708       op = DW_OP_or;
8709       goto do_binop;
8710
8711     case TRUNC_DIV_EXPR:
8712       op = DW_OP_div;
8713       goto do_binop;
8714
8715     case MINUS_EXPR:
8716       op = DW_OP_minus;
8717       goto do_binop;
8718
8719     case TRUNC_MOD_EXPR:
8720       op = DW_OP_mod;
8721       goto do_binop;
8722
8723     case MULT_EXPR:
8724       op = DW_OP_mul;
8725       goto do_binop;
8726
8727     case LSHIFT_EXPR:
8728       op = DW_OP_shl;
8729       goto do_binop;
8730
8731     case RSHIFT_EXPR:
8732       op = (unsignedp ? DW_OP_shr : DW_OP_shra);
8733       goto do_binop;
8734
8735     case PLUS_EXPR:
8736       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
8737           && host_integerp (TREE_OPERAND (loc, 1), 0))
8738         {
8739           ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8740           if (ret == 0)
8741             return 0;
8742
8743           add_loc_descr (&ret,
8744                          new_loc_descr (DW_OP_plus_uconst,
8745                                         tree_low_cst (TREE_OPERAND (loc, 1),
8746                                                       0),
8747                                         0));
8748           break;
8749         }
8750
8751       op = DW_OP_plus;
8752       goto do_binop;
8753
8754     case LE_EXPR:
8755       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8756         return 0;
8757
8758       op = DW_OP_le;
8759       goto do_binop;
8760
8761     case GE_EXPR:
8762       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8763         return 0;
8764
8765       op = DW_OP_ge;
8766       goto do_binop;
8767
8768     case LT_EXPR:
8769       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8770         return 0;
8771
8772       op = DW_OP_lt;
8773       goto do_binop;
8774
8775     case GT_EXPR:
8776       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8777         return 0;
8778
8779       op = DW_OP_gt;
8780       goto do_binop;
8781
8782     case EQ_EXPR:
8783       op = DW_OP_eq;
8784       goto do_binop;
8785
8786     case NE_EXPR:
8787       op = DW_OP_ne;
8788       goto do_binop;
8789
8790     do_binop:
8791       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8792       ret1 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8793       if (ret == 0 || ret1 == 0)
8794         return 0;
8795
8796       add_loc_descr (&ret, ret1);
8797       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8798       break;
8799
8800     case TRUTH_NOT_EXPR:
8801     case BIT_NOT_EXPR:
8802       op = DW_OP_not;
8803       goto do_unop;
8804
8805     case ABS_EXPR:
8806       op = DW_OP_abs;
8807       goto do_unop;
8808
8809     case NEGATE_EXPR:
8810       op = DW_OP_neg;
8811       goto do_unop;
8812
8813     do_unop:
8814       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8815       if (ret == 0)
8816         return 0;
8817
8818       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8819       break;
8820
8821     case MAX_EXPR:
8822       loc = build (COND_EXPR, TREE_TYPE (loc),
8823                    build (LT_EXPR, integer_type_node,
8824                           TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
8825                    TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
8826
8827       /* ... fall through ...  */
8828
8829     case COND_EXPR:
8830       {
8831         dw_loc_descr_ref lhs
8832           = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8833         dw_loc_descr_ref rhs
8834           = loc_descriptor_from_tree (TREE_OPERAND (loc, 2), 0);
8835         dw_loc_descr_ref bra_node, jump_node, tmp;
8836
8837         ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8838         if (ret == 0 || lhs == 0 || rhs == 0)
8839           return 0;
8840
8841         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
8842         add_loc_descr (&ret, bra_node);
8843
8844         add_loc_descr (&ret, rhs);
8845         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
8846         add_loc_descr (&ret, jump_node);
8847
8848         add_loc_descr (&ret, lhs);
8849         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8850         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
8851
8852         /* ??? Need a node to point the skip at.  Use a nop.  */
8853         tmp = new_loc_descr (DW_OP_nop, 0, 0);
8854         add_loc_descr (&ret, tmp);
8855         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8856         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
8857       }
8858       break;
8859
8860     default:
8861       abort ();
8862     }
8863
8864   /* Show if we can't fill the request for an address.  */
8865   if (addressp && indirect_p == 0)
8866     return 0;
8867
8868   /* If we've got an address and don't want one, dereference.  */
8869   if (!addressp && indirect_p > 0)
8870     {
8871       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
8872
8873       if (size > DWARF2_ADDR_SIZE || size == -1)
8874         return 0;
8875       else if (size == DWARF2_ADDR_SIZE)
8876         op = DW_OP_deref;
8877       else
8878         op = DW_OP_deref_size;
8879
8880       add_loc_descr (&ret, new_loc_descr (op, size, 0));
8881     }
8882
8883   return ret;
8884 }
8885
8886 /* Given a value, round it up to the lowest multiple of `boundary'
8887    which is not less than the value itself.  */
8888
8889 static inline HOST_WIDE_INT
8890 ceiling (value, boundary)
8891      HOST_WIDE_INT value;
8892      unsigned int boundary;
8893 {
8894   return (((value + boundary - 1) / boundary) * boundary);
8895 }
8896
8897 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
8898    pointer to the declared type for the relevant field variable, or return
8899    `integer_type_node' if the given node turns out to be an
8900    ERROR_MARK node.  */
8901
8902 static inline tree
8903 field_type (decl)
8904      tree decl;
8905 {
8906   tree type;
8907
8908   if (TREE_CODE (decl) == ERROR_MARK)
8909     return integer_type_node;
8910
8911   type = DECL_BIT_FIELD_TYPE (decl);
8912   if (type == NULL_TREE)
8913     type = TREE_TYPE (decl);
8914
8915   return type;
8916 }
8917
8918 /* Given a pointer to a tree node, return the alignment in bits for
8919    it, or else return BITS_PER_WORD if the node actually turns out to
8920    be an ERROR_MARK node.  */
8921
8922 static inline unsigned
8923 simple_type_align_in_bits (type)
8924      tree type;
8925 {
8926   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
8927 }
8928
8929 static inline unsigned
8930 simple_decl_align_in_bits (decl)
8931      tree decl;
8932 {
8933   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
8934 }
8935
8936 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
8937    lowest addressed byte of the "containing object" for the given FIELD_DECL,
8938    or return 0 if we are unable to determine what that offset is, either
8939    because the argument turns out to be a pointer to an ERROR_MARK node, or
8940    because the offset is actually variable.  (We can't handle the latter case
8941    just yet).  */
8942
8943 static HOST_WIDE_INT
8944 field_byte_offset (decl)
8945      tree decl;
8946 {
8947   unsigned int type_align_in_bits;
8948   unsigned int decl_align_in_bits;
8949   unsigned HOST_WIDE_INT type_size_in_bits;
8950   HOST_WIDE_INT object_offset_in_bits;
8951   tree type;
8952   tree field_size_tree;
8953   HOST_WIDE_INT bitpos_int;
8954   HOST_WIDE_INT deepest_bitpos;
8955   unsigned HOST_WIDE_INT field_size_in_bits;
8956
8957   if (TREE_CODE (decl) == ERROR_MARK)
8958     return 0;
8959   else if (TREE_CODE (decl) != FIELD_DECL)
8960     abort ();
8961
8962   type = field_type (decl);
8963   field_size_tree = DECL_SIZE (decl);
8964
8965   /* The size could be unspecified if there was an error, or for
8966      a flexible array member.  */
8967   if (! field_size_tree)
8968     field_size_tree = bitsize_zero_node;
8969
8970   /* We cannot yet cope with fields whose positions are variable, so
8971      for now, when we see such things, we simply return 0.  Someday, we may
8972      be able to handle such cases, but it will be damn difficult.  */
8973   if (! host_integerp (bit_position (decl), 0))
8974     return 0;
8975
8976   bitpos_int = int_bit_position (decl);
8977
8978   /* If we don't know the size of the field, pretend it's a full word.  */
8979   if (host_integerp (field_size_tree, 1))
8980     field_size_in_bits = tree_low_cst (field_size_tree, 1);
8981   else
8982     field_size_in_bits = BITS_PER_WORD;
8983
8984   type_size_in_bits = simple_type_size_in_bits (type);
8985   type_align_in_bits = simple_type_align_in_bits (type);
8986   decl_align_in_bits = simple_decl_align_in_bits (decl);
8987
8988   /* The GCC front-end doesn't make any attempt to keep track of the starting
8989      bit offset (relative to the start of the containing structure type) of the
8990      hypothetical "containing object" for a bit-field.  Thus, when computing
8991      the byte offset value for the start of the "containing object" of a
8992      bit-field, we must deduce this information on our own. This can be rather
8993      tricky to do in some cases.  For example, handling the following structure
8994      type definition when compiling for an i386/i486 target (which only aligns
8995      long long's to 32-bit boundaries) can be very tricky:
8996
8997          struct S { int field1; long long field2:31; };
8998
8999      Fortunately, there is a simple rule-of-thumb which can be used in such
9000      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9001      structure shown above.  It decides to do this based upon one simple rule
9002      for bit-field allocation.  GCC allocates each "containing object" for each
9003      bit-field at the first (i.e. lowest addressed) legitimate alignment
9004      boundary (based upon the required minimum alignment for the declared type
9005      of the field) which it can possibly use, subject to the condition that
9006      there is still enough available space remaining in the containing object
9007      (when allocated at the selected point) to fully accommodate all of the
9008      bits of the bit-field itself.
9009
9010      This simple rule makes it obvious why GCC allocates 8 bytes for each
9011      object of the structure type shown above.  When looking for a place to
9012      allocate the "containing object" for `field2', the compiler simply tries
9013      to allocate a 64-bit "containing object" at each successive 32-bit
9014      boundary (starting at zero) until it finds a place to allocate that 64-
9015      bit field such that at least 31 contiguous (and previously unallocated)
9016      bits remain within that selected 64 bit field.  (As it turns out, for the
9017      example above, the compiler finds it is OK to allocate the "containing
9018      object" 64-bit field at bit-offset zero within the structure type.)
9019
9020      Here we attempt to work backwards from the limited set of facts we're
9021      given, and we try to deduce from those facts, where GCC must have believed
9022      that the containing object started (within the structure type). The value
9023      we deduce is then used (by the callers of this routine) to generate
9024      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9025      and, in the case of DW_AT_location, regular fields as well).  */
9026
9027   /* Figure out the bit-distance from the start of the structure to the
9028      "deepest" bit of the bit-field.  */
9029   deepest_bitpos = bitpos_int + field_size_in_bits;
9030
9031   /* This is the tricky part.  Use some fancy footwork to deduce where the
9032      lowest addressed bit of the containing object must be.  */
9033   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9034
9035   /* Round up to type_align by default.  This works best for bitfields.  */
9036   object_offset_in_bits += type_align_in_bits - 1;
9037   object_offset_in_bits /= type_align_in_bits;
9038   object_offset_in_bits *= type_align_in_bits;
9039
9040   if (object_offset_in_bits > bitpos_int)
9041     {
9042       /* Sigh, the decl must be packed.  */
9043       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9044
9045       /* Round up to decl_align instead.  */
9046       object_offset_in_bits += decl_align_in_bits - 1;
9047       object_offset_in_bits /= decl_align_in_bits;
9048       object_offset_in_bits *= decl_align_in_bits;
9049     }
9050
9051   return object_offset_in_bits / BITS_PER_UNIT;
9052 }
9053 \f
9054 /* The following routines define various Dwarf attributes and any data
9055    associated with them.  */
9056
9057 /* Add a location description attribute value to a DIE.
9058
9059    This emits location attributes suitable for whole variables and
9060    whole parameters.  Note that the location attributes for struct fields are
9061    generated by the routine `data_member_location_attribute' below.  */
9062
9063 static inline void
9064 add_AT_location_description (die, attr_kind, descr)
9065      dw_die_ref die;
9066      enum dwarf_attribute attr_kind;
9067      dw_loc_descr_ref descr;
9068 {
9069   if (descr != 0)
9070     add_AT_loc (die, attr_kind, descr);
9071 }
9072
9073 /* Attach the specialized form of location attribute used for data members of
9074    struct and union types.  In the special case of a FIELD_DECL node which
9075    represents a bit-field, the "offset" part of this special location
9076    descriptor must indicate the distance in bytes from the lowest-addressed
9077    byte of the containing struct or union type to the lowest-addressed byte of
9078    the "containing object" for the bit-field.  (See the `field_byte_offset'
9079    function above).
9080
9081    For any given bit-field, the "containing object" is a hypothetical object
9082    (of some integral or enum type) within which the given bit-field lives.  The
9083    type of this hypothetical "containing object" is always the same as the
9084    declared type of the individual bit-field itself (for GCC anyway... the
9085    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9086    bytes) of the hypothetical "containing object" which will be given in the
9087    DW_AT_byte_size attribute for this bit-field.  (See the
9088    `byte_size_attribute' function below.)  It is also used when calculating the
9089    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9090    function below.)  */
9091
9092 static void
9093 add_data_member_location_attribute (die, decl)
9094      dw_die_ref die;
9095      tree decl;
9096 {
9097   long offset;
9098   dw_loc_descr_ref loc_descr = 0;
9099
9100   if (TREE_CODE (decl) == TREE_VEC)
9101     {
9102       /* We're working on the TAG_inheritance for a base class.  */
9103       if (TREE_VIA_VIRTUAL (decl) && is_cxx ())
9104         {
9105           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9106              aren't at a fixed offset from all (sub)objects of the same
9107              type.  We need to extract the appropriate offset from our
9108              vtable.  The following dwarf expression means
9109
9110                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9111
9112              This is specific to the V3 ABI, of course.  */
9113
9114           dw_loc_descr_ref tmp;
9115
9116           /* Make a copy of the object address.  */
9117           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9118           add_loc_descr (&loc_descr, tmp);
9119
9120           /* Extract the vtable address.  */
9121           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9122           add_loc_descr (&loc_descr, tmp);
9123
9124           /* Calculate the address of the offset.  */
9125           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9126           if (offset >= 0)
9127             abort ();
9128
9129           tmp = int_loc_descriptor (-offset);
9130           add_loc_descr (&loc_descr, tmp);
9131           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9132           add_loc_descr (&loc_descr, tmp);
9133
9134           /* Extract the offset.  */
9135           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9136           add_loc_descr (&loc_descr, tmp);
9137
9138           /* Add it to the object address.  */
9139           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9140           add_loc_descr (&loc_descr, tmp);
9141         }
9142       else
9143         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9144     }
9145   else
9146     offset = field_byte_offset (decl);
9147
9148   if (! loc_descr)
9149     {
9150       enum dwarf_location_atom op;
9151
9152       /* The DWARF2 standard says that we should assume that the structure
9153          address is already on the stack, so we can specify a structure field
9154          address by using DW_OP_plus_uconst.  */
9155
9156 #ifdef MIPS_DEBUGGING_INFO
9157       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9158          operator correctly.  It works only if we leave the offset on the
9159          stack.  */
9160       op = DW_OP_constu;
9161 #else
9162       op = DW_OP_plus_uconst;
9163 #endif
9164
9165       loc_descr = new_loc_descr (op, offset, 0);
9166     }
9167
9168   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9169 }
9170
9171 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
9172    does not have a "location" either in memory or in a register.  These
9173    things can arise in GNU C when a constant is passed as an actual parameter
9174    to an inlined function.  They can also arise in C++ where declared
9175    constants do not necessarily get memory "homes".  */
9176
9177 static void
9178 add_const_value_attribute (die, rtl)
9179      dw_die_ref die;
9180      rtx rtl;
9181 {
9182   switch (GET_CODE (rtl))
9183     {
9184     case CONST_INT:
9185       /* Note that a CONST_INT rtx could represent either an integer
9186          or a floating-point constant.  A CONST_INT is used whenever
9187          the constant will fit into a single word.  In all such
9188          cases, the original mode of the constant value is wiped
9189          out, and the CONST_INT rtx is assigned VOIDmode.  */
9190       {
9191         HOST_WIDE_INT val = INTVAL (rtl);
9192
9193         /* ??? We really should be using HOST_WIDE_INT throughout.  */
9194         if (val < 0 && (long) val == val)
9195           add_AT_int (die, DW_AT_const_value, (long) val);
9196         else if ((unsigned long) val == (unsigned HOST_WIDE_INT) val)
9197           add_AT_unsigned (die, DW_AT_const_value, (unsigned long) val);
9198         else
9199           {
9200 #if HOST_BITS_PER_LONG * 2 == HOST_BITS_PER_WIDE_INT
9201             add_AT_long_long (die, DW_AT_const_value,
9202                               val >> HOST_BITS_PER_LONG, val);
9203 #else
9204             abort ();
9205 #endif
9206           }
9207       }
9208       break;
9209
9210     case CONST_DOUBLE:
9211       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9212          floating-point constant.  A CONST_DOUBLE is used whenever the
9213          constant requires more than one word in order to be adequately
9214          represented.  We output CONST_DOUBLEs as blocks.  */
9215       {
9216         enum machine_mode mode = GET_MODE (rtl);
9217
9218         if (GET_MODE_CLASS (mode) == MODE_FLOAT)
9219           {
9220             unsigned length = GET_MODE_SIZE (mode) / 4;
9221             long *array = (long *) ggc_alloc (sizeof (long) * length);
9222             REAL_VALUE_TYPE rv;
9223
9224             REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9225             switch (mode)
9226               {
9227               case SFmode:
9228                 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
9229                 break;
9230
9231               case DFmode:
9232                 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
9233                 break;
9234
9235               case XFmode:
9236               case TFmode:
9237                 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
9238                 break;
9239
9240               default:
9241                 abort ();
9242               }
9243
9244             add_AT_float (die, DW_AT_const_value, length, array);
9245           }
9246         else
9247           {
9248             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9249             if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT)
9250               abort ();
9251
9252             add_AT_long_long (die, DW_AT_const_value,
9253                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9254           }
9255       }
9256       break;
9257
9258     case CONST_STRING:
9259       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9260       break;
9261
9262     case SYMBOL_REF:
9263     case LABEL_REF:
9264     case CONST:
9265       add_AT_addr (die, DW_AT_const_value, rtl);
9266       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
9267       break;
9268
9269     case PLUS:
9270       /* In cases where an inlined instance of an inline function is passed
9271          the address of an `auto' variable (which is local to the caller) we
9272          can get a situation where the DECL_RTL of the artificial local
9273          variable (for the inlining) which acts as a stand-in for the
9274          corresponding formal parameter (of the inline function) will look
9275          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9276          exactly a compile-time constant expression, but it isn't the address
9277          of the (artificial) local variable either.  Rather, it represents the
9278          *value* which the artificial local variable always has during its
9279          lifetime.  We currently have no way to represent such quasi-constant
9280          values in Dwarf, so for now we just punt and generate nothing.  */
9281       break;
9282
9283     default:
9284       /* No other kinds of rtx should be possible here.  */
9285       abort ();
9286     }
9287
9288 }
9289
9290 static rtx
9291 rtl_for_decl_location (decl)
9292      tree decl;
9293 {
9294   rtx rtl;
9295
9296   /* Here we have to decide where we are going to say the parameter "lives"
9297      (as far as the debugger is concerned).  We only have a couple of
9298      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9299
9300      DECL_RTL normally indicates where the parameter lives during most of the
9301      activation of the function.  If optimization is enabled however, this
9302      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9303      that the parameter doesn't really live anywhere (as far as the code
9304      generation parts of GCC are concerned) during most of the function's
9305      activation.  That will happen (for example) if the parameter is never
9306      referenced within the function.
9307
9308      We could just generate a location descriptor here for all non-NULL
9309      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9310      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9311      where DECL_RTL is NULL or is a pseudo-reg.
9312
9313      Note however that we can only get away with using DECL_INCOMING_RTL as
9314      a backup substitute for DECL_RTL in certain limited cases.  In cases
9315      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9316      we can be sure that the parameter was passed using the same type as it is
9317      declared to have within the function, and that its DECL_INCOMING_RTL
9318      points us to a place where a value of that type is passed.
9319
9320      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9321      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9322      because in these cases DECL_INCOMING_RTL points us to a value of some
9323      type which is *different* from the type of the parameter itself.  Thus,
9324      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9325      such cases, the debugger would end up (for example) trying to fetch a
9326      `float' from a place which actually contains the first part of a
9327      `double'.  That would lead to really incorrect and confusing
9328      output at debug-time.
9329
9330      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9331      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9332      are a couple of exceptions however.  On little-endian machines we can
9333      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9334      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9335      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9336      when (on a little-endian machine) a non-prototyped function has a
9337      parameter declared to be of type `short' or `char'.  In such cases,
9338      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9339      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9340      passed `int' value.  If the debugger then uses that address to fetch
9341      a `short' or a `char' (on a little-endian machine) the result will be
9342      the correct data, so we allow for such exceptional cases below.
9343
9344      Note that our goal here is to describe the place where the given formal
9345      parameter lives during most of the function's activation (i.e. between the
9346      end of the prologue and the start of the epilogue).  We'll do that as best
9347      as we can. Note however that if the given formal parameter is modified
9348      sometime during the execution of the function, then a stack backtrace (at
9349      debug-time) will show the function as having been called with the *new*
9350      value rather than the value which was originally passed in.  This happens
9351      rarely enough that it is not a major problem, but it *is* a problem, and
9352      I'd like to fix it.
9353
9354      A future version of dwarf2out.c may generate two additional attributes for
9355      any given DW_TAG_formal_parameter DIE which will describe the "passed
9356      type" and the "passed location" for the given formal parameter in addition
9357      to the attributes we now generate to indicate the "declared type" and the
9358      "active location" for each parameter.  This additional set of attributes
9359      could be used by debuggers for stack backtraces. Separately, note that
9360      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9361      This happens (for example) for inlined-instances of inline function formal
9362      parameters which are never referenced.  This really shouldn't be
9363      happening.  All PARM_DECL nodes should get valid non-NULL
9364      DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these
9365      values for inlined instances of inline function parameters, so when we see
9366      such cases, we are just out-of-luck for the time being (until integrate.c
9367      gets fixed).  */
9368
9369   /* Use DECL_RTL as the "location" unless we find something better.  */
9370   rtl = DECL_RTL_IF_SET (decl);
9371
9372   /* When generating abstract instances, ignore everything except
9373      constants, symbols living in memory, and symbols living in
9374      fixed registers.  */
9375   if (! reload_completed)
9376     {
9377       if (rtl
9378           && (CONSTANT_P (rtl)
9379               || (GET_CODE (rtl) == MEM
9380                   && CONSTANT_P (XEXP (rtl, 0)))
9381               || (GET_CODE (rtl) == REG
9382                   && TREE_CODE (decl) == VAR_DECL
9383                   && TREE_STATIC (decl))))
9384         {
9385           rtl = (*targetm.delegitimize_address) (rtl);
9386           return rtl;
9387         }
9388       rtl = NULL_RTX;
9389     }
9390   else if (TREE_CODE (decl) == PARM_DECL)
9391     {
9392       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
9393         {
9394           tree declared_type = type_main_variant (TREE_TYPE (decl));
9395           tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
9396
9397           /* This decl represents a formal parameter which was optimized out.
9398              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9399              all cases where (rtl == NULL_RTX) just below.  */
9400           if (declared_type == passed_type)
9401             rtl = DECL_INCOMING_RTL (decl);
9402           else if (! BYTES_BIG_ENDIAN
9403                    && TREE_CODE (declared_type) == INTEGER_TYPE
9404                    && (GET_MODE_SIZE (TYPE_MODE (declared_type))
9405                        <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
9406             rtl = DECL_INCOMING_RTL (decl);
9407         }
9408
9409       /* If the parm was passed in registers, but lives on the stack, then
9410          make a big endian correction if the mode of the type of the
9411          parameter is not the same as the mode of the rtl.  */
9412       /* ??? This is the same series of checks that are made in dbxout.c before
9413          we reach the big endian correction code there.  It isn't clear if all
9414          of these checks are necessary here, but keeping them all is the safe
9415          thing to do.  */
9416       else if (GET_CODE (rtl) == MEM
9417                && XEXP (rtl, 0) != const0_rtx
9418                && ! CONSTANT_P (XEXP (rtl, 0))
9419                /* Not passed in memory.  */
9420                && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
9421                /* Not passed by invisible reference.  */
9422                && (GET_CODE (XEXP (rtl, 0)) != REG
9423                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
9424                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
9425 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9426                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
9427 #endif
9428                      )
9429                /* Big endian correction check.  */
9430                && BYTES_BIG_ENDIAN
9431                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
9432                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
9433                    < UNITS_PER_WORD))
9434         {
9435           int offset = (UNITS_PER_WORD
9436                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
9437
9438           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
9439                              plus_constant (XEXP (rtl, 0), offset));
9440         }
9441     }
9442
9443   if (rtl != NULL_RTX)
9444     {
9445       rtl = eliminate_regs (rtl, 0, NULL_RTX);
9446 #ifdef LEAF_REG_REMAP
9447       if (current_function_uses_only_leaf_regs)
9448         leaf_renumber_regs_insn (rtl);
9449 #endif
9450     }
9451
9452   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9453      and will have been substituted directly into all expressions that use it.
9454      C does not have such a concept, but C++ and other languages do.  */
9455   else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
9456     {
9457       /* If a variable is initialized with a string constant without embedded
9458          zeros, build CONST_STRING.  */
9459       if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
9460           && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
9461         {
9462           tree arrtype = TREE_TYPE (decl);
9463           tree enttype = TREE_TYPE (arrtype);
9464           tree domain = TYPE_DOMAIN (arrtype);
9465           tree init = DECL_INITIAL (decl);
9466           enum machine_mode mode = TYPE_MODE (enttype);
9467
9468           if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9469               && domain
9470               && integer_zerop (TYPE_MIN_VALUE (domain))
9471               && compare_tree_int (TYPE_MAX_VALUE (domain),
9472                                    TREE_STRING_LENGTH (init) - 1) == 0
9473               && ((size_t) TREE_STRING_LENGTH (init)
9474                   == strlen (TREE_STRING_POINTER (init)) + 1))
9475             rtl = gen_rtx_CONST_STRING (VOIDmode, TREE_STRING_POINTER (init));
9476         }
9477       /* If the initializer is something that we know will expand into an
9478          immediate RTL constant, expand it now.  Expanding anything else
9479          tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9480       else if (TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST
9481                || TREE_CODE (DECL_INITIAL (decl)) == REAL_CST)
9482         {
9483           rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
9484                              EXPAND_INITIALIZER);
9485           /* If expand_expr returns a MEM, it wasn't immediate.  */
9486           if (rtl && GET_CODE (rtl) == MEM)
9487             abort ();
9488         }
9489     }
9490
9491   if (rtl)
9492     rtl = (*targetm.delegitimize_address) (rtl);
9493
9494   /* If we don't look past the constant pool, we risk emitting a
9495      reference to a constant pool entry that isn't referenced from
9496      code, and thus is not emitted.  */
9497   if (rtl)
9498     rtl = avoid_constant_pool_reference (rtl);
9499
9500   return rtl;
9501 }
9502
9503 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
9504    data attribute for a variable or a parameter.  We generate the
9505    DW_AT_const_value attribute only in those cases where the given variable
9506    or parameter does not have a true "location" either in memory or in a
9507    register.  This can happen (for example) when a constant is passed as an
9508    actual argument in a call to an inline function.  (It's possible that
9509    these things can crop up in other ways also.)  Note that one type of
9510    constant value which can be passed into an inlined function is a constant
9511    pointer.  This can happen for example if an actual argument in an inlined
9512    function call evaluates to a compile-time constant address.  */
9513
9514 static void
9515 add_location_or_const_value_attribute (die, decl)
9516      dw_die_ref die;
9517      tree decl;
9518 {
9519   rtx rtl;
9520   dw_loc_descr_ref descr;
9521
9522   if (TREE_CODE (decl) == ERROR_MARK)
9523     return;
9524   else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
9525     abort ();
9526
9527   rtl = rtl_for_decl_location (decl);
9528   if (rtl == NULL_RTX)
9529     return;
9530
9531   switch (GET_CODE (rtl))
9532     {
9533     case ADDRESSOF:
9534       /* The address of a variable that was optimized away;
9535          don't emit anything.  */
9536       break;
9537
9538     case CONST_INT:
9539     case CONST_DOUBLE:
9540     case CONST_STRING:
9541     case SYMBOL_REF:
9542     case LABEL_REF:
9543     case CONST:
9544     case PLUS:
9545       /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
9546       add_const_value_attribute (die, rtl);
9547       break;
9548
9549     case MEM:
9550       if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
9551         {
9552           /* Need loc_descriptor_from_tree since that's where we know
9553              how to handle TLS variables.  Want the object's address
9554              since the top-level DW_AT_location assumes such.  See
9555              the confusion in loc_descriptor for reference.  */
9556           descr = loc_descriptor_from_tree (decl, 1);
9557         }
9558       else
9559         {
9560         case REG:
9561         case SUBREG:
9562         case CONCAT:
9563           descr = loc_descriptor (rtl);
9564         }
9565       add_AT_location_description (die, DW_AT_location, descr);
9566       break;
9567
9568     default:
9569       abort ();
9570     }
9571 }
9572
9573 /* If we don't have a copy of this variable in memory for some reason (such
9574    as a C++ member constant that doesn't have an out-of-line definition),
9575    we should tell the debugger about the constant value.  */
9576
9577 static void
9578 tree_add_const_value_attribute (var_die, decl)
9579      dw_die_ref var_die;
9580      tree decl;
9581 {
9582   tree init = DECL_INITIAL (decl);
9583   tree type = TREE_TYPE (decl);
9584
9585   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init
9586       && initializer_constant_valid_p (init, type) == null_pointer_node)
9587     /* OK */;
9588   else
9589     return;
9590
9591   switch (TREE_CODE (type))
9592     {
9593     case INTEGER_TYPE:
9594       if (host_integerp (init, 0))
9595         add_AT_unsigned (var_die, DW_AT_const_value,
9596                          tree_low_cst (init, 0));
9597       else
9598         add_AT_long_long (var_die, DW_AT_const_value,
9599                           TREE_INT_CST_HIGH (init),
9600                           TREE_INT_CST_LOW (init));
9601       break;
9602
9603     default:;
9604     }
9605 }
9606
9607 /* Generate an DW_AT_name attribute given some string value to be included as
9608    the value of the attribute.  */
9609
9610 static void
9611 add_name_attribute (die, name_string)
9612      dw_die_ref die;
9613      const char *name_string;
9614 {
9615   if (name_string != NULL && *name_string != 0)
9616     {
9617       if (demangle_name_func)
9618         name_string = (*demangle_name_func) (name_string);
9619
9620       add_AT_string (die, DW_AT_name, name_string);
9621     }
9622 }
9623
9624 /* Generate an DW_AT_comp_dir attribute for DIE.  */
9625
9626 static void
9627 add_comp_dir_attribute (die)
9628      dw_die_ref die;
9629 {
9630   const char *wd = getpwd ();
9631   if (wd != NULL)
9632     add_AT_string (die, DW_AT_comp_dir, wd);
9633 }
9634
9635 /* Given a tree node describing an array bound (either lower or upper) output
9636    a representation for that bound.  */
9637
9638 static void
9639 add_bound_info (subrange_die, bound_attr, bound)
9640      dw_die_ref subrange_die;
9641      enum dwarf_attribute bound_attr;
9642      tree bound;
9643 {
9644   switch (TREE_CODE (bound))
9645     {
9646     case ERROR_MARK:
9647       return;
9648
9649     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
9650     case INTEGER_CST:
9651       if (! host_integerp (bound, 0)
9652           || (bound_attr == DW_AT_lower_bound
9653               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
9654                   || (is_fortran () && integer_onep (bound)))))
9655         /* use the default */
9656         ;
9657       else
9658         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
9659       break;
9660
9661     case CONVERT_EXPR:
9662     case NOP_EXPR:
9663     case NON_LVALUE_EXPR:
9664     case VIEW_CONVERT_EXPR:
9665       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
9666       break;
9667
9668     case SAVE_EXPR:
9669       /* If optimization is turned on, the SAVE_EXPRs that describe how to
9670          access the upper bound values may be bogus.  If they refer to a
9671          register, they may only describe how to get at these values at the
9672          points in the generated code right after they have just been
9673          computed.  Worse yet, in the typical case, the upper bound values
9674          will not even *be* computed in the optimized code (though the
9675          number of elements will), so these SAVE_EXPRs are entirely
9676          bogus. In order to compensate for this fact, we check here to see
9677          if optimization is enabled, and if so, we don't add an attribute
9678          for the (unknown and unknowable) upper bound.  This should not
9679          cause too much trouble for existing (stupid?)  debuggers because
9680          they have to deal with empty upper bounds location descriptions
9681          anyway in order to be able to deal with incomplete array types.
9682          Of course an intelligent debugger (GDB?)  should be able to
9683          comprehend that a missing upper bound specification in an array
9684          type used for a storage class `auto' local array variable
9685          indicates that the upper bound is both unknown (at compile- time)
9686          and unknowable (at run-time) due to optimization.
9687
9688          We assume that a MEM rtx is safe because gcc wouldn't put the
9689          value there unless it was going to be used repeatedly in the
9690          function, i.e. for cleanups.  */
9691       if (SAVE_EXPR_RTL (bound)
9692           && (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM))
9693         {
9694           dw_die_ref ctx = lookup_decl_die (current_function_decl);
9695           dw_die_ref decl_die = new_die (DW_TAG_variable, ctx, bound);
9696           rtx loc = SAVE_EXPR_RTL (bound);
9697
9698           /* If the RTL for the SAVE_EXPR is memory, handle the case where
9699              it references an outer function's frame.  */
9700           if (GET_CODE (loc) == MEM)
9701             {
9702               rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
9703
9704               if (XEXP (loc, 0) != new_addr)
9705                 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
9706             }
9707
9708           add_AT_flag (decl_die, DW_AT_artificial, 1);
9709           add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9710           add_AT_location_description (decl_die, DW_AT_location,
9711                                        loc_descriptor (loc));
9712           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9713         }
9714
9715       /* Else leave out the attribute.  */
9716       break;
9717
9718     case VAR_DECL:
9719     case PARM_DECL:
9720       {
9721         dw_die_ref decl_die = lookup_decl_die (bound);
9722
9723         /* ??? Can this happen, or should the variable have been bound
9724            first?  Probably it can, since I imagine that we try to create
9725            the types of parameters in the order in which they exist in
9726            the list, and won't have created a forward reference to a
9727            later parameter.  */
9728         if (decl_die != NULL)
9729           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9730         break;
9731       }
9732
9733     default:
9734       {
9735         /* Otherwise try to create a stack operation procedure to
9736            evaluate the value of the array bound.  */
9737
9738         dw_die_ref ctx, decl_die;
9739         dw_loc_descr_ref loc;
9740
9741         loc = loc_descriptor_from_tree (bound, 0);
9742         if (loc == NULL)
9743           break;
9744
9745         if (current_function_decl == 0)
9746           ctx = comp_unit_die;
9747         else
9748           ctx = lookup_decl_die (current_function_decl);
9749
9750         /* If we weren't able to find a context, it's most likely the case
9751            that we are processing the return type of the function.  So
9752            make a SAVE_EXPR to point to it and have the limbo DIE code
9753            find the proper die.  The save_expr function doesn't always
9754            make a SAVE_EXPR, so do it ourselves.  */
9755         if (ctx == 0)
9756           bound = build (SAVE_EXPR, TREE_TYPE (bound), bound,
9757                          current_function_decl, NULL_TREE);
9758
9759         decl_die = new_die (DW_TAG_variable, ctx, bound);
9760         add_AT_flag (decl_die, DW_AT_artificial, 1);
9761         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9762         add_AT_loc (decl_die, DW_AT_location, loc);
9763
9764         add_AT_die_ref (subrange_die, bound_attr, decl_die);
9765         break;
9766       }
9767     }
9768 }
9769
9770 /* Note that the block of subscript information for an array type also
9771    includes information about the element type of type given array type.  */
9772
9773 static void
9774 add_subscript_info (type_die, type)
9775      dw_die_ref type_die;
9776      tree type;
9777 {
9778 #ifndef MIPS_DEBUGGING_INFO
9779   unsigned dimension_number;
9780 #endif
9781   tree lower, upper;
9782   dw_die_ref subrange_die;
9783
9784   /* The GNU compilers represent multidimensional array types as sequences of
9785      one dimensional array types whose element types are themselves array
9786      types.  Here we squish that down, so that each multidimensional array
9787      type gets only one array_type DIE in the Dwarf debugging info. The draft
9788      Dwarf specification say that we are allowed to do this kind of
9789      compression in C (because there is no difference between an array or
9790      arrays and a multidimensional array in C) but for other source languages
9791      (e.g. Ada) we probably shouldn't do this.  */
9792
9793   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
9794      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
9795      We work around this by disabling this feature.  See also
9796      gen_array_type_die.  */
9797 #ifndef MIPS_DEBUGGING_INFO
9798   for (dimension_number = 0;
9799        TREE_CODE (type) == ARRAY_TYPE;
9800        type = TREE_TYPE (type), dimension_number++)
9801 #endif
9802     {
9803       tree domain = TYPE_DOMAIN (type);
9804
9805       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
9806          and (in GNU C only) variable bounds.  Handle all three forms
9807          here.  */
9808       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
9809       if (domain)
9810         {
9811           /* We have an array type with specified bounds.  */
9812           lower = TYPE_MIN_VALUE (domain);
9813           upper = TYPE_MAX_VALUE (domain);
9814
9815           /* define the index type.  */
9816           if (TREE_TYPE (domain))
9817             {
9818               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
9819                  TREE_TYPE field.  We can't emit debug info for this
9820                  because it is an unnamed integral type.  */
9821               if (TREE_CODE (domain) == INTEGER_TYPE
9822                   && TYPE_NAME (domain) == NULL_TREE
9823                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
9824                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
9825                 ;
9826               else
9827                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
9828                                     type_die);
9829             }
9830
9831           /* ??? If upper is NULL, the array has unspecified length,
9832              but it does have a lower bound.  This happens with Fortran
9833                dimension arr(N:*)
9834              Since the debugger is definitely going to need to know N
9835              to produce useful results, go ahead and output the lower
9836              bound solo, and hope the debugger can cope.  */
9837
9838           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
9839           if (upper)
9840             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
9841         }
9842
9843       /* Otherwise we have an array type with an unspecified length.  The
9844          DWARF-2 spec does not say how to handle this; let's just leave out the
9845          bounds.  */
9846     }
9847 }
9848
9849 static void
9850 add_byte_size_attribute (die, tree_node)
9851      dw_die_ref die;
9852      tree tree_node;
9853 {
9854   unsigned size;
9855
9856   switch (TREE_CODE (tree_node))
9857     {
9858     case ERROR_MARK:
9859       size = 0;
9860       break;
9861     case ENUMERAL_TYPE:
9862     case RECORD_TYPE:
9863     case UNION_TYPE:
9864     case QUAL_UNION_TYPE:
9865       size = int_size_in_bytes (tree_node);
9866       break;
9867     case FIELD_DECL:
9868       /* For a data member of a struct or union, the DW_AT_byte_size is
9869          generally given as the number of bytes normally allocated for an
9870          object of the *declared* type of the member itself.  This is true
9871          even for bit-fields.  */
9872       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
9873       break;
9874     default:
9875       abort ();
9876     }
9877
9878   /* Note that `size' might be -1 when we get to this point.  If it is, that
9879      indicates that the byte size of the entity in question is variable.  We
9880      have no good way of expressing this fact in Dwarf at the present time,
9881      so just let the -1 pass on through.  */
9882   add_AT_unsigned (die, DW_AT_byte_size, size);
9883 }
9884
9885 /* For a FIELD_DECL node which represents a bit-field, output an attribute
9886    which specifies the distance in bits from the highest order bit of the
9887    "containing object" for the bit-field to the highest order bit of the
9888    bit-field itself.
9889
9890    For any given bit-field, the "containing object" is a hypothetical object
9891    (of some integral or enum type) within which the given bit-field lives.  The
9892    type of this hypothetical "containing object" is always the same as the
9893    declared type of the individual bit-field itself.  The determination of the
9894    exact location of the "containing object" for a bit-field is rather
9895    complicated.  It's handled by the `field_byte_offset' function (above).
9896
9897    Note that it is the size (in bytes) of the hypothetical "containing object"
9898    which will be given in the DW_AT_byte_size attribute for this bit-field.
9899    (See `byte_size_attribute' above).  */
9900
9901 static inline void
9902 add_bit_offset_attribute (die, decl)
9903      dw_die_ref die;
9904      tree decl;
9905 {
9906   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
9907   tree type = DECL_BIT_FIELD_TYPE (decl);
9908   HOST_WIDE_INT bitpos_int;
9909   HOST_WIDE_INT highest_order_object_bit_offset;
9910   HOST_WIDE_INT highest_order_field_bit_offset;
9911   HOST_WIDE_INT unsigned bit_offset;
9912
9913   /* Must be a field and a bit field.  */
9914   if (!type
9915       || TREE_CODE (decl) != FIELD_DECL)
9916     abort ();
9917
9918   /* We can't yet handle bit-fields whose offsets are variable, so if we
9919      encounter such things, just return without generating any attribute
9920      whatsoever.  Likewise for variable or too large size.  */
9921   if (! host_integerp (bit_position (decl), 0)
9922       || ! host_integerp (DECL_SIZE (decl), 1))
9923     return;
9924
9925   bitpos_int = int_bit_position (decl);
9926
9927   /* Note that the bit offset is always the distance (in bits) from the
9928      highest-order bit of the "containing object" to the highest-order bit of
9929      the bit-field itself.  Since the "high-order end" of any object or field
9930      is different on big-endian and little-endian machines, the computation
9931      below must take account of these differences.  */
9932   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
9933   highest_order_field_bit_offset = bitpos_int;
9934
9935   if (! BYTES_BIG_ENDIAN)
9936     {
9937       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
9938       highest_order_object_bit_offset += simple_type_size_in_bits (type);
9939     }
9940
9941   bit_offset
9942     = (! BYTES_BIG_ENDIAN
9943        ? highest_order_object_bit_offset - highest_order_field_bit_offset
9944        : highest_order_field_bit_offset - highest_order_object_bit_offset);
9945
9946   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
9947 }
9948
9949 /* For a FIELD_DECL node which represents a bit field, output an attribute
9950    which specifies the length in bits of the given field.  */
9951
9952 static inline void
9953 add_bit_size_attribute (die, decl)
9954      dw_die_ref die;
9955      tree decl;
9956 {
9957   /* Must be a field and a bit field.  */
9958   if (TREE_CODE (decl) != FIELD_DECL
9959       || ! DECL_BIT_FIELD_TYPE (decl))
9960     abort ();
9961
9962   if (host_integerp (DECL_SIZE (decl), 1))
9963     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
9964 }
9965
9966 /* If the compiled language is ANSI C, then add a 'prototyped'
9967    attribute, if arg types are given for the parameters of a function.  */
9968
9969 static inline void
9970 add_prototyped_attribute (die, func_type)
9971      dw_die_ref die;
9972      tree func_type;
9973 {
9974   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
9975       && TYPE_ARG_TYPES (func_type) != NULL)
9976     add_AT_flag (die, DW_AT_prototyped, 1);
9977 }
9978
9979 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
9980    by looking in either the type declaration or object declaration
9981    equate table.  */
9982
9983 static inline void
9984 add_abstract_origin_attribute (die, origin)
9985      dw_die_ref die;
9986      tree origin;
9987 {
9988   dw_die_ref origin_die = NULL;
9989
9990   if (TREE_CODE (origin) != FUNCTION_DECL)
9991     {
9992       /* We may have gotten separated from the block for the inlined
9993          function, if we're in an exception handler or some such; make
9994          sure that the abstract function has been written out.
9995
9996          Doing this for nested functions is wrong, however; functions are
9997          distinct units, and our context might not even be inline.  */
9998       tree fn = origin;
9999
10000       if (TYPE_P (fn))
10001         fn = TYPE_STUB_DECL (fn);
10002
10003       fn = decl_function_context (fn);
10004       if (fn)
10005         dwarf2out_abstract_function (fn);
10006     }
10007
10008   if (DECL_P (origin))
10009     origin_die = lookup_decl_die (origin);
10010   else if (TYPE_P (origin))
10011     origin_die = lookup_type_die (origin);
10012
10013   if (origin_die == NULL)
10014     abort ();
10015
10016   add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10017 }
10018
10019 /* We do not currently support the pure_virtual attribute.  */
10020
10021 static inline void
10022 add_pure_or_virtual_attribute (die, func_decl)
10023      dw_die_ref die;
10024      tree func_decl;
10025 {
10026   if (DECL_VINDEX (func_decl))
10027     {
10028       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10029
10030       if (host_integerp (DECL_VINDEX (func_decl), 0))
10031         add_AT_loc (die, DW_AT_vtable_elem_location,
10032                     new_loc_descr (DW_OP_constu,
10033                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10034                                    0));
10035
10036       /* GNU extension: Record what type this method came from originally.  */
10037       if (debug_info_level > DINFO_LEVEL_TERSE)
10038         add_AT_die_ref (die, DW_AT_containing_type,
10039                         lookup_type_die (DECL_CONTEXT (func_decl)));
10040     }
10041 }
10042 \f
10043 /* Add source coordinate attributes for the given decl.  */
10044
10045 static void
10046 add_src_coords_attributes (die, decl)
10047      dw_die_ref die;
10048      tree decl;
10049 {
10050   unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10051
10052   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10053   add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
10054 }
10055
10056 /* Add an DW_AT_name attribute and source coordinate attribute for the
10057    given decl, but only if it actually has a name.  */
10058
10059 static void
10060 add_name_and_src_coords_attributes (die, decl)
10061      dw_die_ref die;
10062      tree decl;
10063 {
10064   tree decl_name;
10065
10066   decl_name = DECL_NAME (decl);
10067   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10068     {
10069       add_name_attribute (die, dwarf2_name (decl, 0));
10070       if (! DECL_ARTIFICIAL (decl))
10071         add_src_coords_attributes (die, decl);
10072
10073       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10074           && TREE_PUBLIC (decl)
10075           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10076           && !DECL_ABSTRACT (decl))
10077         add_AT_string (die, DW_AT_MIPS_linkage_name,
10078                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10079     }
10080
10081 #ifdef VMS_DEBUGGING_INFO
10082   /* Get the function's name, as described by its RTL.  This may be different
10083      from the DECL_NAME name used in the source file.  */
10084   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10085     {
10086       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10087                    XEXP (DECL_RTL (decl), 0));
10088       VARRAY_PUSH_RTX (used_rtx_varray, XEXP (DECL_RTL (decl), 0));
10089     }
10090 #endif
10091 }
10092
10093 /* Push a new declaration scope.  */
10094
10095 static void
10096 push_decl_scope (scope)
10097      tree scope;
10098 {
10099   VARRAY_PUSH_TREE (decl_scope_table, scope);
10100 }
10101
10102 /* Pop a declaration scope.  */
10103
10104 static inline void
10105 pop_decl_scope ()
10106 {
10107   if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0)
10108     abort ();
10109
10110   VARRAY_POP (decl_scope_table);
10111 }
10112
10113 /* Return the DIE for the scope that immediately contains this type.
10114    Non-named types get global scope.  Named types nested in other
10115    types get their containing scope if it's open, or global scope
10116    otherwise.  All other types (i.e. function-local named types) get
10117    the current active scope.  */
10118
10119 static dw_die_ref
10120 scope_die_for (t, context_die)
10121      tree t;
10122      dw_die_ref context_die;
10123 {
10124   dw_die_ref scope_die = NULL;
10125   tree containing_scope;
10126   int i;
10127
10128   /* Non-types always go in the current scope.  */
10129   if (! TYPE_P (t))
10130     abort ();
10131
10132   containing_scope = TYPE_CONTEXT (t);
10133
10134   /* Ignore namespaces for the moment.  */
10135   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10136     containing_scope = NULL_TREE;
10137
10138   /* Ignore function type "scopes" from the C frontend.  They mean that
10139      a tagged type is local to a parmlist of a function declarator, but
10140      that isn't useful to DWARF.  */
10141   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10142     containing_scope = NULL_TREE;
10143
10144   if (containing_scope == NULL_TREE)
10145     scope_die = comp_unit_die;
10146   else if (TYPE_P (containing_scope))
10147     {
10148       /* For types, we can just look up the appropriate DIE.  But
10149          first we check to see if we're in the middle of emitting it
10150          so we know where the new DIE should go.  */
10151       for (i = VARRAY_ACTIVE_SIZE (decl_scope_table) - 1; i >= 0; --i)
10152         if (VARRAY_TREE (decl_scope_table, i) == containing_scope)
10153           break;
10154
10155       if (i < 0)
10156         {
10157           if (debug_info_level > DINFO_LEVEL_TERSE
10158               && !TREE_ASM_WRITTEN (containing_scope))
10159             abort ();
10160
10161           /* If none of the current dies are suitable, we get file scope.  */
10162           scope_die = comp_unit_die;
10163         }
10164       else
10165         scope_die = lookup_type_die (containing_scope);
10166     }
10167   else
10168     scope_die = context_die;
10169
10170   return scope_die;
10171 }
10172
10173 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10174
10175 static inline int
10176 local_scope_p (context_die)
10177      dw_die_ref context_die;
10178 {
10179   for (; context_die; context_die = context_die->die_parent)
10180     if (context_die->die_tag == DW_TAG_inlined_subroutine
10181         || context_die->die_tag == DW_TAG_subprogram)
10182       return 1;
10183
10184   return 0;
10185 }
10186
10187 /* Returns nonzero if CONTEXT_DIE is a class.  */
10188
10189 static inline int
10190 class_scope_p (context_die)
10191      dw_die_ref context_die;
10192 {
10193   return (context_die
10194           && (context_die->die_tag == DW_TAG_structure_type
10195               || context_die->die_tag == DW_TAG_union_type));
10196 }
10197
10198 /* Many forms of DIEs require a "type description" attribute.  This
10199    routine locates the proper "type descriptor" die for the type given
10200    by 'type', and adds an DW_AT_type attribute below the given die.  */
10201
10202 static void
10203 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
10204      dw_die_ref object_die;
10205      tree type;
10206      int decl_const;
10207      int decl_volatile;
10208      dw_die_ref context_die;
10209 {
10210   enum tree_code code  = TREE_CODE (type);
10211   dw_die_ref type_die  = NULL;
10212
10213   /* ??? If this type is an unnamed subrange type of an integral or
10214      floating-point type, use the inner type.  This is because we have no
10215      support for unnamed types in base_type_die.  This can happen if this is
10216      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10217   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10218       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10219     type = TREE_TYPE (type), code = TREE_CODE (type);
10220
10221   if (code == ERROR_MARK
10222       /* Handle a special case.  For functions whose return type is void, we
10223          generate *no* type attribute.  (Note that no object may have type
10224          `void', so this only applies to function return types).  */
10225       || code == VOID_TYPE)
10226     return;
10227
10228   type_die = modified_type_die (type,
10229                                 decl_const || TYPE_READONLY (type),
10230                                 decl_volatile || TYPE_VOLATILE (type),
10231                                 context_die);
10232
10233   if (type_die != NULL)
10234     add_AT_die_ref (object_die, DW_AT_type, type_die);
10235 }
10236
10237 /* Given a tree pointer to a struct, class, union, or enum type node, return
10238    a pointer to the (string) tag name for the given type, or zero if the type
10239    was declared without a tag.  */
10240
10241 static const char *
10242 type_tag (type)
10243      tree type;
10244 {
10245   const char *name = 0;
10246
10247   if (TYPE_NAME (type) != 0)
10248     {
10249       tree t = 0;
10250
10251       /* Find the IDENTIFIER_NODE for the type name.  */
10252       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
10253         t = TYPE_NAME (type);
10254
10255       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10256          a TYPE_DECL node, regardless of whether or not a `typedef' was
10257          involved.  */
10258       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10259                && ! DECL_IGNORED_P (TYPE_NAME (type)))
10260         t = DECL_NAME (TYPE_NAME (type));
10261
10262       /* Now get the name as a string, or invent one.  */
10263       if (t != 0)
10264         name = IDENTIFIER_POINTER (t);
10265     }
10266
10267   return (name == 0 || *name == '\0') ? 0 : name;
10268 }
10269
10270 /* Return the type associated with a data member, make a special check
10271    for bit field types.  */
10272
10273 static inline tree
10274 member_declared_type (member)
10275      tree member;
10276 {
10277   return (DECL_BIT_FIELD_TYPE (member)
10278           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
10279 }
10280
10281 /* Get the decl's label, as described by its RTL. This may be different
10282    from the DECL_NAME name used in the source file.  */
10283
10284 #if 0
10285 static const char *
10286 decl_start_label (decl)
10287      tree decl;
10288 {
10289   rtx x;
10290   const char *fnname;
10291
10292   x = DECL_RTL (decl);
10293   if (GET_CODE (x) != MEM)
10294     abort ();
10295
10296   x = XEXP (x, 0);
10297   if (GET_CODE (x) != SYMBOL_REF)
10298     abort ();
10299
10300   fnname = XSTR (x, 0);
10301   return fnname;
10302 }
10303 #endif
10304 \f
10305 /* These routines generate the internal representation of the DIE's for
10306    the compilation unit.  Debugging information is collected by walking
10307    the declaration trees passed in from dwarf2out_decl().  */
10308
10309 static void
10310 gen_array_type_die (type, context_die)
10311      tree type;
10312      dw_die_ref context_die;
10313 {
10314   dw_die_ref scope_die = scope_die_for (type, context_die);
10315   dw_die_ref array_die;
10316   tree element_type;
10317
10318   /* ??? The SGI dwarf reader fails for array of array of enum types unless
10319      the inner array type comes before the outer array type.  Thus we must
10320      call gen_type_die before we call new_die.  See below also.  */
10321 #ifdef MIPS_DEBUGGING_INFO
10322   gen_type_die (TREE_TYPE (type), context_die);
10323 #endif
10324
10325   array_die = new_die (DW_TAG_array_type, scope_die, type);
10326   add_name_attribute (array_die, type_tag (type));
10327   equate_type_number_to_die (type, array_die);
10328
10329   if (TREE_CODE (type) == VECTOR_TYPE)
10330     {
10331       /* The frontend feeds us a representation for the vector as a struct
10332          containing an array.  Pull out the array type.  */
10333       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
10334       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
10335     }
10336
10337 #if 0
10338   /* We default the array ordering.  SDB will probably do
10339      the right things even if DW_AT_ordering is not present.  It's not even
10340      an issue until we start to get into multidimensional arrays anyway.  If
10341      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10342      then we'll have to put the DW_AT_ordering attribute back in.  (But if
10343      and when we find out that we need to put these in, we will only do so
10344      for multidimensional arrays.  */
10345   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
10346 #endif
10347
10348 #ifdef MIPS_DEBUGGING_INFO
10349   /* The SGI compilers handle arrays of unknown bound by setting
10350      AT_declaration and not emitting any subrange DIEs.  */
10351   if (! TYPE_DOMAIN (type))
10352     add_AT_unsigned (array_die, DW_AT_declaration, 1);
10353   else
10354 #endif
10355     add_subscript_info (array_die, type);
10356
10357   /* Add representation of the type of the elements of this array type.  */
10358   element_type = TREE_TYPE (type);
10359
10360   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10361      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10362      We work around this by disabling this feature.  See also
10363      add_subscript_info.  */
10364 #ifndef MIPS_DEBUGGING_INFO
10365   while (TREE_CODE (element_type) == ARRAY_TYPE)
10366     element_type = TREE_TYPE (element_type);
10367
10368   gen_type_die (element_type, context_die);
10369 #endif
10370
10371   add_type_attribute (array_die, element_type, 0, 0, context_die);
10372 }
10373
10374 static void
10375 gen_set_type_die (type, context_die)
10376      tree type;
10377      dw_die_ref context_die;
10378 {
10379   dw_die_ref type_die
10380     = new_die (DW_TAG_set_type, scope_die_for (type, context_die), type);
10381
10382   equate_type_number_to_die (type, type_die);
10383   add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
10384 }
10385
10386 #if 0
10387 static void
10388 gen_entry_point_die (decl, context_die)
10389      tree decl;
10390      dw_die_ref context_die;
10391 {
10392   tree origin = decl_ultimate_origin (decl);
10393   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
10394
10395   if (origin != NULL)
10396     add_abstract_origin_attribute (decl_die, origin);
10397   else
10398     {
10399       add_name_and_src_coords_attributes (decl_die, decl);
10400       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
10401                           0, 0, context_die);
10402     }
10403
10404   if (DECL_ABSTRACT (decl))
10405     equate_decl_number_to_die (decl, decl_die);
10406   else
10407     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
10408 }
10409 #endif
10410
10411 /* Walk through the list of incomplete types again, trying once more to
10412    emit full debugging info for them.  */
10413
10414 static void
10415 retry_incomplete_types ()
10416 {
10417   int i;
10418
10419   for (i = VARRAY_ACTIVE_SIZE (incomplete_types) - 1; i >= 0; i--)
10420     gen_type_die (VARRAY_TREE (incomplete_types, i), comp_unit_die);
10421 }
10422
10423 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
10424
10425 static void
10426 gen_inlined_enumeration_type_die (type, context_die)
10427      tree type;
10428      dw_die_ref context_die;
10429 {
10430   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
10431
10432   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10433      be incomplete and such types are not marked.  */
10434   add_abstract_origin_attribute (type_die, type);
10435 }
10436
10437 /* Generate a DIE to represent an inlined instance of a structure type.  */
10438
10439 static void
10440 gen_inlined_structure_type_die (type, context_die)
10441      tree type;
10442      dw_die_ref context_die;
10443 {
10444   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
10445
10446   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10447      be incomplete and such types are not marked.  */
10448   add_abstract_origin_attribute (type_die, type);
10449 }
10450
10451 /* Generate a DIE to represent an inlined instance of a union type.  */
10452
10453 static void
10454 gen_inlined_union_type_die (type, context_die)
10455      tree type;
10456      dw_die_ref context_die;
10457 {
10458   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
10459
10460   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10461      be incomplete and such types are not marked.  */
10462   add_abstract_origin_attribute (type_die, type);
10463 }
10464
10465 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
10466    include all of the information about the enumeration values also. Each
10467    enumerated type name/value is listed as a child of the enumerated type
10468    DIE.  */
10469
10470 static void
10471 gen_enumeration_type_die (type, context_die)
10472      tree type;
10473      dw_die_ref context_die;
10474 {
10475   dw_die_ref type_die = lookup_type_die (type);
10476
10477   if (type_die == NULL)
10478     {
10479       type_die = new_die (DW_TAG_enumeration_type,
10480                           scope_die_for (type, context_die), type);
10481       equate_type_number_to_die (type, type_die);
10482       add_name_attribute (type_die, type_tag (type));
10483     }
10484   else if (! TYPE_SIZE (type))
10485     return;
10486   else
10487     remove_AT (type_die, DW_AT_declaration);
10488
10489   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
10490      given enum type is incomplete, do not generate the DW_AT_byte_size
10491      attribute or the DW_AT_element_list attribute.  */
10492   if (TYPE_SIZE (type))
10493     {
10494       tree link;
10495
10496       TREE_ASM_WRITTEN (type) = 1;
10497       add_byte_size_attribute (type_die, type);
10498       if (TYPE_STUB_DECL (type) != NULL_TREE)
10499         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
10500
10501       /* If the first reference to this type was as the return type of an
10502          inline function, then it may not have a parent.  Fix this now.  */
10503       if (type_die->die_parent == NULL)
10504         add_child_die (scope_die_for (type, context_die), type_die);
10505
10506       for (link = TYPE_FIELDS (type);
10507            link != NULL; link = TREE_CHAIN (link))
10508         {
10509           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
10510
10511           add_name_attribute (enum_die,
10512                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
10513
10514           if (host_integerp (TREE_VALUE (link), 0))
10515             {
10516               if (tree_int_cst_sgn (TREE_VALUE (link)) < 0)
10517                 add_AT_int (enum_die, DW_AT_const_value,
10518                             tree_low_cst (TREE_VALUE (link), 0));
10519               else
10520                 add_AT_unsigned (enum_die, DW_AT_const_value,
10521                                  tree_low_cst (TREE_VALUE (link), 0));
10522             }
10523         }
10524     }
10525   else
10526     add_AT_flag (type_die, DW_AT_declaration, 1);
10527 }
10528
10529 /* Generate a DIE to represent either a real live formal parameter decl or to
10530    represent just the type of some formal parameter position in some function
10531    type.
10532
10533    Note that this routine is a bit unusual because its argument may be a
10534    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10535    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10536    node.  If it's the former then this function is being called to output a
10537    DIE to represent a formal parameter object (or some inlining thereof).  If
10538    it's the latter, then this function is only being called to output a
10539    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10540    argument type of some subprogram type.  */
10541
10542 static dw_die_ref
10543 gen_formal_parameter_die (node, context_die)
10544      tree node;
10545      dw_die_ref context_die;
10546 {
10547   dw_die_ref parm_die
10548     = new_die (DW_TAG_formal_parameter, context_die, node);
10549   tree origin;
10550
10551   switch (TREE_CODE_CLASS (TREE_CODE (node)))
10552     {
10553     case 'd':
10554       origin = decl_ultimate_origin (node);
10555       if (origin != NULL)
10556         add_abstract_origin_attribute (parm_die, origin);
10557       else
10558         {
10559           add_name_and_src_coords_attributes (parm_die, node);
10560           add_type_attribute (parm_die, TREE_TYPE (node),
10561                               TREE_READONLY (node),
10562                               TREE_THIS_VOLATILE (node),
10563                               context_die);
10564           if (DECL_ARTIFICIAL (node))
10565             add_AT_flag (parm_die, DW_AT_artificial, 1);
10566         }
10567
10568       equate_decl_number_to_die (node, parm_die);
10569       if (! DECL_ABSTRACT (node))
10570         add_location_or_const_value_attribute (parm_die, node);
10571
10572       break;
10573
10574     case 't':
10575       /* We were called with some kind of a ..._TYPE node.  */
10576       add_type_attribute (parm_die, node, 0, 0, context_die);
10577       break;
10578
10579     default:
10580       abort ();
10581     }
10582
10583   return parm_die;
10584 }
10585
10586 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10587    at the end of an (ANSI prototyped) formal parameters list.  */
10588
10589 static void
10590 gen_unspecified_parameters_die (decl_or_type, context_die)
10591      tree decl_or_type;
10592      dw_die_ref context_die;
10593 {
10594   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
10595 }
10596
10597 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10598    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10599    parameters as specified in some function type specification (except for
10600    those which appear as part of a function *definition*).  */
10601
10602 static void
10603 gen_formal_types_die (function_or_method_type, context_die)
10604      tree function_or_method_type;
10605      dw_die_ref context_die;
10606 {
10607   tree link;
10608   tree formal_type = NULL;
10609   tree first_parm_type;
10610   tree arg;
10611
10612   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
10613     {
10614       arg = DECL_ARGUMENTS (function_or_method_type);
10615       function_or_method_type = TREE_TYPE (function_or_method_type);
10616     }
10617   else
10618     arg = NULL_TREE;
10619
10620   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
10621
10622   /* Make our first pass over the list of formal parameter types and output a
10623      DW_TAG_formal_parameter DIE for each one.  */
10624   for (link = first_parm_type; link; )
10625     {
10626       dw_die_ref parm_die;
10627
10628       formal_type = TREE_VALUE (link);
10629       if (formal_type == void_type_node)
10630         break;
10631
10632       /* Output a (nameless) DIE to represent the formal parameter itself.  */
10633       parm_die = gen_formal_parameter_die (formal_type, context_die);
10634       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
10635            && link == first_parm_type)
10636           || (arg && DECL_ARTIFICIAL (arg)))
10637         add_AT_flag (parm_die, DW_AT_artificial, 1);
10638
10639       link = TREE_CHAIN (link);
10640       if (arg)
10641         arg = TREE_CHAIN (arg);
10642     }
10643
10644   /* If this function type has an ellipsis, add a
10645      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
10646   if (formal_type != void_type_node)
10647     gen_unspecified_parameters_die (function_or_method_type, context_die);
10648
10649   /* Make our second (and final) pass over the list of formal parameter types
10650      and output DIEs to represent those types (as necessary).  */
10651   for (link = TYPE_ARG_TYPES (function_or_method_type);
10652        link && TREE_VALUE (link);
10653        link = TREE_CHAIN (link))
10654     gen_type_die (TREE_VALUE (link), context_die);
10655 }
10656
10657 /* We want to generate the DIE for TYPE so that we can generate the
10658    die for MEMBER, which has been defined; we will need to refer back
10659    to the member declaration nested within TYPE.  If we're trying to
10660    generate minimal debug info for TYPE, processing TYPE won't do the
10661    trick; we need to attach the member declaration by hand.  */
10662
10663 static void
10664 gen_type_die_for_member (type, member, context_die)
10665      tree type, member;
10666      dw_die_ref context_die;
10667 {
10668   gen_type_die (type, context_die);
10669
10670   /* If we're trying to avoid duplicate debug info, we may not have
10671      emitted the member decl for this function.  Emit it now.  */
10672   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
10673       && ! lookup_decl_die (member))
10674     {
10675       if (decl_ultimate_origin (member))
10676         abort ();
10677
10678       push_decl_scope (type);
10679       if (TREE_CODE (member) == FUNCTION_DECL)
10680         gen_subprogram_die (member, lookup_type_die (type));
10681       else
10682         gen_variable_die (member, lookup_type_die (type));
10683
10684       pop_decl_scope ();
10685     }
10686 }
10687
10688 /* Generate the DWARF2 info for the "abstract" instance of a function which we
10689    may later generate inlined and/or out-of-line instances of.  */
10690
10691 static void
10692 dwarf2out_abstract_function (decl)
10693      tree decl;
10694 {
10695   dw_die_ref old_die;
10696   tree save_fn;
10697   tree context;
10698   int was_abstract = DECL_ABSTRACT (decl);
10699
10700   /* Make sure we have the actual abstract inline, not a clone.  */
10701   decl = DECL_ORIGIN (decl);
10702
10703   old_die = lookup_decl_die (decl);
10704   if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
10705     /* We've already generated the abstract instance.  */
10706     return;
10707
10708   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
10709      we don't get confused by DECL_ABSTRACT.  */
10710   if (debug_info_level > DINFO_LEVEL_TERSE)
10711     {
10712       context = decl_class_context (decl);
10713       if (context)
10714         gen_type_die_for_member
10715           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
10716     }
10717
10718   /* Pretend we've just finished compiling this function.  */
10719   save_fn = current_function_decl;
10720   current_function_decl = decl;
10721
10722   set_decl_abstract_flags (decl, 1);
10723   dwarf2out_decl (decl);
10724   if (! was_abstract)
10725     set_decl_abstract_flags (decl, 0);
10726
10727   current_function_decl = save_fn;
10728 }
10729
10730 /* Generate a DIE to represent a declared function (either file-scope or
10731    block-local).  */
10732
10733 static void
10734 gen_subprogram_die (decl, context_die)
10735      tree decl;
10736      dw_die_ref context_die;
10737 {
10738   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10739   tree origin = decl_ultimate_origin (decl);
10740   dw_die_ref subr_die;
10741   rtx fp_reg;
10742   tree fn_arg_types;
10743   tree outer_scope;
10744   dw_die_ref old_die = lookup_decl_die (decl);
10745   int declaration = (current_function_decl != decl
10746                      || class_scope_p (context_die));
10747
10748   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
10749      started to generate the abstract instance of an inline, decided to output
10750      its containing class, and proceeded to emit the declaration of the inline
10751      from the member list for the class.  If so, DECLARATION takes priority;
10752      we'll get back to the abstract instance when done with the class.  */
10753
10754   /* The class-scope declaration DIE must be the primary DIE.  */
10755   if (origin && declaration && class_scope_p (context_die))
10756     {
10757       origin = NULL;
10758       if (old_die)
10759         abort ();
10760     }
10761
10762   if (origin != NULL)
10763     {
10764       if (declaration && ! local_scope_p (context_die))
10765         abort ();
10766
10767       /* Fixup die_parent for the abstract instance of a nested
10768          inline function.  */
10769       if (old_die && old_die->die_parent == NULL)
10770         add_child_die (context_die, old_die);
10771
10772       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10773       add_abstract_origin_attribute (subr_die, origin);
10774     }
10775   else if (old_die)
10776     {
10777       unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10778
10779       if (!get_AT_flag (old_die, DW_AT_declaration)
10780           /* We can have a normal definition following an inline one in the
10781              case of redefinition of GNU C extern inlines.
10782              It seems reasonable to use AT_specification in this case.  */
10783           && !get_AT_unsigned (old_die, DW_AT_inline))
10784         {
10785           /* ??? This can happen if there is a bug in the program, for
10786              instance, if it has duplicate function definitions.  Ideally,
10787              we should detect this case and ignore it.  For now, if we have
10788              already reported an error, any error at all, then assume that
10789              we got here because of an input error, not a dwarf2 bug.  */
10790           if (errorcount)
10791             return;
10792           abort ();
10793         }
10794
10795       /* If the definition comes from the same place as the declaration,
10796          maybe use the old DIE.  We always want the DIE for this function
10797          that has the *_pc attributes to be under comp_unit_die so the
10798          debugger can find it.  We also need to do this for abstract
10799          instances of inlines, since the spec requires the out-of-line copy
10800          to have the same parent.  For local class methods, this doesn't
10801          apply; we just use the old DIE.  */
10802       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
10803           && (DECL_ARTIFICIAL (decl)
10804               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
10805                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
10806                       == (unsigned) DECL_SOURCE_LINE (decl)))))
10807         {
10808           subr_die = old_die;
10809
10810           /* Clear out the declaration attribute and the parm types.  */
10811           remove_AT (subr_die, DW_AT_declaration);
10812           remove_children (subr_die);
10813         }
10814       else
10815         {
10816           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10817           add_AT_die_ref (subr_die, DW_AT_specification, old_die);
10818           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
10819             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
10820           if (get_AT_unsigned (old_die, DW_AT_decl_line)
10821               != (unsigned) DECL_SOURCE_LINE (decl))
10822             add_AT_unsigned
10823               (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
10824         }
10825     }
10826   else
10827     {
10828       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10829
10830       if (TREE_PUBLIC (decl))
10831         add_AT_flag (subr_die, DW_AT_external, 1);
10832
10833       add_name_and_src_coords_attributes (subr_die, decl);
10834       if (debug_info_level > DINFO_LEVEL_TERSE)
10835         {
10836           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
10837           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
10838                               0, 0, context_die);
10839         }
10840
10841       add_pure_or_virtual_attribute (subr_die, decl);
10842       if (DECL_ARTIFICIAL (decl))
10843         add_AT_flag (subr_die, DW_AT_artificial, 1);
10844
10845       if (TREE_PROTECTED (decl))
10846         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
10847       else if (TREE_PRIVATE (decl))
10848         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
10849     }
10850
10851   if (declaration)
10852     {
10853       if (!old_die || !get_AT_unsigned (old_die, DW_AT_inline))
10854         {
10855           add_AT_flag (subr_die, DW_AT_declaration, 1);
10856
10857           /* The first time we see a member function, it is in the context of
10858              the class to which it belongs.  We make sure of this by emitting
10859              the class first.  The next time is the definition, which is
10860              handled above.  The two may come from the same source text.  */
10861           if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
10862             equate_decl_number_to_die (decl, subr_die);
10863         }
10864     }
10865   else if (DECL_ABSTRACT (decl))
10866     {
10867       if (DECL_INLINE (decl) && !flag_no_inline)
10868         {
10869           /* ??? Checking DECL_DEFER_OUTPUT is correct for static
10870              inline functions, but not for extern inline functions.
10871              We can't get this completely correct because information
10872              about whether the function was declared inline is not
10873              saved anywhere.  */
10874           if (DECL_DEFER_OUTPUT (decl))
10875             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
10876           else
10877             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
10878         }
10879       else
10880         add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
10881
10882       equate_decl_number_to_die (decl, subr_die);
10883     }
10884   else if (!DECL_EXTERNAL (decl))
10885     {
10886       if (!old_die || !get_AT_unsigned (old_die, DW_AT_inline))
10887         equate_decl_number_to_die (decl, subr_die);
10888
10889       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
10890                                    current_function_funcdef_no);
10891       add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
10892       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10893                                    current_function_funcdef_no);
10894       add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
10895
10896       add_pubname (decl, subr_die);
10897       add_arange (decl, subr_die);
10898
10899 #ifdef MIPS_DEBUGGING_INFO
10900       /* Add a reference to the FDE for this routine.  */
10901       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
10902 #endif
10903
10904       /* Define the "frame base" location for this routine.  We use the
10905          frame pointer or stack pointer registers, since the RTL for local
10906          variables is relative to one of them.  */
10907       fp_reg
10908         = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
10909       add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
10910
10911 #if 0
10912       /* ??? This fails for nested inline functions, because context_display
10913          is not part of the state saved/restored for inline functions.  */
10914       if (current_function_needs_context)
10915         add_AT_location_description (subr_die, DW_AT_static_link,
10916                              loc_descriptor (lookup_static_chain (decl)));
10917 #endif
10918     }
10919
10920   /* Now output descriptions of the arguments for this function. This gets
10921      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
10922      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
10923      `...' at the end of the formal parameter list.  In order to find out if
10924      there was a trailing ellipsis or not, we must instead look at the type
10925      associated with the FUNCTION_DECL.  This will be a node of type
10926      FUNCTION_TYPE. If the chain of type nodes hanging off of this
10927      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
10928      an ellipsis at the end.  */
10929
10930   /* In the case where we are describing a mere function declaration, all we
10931      need to do here (and all we *can* do here) is to describe the *types* of
10932      its formal parameters.  */
10933   if (debug_info_level <= DINFO_LEVEL_TERSE)
10934     ;
10935   else if (declaration)
10936     gen_formal_types_die (decl, subr_die);
10937   else
10938     {
10939       /* Generate DIEs to represent all known formal parameters */
10940       tree arg_decls = DECL_ARGUMENTS (decl);
10941       tree parm;
10942
10943       /* When generating DIEs, generate the unspecified_parameters DIE
10944          instead if we come across the arg "__builtin_va_alist" */
10945       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
10946         if (TREE_CODE (parm) == PARM_DECL)
10947           {
10948             if (DECL_NAME (parm)
10949                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
10950                             "__builtin_va_alist"))
10951               gen_unspecified_parameters_die (parm, subr_die);
10952             else
10953               gen_decl_die (parm, subr_die);
10954           }
10955
10956       /* Decide whether we need an unspecified_parameters DIE at the end.
10957          There are 2 more cases to do this for: 1) the ansi ... declaration -
10958          this is detectable when the end of the arg list is not a
10959          void_type_node 2) an unprototyped function declaration (not a
10960          definition).  This just means that we have no info about the
10961          parameters at all.  */
10962       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
10963       if (fn_arg_types != NULL)
10964         {
10965           /* this is the prototyped case, check for ...  */
10966           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
10967             gen_unspecified_parameters_die (decl, subr_die);
10968         }
10969       else if (DECL_INITIAL (decl) == NULL_TREE)
10970         gen_unspecified_parameters_die (decl, subr_die);
10971     }
10972
10973   /* Output Dwarf info for all of the stuff within the body of the function
10974      (if it has one - it may be just a declaration).  */
10975   outer_scope = DECL_INITIAL (decl);
10976
10977   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
10978      a function.  This BLOCK actually represents the outermost binding contour
10979      for the function, i.e. the contour in which the function's formal
10980      parameters and labels get declared. Curiously, it appears that the front
10981      end doesn't actually put the PARM_DECL nodes for the current function onto
10982      the BLOCK_VARS list for this outer scope, but are strung off of the
10983      DECL_ARGUMENTS list for the function instead.
10984
10985      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
10986      the LABEL_DECL nodes for the function however, and we output DWARF info
10987      for those in decls_for_scope.  Just within the `outer_scope' there will be
10988      a BLOCK node representing the function's outermost pair of curly braces,
10989      and any blocks used for the base and member initializers of a C++
10990      constructor function.  */
10991   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
10992     {
10993       current_function_has_inlines = 0;
10994       decls_for_scope (outer_scope, subr_die, 0);
10995
10996 #if 0 && defined (MIPS_DEBUGGING_INFO)
10997       if (current_function_has_inlines)
10998         {
10999           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11000           if (! comp_unit_has_inlines)
11001             {
11002               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11003               comp_unit_has_inlines = 1;
11004             }
11005         }
11006 #endif
11007     }
11008 }
11009
11010 /* Generate a DIE to represent a declared data object.  */
11011
11012 static void
11013 gen_variable_die (decl, context_die)
11014      tree decl;
11015      dw_die_ref context_die;
11016 {
11017   tree origin = decl_ultimate_origin (decl);
11018   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11019
11020   dw_die_ref old_die = lookup_decl_die (decl);
11021   int declaration = (DECL_EXTERNAL (decl)
11022                      || class_scope_p (context_die));
11023
11024   if (origin != NULL)
11025     add_abstract_origin_attribute (var_die, origin);
11026
11027   /* Loop unrolling can create multiple blocks that refer to the same
11028      static variable, so we must test for the DW_AT_declaration flag.
11029
11030      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11031      copy decls and set the DECL_ABSTRACT flag on them instead of
11032      sharing them.
11033
11034      ??? Duplicated blocks have been rewritten to use .debug_ranges.  */
11035   else if (old_die && TREE_STATIC (decl)
11036            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11037     {
11038       /* This is a definition of a C++ class level static.  */
11039       add_AT_die_ref (var_die, DW_AT_specification, old_die);
11040       if (DECL_NAME (decl))
11041         {
11042           unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
11043
11044           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11045             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11046
11047           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11048               != (unsigned) DECL_SOURCE_LINE (decl))
11049
11050             add_AT_unsigned (var_die, DW_AT_decl_line,
11051                              DECL_SOURCE_LINE (decl));
11052         }
11053     }
11054   else
11055     {
11056       add_name_and_src_coords_attributes (var_die, decl);
11057       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11058                           TREE_THIS_VOLATILE (decl), context_die);
11059
11060       if (TREE_PUBLIC (decl))
11061         add_AT_flag (var_die, DW_AT_external, 1);
11062
11063       if (DECL_ARTIFICIAL (decl))
11064         add_AT_flag (var_die, DW_AT_artificial, 1);
11065
11066       if (TREE_PROTECTED (decl))
11067         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11068       else if (TREE_PRIVATE (decl))
11069         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11070     }
11071
11072   if (declaration)
11073     add_AT_flag (var_die, DW_AT_declaration, 1);
11074
11075   if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
11076     equate_decl_number_to_die (decl, var_die);
11077
11078   if (! declaration && ! DECL_ABSTRACT (decl))
11079     {
11080       add_location_or_const_value_attribute (var_die, decl);
11081       add_pubname (decl, var_die);
11082     }
11083   else
11084     tree_add_const_value_attribute (var_die, decl);
11085 }
11086
11087 /* Generate a DIE to represent a label identifier.  */
11088
11089 static void
11090 gen_label_die (decl, context_die)
11091      tree decl;
11092      dw_die_ref context_die;
11093 {
11094   tree origin = decl_ultimate_origin (decl);
11095   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11096   rtx insn;
11097   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11098
11099   if (origin != NULL)
11100     add_abstract_origin_attribute (lbl_die, origin);
11101   else
11102     add_name_and_src_coords_attributes (lbl_die, decl);
11103
11104   if (DECL_ABSTRACT (decl))
11105     equate_decl_number_to_die (decl, lbl_die);
11106   else
11107     {
11108       insn = DECL_RTL (decl);
11109
11110       /* Deleted labels are programmer specified labels which have been
11111          eliminated because of various optimisations.  We still emit them
11112          here so that it is possible to put breakpoints on them.  */
11113       if (GET_CODE (insn) == CODE_LABEL
11114           || ((GET_CODE (insn) == NOTE
11115                && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
11116         {
11117           /* When optimization is enabled (via -O) some parts of the compiler
11118              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11119              represent source-level labels which were explicitly declared by
11120              the user.  This really shouldn't be happening though, so catch
11121              it if it ever does happen.  */
11122           if (INSN_DELETED_P (insn))
11123             abort ();
11124
11125           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11126           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11127         }
11128     }
11129 }
11130
11131 /* Generate a DIE for a lexical block.  */
11132
11133 static void
11134 gen_lexical_block_die (stmt, context_die, depth)
11135      tree stmt;
11136      dw_die_ref context_die;
11137      int depth;
11138 {
11139   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
11140   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11141
11142   if (! BLOCK_ABSTRACT (stmt))
11143     {
11144       if (BLOCK_FRAGMENT_CHAIN (stmt))
11145         {
11146           tree chain;
11147
11148           add_AT_range_list (stmt_die, DW_AT_ranges, add_ranges (stmt));
11149
11150           chain = BLOCK_FRAGMENT_CHAIN (stmt);
11151           do
11152             {
11153               add_ranges (chain);
11154               chain = BLOCK_FRAGMENT_CHAIN (chain);
11155             }
11156           while (chain);
11157           add_ranges (NULL);
11158         }
11159       else
11160         {
11161           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11162                                        BLOCK_NUMBER (stmt));
11163           add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
11164           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11165                                        BLOCK_NUMBER (stmt));
11166           add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
11167         }
11168     }
11169
11170   decls_for_scope (stmt, stmt_die, depth);
11171 }
11172
11173 /* Generate a DIE for an inlined subprogram.  */
11174
11175 static void
11176 gen_inlined_subroutine_die (stmt, context_die, depth)
11177      tree stmt;
11178      dw_die_ref context_die;
11179      int depth;
11180 {
11181   if (! BLOCK_ABSTRACT (stmt))
11182     {
11183       dw_die_ref subr_die
11184         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
11185       tree decl = block_ultimate_origin (stmt);
11186       char label[MAX_ARTIFICIAL_LABEL_BYTES];
11187
11188       /* Emit info for the abstract instance first, if we haven't yet.  */
11189       dwarf2out_abstract_function (decl);
11190
11191       add_abstract_origin_attribute (subr_die, decl);
11192       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11193                                    BLOCK_NUMBER (stmt));
11194       add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
11195       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11196                                    BLOCK_NUMBER (stmt));
11197       add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
11198       decls_for_scope (stmt, subr_die, depth);
11199       current_function_has_inlines = 1;
11200     }
11201   else
11202     /* We may get here if we're the outer block of function A that was
11203        inlined into function B that was inlined into function C.  When
11204        generating debugging info for C, dwarf2out_abstract_function(B)
11205        would mark all inlined blocks as abstract, including this one.
11206        So, we wouldn't (and shouldn't) expect labels to be generated
11207        for this one.  Instead, just emit debugging info for
11208        declarations within the block.  This is particularly important
11209        in the case of initializers of arguments passed from B to us:
11210        if they're statement expressions containing declarations, we
11211        wouldn't generate dies for their abstract variables, and then,
11212        when generating dies for the real variables, we'd die (pun
11213        intended :-)  */
11214     gen_lexical_block_die (stmt, context_die, depth);
11215 }
11216
11217 /* Generate a DIE for a field in a record, or structure.  */
11218
11219 static void
11220 gen_field_die (decl, context_die)
11221      tree decl;
11222      dw_die_ref context_die;
11223 {
11224   dw_die_ref decl_die = new_die (DW_TAG_member, context_die, decl);
11225
11226   add_name_and_src_coords_attributes (decl_die, decl);
11227   add_type_attribute (decl_die, member_declared_type (decl),
11228                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
11229                       context_die);
11230
11231   if (DECL_BIT_FIELD_TYPE (decl))
11232     {
11233       add_byte_size_attribute (decl_die, decl);
11234       add_bit_size_attribute (decl_die, decl);
11235       add_bit_offset_attribute (decl_die, decl);
11236     }
11237
11238   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
11239     add_data_member_location_attribute (decl_die, decl);
11240
11241   if (DECL_ARTIFICIAL (decl))
11242     add_AT_flag (decl_die, DW_AT_artificial, 1);
11243
11244   if (TREE_PROTECTED (decl))
11245     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
11246   else if (TREE_PRIVATE (decl))
11247     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
11248 }
11249
11250 #if 0
11251 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11252    Use modified_type_die instead.
11253    We keep this code here just in case these types of DIEs may be needed to
11254    represent certain things in other languages (e.g. Pascal) someday.  */
11255
11256 static void
11257 gen_pointer_type_die (type, context_die)
11258      tree type;
11259      dw_die_ref context_die;
11260 {
11261   dw_die_ref ptr_die
11262     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
11263
11264   equate_type_number_to_die (type, ptr_die);
11265   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11266   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11267 }
11268
11269 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11270    Use modified_type_die instead.
11271    We keep this code here just in case these types of DIEs may be needed to
11272    represent certain things in other languages (e.g. Pascal) someday.  */
11273
11274 static void
11275 gen_reference_type_die (type, context_die)
11276      tree type;
11277      dw_die_ref context_die;
11278 {
11279   dw_die_ref ref_die
11280     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
11281
11282   equate_type_number_to_die (type, ref_die);
11283   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
11284   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11285 }
11286 #endif
11287
11288 /* Generate a DIE for a pointer to a member type.  */
11289
11290 static void
11291 gen_ptr_to_mbr_type_die (type, context_die)
11292      tree type;
11293      dw_die_ref context_die;
11294 {
11295   dw_die_ref ptr_die
11296     = new_die (DW_TAG_ptr_to_member_type,
11297                scope_die_for (type, context_die), type);
11298
11299   equate_type_number_to_die (type, ptr_die);
11300   add_AT_die_ref (ptr_die, DW_AT_containing_type,
11301                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
11302   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11303 }
11304
11305 /* Generate the DIE for the compilation unit.  */
11306
11307 static dw_die_ref
11308 gen_compile_unit_die (filename)
11309      const char *filename;
11310 {
11311   dw_die_ref die;
11312   char producer[250];
11313   const char *language_string = lang_hooks.name;
11314   int language;
11315
11316   die = new_die (DW_TAG_compile_unit, NULL, NULL);
11317
11318   if (filename)
11319     {
11320       add_name_attribute (die, filename);
11321       if (filename[0] != DIR_SEPARATOR)
11322         add_comp_dir_attribute (die);
11323     }
11324
11325   sprintf (producer, "%s %s", language_string, version_string);
11326
11327 #ifdef MIPS_DEBUGGING_INFO
11328   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11329      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11330      not appear in the producer string, the debugger reaches the conclusion
11331      that the object file is stripped and has no debugging information.
11332      To get the MIPS/SGI debugger to believe that there is debugging
11333      information in the object file, we add a -g to the producer string.  */
11334   if (debug_info_level > DINFO_LEVEL_TERSE)
11335     strcat (producer, " -g");
11336 #endif
11337
11338   add_AT_string (die, DW_AT_producer, producer);
11339
11340   if (strcmp (language_string, "GNU C++") == 0)
11341     language = DW_LANG_C_plus_plus;
11342   else if (strcmp (language_string, "GNU Ada") == 0)
11343     language = DW_LANG_Ada83;
11344   else if (strcmp (language_string, "GNU F77") == 0)
11345     language = DW_LANG_Fortran77;
11346   else if (strcmp (language_string, "GNU Pascal") == 0)
11347     language = DW_LANG_Pascal83;
11348   else if (strcmp (language_string, "GNU Java") == 0)
11349     language = DW_LANG_Java;
11350   else
11351     language = DW_LANG_C89;
11352
11353   add_AT_unsigned (die, DW_AT_language, language);
11354   return die;
11355 }
11356
11357 /* Generate a DIE for a string type.  */
11358
11359 static void
11360 gen_string_type_die (type, context_die)
11361      tree type;
11362      dw_die_ref context_die;
11363 {
11364   dw_die_ref type_die
11365     = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
11366
11367   equate_type_number_to_die (type, type_die);
11368
11369   /* ??? Fudge the string length attribute for now.
11370      TODO: add string length info.  */
11371 #if 0
11372   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
11373   bound_representation (upper_bound, 0, 'u');
11374 #endif
11375 }
11376
11377 /* Generate the DIE for a base class.  */
11378
11379 static void
11380 gen_inheritance_die (binfo, access, context_die)
11381      tree binfo, access;
11382      dw_die_ref context_die;
11383 {
11384   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
11385
11386   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
11387   add_data_member_location_attribute (die, binfo);
11388
11389   if (TREE_VIA_VIRTUAL (binfo))
11390     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11391
11392   if (access == access_public_node)
11393     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
11394   else if (access == access_protected_node)
11395     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
11396 }
11397
11398 /* Generate a DIE for a class member.  */
11399
11400 static void
11401 gen_member_die (type, context_die)
11402      tree type;
11403      dw_die_ref context_die;
11404 {
11405   tree member;
11406   tree binfo = TYPE_BINFO (type);
11407   dw_die_ref child;
11408
11409   /* If this is not an incomplete type, output descriptions of each of its
11410      members. Note that as we output the DIEs necessary to represent the
11411      members of this record or union type, we will also be trying to output
11412      DIEs to represent the *types* of those members. However the `type'
11413      function (above) will specifically avoid generating type DIEs for member
11414      types *within* the list of member DIEs for this (containing) type except
11415      for those types (of members) which are explicitly marked as also being
11416      members of this (containing) type themselves.  The g++ front- end can
11417      force any given type to be treated as a member of some other (containing)
11418      type by setting the TYPE_CONTEXT of the given (member) type to point to
11419      the TREE node representing the appropriate (containing) type.  */
11420
11421   /* First output info about the base classes.  */
11422   if (binfo && BINFO_BASETYPES (binfo))
11423     {
11424       tree bases = BINFO_BASETYPES (binfo);
11425       tree accesses = BINFO_BASEACCESSES (binfo);
11426       int n_bases = TREE_VEC_LENGTH (bases);
11427       int i;
11428
11429       for (i = 0; i < n_bases; i++)
11430         gen_inheritance_die (TREE_VEC_ELT (bases, i),
11431                              (accesses ? TREE_VEC_ELT (accesses, i)
11432                               : access_public_node), context_die);
11433     }
11434
11435   /* Now output info about the data members and type members.  */
11436   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
11437     {
11438       /* If we thought we were generating minimal debug info for TYPE
11439          and then changed our minds, some of the member declarations
11440          may have already been defined.  Don't define them again, but
11441          do put them in the right order.  */
11442
11443       child = lookup_decl_die (member);
11444       if (child)
11445         splice_child_die (context_die, child);
11446       else
11447         gen_decl_die (member, context_die);
11448     }
11449
11450   /* Now output info about the function members (if any).  */
11451   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
11452     {
11453       /* Don't include clones in the member list.  */
11454       if (DECL_ABSTRACT_ORIGIN (member))
11455         continue;
11456
11457       child = lookup_decl_die (member);
11458       if (child)
11459         splice_child_die (context_die, child);
11460       else
11461         gen_decl_die (member, context_die);
11462     }
11463 }
11464
11465 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
11466    is set, we pretend that the type was never defined, so we only get the
11467    member DIEs needed by later specification DIEs.  */
11468
11469 static void
11470 gen_struct_or_union_type_die (type, context_die)
11471      tree type;
11472      dw_die_ref context_die;
11473 {
11474   dw_die_ref type_die = lookup_type_die (type);
11475   dw_die_ref scope_die = 0;
11476   int nested = 0;
11477   int complete = (TYPE_SIZE (type)
11478                   && (! TYPE_STUB_DECL (type)
11479                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
11480
11481   if (type_die && ! complete)
11482     return;
11483
11484   if (TYPE_CONTEXT (type) != NULL_TREE
11485       && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
11486     nested = 1;
11487
11488   scope_die = scope_die_for (type, context_die);
11489
11490   if (! type_die || (nested && scope_die == comp_unit_die))
11491     /* First occurrence of type or toplevel definition of nested class.  */
11492     {
11493       dw_die_ref old_die = type_die;
11494
11495       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
11496                           ? DW_TAG_structure_type : DW_TAG_union_type,
11497                           scope_die, type);
11498       equate_type_number_to_die (type, type_die);
11499       if (old_die)
11500         add_AT_die_ref (type_die, DW_AT_specification, old_die);
11501       else
11502         add_name_attribute (type_die, type_tag (type));
11503     }
11504   else
11505     remove_AT (type_die, DW_AT_declaration);
11506
11507   /* If this type has been completed, then give it a byte_size attribute and
11508      then give a list of members.  */
11509   if (complete)
11510     {
11511       /* Prevent infinite recursion in cases where the type of some member of
11512          this type is expressed in terms of this type itself.  */
11513       TREE_ASM_WRITTEN (type) = 1;
11514       add_byte_size_attribute (type_die, type);
11515       if (TYPE_STUB_DECL (type) != NULL_TREE)
11516         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11517
11518       /* If the first reference to this type was as the return type of an
11519          inline function, then it may not have a parent.  Fix this now.  */
11520       if (type_die->die_parent == NULL)
11521         add_child_die (scope_die, type_die);
11522
11523       push_decl_scope (type);
11524       gen_member_die (type, type_die);
11525       pop_decl_scope ();
11526
11527       /* GNU extension: Record what type our vtable lives in.  */
11528       if (TYPE_VFIELD (type))
11529         {
11530           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
11531
11532           gen_type_die (vtype, context_die);
11533           add_AT_die_ref (type_die, DW_AT_containing_type,
11534                           lookup_type_die (vtype));
11535         }
11536     }
11537   else
11538     {
11539       add_AT_flag (type_die, DW_AT_declaration, 1);
11540
11541       /* We don't need to do this for function-local types.  */
11542       if (TYPE_STUB_DECL (type)
11543           && ! decl_function_context (TYPE_STUB_DECL (type)))
11544         VARRAY_PUSH_TREE (incomplete_types, type);
11545     }
11546 }
11547
11548 /* Generate a DIE for a subroutine _type_.  */
11549
11550 static void
11551 gen_subroutine_type_die (type, context_die)
11552      tree type;
11553      dw_die_ref context_die;
11554 {
11555   tree return_type = TREE_TYPE (type);
11556   dw_die_ref subr_die
11557     = new_die (DW_TAG_subroutine_type,
11558                scope_die_for (type, context_die), type);
11559
11560   equate_type_number_to_die (type, subr_die);
11561   add_prototyped_attribute (subr_die, type);
11562   add_type_attribute (subr_die, return_type, 0, 0, context_die);
11563   gen_formal_types_die (type, subr_die);
11564 }
11565
11566 /* Generate a DIE for a type definition */
11567
11568 static void
11569 gen_typedef_die (decl, context_die)
11570      tree decl;
11571      dw_die_ref context_die;
11572 {
11573   dw_die_ref type_die;
11574   tree origin;
11575
11576   if (TREE_ASM_WRITTEN (decl))
11577     return;
11578
11579   TREE_ASM_WRITTEN (decl) = 1;
11580   type_die = new_die (DW_TAG_typedef, context_die, decl);
11581   origin = decl_ultimate_origin (decl);
11582   if (origin != NULL)
11583     add_abstract_origin_attribute (type_die, origin);
11584   else
11585     {
11586       tree type;
11587
11588       add_name_and_src_coords_attributes (type_die, decl);
11589       if (DECL_ORIGINAL_TYPE (decl))
11590         {
11591           type = DECL_ORIGINAL_TYPE (decl);
11592
11593           if (type == TREE_TYPE (decl))
11594             abort ();
11595           else
11596             equate_type_number_to_die (TREE_TYPE (decl), type_die);
11597         }
11598       else
11599         type = TREE_TYPE (decl);
11600
11601       add_type_attribute (type_die, type, TREE_READONLY (decl),
11602                           TREE_THIS_VOLATILE (decl), context_die);
11603     }
11604
11605   if (DECL_ABSTRACT (decl))
11606     equate_decl_number_to_die (decl, type_die);
11607 }
11608
11609 /* Generate a type description DIE.  */
11610
11611 static void
11612 gen_type_die (type, context_die)
11613      tree type;
11614      dw_die_ref context_die;
11615 {
11616   int need_pop;
11617
11618   if (type == NULL_TREE || type == error_mark_node)
11619     return;
11620
11621   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11622       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
11623     {
11624       if (TREE_ASM_WRITTEN (type))
11625         return;
11626
11627       /* Prevent broken recursion; we can't hand off to the same type.  */
11628       if (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) == type)
11629         abort ();
11630
11631       TREE_ASM_WRITTEN (type) = 1;
11632       gen_decl_die (TYPE_NAME (type), context_die);
11633       return;
11634     }
11635
11636   /* We are going to output a DIE to represent the unqualified version
11637      of this type (i.e. without any const or volatile qualifiers) so
11638      get the main variant (i.e. the unqualified version) of this type
11639      now.  (Vectors are special because the debugging info is in the
11640      cloned type itself).  */
11641   if (TREE_CODE (type) != VECTOR_TYPE)
11642     type = type_main_variant (type);
11643
11644   if (TREE_ASM_WRITTEN (type))
11645     return;
11646
11647   switch (TREE_CODE (type))
11648     {
11649     case ERROR_MARK:
11650       break;
11651
11652     case POINTER_TYPE:
11653     case REFERENCE_TYPE:
11654       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
11655          ensures that the gen_type_die recursion will terminate even if the
11656          type is recursive.  Recursive types are possible in Ada.  */
11657       /* ??? We could perhaps do this for all types before the switch
11658          statement.  */
11659       TREE_ASM_WRITTEN (type) = 1;
11660
11661       /* For these types, all that is required is that we output a DIE (or a
11662          set of DIEs) to represent the "basis" type.  */
11663       gen_type_die (TREE_TYPE (type), context_die);
11664       break;
11665
11666     case OFFSET_TYPE:
11667       /* This code is used for C++ pointer-to-data-member types.
11668          Output a description of the relevant class type.  */
11669       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
11670
11671       /* Output a description of the type of the object pointed to.  */
11672       gen_type_die (TREE_TYPE (type), context_die);
11673
11674       /* Now output a DIE to represent this pointer-to-data-member type
11675          itself.  */
11676       gen_ptr_to_mbr_type_die (type, context_die);
11677       break;
11678
11679     case SET_TYPE:
11680       gen_type_die (TYPE_DOMAIN (type), context_die);
11681       gen_set_type_die (type, context_die);
11682       break;
11683
11684     case FILE_TYPE:
11685       gen_type_die (TREE_TYPE (type), context_die);
11686       abort ();                 /* No way to represent these in Dwarf yet!  */
11687       break;
11688
11689     case FUNCTION_TYPE:
11690       /* Force out return type (in case it wasn't forced out already).  */
11691       gen_type_die (TREE_TYPE (type), context_die);
11692       gen_subroutine_type_die (type, context_die);
11693       break;
11694
11695     case METHOD_TYPE:
11696       /* Force out return type (in case it wasn't forced out already).  */
11697       gen_type_die (TREE_TYPE (type), context_die);
11698       gen_subroutine_type_die (type, context_die);
11699       break;
11700
11701     case ARRAY_TYPE:
11702       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
11703         {
11704           gen_type_die (TREE_TYPE (type), context_die);
11705           gen_string_type_die (type, context_die);
11706         }
11707       else
11708         gen_array_type_die (type, context_die);
11709       break;
11710
11711     case VECTOR_TYPE:
11712       gen_array_type_die (type, context_die);
11713       break;
11714
11715     case ENUMERAL_TYPE:
11716     case RECORD_TYPE:
11717     case UNION_TYPE:
11718     case QUAL_UNION_TYPE:
11719       /* If this is a nested type whose containing class hasn't been written
11720          out yet, writing it out will cover this one, too.  This does not apply
11721          to instantiations of member class templates; they need to be added to
11722          the containing class as they are generated.  FIXME: This hurts the
11723          idea of combining type decls from multiple TUs, since we can't predict
11724          what set of template instantiations we'll get.  */
11725       if (TYPE_CONTEXT (type)
11726           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
11727           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
11728         {
11729           gen_type_die (TYPE_CONTEXT (type), context_die);
11730
11731           if (TREE_ASM_WRITTEN (type))
11732             return;
11733
11734           /* If that failed, attach ourselves to the stub.  */
11735           push_decl_scope (TYPE_CONTEXT (type));
11736           context_die = lookup_type_die (TYPE_CONTEXT (type));
11737           need_pop = 1;
11738         }
11739       else
11740         need_pop = 0;
11741
11742       if (TREE_CODE (type) == ENUMERAL_TYPE)
11743         gen_enumeration_type_die (type, context_die);
11744       else
11745         gen_struct_or_union_type_die (type, context_die);
11746
11747       if (need_pop)
11748         pop_decl_scope ();
11749
11750       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
11751          it up if it is ever completed.  gen_*_type_die will set it for us
11752          when appropriate.  */
11753       return;
11754
11755     case VOID_TYPE:
11756     case INTEGER_TYPE:
11757     case REAL_TYPE:
11758     case COMPLEX_TYPE:
11759     case BOOLEAN_TYPE:
11760     case CHAR_TYPE:
11761       /* No DIEs needed for fundamental types.  */
11762       break;
11763
11764     case LANG_TYPE:
11765       /* No Dwarf representation currently defined.  */
11766       break;
11767
11768     default:
11769       abort ();
11770     }
11771
11772   TREE_ASM_WRITTEN (type) = 1;
11773 }
11774
11775 /* Generate a DIE for a tagged type instantiation.  */
11776
11777 static void
11778 gen_tagged_type_instantiation_die (type, context_die)
11779      tree type;
11780      dw_die_ref context_die;
11781 {
11782   if (type == NULL_TREE || type == error_mark_node)
11783     return;
11784
11785   /* We are going to output a DIE to represent the unqualified version of
11786      this type (i.e. without any const or volatile qualifiers) so make sure
11787      that we have the main variant (i.e. the unqualified version) of this
11788      type now.  */
11789   if (type != type_main_variant (type))
11790     abort ();
11791
11792   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
11793      an instance of an unresolved type.  */
11794
11795   switch (TREE_CODE (type))
11796     {
11797     case ERROR_MARK:
11798       break;
11799
11800     case ENUMERAL_TYPE:
11801       gen_inlined_enumeration_type_die (type, context_die);
11802       break;
11803
11804     case RECORD_TYPE:
11805       gen_inlined_structure_type_die (type, context_die);
11806       break;
11807
11808     case UNION_TYPE:
11809     case QUAL_UNION_TYPE:
11810       gen_inlined_union_type_die (type, context_die);
11811       break;
11812
11813     default:
11814       abort ();
11815     }
11816 }
11817
11818 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
11819    things which are local to the given block.  */
11820
11821 static void
11822 gen_block_die (stmt, context_die, depth)
11823      tree stmt;
11824      dw_die_ref context_die;
11825      int depth;
11826 {
11827   int must_output_die = 0;
11828   tree origin;
11829   tree decl;
11830   enum tree_code origin_code;
11831
11832   /* Ignore blocks never really used to make RTL.  */
11833   if (stmt == NULL_TREE || !TREE_USED (stmt)
11834       || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt)))
11835     return;
11836
11837   /* If the block is one fragment of a non-contiguous block, do not
11838      process the variables, since they will have been done by the
11839      origin block.  Do process subblocks.  */
11840   if (BLOCK_FRAGMENT_ORIGIN (stmt))
11841     {
11842       tree sub;
11843
11844       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
11845         gen_block_die (sub, context_die, depth + 1);
11846
11847       return;
11848     }
11849
11850   /* Determine the "ultimate origin" of this block.  This block may be an
11851      inlined instance of an inlined instance of inline function, so we have
11852      to trace all of the way back through the origin chain to find out what
11853      sort of node actually served as the original seed for the creation of
11854      the current block.  */
11855   origin = block_ultimate_origin (stmt);
11856   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
11857
11858   /* Determine if we need to output any Dwarf DIEs at all to represent this
11859      block.  */
11860   if (origin_code == FUNCTION_DECL)
11861     /* The outer scopes for inlinings *must* always be represented.  We
11862        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
11863     must_output_die = 1;
11864   else
11865     {
11866       /* In the case where the current block represents an inlining of the
11867          "body block" of an inline function, we must *NOT* output any DIE for
11868          this block because we have already output a DIE to represent the whole
11869          inlined function scope and the "body block" of any function doesn't
11870          really represent a different scope according to ANSI C rules.  So we
11871          check here to make sure that this block does not represent a "body
11872          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
11873       if (! is_body_block (origin ? origin : stmt))
11874         {
11875           /* Determine if this block directly contains any "significant"
11876              local declarations which we will need to output DIEs for.  */
11877           if (debug_info_level > DINFO_LEVEL_TERSE)
11878             /* We are not in terse mode so *any* local declaration counts
11879                as being a "significant" one.  */
11880             must_output_die = (BLOCK_VARS (stmt) != NULL);
11881           else
11882             /* We are in terse mode, so only local (nested) function
11883                definitions count as "significant" local declarations.  */
11884             for (decl = BLOCK_VARS (stmt);
11885                  decl != NULL; decl = TREE_CHAIN (decl))
11886               if (TREE_CODE (decl) == FUNCTION_DECL
11887                   && DECL_INITIAL (decl))
11888                 {
11889                   must_output_die = 1;
11890                   break;
11891                 }
11892         }
11893     }
11894
11895   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
11896      DIE for any block which contains no significant local declarations at
11897      all.  Rather, in such cases we just call `decls_for_scope' so that any
11898      needed Dwarf info for any sub-blocks will get properly generated. Note
11899      that in terse mode, our definition of what constitutes a "significant"
11900      local declaration gets restricted to include only inlined function
11901      instances and local (nested) function definitions.  */
11902   if (must_output_die)
11903     {
11904       if (origin_code == FUNCTION_DECL)
11905         gen_inlined_subroutine_die (stmt, context_die, depth);
11906       else
11907         gen_lexical_block_die (stmt, context_die, depth);
11908     }
11909   else
11910     decls_for_scope (stmt, context_die, depth);
11911 }
11912
11913 /* Generate all of the decls declared within a given scope and (recursively)
11914    all of its sub-blocks.  */
11915
11916 static void
11917 decls_for_scope (stmt, context_die, depth)
11918      tree stmt;
11919      dw_die_ref context_die;
11920      int depth;
11921 {
11922   tree decl;
11923   tree subblocks;
11924
11925   /* Ignore blocks never really used to make RTL.  */
11926   if (stmt == NULL_TREE || ! TREE_USED (stmt))
11927     return;
11928
11929   /* Output the DIEs to represent all of the data objects and typedefs
11930      declared directly within this block but not within any nested
11931      sub-blocks.  Also, nested function and tag DIEs have been
11932      generated with a parent of NULL; fix that up now.  */
11933   for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
11934     {
11935       dw_die_ref die;
11936
11937       if (TREE_CODE (decl) == FUNCTION_DECL)
11938         die = lookup_decl_die (decl);
11939       else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
11940         die = lookup_type_die (TREE_TYPE (decl));
11941       else
11942         die = NULL;
11943
11944       if (die != NULL && die->die_parent == NULL)
11945         add_child_die (context_die, die);
11946       else
11947         gen_decl_die (decl, context_die);
11948     }
11949
11950   /* Output the DIEs to represent all sub-blocks (and the items declared
11951      therein) of this block.  */
11952   for (subblocks = BLOCK_SUBBLOCKS (stmt);
11953        subblocks != NULL;
11954        subblocks = BLOCK_CHAIN (subblocks))
11955     gen_block_die (subblocks, context_die, depth + 1);
11956 }
11957
11958 /* Is this a typedef we can avoid emitting?  */
11959
11960 static inline int
11961 is_redundant_typedef (decl)
11962      tree decl;
11963 {
11964   if (TYPE_DECL_IS_STUB (decl))
11965     return 1;
11966
11967   if (DECL_ARTIFICIAL (decl)
11968       && DECL_CONTEXT (decl)
11969       && is_tagged_type (DECL_CONTEXT (decl))
11970       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
11971       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
11972     /* Also ignore the artificial member typedef for the class name.  */
11973     return 1;
11974
11975   return 0;
11976 }
11977
11978 /* Generate Dwarf debug information for a decl described by DECL.  */
11979
11980 static void
11981 gen_decl_die (decl, context_die)
11982      tree decl;
11983      dw_die_ref context_die;
11984 {
11985   tree origin;
11986
11987   if (DECL_P (decl) && DECL_IGNORED_P (decl))
11988     return;
11989
11990   switch (TREE_CODE (decl))
11991     {
11992     case ERROR_MARK:
11993       break;
11994
11995     case CONST_DECL:
11996       /* The individual enumerators of an enum type get output when we output
11997          the Dwarf representation of the relevant enum type itself.  */
11998       break;
11999
12000     case FUNCTION_DECL:
12001       /* Don't output any DIEs to represent mere function declarations,
12002          unless they are class members or explicit block externs.  */
12003       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12004           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
12005         break;
12006
12007       /* If we're emitting a clone, emit info for the abstract instance.  */
12008       if (DECL_ORIGIN (decl) != decl)
12009         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
12010
12011       /* If we're emitting an out-of-line copy of an inline function,
12012          emit info for the abstract instance and set up to refer to it.  */
12013       else if (DECL_INLINE (decl) && ! DECL_ABSTRACT (decl)
12014                && ! class_scope_p (context_die)
12015                /* dwarf2out_abstract_function won't emit a die if this is just
12016                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
12017                   that case, because that works only if we have a die.  */
12018                && DECL_INITIAL (decl) != NULL_TREE)
12019         {
12020           dwarf2out_abstract_function (decl);
12021           set_decl_origin_self (decl);
12022         }
12023
12024       /* Otherwise we're emitting the primary DIE for this decl.  */
12025       else if (debug_info_level > DINFO_LEVEL_TERSE)
12026         {
12027           /* Before we describe the FUNCTION_DECL itself, make sure that we
12028              have described its return type.  */
12029           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
12030
12031           /* And its virtual context.  */
12032           if (DECL_VINDEX (decl) != NULL_TREE)
12033             gen_type_die (DECL_CONTEXT (decl), context_die);
12034
12035           /* And its containing type.  */
12036           origin = decl_class_context (decl);
12037           if (origin != NULL_TREE)
12038             gen_type_die_for_member (origin, decl, context_die);
12039         }
12040
12041       /* Now output a DIE to represent the function itself.  */
12042       gen_subprogram_die (decl, context_die);
12043       break;
12044
12045     case TYPE_DECL:
12046       /* If we are in terse mode, don't generate any DIEs to represent any
12047          actual typedefs.  */
12048       if (debug_info_level <= DINFO_LEVEL_TERSE)
12049         break;
12050
12051       /* In the special case of a TYPE_DECL node representing the declaration
12052          of some type tag, if the given TYPE_DECL is marked as having been
12053          instantiated from some other (original) TYPE_DECL node (e.g. one which
12054          was generated within the original definition of an inline function) we
12055          have to generate a special (abbreviated) DW_TAG_structure_type,
12056          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
12057       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
12058         {
12059           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
12060           break;
12061         }
12062
12063       if (is_redundant_typedef (decl))
12064         gen_type_die (TREE_TYPE (decl), context_die);
12065       else
12066         /* Output a DIE to represent the typedef itself.  */
12067         gen_typedef_die (decl, context_die);
12068       break;
12069
12070     case LABEL_DECL:
12071       if (debug_info_level >= DINFO_LEVEL_NORMAL)
12072         gen_label_die (decl, context_die);
12073       break;
12074
12075     case VAR_DECL:
12076       /* If we are in terse mode, don't generate any DIEs to represent any
12077          variable declarations or definitions.  */
12078       if (debug_info_level <= DINFO_LEVEL_TERSE)
12079         break;
12080
12081       /* Output any DIEs that are needed to specify the type of this data
12082          object.  */
12083       gen_type_die (TREE_TYPE (decl), context_die);
12084
12085       /* And its containing type.  */
12086       origin = decl_class_context (decl);
12087       if (origin != NULL_TREE)
12088         gen_type_die_for_member (origin, decl, context_die);
12089
12090       /* Now output the DIE to represent the data object itself.  This gets
12091          complicated because of the possibility that the VAR_DECL really
12092          represents an inlined instance of a formal parameter for an inline
12093          function.  */
12094       origin = decl_ultimate_origin (decl);
12095       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
12096         gen_formal_parameter_die (decl, context_die);
12097       else
12098         gen_variable_die (decl, context_die);
12099       break;
12100
12101     case FIELD_DECL:
12102       /* Ignore the nameless fields that are used to skip bits but handle C++
12103          anonymous unions.  */
12104       if (DECL_NAME (decl) != NULL_TREE
12105           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
12106         {
12107           gen_type_die (member_declared_type (decl), context_die);
12108           gen_field_die (decl, context_die);
12109         }
12110       break;
12111
12112     case PARM_DECL:
12113       gen_type_die (TREE_TYPE (decl), context_die);
12114       gen_formal_parameter_die (decl, context_die);
12115       break;
12116
12117     case NAMESPACE_DECL:
12118       /* Ignore for now.  */
12119       break;
12120
12121     default:
12122       abort ();
12123     }
12124 }
12125 \f
12126 /* Add Ada "use" clause information for SGI Workshop debugger.  */
12127
12128 void
12129 dwarf2out_add_library_unit_info (filename, context_list)
12130      const char *filename;
12131      const char *context_list;
12132 {
12133   unsigned int file_index;
12134
12135   if (filename != NULL)
12136     {
12137       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
12138       tree context_list_decl
12139         = build_decl (LABEL_DECL, get_identifier (context_list),
12140                       void_type_node);
12141
12142       TREE_PUBLIC (context_list_decl) = TRUE;
12143       add_name_attribute (unit_die, context_list);
12144       file_index = lookup_filename (filename);
12145       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
12146       add_pubname (context_list_decl, unit_die);
12147     }
12148 }
12149
12150 /* Output debug information for global decl DECL.  Called from toplev.c after
12151    compilation proper has finished.  */
12152
12153 static void
12154 dwarf2out_global_decl (decl)
12155      tree decl;
12156 {
12157   /* Output DWARF2 information for file-scope tentative data object
12158      declarations, file-scope (extern) function declarations (which had no
12159      corresponding body) and file-scope tagged type declarations and
12160      definitions which have not yet been forced out.  */
12161   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
12162     dwarf2out_decl (decl);
12163 }
12164
12165 /* Write the debugging output for DECL.  */
12166
12167 void
12168 dwarf2out_decl (decl)
12169      tree decl;
12170 {
12171   dw_die_ref context_die = comp_unit_die;
12172
12173   switch (TREE_CODE (decl))
12174     {
12175     case ERROR_MARK:
12176       return;
12177
12178     case FUNCTION_DECL:
12179       /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
12180          builtin function.  Explicit programmer-supplied declarations of
12181          these same functions should NOT be ignored however.  */
12182       if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
12183         return;
12184
12185       /* What we would really like to do here is to filter out all mere
12186          file-scope declarations of file-scope functions which are never
12187          referenced later within this translation unit (and keep all of ones
12188          that *are* referenced later on) but we aren't clairvoyant, so we have
12189          no idea which functions will be referenced in the future (i.e. later
12190          on within the current translation unit). So here we just ignore all
12191          file-scope function declarations which are not also definitions.  If
12192          and when the debugger needs to know something about these functions,
12193          it will have to hunt around and find the DWARF information associated
12194          with the definition of the function.
12195
12196          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
12197          nodes represent definitions and which ones represent mere
12198          declarations.  We have to check DECL_INITIAL instead. That's because
12199          the C front-end supports some weird semantics for "extern inline"
12200          function definitions.  These can get inlined within the current
12201          translation unit (an thus, we need to generate Dwarf info for their
12202          abstract instances so that the Dwarf info for the concrete inlined
12203          instances can have something to refer to) but the compiler never
12204          generates any out-of-lines instances of such things (despite the fact
12205          that they *are* definitions).
12206
12207          The important point is that the C front-end marks these "extern
12208          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
12209          them anyway. Note that the C++ front-end also plays some similar games
12210          for inline function definitions appearing within include files which
12211          also contain `#pragma interface' pragmas.  */
12212       if (DECL_INITIAL (decl) == NULL_TREE)
12213         return;
12214
12215       /* If we're a nested function, initially use a parent of NULL; if we're
12216          a plain function, this will be fixed up in decls_for_scope.  If
12217          we're a method, it will be ignored, since we already have a DIE.  */
12218       if (decl_function_context (decl))
12219         context_die = NULL;
12220       break;
12221
12222     case VAR_DECL:
12223       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12224          declaration and if the declaration was never even referenced from
12225          within this entire compilation unit.  We suppress these DIEs in
12226          order to save space in the .debug section (by eliminating entries
12227          which are probably useless).  Note that we must not suppress
12228          block-local extern declarations (whether used or not) because that
12229          would screw-up the debugger's name lookup mechanism and cause it to
12230          miss things which really ought to be in scope at a given point.  */
12231       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
12232         return;
12233
12234       /* If we are in terse mode, don't generate any DIEs to represent any
12235          variable declarations or definitions.  */
12236       if (debug_info_level <= DINFO_LEVEL_TERSE)
12237         return;
12238       break;
12239
12240     case TYPE_DECL:
12241       /* Don't emit stubs for types unless they are needed by other DIEs.  */
12242       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
12243         return;
12244
12245       /* Don't bother trying to generate any DIEs to represent any of the
12246          normal built-in types for the language we are compiling.  */
12247       if (DECL_SOURCE_LINE (decl) == 0)
12248         {
12249           /* OK, we need to generate one for `bool' so GDB knows what type
12250              comparisons have.  */
12251           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
12252                == DW_LANG_C_plus_plus)
12253               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
12254               && ! DECL_IGNORED_P (decl))
12255             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
12256
12257           return;
12258         }
12259
12260       /* If we are in terse mode, don't generate any DIEs for types.  */
12261       if (debug_info_level <= DINFO_LEVEL_TERSE)
12262         return;
12263
12264       /* If we're a function-scope tag, initially use a parent of NULL;
12265          this will be fixed up in decls_for_scope.  */
12266       if (decl_function_context (decl))
12267         context_die = NULL;
12268
12269       break;
12270
12271     default:
12272       return;
12273     }
12274
12275   gen_decl_die (decl, context_die);
12276 }
12277
12278 /* Output a marker (i.e. a label) for the beginning of the generated code for
12279    a lexical block.  */
12280
12281 static void
12282 dwarf2out_begin_block (line, blocknum)
12283      unsigned int line ATTRIBUTE_UNUSED;
12284      unsigned int blocknum;
12285 {
12286   function_section (current_function_decl);
12287   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
12288 }
12289
12290 /* Output a marker (i.e. a label) for the end of the generated code for a
12291    lexical block.  */
12292
12293 static void
12294 dwarf2out_end_block (line, blocknum)
12295      unsigned int line ATTRIBUTE_UNUSED;
12296      unsigned int blocknum;
12297 {
12298   function_section (current_function_decl);
12299   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
12300 }
12301
12302 /* Returns nonzero if it is appropriate not to emit any debugging
12303    information for BLOCK, because it doesn't contain any instructions.
12304
12305    Don't allow this for blocks with nested functions or local classes
12306    as we would end up with orphans, and in the presence of scheduling
12307    we may end up calling them anyway.  */
12308
12309 static bool
12310 dwarf2out_ignore_block (block)
12311      tree block;
12312 {
12313   tree decl;
12314
12315   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
12316     if (TREE_CODE (decl) == FUNCTION_DECL
12317         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
12318       return 0;
12319
12320   return 1;
12321 }
12322
12323 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12324    dwarf2out.c) and return its "index".  The index of each (known) filename is
12325    just a unique number which is associated with only that one filename.  We
12326    need such numbers for the sake of generating labels (in the .debug_sfnames
12327    section) and references to those files numbers (in the .debug_srcinfo
12328    and.debug_macinfo sections).  If the filename given as an argument is not
12329    found in our current list, add it to the list and assign it the next
12330    available unique index number.  In order to speed up searches, we remember
12331    the index of the filename was looked up last.  This handles the majority of
12332    all searches.  */
12333
12334 static unsigned
12335 lookup_filename (file_name)
12336      const char *file_name;
12337 {
12338   size_t i, n;
12339   char *save_file_name;
12340
12341   /* ??? Why isn't DECL_SOURCE_FILE left null instead.  */
12342   if (strcmp (file_name, "<internal>") == 0
12343       || strcmp (file_name, "<built-in>") == 0)
12344     return 0;
12345
12346   /* Check to see if the file name that was searched on the previous
12347      call matches this file name.  If so, return the index.  */
12348   if (file_table_last_lookup_index != 0)
12349     {
12350       const char *last
12351         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
12352       if (strcmp (file_name, last) == 0)
12353         return file_table_last_lookup_index;
12354     }
12355
12356   /* Didn't match the previous lookup, search the table */
12357   n = VARRAY_ACTIVE_SIZE (file_table);
12358   for (i = 1; i < n; i++)
12359     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
12360       {
12361         file_table_last_lookup_index = i;
12362         return i;
12363       }
12364
12365   /* Add the new entry to the end of the filename table.  */
12366   file_table_last_lookup_index = n;
12367   save_file_name = (char *) ggc_strdup (file_name);
12368   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
12369   VARRAY_PUSH_UINT (file_table_emitted, 0);
12370
12371   return i;
12372 }
12373
12374 static int
12375 maybe_emit_file (fileno)
12376      int fileno;
12377 {
12378   static int emitcount = 0;
12379   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
12380     {
12381       if (!VARRAY_UINT (file_table_emitted, fileno))
12382         {
12383           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
12384           fprintf (asm_out_file, "\t.file %u ",
12385                    VARRAY_UINT (file_table_emitted, fileno));
12386           output_quoted_string (asm_out_file,
12387                                 VARRAY_CHAR_PTR (file_table, fileno));
12388           fputc ('\n', asm_out_file);
12389         }
12390       return VARRAY_UINT (file_table_emitted, fileno);
12391     }
12392   else
12393     return fileno;
12394 }
12395
12396 static void
12397 init_file_table ()
12398 {
12399   /* Allocate the initial hunk of the file_table.  */
12400   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
12401   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
12402
12403   /* Skip the first entry - file numbers begin at 1.  */
12404   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
12405   VARRAY_PUSH_UINT (file_table_emitted, 0);
12406   file_table_last_lookup_index = 0;
12407 }
12408
12409 /* Output a label to mark the beginning of a source code line entry
12410    and record information relating to this source line, in
12411    'line_info_table' for later output of the .debug_line section.  */
12412
12413 static void
12414 dwarf2out_source_line (line, filename)
12415      unsigned int line;
12416      const char *filename;
12417 {
12418   if (debug_info_level >= DINFO_LEVEL_NORMAL)
12419     {
12420       function_section (current_function_decl);
12421
12422       /* If requested, emit something human-readable.  */
12423       if (flag_debug_asm)
12424         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
12425                  filename, line);
12426
12427       if (DWARF2_ASM_LINE_DEBUG_INFO)
12428         {
12429           unsigned file_num = lookup_filename (filename);
12430
12431           file_num = maybe_emit_file (file_num);
12432
12433           /* Emit the .loc directive understood by GNU as.  */
12434           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
12435
12436           /* Indicate that line number info exists.  */
12437           line_info_table_in_use++;
12438
12439           /* Indicate that multiple line number tables exist.  */
12440           if (DECL_SECTION_NAME (current_function_decl))
12441             separate_line_info_table_in_use++;
12442         }
12443       else if (DECL_SECTION_NAME (current_function_decl))
12444         {
12445           dw_separate_line_info_ref line_info;
12446           (*targetm.asm_out.internal_label) (asm_out_file, SEPARATE_LINE_CODE_LABEL,
12447                                      separate_line_info_table_in_use);
12448
12449           /* expand the line info table if necessary */
12450           if (separate_line_info_table_in_use
12451               == separate_line_info_table_allocated)
12452             {
12453               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12454               separate_line_info_table
12455                 = (dw_separate_line_info_ref)
12456                   ggc_realloc (separate_line_info_table,
12457                                separate_line_info_table_allocated
12458                                * sizeof (dw_separate_line_info_entry));
12459               memset ((separate_line_info_table
12460                        + separate_line_info_table_in_use),
12461                       0,
12462                       (LINE_INFO_TABLE_INCREMENT
12463                        * sizeof (dw_separate_line_info_entry)));
12464             }
12465
12466           /* Add the new entry at the end of the line_info_table.  */
12467           line_info
12468             = &separate_line_info_table[separate_line_info_table_in_use++];
12469           line_info->dw_file_num = lookup_filename (filename);
12470           line_info->dw_line_num = line;
12471           line_info->function = current_function_funcdef_no;
12472         }
12473       else
12474         {
12475           dw_line_info_ref line_info;
12476
12477           (*targetm.asm_out.internal_label) (asm_out_file, LINE_CODE_LABEL,
12478                                      line_info_table_in_use);
12479
12480           /* Expand the line info table if necessary.  */
12481           if (line_info_table_in_use == line_info_table_allocated)
12482             {
12483               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12484               line_info_table
12485                 = ggc_realloc (line_info_table,
12486                                (line_info_table_allocated
12487                                 * sizeof (dw_line_info_entry)));
12488               memset (line_info_table + line_info_table_in_use, 0,
12489                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
12490             }
12491
12492           /* Add the new entry at the end of the line_info_table.  */
12493           line_info = &line_info_table[line_info_table_in_use++];
12494           line_info->dw_file_num = lookup_filename (filename);
12495           line_info->dw_line_num = line;
12496         }
12497     }
12498 }
12499
12500 /* Record the beginning of a new source file.  */
12501
12502 static void
12503 dwarf2out_start_source_file (lineno, filename)
12504      unsigned int lineno;
12505      const char *filename;
12506 {
12507   if (flag_eliminate_dwarf2_dups && !is_main_source)
12508     {
12509       /* Record the beginning of the file for break_out_includes.  */
12510       dw_die_ref bincl_die;
12511
12512       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
12513       add_AT_string (bincl_die, DW_AT_name, filename);
12514     }
12515
12516   is_main_source = 0;
12517
12518   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12519     {
12520       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12521       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
12522       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
12523                                    lineno);
12524       maybe_emit_file (lookup_filename (filename));
12525       dw2_asm_output_data_uleb128 (lookup_filename (filename),
12526                                    "Filename we just started");
12527     }
12528 }
12529
12530 /* Record the end of a source file.  */
12531
12532 static void
12533 dwarf2out_end_source_file (lineno)
12534      unsigned int lineno ATTRIBUTE_UNUSED;
12535 {
12536   if (flag_eliminate_dwarf2_dups)
12537     /* Record the end of the file for break_out_includes.  */
12538     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
12539
12540   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12541     {
12542       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12543       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
12544     }
12545 }
12546
12547 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
12548    the tail part of the directive line, i.e. the part which is past the
12549    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12550
12551 static void
12552 dwarf2out_define (lineno, buffer)
12553      unsigned lineno ATTRIBUTE_UNUSED;
12554      const char *buffer ATTRIBUTE_UNUSED;
12555 {
12556   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12557     {
12558       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12559       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
12560       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12561       dw2_asm_output_nstring (buffer, -1, "The macro");
12562     }
12563 }
12564
12565 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
12566    the tail part of the directive line, i.e. the part which is past the
12567    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12568
12569 static void
12570 dwarf2out_undef (lineno, buffer)
12571      unsigned lineno ATTRIBUTE_UNUSED;
12572      const char *buffer ATTRIBUTE_UNUSED;
12573 {
12574   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12575     {
12576       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12577       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
12578       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12579       dw2_asm_output_nstring (buffer, -1, "The macro");
12580     }
12581 }
12582
12583 /* Set up for Dwarf output at the start of compilation.  */
12584
12585 static void
12586 dwarf2out_init (input_filename)
12587      const char *input_filename ATTRIBUTE_UNUSED;
12588 {
12589   init_file_table ();
12590
12591   /* Allocate the initial hunk of the decl_die_table.  */
12592   decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
12593                                       * sizeof (dw_die_ref));
12594   decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
12595   decl_die_table_in_use = 0;
12596
12597   /* Allocate the initial hunk of the decl_scope_table.  */
12598   VARRAY_TREE_INIT (decl_scope_table, 256, "decl_scope_table");
12599
12600   /* Allocate the initial hunk of the abbrev_die_table.  */
12601   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
12602                                         * sizeof (dw_die_ref));
12603   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
12604   /* Zero-th entry is allocated, but unused */
12605   abbrev_die_table_in_use = 1;
12606
12607   /* Allocate the initial hunk of the line_info_table.  */
12608   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
12609                                        * sizeof (dw_line_info_entry));
12610   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
12611
12612   /* Zero-th entry is allocated, but unused */
12613   line_info_table_in_use = 1;
12614
12615   /* Generate the initial DIE for the .debug section.  Note that the (string)
12616      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
12617      will (typically) be a relative pathname and that this pathname should be
12618      taken as being relative to the directory from which the compiler was
12619      invoked when the given (base) source file was compiled.  We will fill
12620      in this value in dwarf2out_finish.  */
12621   comp_unit_die = gen_compile_unit_die (NULL);
12622   is_main_source = 1;
12623
12624   VARRAY_TREE_INIT (incomplete_types, 64, "incomplete_types");
12625
12626   VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray");
12627
12628   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
12629   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
12630                                DEBUG_ABBREV_SECTION_LABEL, 0);
12631   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12632     ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
12633   else
12634     strcpy (text_section_label, stripattributes (TEXT_SECTION_NAME));
12635
12636   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
12637                                DEBUG_INFO_SECTION_LABEL, 0);
12638   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
12639                                DEBUG_LINE_SECTION_LABEL, 0);
12640   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
12641                                DEBUG_RANGES_SECTION_LABEL, 0);
12642   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
12643   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
12644   named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG);
12645   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
12646   named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
12647   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
12648
12649   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12650     {
12651       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12652       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
12653                                    DEBUG_MACINFO_SECTION_LABEL, 0);
12654       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
12655     }
12656
12657   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12658     {
12659       text_section ();
12660       ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
12661     }
12662 }
12663
12664 /* A helper function for dwarf2out_finish called through
12665    ht_forall.  Emit one queued .debug_str string.  */
12666
12667 static int
12668 output_indirect_string (h, v)
12669      void **h;
12670      void *v ATTRIBUTE_UNUSED;
12671 {
12672   struct indirect_string_node *node = (struct indirect_string_node *) *h;
12673
12674   if (node->form == DW_FORM_strp)
12675     {
12676       named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS);
12677       ASM_OUTPUT_LABEL (asm_out_file, node->label);
12678       assemble_string (node->str, strlen (node->str) + 1);
12679     }
12680
12681   return 1;
12682 }
12683
12684
12685
12686 /* Clear the marks for a die and its children.
12687    Be cool if the mark isn't set. */
12688
12689 static void
12690 prune_unmark_dies (die)
12691      dw_die_ref die;
12692 {
12693   dw_die_ref c;
12694   die->die_mark = 0;
12695   for (c = die->die_child; c; c = c->die_sib)
12696     prune_unmark_dies (c);
12697 }
12698
12699
12700 /* Given DIE that we're marking as used, find any other dies
12701    it references as attributes and mark them as used.  */
12702
12703 static void
12704 prune_unused_types_walk_attribs (die)
12705      dw_die_ref die;
12706 {
12707   dw_attr_ref a;
12708
12709   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
12710     {
12711       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
12712         {
12713           /* A reference to another DIE.
12714              Make sure that it will get emitted.  */
12715           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
12716         }
12717       else if (a->dw_attr == DW_AT_decl_file)
12718         {
12719           /* A reference to a file.  Make sure the file name is emitted.  */
12720           a->dw_attr_val.v.val_unsigned =
12721             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
12722         }
12723     }
12724 }
12725
12726
12727 /* Mark DIE as being used.  If DOKIDS is true, then walk down
12728    to DIE's children.  */
12729
12730 static void
12731 prune_unused_types_mark (die, dokids)
12732      dw_die_ref die;
12733      int dokids;
12734 {
12735   dw_die_ref c;
12736
12737   if (die->die_mark == 0)
12738     {
12739       /* We haven't done this node yet.  Mark it as used.  */
12740       die->die_mark = 1;
12741
12742       /* We also have to mark its parents as used.
12743          (But we don't want to mark our parents' kids due to this.)  */
12744       if (die->die_parent)
12745         prune_unused_types_mark (die->die_parent, 0);
12746
12747       /* Mark any referenced nodes.  */
12748       prune_unused_types_walk_attribs (die);
12749     }
12750
12751   if (dokids && die->die_mark != 2)
12752     {
12753       /* We need to walk the children, but haven't done so yet.
12754          Remember that we've walked the kids.  */
12755       die->die_mark = 2;
12756
12757       /* Walk them.  */
12758       for (c = die->die_child; c; c = c->die_sib)
12759         {
12760           /* If this is an array type, we need to make sure our
12761              kids get marked, even if they're types. */
12762           if (die->die_tag == DW_TAG_array_type)
12763             prune_unused_types_mark (c, 1);
12764           else
12765             prune_unused_types_walk (c);
12766         }
12767     }
12768 }
12769
12770
12771 /* Walk the tree DIE and mark types that we actually use.  */
12772
12773 static void
12774 prune_unused_types_walk (die)
12775      dw_die_ref die;
12776 {
12777   dw_die_ref c;
12778
12779   /* Don't do anything if this node is already marked.  */
12780   if (die->die_mark)
12781     return;
12782
12783   switch (die->die_tag) {
12784   case DW_TAG_const_type:
12785   case DW_TAG_packed_type:
12786   case DW_TAG_pointer_type:
12787   case DW_TAG_reference_type:
12788   case DW_TAG_volatile_type:
12789   case DW_TAG_typedef:
12790   case DW_TAG_array_type:
12791   case DW_TAG_structure_type:
12792   case DW_TAG_union_type:
12793   case DW_TAG_class_type:
12794   case DW_TAG_friend:
12795   case DW_TAG_variant_part:
12796   case DW_TAG_enumeration_type:
12797   case DW_TAG_subroutine_type:
12798   case DW_TAG_string_type:
12799   case DW_TAG_set_type:
12800   case DW_TAG_subrange_type:
12801   case DW_TAG_ptr_to_member_type:
12802   case DW_TAG_file_type:
12803     /* It's a type node --- don't mark it.  */
12804     return;
12805
12806   default:
12807     /* Mark everything else.  */
12808     break;
12809   }
12810
12811   die->die_mark = 1;
12812
12813   /* Now, mark any dies referenced from here.  */
12814   prune_unused_types_walk_attribs (die);
12815
12816   /* Mark children.  */
12817   for (c = die->die_child; c; c = c->die_sib)
12818     prune_unused_types_walk (c);
12819 }
12820
12821
12822 /* Remove from the tree DIE any dies that aren't marked.  */
12823
12824 static void
12825 prune_unused_types_prune (die)
12826      dw_die_ref die;
12827 {
12828   dw_die_ref c, p, n;
12829   if (!die->die_mark)
12830     abort();
12831
12832   p = NULL;
12833   for (c = die->die_child; c; c = n)
12834     {
12835       n = c->die_sib;
12836       if (c->die_mark)
12837         {
12838           prune_unused_types_prune (c);
12839           p = c;
12840         }
12841       else
12842         {
12843           if (p)
12844             p->die_sib = n;
12845           else
12846             die->die_child = n;
12847           free_die (c);
12848         }
12849     }
12850 }
12851
12852
12853 /* Remove dies representing declarations that we never use.  */
12854
12855 static void
12856 prune_unused_types ()
12857 {
12858   unsigned int i;
12859   limbo_die_node *node;
12860
12861   /* Clear all the marks.  */
12862   prune_unmark_dies (comp_unit_die);
12863   for (node = limbo_die_list; node; node = node->next)
12864     prune_unmark_dies (node->die);
12865
12866   /* Set the mark on nodes that are actually used.  */
12867   prune_unused_types_walk (comp_unit_die);
12868   for (node = limbo_die_list; node; node = node->next)
12869     prune_unused_types_walk (node->die);
12870
12871   /* Also set the mark on nodes referenced from the
12872      pubname_table or arange_table.  */
12873   for (i=0; i < pubname_table_in_use; i++)
12874     {
12875       prune_unused_types_mark (pubname_table[i].die, 1);
12876     }
12877   for (i=0; i < arange_table_in_use; i++)
12878     {
12879       prune_unused_types_mark (arange_table[i], 1);
12880     }
12881
12882   /* Get rid of nodes that aren't marked.  */
12883   prune_unused_types_prune (comp_unit_die);
12884   for (node = limbo_die_list; node; node = node->next)
12885     prune_unused_types_prune (node->die);
12886
12887   /* Leave the marks clear.  */
12888   prune_unmark_dies (comp_unit_die);
12889   for (node = limbo_die_list; node; node = node->next)
12890     prune_unmark_dies (node->die);
12891 }
12892
12893 /* Output stuff that dwarf requires at the end of every file,
12894    and generate the DWARF-2 debugging info.  */
12895
12896 static void
12897 dwarf2out_finish (input_filename)
12898      const char *input_filename;
12899 {
12900   limbo_die_node *node, *next_node;
12901   dw_die_ref die = 0;
12902
12903   /* Add the name for the main input file now.  We delayed this from
12904      dwarf2out_init to avoid complications with PCH.  */
12905   add_name_attribute (comp_unit_die, input_filename);
12906   if (input_filename[0] != DIR_SEPARATOR)
12907     add_comp_dir_attribute (comp_unit_die);
12908   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
12909     {
12910       size_t i;
12911       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
12912         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR)
12913           {
12914             add_comp_dir_attribute (comp_unit_die);
12915             break;
12916           }
12917     }
12918
12919   /* Traverse the limbo die list, and add parent/child links.  The only
12920      dies without parents that should be here are concrete instances of
12921      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
12922      For concrete instances, we can get the parent die from the abstract
12923      instance.  */
12924   for (node = limbo_die_list; node; node = next_node)
12925     {
12926       next_node = node->next;
12927       die = node->die;
12928
12929       if (die->die_parent == NULL)
12930         {
12931           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
12932           tree context;
12933
12934           if (origin)
12935             add_child_die (origin->die_parent, die);
12936           else if (die == comp_unit_die)
12937             ;
12938           /* If this was an expression for a bound involved in a function
12939              return type, it may be a SAVE_EXPR for which we weren't able
12940              to find a DIE previously.  So try now.  */
12941           else if (node->created_for
12942                    && TREE_CODE (node->created_for) == SAVE_EXPR
12943                    && 0 != (origin = (lookup_decl_die
12944                                       (SAVE_EXPR_CONTEXT
12945                                        (node->created_for)))))
12946             add_child_die (origin, die);
12947           else if (errorcount > 0 || sorrycount > 0)
12948             /* It's OK to be confused by errors in the input.  */
12949             add_child_die (comp_unit_die, die);
12950           else if (node->created_for
12951                    && ((DECL_P (node->created_for)
12952                         && (context = DECL_CONTEXT (node->created_for)))
12953                        || (TYPE_P (node->created_for)
12954                            && (context = TYPE_CONTEXT (node->created_for))))
12955                    && TREE_CODE (context) == FUNCTION_DECL)
12956             {
12957               /* In certain situations, the lexical block containing a
12958                  nested function can be optimized away, which results
12959                  in the nested function die being orphaned.  Likewise
12960                  with the return type of that nested function.  Force
12961                  this to be a child of the containing function.  */
12962               origin = lookup_decl_die (context);
12963               if (! origin)
12964                 abort ();
12965               add_child_die (origin, die);
12966             }
12967           else
12968             abort ();
12969         }
12970     }
12971
12972   limbo_die_list = NULL;
12973
12974   /* Walk through the list of incomplete types again, trying once more to
12975      emit full debugging info for them.  */
12976   retry_incomplete_types ();
12977
12978   /* We need to reverse all the dies before break_out_includes, or
12979      we'll see the end of an include file before the beginning.  */
12980   reverse_all_dies (comp_unit_die);
12981
12982   if (flag_eliminate_unused_debug_types)
12983     prune_unused_types ();
12984
12985   /* Generate separate CUs for each of the include files we've seen.
12986      They will go into limbo_die_list.  */
12987   if (flag_eliminate_dwarf2_dups)
12988     break_out_includes (comp_unit_die);
12989
12990   /* Traverse the DIE's and add add sibling attributes to those DIE's
12991      that have children.  */
12992   add_sibling_attributes (comp_unit_die);
12993   for (node = limbo_die_list; node; node = node->next)
12994     add_sibling_attributes (node->die);
12995
12996   /* Output a terminator label for the .text section.  */
12997   text_section ();
12998   (*targetm.asm_out.internal_label) (asm_out_file, TEXT_END_LABEL, 0);
12999
13000   /* Output the source line correspondence table.  We must do this
13001      even if there is no line information.  Otherwise, on an empty
13002      translation unit, we will generate a present, but empty,
13003      .debug_info section.  IRIX 6.5 `nm' will then complain when
13004      examining the file.  */
13005   if (! DWARF2_ASM_LINE_DEBUG_INFO)
13006     {
13007       named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
13008       output_line_info ();
13009     }
13010
13011   /* Output location list section if necessary.  */
13012   if (have_location_lists)
13013     {
13014       /* Output the location lists info.  */
13015       named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG);
13016       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
13017                                    DEBUG_LOC_SECTION_LABEL, 0);
13018       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
13019       output_location_lists (die);
13020       have_location_lists = 0;
13021     }
13022
13023   /* We can only use the low/high_pc attributes if all of the code was
13024      in .text.  */
13025   if (separate_line_info_table_in_use == 0)
13026     {
13027       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
13028       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
13029     }
13030
13031   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
13032      "base address".  Use zero so that these addresses become absolute.  */
13033   else if (have_location_lists || ranges_table_in_use)
13034     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
13035
13036   if (debug_info_level >= DINFO_LEVEL_NORMAL)
13037     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
13038                        debug_line_section_label);
13039
13040   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13041     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
13042
13043   /* Output all of the compilation units.  We put the main one last so that
13044      the offsets are available to output_pubnames.  */
13045   for (node = limbo_die_list; node; node = node->next)
13046     output_comp_unit (node->die, 0);
13047
13048   output_comp_unit (comp_unit_die, 0);
13049
13050   /* Output the abbreviation table.  */
13051   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
13052   output_abbrev_section ();
13053
13054   /* Output public names table if necessary.  */
13055   if (pubname_table_in_use)
13056     {
13057       named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG);
13058       output_pubnames ();
13059     }
13060
13061   /* Output the address range information.  We only put functions in the arange
13062      table, so don't write it out if we don't have any.  */
13063   if (fde_table_in_use)
13064     {
13065       named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG);
13066       output_aranges ();
13067     }
13068
13069   /* Output ranges section if necessary.  */
13070   if (ranges_table_in_use)
13071     {
13072       named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG);
13073       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
13074       output_ranges ();
13075     }
13076
13077   /* Have to end the primary source file.  */
13078   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13079     {
13080       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13081       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13082       dw2_asm_output_data (1, 0, "End compilation unit");
13083     }
13084
13085   /* If we emitted any DW_FORM_strp form attribute, output the string
13086      table too.  */
13087   if (debug_str_hash)
13088     htab_traverse (debug_str_hash, output_indirect_string, NULL);
13089 }
13090 #else
13091
13092 /* This should never be used, but its address is needed for comparisons.  */
13093 const struct gcc_debug_hooks dwarf2_debug_hooks;
13094
13095 #endif /* DWARF2_DEBUGGING_INFO */
13096
13097 #include "gt-dwarf2out.h"