gcc/dwarf2out.c

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