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