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, 2006, 2007 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 3, 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 COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 /* TODO: Emit .debug_line header even when there are no functions, since
  25            the file numbers are used by .debug_info.  Alternately, leave
  26            out locations for types and decls.
  27          Avoid talking about ctors and op= for PODs.
  28          Factor out common prologue sequences into multiple CIEs.  */
  29
  30 /* The first part of this file deals with the DWARF 2 frame unwind
  31    information, which is also used by the GCC efficient exception handling
  32    mechanism.  The second part, controlled only by an #ifdef
  33    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  34    information.  */
  35
  36 /* DWARF2 Abbreviation Glossary:
  37
  38    CFA = Canonical Frame Address
  39            a fixed address on the stack which identifies a call frame.
  40            We define it to be the value of SP just before the call insn.
  41            The CFA register and offset, which may change during the course
  42            of the function, are used to calculate its value at runtime.
  43
  44    CFI = Call Frame Instruction
  45            an instruction for the DWARF2 abstract machine
  46
  47    CIE = Common Information Entry
  48            information describing information common to one or more FDEs
  49
  50    DIE = Debugging Information Entry
  51
  52    FDE = Frame Description Entry
  53            information describing the stack call frame, in particular,
  54            how to restore registers
  55
  56    DW_CFA_... = DWARF2 CFA call frame instruction
  57    DW_TAG_... = DWARF2 DIE tag */
  58
  59 #include "config.h"
  60 #include "system.h"
  61 #include "coretypes.h"
  62 #include "tm.h"
  63 #include "tree.h"
  64 #include "version.h"
  65 #include "flags.h"
  66 #include "real.h"
  67 #include "rtl.h"
  68 #include "hard-reg-set.h"
  69 #include "regs.h"
  70 #include "insn-config.h"
  71 #include "reload.h"
  72 #include "function.h"
  73 #include "output.h"
  74 #include "expr.h"
  75 #include "libfuncs.h"
  76 #include "except.h"
  77 #include "dwarf2.h"
  78 #include "dwarf2out.h"
  79 #include "dwarf2asm.h"
  80 #include "toplev.h"
  81 #include "varray.h"
  82 #include "ggc.h"
  83 #include "md5.h"
  84 #include "tm_p.h"
  85 #include "diagnostic.h"
  86 #include "debug.h"
  87 #include "target.h"
  88 #include "langhooks.h"
  89 #include "hashtab.h"
  90 #include "cgraph.h"
  91 #include "input.h"
  92
  93 #ifdef DWARF2_DEBUGGING_INFO
  94 static void dwarf2out_source_line (unsigned int, const char *);
  95 #endif
  96
  97 #ifndef DWARF2_FRAME_INFO
  98 # ifdef DWARF2_DEBUGGING_INFO
  99 #  define DWARF2_FRAME_INFO \
 100   (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
 101 # else
 102 #  define DWARF2_FRAME_INFO 0
 103 # endif
 104 #endif
 105
 106 /* Map register numbers held in the call frame info that gcc has
 107    collected using DWARF_FRAME_REGNUM to those that should be output in
 108    .debug_frame and .eh_frame.  */
 109 #ifndef DWARF2_FRAME_REG_OUT
 110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
 111 #endif
 112
 113 /* Decide whether we want to emit frame unwind information for the current
 114    translation unit.  */
 115
 116 int
 117 dwarf2out_do_frame (void)
 118 {
 119   /* We want to emit correct CFA location expressions or lists, so we
 120      have to return true if we're going to output debug info, even if
 121      we're not going to output frame or unwind info.  */
 122   return (write_symbols == DWARF2_DEBUG
 123           || write_symbols == VMS_AND_DWARF2_DEBUG
 124           || DWARF2_FRAME_INFO
 125 #ifdef DWARF2_UNWIND_INFO
 126           || (DWARF2_UNWIND_INFO
 127               && (flag_unwind_tables
 128                   || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
 129 #endif
 130           );
 131 }
 132
 133 /* The size of the target's pointer type.  */
 134 #ifndef PTR_SIZE
 135 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 136 #endif
 137
 138 /* Array of RTXes referenced by the debugging information, which therefore
 139    must be kept around forever.  */
 140 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 141
 142 /* A pointer to the base of a list of incomplete types which might be
 143    completed at some later time.  incomplete_types_list needs to be a
 144    VEC(tree,gc) because we want to tell the garbage collector about
 145    it.  */
 146 static GTY(()) VEC(tree,gc) *incomplete_types;
 147
 148 /* A pointer to the base of a table of references to declaration
 149    scopes.  This table is a display which tracks the nesting
 150    of declaration scopes at the current scope and containing
 151    scopes.  This table is used to find the proper place to
 152    define type declaration DIE's.  */
 153 static GTY(()) VEC(tree,gc) *decl_scope_table;
 154
 155 /* Pointers to various DWARF2 sections.  */
 156 static GTY(()) section *debug_info_section;
 157 static GTY(()) section *debug_abbrev_section;
 158 static GTY(()) section *debug_aranges_section;
 159 static GTY(()) section *debug_macinfo_section;
 160 static GTY(()) section *debug_line_section;
 161 static GTY(()) section *debug_loc_section;
 162 static GTY(()) section *debug_pubnames_section;
 163 static GTY(()) section *debug_pubtypes_section;
 164 static GTY(()) section *debug_str_section;
 165 static GTY(()) section *debug_ranges_section;
 166 static GTY(()) section *debug_frame_section;
 167
 168 /* How to start an assembler comment.  */
 169 #ifndef ASM_COMMENT_START
 170 #define ASM_COMMENT_START ";#"
 171 #endif
 172
 173 typedef struct dw_cfi_struct *dw_cfi_ref;
 174 typedef struct dw_fde_struct *dw_fde_ref;
 175 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 176
 177 /* Call frames are described using a sequence of Call Frame
 178    Information instructions.  The register number, offset
 179    and address fields are provided as possible operands;
 180    their use is selected by the opcode field.  */
 181
 182 enum dw_cfi_oprnd_type {
 183   dw_cfi_oprnd_unused,
 184   dw_cfi_oprnd_reg_num,
 185   dw_cfi_oprnd_offset,
 186   dw_cfi_oprnd_addr,
 187   dw_cfi_oprnd_loc
 188 };
 189
 190 typedef union dw_cfi_oprnd_struct GTY(())
 191 {
 192   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 193   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 194   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 195   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 196 }
 197 dw_cfi_oprnd;
 198
 199 typedef struct dw_cfi_struct GTY(())
 200 {
 201   dw_cfi_ref dw_cfi_next;
 202   enum dwarf_call_frame_info dw_cfi_opc;
 203   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 204     dw_cfi_oprnd1;
 205   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 206     dw_cfi_oprnd2;
 207 }
 208 dw_cfi_node;
 209
 210 /* This is how we define the location of the CFA. We use to handle it
 211    as REG + OFFSET all the time,  but now it can be more complex.
 212    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 213    Instead of passing around REG and OFFSET, we pass a copy
 214    of this structure.  */
 215 typedef struct cfa_loc GTY(())
 216 {
 217   HOST_WIDE_INT offset;
 218   HOST_WIDE_INT base_offset;
 219   unsigned int reg;
 220   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 221 } dw_cfa_location;
 222
 223 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 224    refer to a single Common Information Entry (CIE), defined at
 225    the beginning of the .debug_frame section.  This use of a single
 226    CIE obviates the need to keep track of multiple CIE's
 227    in the DWARF generation routines below.  */
 228
 229 typedef struct dw_fde_struct GTY(())
 230 {
 231   tree decl;
 232   const char *dw_fde_begin;
 233   const char *dw_fde_current_label;
 234   const char *dw_fde_end;
 235   const char *dw_fde_hot_section_label;
 236   const char *dw_fde_hot_section_end_label;
 237   const char *dw_fde_unlikely_section_label;
 238   const char *dw_fde_unlikely_section_end_label;
 239   bool dw_fde_switched_sections;
 240   dw_cfi_ref dw_fde_cfi;
 241   unsigned funcdef_number;
 242   unsigned all_throwers_are_sibcalls : 1;
 243   unsigned nothrow : 1;
 244   unsigned uses_eh_lsda : 1;
 245 }
 246 dw_fde_node;
 247
 248 /* Maximum size (in bytes) of an artificially generated label.  */
 249 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 250
 251 /* The size of addresses as they appear in the Dwarf 2 data.
 252    Some architectures use word addresses to refer to code locations,
 253    but Dwarf 2 info always uses byte addresses.  On such machines,
 254    Dwarf 2 addresses need to be larger than the architecture's
 255    pointers.  */
 256 #ifndef DWARF2_ADDR_SIZE
 257 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 258 #endif
 259
 260 /* The size in bytes of a DWARF field indicating an offset or length
 261    relative to a debug info section, specified to be 4 bytes in the
 262    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 263    as PTR_SIZE.  */
 264
 265 #ifndef DWARF_OFFSET_SIZE
 266 #define DWARF_OFFSET_SIZE 4
 267 #endif
 268
 269 /* According to the (draft) DWARF 3 specification, the initial length
 270    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 271    bytes are 0xffffffff, followed by the length stored in the next 8
 272    bytes.
 273
 274    However, the SGI/MIPS ABI uses an initial length which is equal to
 275    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 276
 277 #ifndef DWARF_INITIAL_LENGTH_SIZE
 278 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 279 #endif
 280
 281 #define DWARF_VERSION 2
 282
 283 /* Round SIZE up to the nearest BOUNDARY.  */
 284 #define DWARF_ROUND(SIZE,BOUNDARY) \
 285   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 286
 287 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 288 #ifndef DWARF_CIE_DATA_ALIGNMENT
 289 #ifdef STACK_GROWS_DOWNWARD
 290 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 291 #else
 292 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 293 #endif
 294 #endif
 295
 296 /* CIE identifier.  */
 297 #if HOST_BITS_PER_WIDE_INT >= 64
 298 #define DWARF_CIE_ID \
 299   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
 300 #else
 301 #define DWARF_CIE_ID DW_CIE_ID
 302 #endif
 303
 304 /* A pointer to the base of a table that contains frame description
 305    information for each routine.  */
 306 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 307
 308 /* Number of elements currently allocated for fde_table.  */
 309 static GTY(()) unsigned fde_table_allocated;
 310
 311 /* Number of elements in fde_table currently in use.  */
 312 static GTY(()) unsigned fde_table_in_use;
 313
 314 /* Size (in elements) of increments by which we may expand the
 315    fde_table.  */
 316 #define FDE_TABLE_INCREMENT 256
 317
 318 /* A list of call frame insns for the CIE.  */
 319 static GTY(()) dw_cfi_ref cie_cfi_head;
 320
 321 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 322 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 323    attribute that accelerates the lookup of the FDE associated
 324    with the subprogram.  This variable holds the table index of the FDE
 325    associated with the current function (body) definition.  */
 326 static unsigned current_funcdef_fde;
 327 #endif
 328
 329 struct indirect_string_node GTY(())
 330 {
 331   const char *str;
 332   unsigned int refcount;
 333   unsigned int form;
 334   char *label;
 335 };
 336
 337 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 338
 339 static GTY(()) int dw2_string_counter;
 340 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 341
 342 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 343
 344 /* Forward declarations for functions defined in this file.  */
 345
 346 static char *stripattributes (const char *);
 347 static const char *dwarf_cfi_name (unsigned);
 348 static dw_cfi_ref new_cfi (void);
 349 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 350 static void add_fde_cfi (const char *, dw_cfi_ref);
 351 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
 352 static void lookup_cfa (dw_cfa_location *);
 353 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 354 #ifdef DWARF2_UNWIND_INFO
 355 static void initial_return_save (rtx);
 356 #endif
 357 static HOST_WIDE_INT stack_adjust_offset (const_rtx);
 358 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 359 static void output_call_frame_info (int);
 360 static void dwarf2out_stack_adjust (rtx, bool);
 361 static void flush_queued_reg_saves (void);
 362 static bool clobbers_queued_reg_save (const_rtx);
 363 static void dwarf2out_frame_debug_expr (rtx, const char *);
 364
 365 /* Support for complex CFA locations.  */
 366 static void output_cfa_loc (dw_cfi_ref);
 367 static void get_cfa_from_loc_descr (dw_cfa_location *,
 368                                     struct dw_loc_descr_struct *);
 369 static struct dw_loc_descr_struct *build_cfa_loc
 370   (dw_cfa_location *, HOST_WIDE_INT);
 371 static void def_cfa_1 (const char *, dw_cfa_location *);
 372
 373 /* How to start an assembler comment.  */
 374 #ifndef ASM_COMMENT_START
 375 #define ASM_COMMENT_START ";#"
 376 #endif
 377
 378 /* Data and reference forms for relocatable data.  */
 379 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 380 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 381
 382 #ifndef DEBUG_FRAME_SECTION
 383 #define DEBUG_FRAME_SECTION     ".debug_frame"
 384 #endif
 385
 386 #ifndef FUNC_BEGIN_LABEL
 387 #define FUNC_BEGIN_LABEL        "LFB"
 388 #endif
 389
 390 #ifndef FUNC_END_LABEL
 391 #define FUNC_END_LABEL          "LFE"
 392 #endif
 393
 394 #ifndef FRAME_BEGIN_LABEL
 395 #define FRAME_BEGIN_LABEL       "Lframe"
 396 #endif
 397 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 398 #define CIE_END_LABEL           "LECIE"
 399 #define FDE_LABEL               "LSFDE"
 400 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 401 #define FDE_END_LABEL           "LEFDE"
 402 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 403 #define LINE_NUMBER_END_LABEL   "LELT"
 404 #define LN_PROLOG_AS_LABEL      "LASLTP"
 405 #define LN_PROLOG_END_LABEL     "LELTP"
 406 #define DIE_LABEL_PREFIX        "DW"
 407
 408 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 409    is the column for PC, or the first column after all of the hard
 410    registers.  */
 411 #ifndef DWARF_FRAME_RETURN_COLUMN
 412 #ifdef PC_REGNUM
 413 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 414 #else
 415 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 416 #endif
 417 #endif
 418
 419 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 420    default, we just provide columns for all registers.  */
 421 #ifndef DWARF_FRAME_REGNUM
 422 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 423 #endif
 424 \f
 425 /* Hook used by __throw.  */
 426
 427 rtx
 428 expand_builtin_dwarf_sp_column (void)
 429 {
 430   unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
 431   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
 432 }
 433
 434 /* Return a pointer to a copy of the section string name S with all
 435    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 436
 437 static inline char *
 438 stripattributes (const char *s)
 439 {
 440   char *stripped = XNEWVEC (char, strlen (s) + 2);
 441   char *p = stripped;
 442
 443   *p++ = '*';
 444
 445   while (*s && *s != ',')
 446     *p++ = *s++;
 447
 448   *p = '\0';
 449   return stripped;
 450 }
 451
 452 /* MEM is a memory reference for the register size table, each element of
 453    which has mode MODE.  Initialize column C as a return address column.  */
 454
 455 static void
 456 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
 457 {
 458   HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
 459   HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
 460   emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 461 }
 462
 463 /* Generate code to initialize the register size table.  */
 464
 465 void
 466 expand_builtin_init_dwarf_reg_sizes (tree address)
 467 {
 468   unsigned int i;
 469   enum machine_mode mode = TYPE_MODE (char_type_node);
 470   rtx addr = expand_normal (address);
 471   rtx mem = gen_rtx_MEM (BLKmode, addr);
 472   bool wrote_return_column = false;
 473
 474   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 475     {
 476       int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
 477
 478       if (rnum < DWARF_FRAME_REGISTERS)
 479         {
 480           HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
 481           enum machine_mode save_mode = reg_raw_mode[i];
 482           HOST_WIDE_INT size;
 483
 484           if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 485             save_mode = choose_hard_reg_mode (i, 1, true);
 486           if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 487             {
 488               if (save_mode == VOIDmode)
 489                 continue;
 490               wrote_return_column = true;
 491             }
 492           size = GET_MODE_SIZE (save_mode);
 493           if (offset < 0)
 494             continue;
 495
 496           emit_move_insn (adjust_address (mem, mode, offset),
 497                           gen_int_mode (size, mode));
 498         }
 499     }
 500
 501   if (!wrote_return_column)
 502     init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
 503
 504 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 505   init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
 506 #endif
 507
 508   targetm.init_dwarf_reg_sizes_extra (address);
 509 }
 510
 511 /* Convert a DWARF call frame info. operation to its string name */
 512
 513 static const char *
 514 dwarf_cfi_name (unsigned int cfi_opc)
 515 {
 516   switch (cfi_opc)
 517     {
 518     case DW_CFA_advance_loc:
 519       return "DW_CFA_advance_loc";
 520     case DW_CFA_offset:
 521       return "DW_CFA_offset";
 522     case DW_CFA_restore:
 523       return "DW_CFA_restore";
 524     case DW_CFA_nop:
 525       return "DW_CFA_nop";
 526     case DW_CFA_set_loc:
 527       return "DW_CFA_set_loc";
 528     case DW_CFA_advance_loc1:
 529       return "DW_CFA_advance_loc1";
 530     case DW_CFA_advance_loc2:
 531       return "DW_CFA_advance_loc2";
 532     case DW_CFA_advance_loc4:
 533       return "DW_CFA_advance_loc4";
 534     case DW_CFA_offset_extended:
 535       return "DW_CFA_offset_extended";
 536     case DW_CFA_restore_extended:
 537       return "DW_CFA_restore_extended";
 538     case DW_CFA_undefined:
 539       return "DW_CFA_undefined";
 540     case DW_CFA_same_value:
 541       return "DW_CFA_same_value";
 542     case DW_CFA_register:
 543       return "DW_CFA_register";
 544     case DW_CFA_remember_state:
 545       return "DW_CFA_remember_state";
 546     case DW_CFA_restore_state:
 547       return "DW_CFA_restore_state";
 548     case DW_CFA_def_cfa:
 549       return "DW_CFA_def_cfa";
 550     case DW_CFA_def_cfa_register:
 551       return "DW_CFA_def_cfa_register";
 552     case DW_CFA_def_cfa_offset:
 553       return "DW_CFA_def_cfa_offset";
 554
 555     /* DWARF 3 */
 556     case DW_CFA_def_cfa_expression:
 557       return "DW_CFA_def_cfa_expression";
 558     case DW_CFA_expression:
 559       return "DW_CFA_expression";
 560     case DW_CFA_offset_extended_sf:
 561       return "DW_CFA_offset_extended_sf";
 562     case DW_CFA_def_cfa_sf:
 563       return "DW_CFA_def_cfa_sf";
 564     case DW_CFA_def_cfa_offset_sf:
 565       return "DW_CFA_def_cfa_offset_sf";
 566
 567     /* SGI/MIPS specific */
 568     case DW_CFA_MIPS_advance_loc8:
 569       return "DW_CFA_MIPS_advance_loc8";
 570
 571     /* GNU extensions */
 572     case DW_CFA_GNU_window_save:
 573       return "DW_CFA_GNU_window_save";
 574     case DW_CFA_GNU_args_size:
 575       return "DW_CFA_GNU_args_size";
 576     case DW_CFA_GNU_negative_offset_extended:
 577       return "DW_CFA_GNU_negative_offset_extended";
 578
 579     default:
 580       return "DW_CFA_<unknown>";
 581     }
 582 }
 583
 584 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 585
 586 static inline dw_cfi_ref
 587 new_cfi (void)
 588 {
 589   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
 590
 591   cfi->dw_cfi_next = NULL;
 592   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 593   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 594
 595   return cfi;
 596 }
 597
 598 /* Add a Call Frame Instruction to list of instructions.  */
 599
 600 static inline void
 601 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 602 {
 603   dw_cfi_ref *p;
 604
 605   /* Find the end of the chain.  */
 606   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 607     ;
 608
 609   *p = cfi;
 610 }
 611
 612 /* Generate a new label for the CFI info to refer to.  */
 613
 614 char *
 615 dwarf2out_cfi_label (void)
 616 {
 617   static char label[20];
 618
 619   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 620   ASM_OUTPUT_LABEL (asm_out_file, label);
 621   return label;
 622 }
 623
 624 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 625    or to the CIE if LABEL is NULL.  */
 626
 627 static void
 628 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 629 {
 630   if (label)
 631     {
 632       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 633
 634       if (*label == 0)
 635         label = dwarf2out_cfi_label ();
 636
 637       if (fde->dw_fde_current_label == NULL
 638           || strcmp (label, fde->dw_fde_current_label) != 0)
 639         {
 640           dw_cfi_ref xcfi;
 641
 642           label = xstrdup (label);
 643
 644           /* Set the location counter to the new label.  */
 645           xcfi = new_cfi ();
 646           /* If we have a current label, advance from there, otherwise
 647              set the location directly using set_loc.  */
 648           xcfi->dw_cfi_opc = fde->dw_fde_current_label
 649                              ? DW_CFA_advance_loc4
 650                              : DW_CFA_set_loc;
 651           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 652           add_cfi (&fde->dw_fde_cfi, xcfi);
 653
 654           fde->dw_fde_current_label = label;
 655         }
 656
 657       add_cfi (&fde->dw_fde_cfi, cfi);
 658     }
 659
 660   else
 661     add_cfi (&cie_cfi_head, cfi);
 662 }
 663
 664 /* Subroutine of lookup_cfa.  */
 665
 666 static void
 667 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
 668 {
 669   switch (cfi->dw_cfi_opc)
 670     {
 671     case DW_CFA_def_cfa_offset:
 672       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 673       break;
 674     case DW_CFA_def_cfa_offset_sf:
 675       loc->offset
 676         = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 677       break;
 678     case DW_CFA_def_cfa_register:
 679       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 680       break;
 681     case DW_CFA_def_cfa:
 682       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 683       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 684       break;
 685     case DW_CFA_def_cfa_sf:
 686       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 687       loc->offset
 688         = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 689       break;
 690     case DW_CFA_def_cfa_expression:
 691       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 692       break;
 693     default:
 694       break;
 695     }
 696 }
 697
 698 /* Find the previous value for the CFA.  */
 699
 700 static void
 701 lookup_cfa (dw_cfa_location *loc)
 702 {
 703   dw_cfi_ref cfi;
 704
 705   loc->reg = INVALID_REGNUM;
 706   loc->offset = 0;
 707   loc->indirect = 0;
 708   loc->base_offset = 0;
 709
 710   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 711     lookup_cfa_1 (cfi, loc);
 712
 713   if (fde_table_in_use)
 714     {
 715       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 716       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 717         lookup_cfa_1 (cfi, loc);
 718     }
 719 }
 720
 721 /* The current rule for calculating the DWARF2 canonical frame address.  */
 722 static dw_cfa_location cfa;
 723
 724 /* The register used for saving registers to the stack, and its offset
 725    from the CFA.  */
 726 static dw_cfa_location cfa_store;
 727
 728 /* The running total of the size of arguments pushed onto the stack.  */
 729 static HOST_WIDE_INT args_size;
 730
 731 /* The last args_size we actually output.  */
 732 static HOST_WIDE_INT old_args_size;
 733
 734 /* Entry point to update the canonical frame address (CFA).
 735    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 736    calculated from REG+OFFSET.  */
 737
 738 void
 739 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 740 {
 741   dw_cfa_location loc;
 742   loc.indirect = 0;
 743   loc.base_offset = 0;
 744   loc.reg = reg;
 745   loc.offset = offset;
 746   def_cfa_1 (label, &loc);
 747 }
 748
 749 /* Determine if two dw_cfa_location structures define the same data.  */
 750
 751 static bool
 752 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
 753 {
 754   return (loc1->reg == loc2->reg
 755           && loc1->offset == loc2->offset
 756           && loc1->indirect == loc2->indirect
 757           && (loc1->indirect == 0
 758               || loc1->base_offset == loc2->base_offset));
 759 }
 760
 761 /* This routine does the actual work.  The CFA is now calculated from
 762    the dw_cfa_location structure.  */
 763
 764 static void
 765 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
 766 {
 767   dw_cfi_ref cfi;
 768   dw_cfa_location old_cfa, loc;
 769
 770   cfa = *loc_p;
 771   loc = *loc_p;
 772
 773   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 774     cfa_store.offset = loc.offset;
 775
 776   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 777   lookup_cfa (&old_cfa);
 778
 779   /* If nothing changed, no need to issue any call frame instructions.  */
 780   if (cfa_equal_p (&loc, &old_cfa))
 781     return;
 782
 783   cfi = new_cfi ();
 784
 785   if (loc.reg == old_cfa.reg && !loc.indirect)
 786     {
 787       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
 788          the CFA register did not change but the offset did.  */
 789       if (loc.offset < 0)
 790         {
 791           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 792           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 793
 794           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
 795           cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
 796         }
 797       else
 798         {
 799           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 800           cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 801         }
 802     }
 803
 804 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 805   else if (loc.offset == old_cfa.offset
 806            && old_cfa.reg != INVALID_REGNUM
 807            && !loc.indirect)
 808     {
 809       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 810          indicating the CFA register has changed to <register> but the
 811          offset has not changed.  */
 812       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 813       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 814     }
 815 #endif
 816
 817   else if (loc.indirect == 0)
 818     {
 819       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 820          indicating the CFA register has changed to <register> with
 821          the specified offset.  */
 822       if (loc.offset < 0)
 823         {
 824           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 825           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 826
 827           cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
 828           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 829           cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
 830         }
 831       else
 832         {
 833           cfi->dw_cfi_opc = DW_CFA_def_cfa;
 834           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 835           cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 836         }
 837     }
 838   else
 839     {
 840       /* Construct a DW_CFA_def_cfa_expression instruction to
 841          calculate the CFA using a full location expression since no
 842          register-offset pair is available.  */
 843       struct dw_loc_descr_struct *loc_list;
 844
 845       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 846       loc_list = build_cfa_loc (&loc, 0);
 847       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 848     }
 849
 850   add_fde_cfi (label, cfi);
 851 }
 852
 853 /* Add the CFI for saving a register.  REG is the CFA column number.
 854    LABEL is passed to add_fde_cfi.
 855    If SREG is -1, the register is saved at OFFSET from the CFA;
 856    otherwise it is saved in SREG.  */
 857
 858 static void
 859 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
 860 {
 861   dw_cfi_ref cfi = new_cfi ();
 862
 863   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 864
 865   if (sreg == INVALID_REGNUM)
 866     {
 867       if (reg & ~0x3f)
 868         /* The register number won't fit in 6 bits, so we have to use
 869            the long form.  */
 870         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 871       else
 872         cfi->dw_cfi_opc = DW_CFA_offset;
 873
 874 #ifdef ENABLE_CHECKING
 875       {
 876         /* If we get an offset that is not a multiple of
 877            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 878            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 879            description.  */
 880         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 881
 882         gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
 883       }
 884 #endif
 885       offset /= DWARF_CIE_DATA_ALIGNMENT;
 886       if (offset < 0)
 887         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 888
 889       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 890     }
 891   else if (sreg == reg)
 892     cfi->dw_cfi_opc = DW_CFA_same_value;
 893   else
 894     {
 895       cfi->dw_cfi_opc = DW_CFA_register;
 896       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 897     }
 898
 899   add_fde_cfi (label, cfi);
 900 }
 901
 902 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 903    This CFI tells the unwinder that it needs to restore the window registers
 904    from the previous frame's window save area.
 905
 906    ??? Perhaps we should note in the CIE where windows are saved (instead of
 907    assuming 0(cfa)) and what registers are in the window.  */
 908
 909 void
 910 dwarf2out_window_save (const char *label)
 911 {
 912   dw_cfi_ref cfi = new_cfi ();
 913
 914   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 915   add_fde_cfi (label, cfi);
 916 }
 917
 918 /* Add a CFI to update the running total of the size of arguments
 919    pushed onto the stack.  */
 920
 921 void
 922 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
 923 {
 924   dw_cfi_ref cfi;
 925
 926   if (size == old_args_size)
 927     return;
 928
 929   old_args_size = size;
 930
 931   cfi = new_cfi ();
 932   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 933   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 934   add_fde_cfi (label, cfi);
 935 }
 936
 937 /* Entry point for saving a register to the stack.  REG is the GCC register
 938    number.  LABEL and OFFSET are passed to reg_save.  */
 939
 940 void
 941 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 942 {
 943   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
 944 }
 945
 946 /* Entry point for saving the return address in the stack.
 947    LABEL and OFFSET are passed to reg_save.  */
 948
 949 void
 950 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
 951 {
 952   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
 953 }
 954
 955 /* Entry point for saving the return address in a register.
 956    LABEL and SREG are passed to reg_save.  */
 957
 958 void
 959 dwarf2out_return_reg (const char *label, unsigned int sreg)
 960 {
 961   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
 962 }
 963
 964 #ifdef DWARF2_UNWIND_INFO
 965 /* Record the initial position of the return address.  RTL is
 966    INCOMING_RETURN_ADDR_RTX.  */
 967
 968 static void
 969 initial_return_save (rtx rtl)
 970 {
 971   unsigned int reg = INVALID_REGNUM;
 972   HOST_WIDE_INT offset = 0;
 973
 974   switch (GET_CODE (rtl))
 975     {
 976     case REG:
 977       /* RA is in a register.  */
 978       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 979       break;
 980
 981     case MEM:
 982       /* RA is on the stack.  */
 983       rtl = XEXP (rtl, 0);
 984       switch (GET_CODE (rtl))
 985         {
 986         case REG:
 987           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
 988           offset = 0;
 989           break;
 990
 991         case PLUS:
 992           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 993           offset = INTVAL (XEXP (rtl, 1));
 994           break;
 995
 996         case MINUS:
 997           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 998           offset = -INTVAL (XEXP (rtl, 1));
 999           break;
1000
1001         default:
1002           gcc_unreachable ();
1003         }
1004
1005       break;
1006
1007     case PLUS:
1008       /* The return address is at some offset from any value we can
1009          actually load.  For instance, on the SPARC it is in %i7+8. Just
1010          ignore the offset for now; it doesn't matter for unwinding frames.  */
1011       gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1012       initial_return_save (XEXP (rtl, 0));
1013       return;
1014
1015     default:
1016       gcc_unreachable ();
1017     }
1018
1019   if (reg != DWARF_FRAME_RETURN_COLUMN)
1020     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1021 }
1022 #endif
1023
1024 /* Given a SET, calculate the amount of stack adjustment it
1025    contains.  */
1026
1027 static HOST_WIDE_INT
1028 stack_adjust_offset (const_rtx pattern)
1029 {
1030   const_rtx src = SET_SRC (pattern);
1031   const_rtx dest = SET_DEST (pattern);
1032   HOST_WIDE_INT offset = 0;
1033   enum rtx_code code;
1034
1035   if (dest == stack_pointer_rtx)
1036     {
1037       /* (set (reg sp) (plus (reg sp) (const_int))) */
1038       code = GET_CODE (src);
1039       if (! (code == PLUS || code == MINUS)
1040           || XEXP (src, 0) != stack_pointer_rtx
1041           || GET_CODE (XEXP (src, 1)) != CONST_INT)
1042         return 0;
1043
1044       offset = INTVAL (XEXP (src, 1));
1045       if (code == PLUS)
1046         offset = -offset;
1047     }
1048   else if (MEM_P (dest))
1049     {
1050       /* (set (mem (pre_dec (reg sp))) (foo)) */
1051       src = XEXP (dest, 0);
1052       code = GET_CODE (src);
1053
1054       switch (code)
1055         {
1056         case PRE_MODIFY:
1057         case POST_MODIFY:
1058           if (XEXP (src, 0) == stack_pointer_rtx)
1059             {
1060               rtx val = XEXP (XEXP (src, 1), 1);
1061               /* We handle only adjustments by constant amount.  */
1062               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1063                           && GET_CODE (val) == CONST_INT);
1064               offset = -INTVAL (val);
1065               break;
1066             }
1067           return 0;
1068
1069         case PRE_DEC:
1070         case POST_DEC:
1071           if (XEXP (src, 0) == stack_pointer_rtx)
1072             {
1073               offset = GET_MODE_SIZE (GET_MODE (dest));
1074               break;
1075             }
1076           return 0;
1077
1078         case PRE_INC:
1079         case POST_INC:
1080           if (XEXP (src, 0) == stack_pointer_rtx)
1081             {
1082               offset = -GET_MODE_SIZE (GET_MODE (dest));
1083               break;
1084             }
1085           return 0;
1086
1087         default:
1088           return 0;
1089         }
1090     }
1091   else
1092     return 0;
1093
1094   return offset;
1095 }
1096
1097 /* Check INSN to see if it looks like a push or a stack adjustment, and
1098    make a note of it if it does.  EH uses this information to find out how
1099    much extra space it needs to pop off the stack.  */
1100
1101 static void
1102 dwarf2out_stack_adjust (rtx insn, bool after_p)
1103 {
1104   HOST_WIDE_INT offset;
1105   const char *label;
1106   int i;
1107
1108   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1109      with this function.  Proper support would require all frame-related
1110      insns to be marked, and to be able to handle saving state around
1111      epilogues textually in the middle of the function.  */
1112   if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1113     return;
1114
1115   /* If only calls can throw, and we have a frame pointer,
1116      save up adjustments until we see the CALL_INSN.  */
1117   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1118     {
1119       if (CALL_P (insn) && !after_p)
1120         {
1121           /* Extract the size of the args from the CALL rtx itself.  */
1122           insn = PATTERN (insn);
1123           if (GET_CODE (insn) == PARALLEL)
1124             insn = XVECEXP (insn, 0, 0);
1125           if (GET_CODE (insn) == SET)
1126             insn = SET_SRC (insn);
1127           gcc_assert (GET_CODE (insn) == CALL);
1128           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1129         }
1130       return;
1131     }
1132
1133   if (CALL_P (insn) && !after_p)
1134     {
1135       if (!flag_asynchronous_unwind_tables)
1136         dwarf2out_args_size ("", args_size);
1137       return;
1138     }
1139   else if (BARRIER_P (insn))
1140     {
1141       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1142          the compiler will have already emitted a stack adjustment, but
1143          doesn't bother for calls to noreturn functions.  */
1144 #ifdef STACK_GROWS_DOWNWARD
1145       offset = -args_size;
1146 #else
1147       offset = args_size;
1148 #endif
1149     }
1150   else if (GET_CODE (PATTERN (insn)) == SET)
1151     offset = stack_adjust_offset (PATTERN (insn));
1152   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1153            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1154     {
1155       /* There may be stack adjustments inside compound insns.  Search
1156          for them.  */
1157       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1158         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1159           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1160     }
1161   else
1162     return;
1163
1164   if (offset == 0)
1165     return;
1166
1167   if (cfa.reg == STACK_POINTER_REGNUM)
1168     cfa.offset += offset;
1169
1170 #ifndef STACK_GROWS_DOWNWARD
1171   offset = -offset;
1172 #endif
1173
1174   args_size += offset;
1175   if (args_size < 0)
1176     args_size = 0;
1177
1178   label = dwarf2out_cfi_label ();
1179   def_cfa_1 (label, &cfa);
1180   if (flag_asynchronous_unwind_tables)
1181     dwarf2out_args_size (label, args_size);
1182 }
1183
1184 #endif
1185
1186 /* We delay emitting a register save until either (a) we reach the end
1187    of the prologue or (b) the register is clobbered.  This clusters
1188    register saves so that there are fewer pc advances.  */
1189
1190 struct queued_reg_save GTY(())
1191 {
1192   struct queued_reg_save *next;
1193   rtx reg;
1194   HOST_WIDE_INT cfa_offset;
1195   rtx saved_reg;
1196 };
1197
1198 static GTY(()) struct queued_reg_save *queued_reg_saves;
1199
1200 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1201 struct reg_saved_in_data GTY(()) {
1202   rtx orig_reg;
1203   rtx saved_in_reg;
1204 };
1205
1206 /* A list of registers saved in other registers.
1207    The list intentionally has a small maximum capacity of 4; if your
1208    port needs more than that, you might consider implementing a
1209    more efficient data structure.  */
1210 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1211 static GTY(()) size_t num_regs_saved_in_regs;
1212
1213 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1214 static const char *last_reg_save_label;
1215
1216 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1217    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1218
1219 static void
1220 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1221 {
1222   struct queued_reg_save *q;
1223
1224   /* Duplicates waste space, but it's also necessary to remove them
1225      for correctness, since the queue gets output in reverse
1226      order.  */
1227   for (q = queued_reg_saves; q != NULL; q = q->next)
1228     if (REGNO (q->reg) == REGNO (reg))
1229       break;
1230
1231   if (q == NULL)
1232     {
1233       q = ggc_alloc (sizeof (*q));
1234       q->next = queued_reg_saves;
1235       queued_reg_saves = q;
1236     }
1237
1238   q->reg = reg;
1239   q->cfa_offset = offset;
1240   q->saved_reg = sreg;
1241
1242   last_reg_save_label = label;
1243 }
1244
1245 /* Output all the entries in QUEUED_REG_SAVES.  */
1246
1247 static void
1248 flush_queued_reg_saves (void)
1249 {
1250   struct queued_reg_save *q;
1251
1252   for (q = queued_reg_saves; q; q = q->next)
1253     {
1254       size_t i;
1255       unsigned int reg, sreg;
1256
1257       for (i = 0; i < num_regs_saved_in_regs; i++)
1258         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1259           break;
1260       if (q->saved_reg && i == num_regs_saved_in_regs)
1261         {
1262           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1263           num_regs_saved_in_regs++;
1264         }
1265       if (i != num_regs_saved_in_regs)
1266         {
1267           regs_saved_in_regs[i].orig_reg = q->reg;
1268           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1269         }
1270
1271       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1272       if (q->saved_reg)
1273         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1274       else
1275         sreg = INVALID_REGNUM;
1276       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1277     }
1278
1279   queued_reg_saves = NULL;
1280   last_reg_save_label = NULL;
1281 }
1282
1283 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1284    location for?  Or, does it clobber a register which we've previously
1285    said that some other register is saved in, and for which we now
1286    have a new location for?  */
1287
1288 static bool
1289 clobbers_queued_reg_save (const_rtx insn)
1290 {
1291   struct queued_reg_save *q;
1292
1293   for (q = queued_reg_saves; q; q = q->next)
1294     {
1295       size_t i;
1296       if (modified_in_p (q->reg, insn))
1297         return true;
1298       for (i = 0; i < num_regs_saved_in_regs; i++)
1299         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1300             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1301           return true;
1302     }
1303
1304   return false;
1305 }
1306
1307 /* Entry point for saving the first register into the second.  */
1308
1309 void
1310 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1311 {
1312   size_t i;
1313   unsigned int regno, sregno;
1314
1315   for (i = 0; i < num_regs_saved_in_regs; i++)
1316     if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1317       break;
1318   if (i == num_regs_saved_in_regs)
1319     {
1320       gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1321       num_regs_saved_in_regs++;
1322     }
1323   regs_saved_in_regs[i].orig_reg = reg;
1324   regs_saved_in_regs[i].saved_in_reg = sreg;
1325
1326   regno = DWARF_FRAME_REGNUM (REGNO (reg));
1327   sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1328   reg_save (label, regno, sregno, 0);
1329 }
1330
1331 /* What register, if any, is currently saved in REG?  */
1332
1333 static rtx
1334 reg_saved_in (rtx reg)
1335 {
1336   unsigned int regn = REGNO (reg);
1337   size_t i;
1338   struct queued_reg_save *q;
1339
1340   for (q = queued_reg_saves; q; q = q->next)
1341     if (q->saved_reg && regn == REGNO (q->saved_reg))
1342       return q->reg;
1343
1344   for (i = 0; i < num_regs_saved_in_regs; i++)
1345     if (regs_saved_in_regs[i].saved_in_reg
1346         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1347       return regs_saved_in_regs[i].orig_reg;
1348
1349   return NULL_RTX;
1350 }
1351
1352
1353 /* A temporary register holding an integral value used in adjusting SP
1354    or setting up the store_reg.  The "offset" field holds the integer
1355    value, not an offset.  */
1356 static dw_cfa_location cfa_temp;
1357
1358 /* Record call frame debugging information for an expression EXPR,
1359    which either sets SP or FP (adjusting how we calculate the frame
1360    address) or saves a register to the stack or another register.
1361    LABEL indicates the address of EXPR.
1362
1363    This function encodes a state machine mapping rtxes to actions on
1364    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1365    users need not read the source code.
1366
1367   The High-Level Picture
1368
1369   Changes in the register we use to calculate the CFA: Currently we
1370   assume that if you copy the CFA register into another register, we
1371   should take the other one as the new CFA register; this seems to
1372   work pretty well.  If it's wrong for some target, it's simple
1373   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1374
1375   Changes in the register we use for saving registers to the stack:
1376   This is usually SP, but not always.  Again, we deduce that if you
1377   copy SP into another register (and SP is not the CFA register),
1378   then the new register is the one we will be using for register
1379   saves.  This also seems to work.
1380
1381   Register saves: There's not much guesswork about this one; if
1382   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1383   register save, and the register used to calculate the destination
1384   had better be the one we think we're using for this purpose.
1385   It's also assumed that a copy from a call-saved register to another
1386   register is saving that register if RTX_FRAME_RELATED_P is set on
1387   that instruction.  If the copy is from a call-saved register to
1388   the *same* register, that means that the register is now the same
1389   value as in the caller.
1390
1391   Except: If the register being saved is the CFA register, and the
1392   offset is nonzero, we are saving the CFA, so we assume we have to
1393   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1394   the intent is to save the value of SP from the previous frame.
1395
1396   In addition, if a register has previously been saved to a different
1397   register,
1398
1399   Invariants / Summaries of Rules
1400
1401   cfa          current rule for calculating the CFA.  It usually
1402                consists of a register and an offset.
1403   cfa_store    register used by prologue code to save things to the stack
1404                cfa_store.offset is the offset from the value of
1405                cfa_store.reg to the actual CFA
1406   cfa_temp     register holding an integral value.  cfa_temp.offset
1407                stores the value, which will be used to adjust the
1408                stack pointer.  cfa_temp is also used like cfa_store,
1409                to track stores to the stack via fp or a temp reg.
1410
1411   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1412                with cfa.reg as the first operand changes the cfa.reg and its
1413                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1414                cfa_temp.offset.
1415
1416   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1417                expression yielding a constant.  This sets cfa_temp.reg
1418                and cfa_temp.offset.
1419
1420   Rule 5:      Create a new register cfa_store used to save items to the
1421                stack.
1422
1423   Rules 10-14: Save a register to the stack.  Define offset as the
1424                difference of the original location and cfa_store's
1425                location (or cfa_temp's location if cfa_temp is used).
1426
1427   The Rules
1428
1429   "{a,b}" indicates a choice of a xor b.
1430   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1431
1432   Rule 1:
1433   (set <reg1> <reg2>:cfa.reg)
1434   effects: cfa.reg = <reg1>
1435            cfa.offset unchanged
1436            cfa_temp.reg = <reg1>
1437            cfa_temp.offset = cfa.offset
1438
1439   Rule 2:
1440   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1441                               {<const_int>,<reg>:cfa_temp.reg}))
1442   effects: cfa.reg = sp if fp used
1443            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1444            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1445              if cfa_store.reg==sp
1446
1447   Rule 3:
1448   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1449   effects: cfa.reg = fp
1450            cfa_offset += +/- <const_int>
1451
1452   Rule 4:
1453   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1454   constraints: <reg1> != fp
1455                <reg1> != sp
1456   effects: cfa.reg = <reg1>
1457            cfa_temp.reg = <reg1>
1458            cfa_temp.offset = cfa.offset
1459
1460   Rule 5:
1461   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1462   constraints: <reg1> != fp
1463                <reg1> != sp
1464   effects: cfa_store.reg = <reg1>
1465            cfa_store.offset = cfa.offset - cfa_temp.offset
1466
1467   Rule 6:
1468   (set <reg> <const_int>)
1469   effects: cfa_temp.reg = <reg>
1470            cfa_temp.offset = <const_int>
1471
1472   Rule 7:
1473   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1474   effects: cfa_temp.reg = <reg1>
1475            cfa_temp.offset |= <const_int>
1476
1477   Rule 8:
1478   (set <reg> (high <exp>))
1479   effects: none
1480
1481   Rule 9:
1482   (set <reg> (lo_sum <exp> <const_int>))
1483   effects: cfa_temp.reg = <reg>
1484            cfa_temp.offset = <const_int>
1485
1486   Rule 10:
1487   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1488   effects: cfa_store.offset -= <const_int>
1489            cfa.offset = cfa_store.offset if cfa.reg == sp
1490            cfa.reg = sp
1491            cfa.base_offset = -cfa_store.offset
1492
1493   Rule 11:
1494   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1495   effects: cfa_store.offset += -/+ mode_size(mem)
1496            cfa.offset = cfa_store.offset if cfa.reg == sp
1497            cfa.reg = sp
1498            cfa.base_offset = -cfa_store.offset
1499
1500   Rule 12:
1501   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1502
1503        <reg2>)
1504   effects: cfa.reg = <reg1>
1505            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1506
1507   Rule 13:
1508   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1509   effects: cfa.reg = <reg1>
1510            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1511
1512   Rule 14:
1513   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1514   effects: cfa.reg = <reg1>
1515            cfa.base_offset = -cfa_temp.offset
1516            cfa_temp.offset -= mode_size(mem)
1517
1518   Rule 15:
1519   (set <reg> {unspec, unspec_volatile})
1520   effects: target-dependent  */
1521
1522 static void
1523 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1524 {
1525   rtx src, dest;
1526   HOST_WIDE_INT offset;
1527
1528   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1529      the PARALLEL independently. The first element is always processed if
1530      it is a SET. This is for backward compatibility.   Other elements
1531      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1532      flag is set in them.  */
1533   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1534     {
1535       int par_index;
1536       int limit = XVECLEN (expr, 0);
1537       rtx elem;
1538
1539       /* PARALLELs have strict read-modify-write semantics, so we
1540          ought to evaluate every rvalue before changing any lvalue.
1541          It's cumbersome to do that in general, but there's an
1542          easy approximation that is enough for all current users:
1543          handle register saves before register assignments.  */
1544       if (GET_CODE (expr) == PARALLEL)
1545         for (par_index = 0; par_index < limit; par_index++)
1546           {
1547             elem = XVECEXP (expr, 0, par_index);
1548             if (GET_CODE (elem) == SET
1549                 && MEM_P (SET_DEST (elem))
1550                 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1551               dwarf2out_frame_debug_expr (elem, label);
1552           }
1553
1554       for (par_index = 0; par_index < limit; par_index++)
1555         {
1556           elem = XVECEXP (expr, 0, par_index);
1557           if (GET_CODE (elem) == SET
1558               && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
1559               && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1560             dwarf2out_frame_debug_expr (elem, label);
1561         }
1562       return;
1563     }
1564
1565   gcc_assert (GET_CODE (expr) == SET);
1566
1567   src = SET_SRC (expr);
1568   dest = SET_DEST (expr);
1569
1570   if (REG_P (src))
1571     {
1572       rtx rsi = reg_saved_in (src);
1573       if (rsi)
1574         src = rsi;
1575     }
1576
1577   switch (GET_CODE (dest))
1578     {
1579     case REG:
1580       switch (GET_CODE (src))
1581         {
1582           /* Setting FP from SP.  */
1583         case REG:
1584           if (cfa.reg == (unsigned) REGNO (src))
1585             {
1586               /* Rule 1 */
1587               /* Update the CFA rule wrt SP or FP.  Make sure src is
1588                  relative to the current CFA register.
1589
1590                  We used to require that dest be either SP or FP, but the
1591                  ARM copies SP to a temporary register, and from there to
1592                  FP.  So we just rely on the backends to only set
1593                  RTX_FRAME_RELATED_P on appropriate insns.  */
1594               cfa.reg = REGNO (dest);
1595               cfa_temp.reg = cfa.reg;
1596               cfa_temp.offset = cfa.offset;
1597             }
1598           else
1599             {
1600               /* Saving a register in a register.  */
1601               gcc_assert (!fixed_regs [REGNO (dest)]
1602                           /* For the SPARC and its register window.  */
1603                           || (DWARF_FRAME_REGNUM (REGNO (src))
1604                               == DWARF_FRAME_RETURN_COLUMN));
1605               queue_reg_save (label, src, dest, 0);
1606             }
1607           break;
1608
1609         case PLUS:
1610         case MINUS:
1611         case LO_SUM:
1612           if (dest == stack_pointer_rtx)
1613             {
1614               /* Rule 2 */
1615               /* Adjusting SP.  */
1616               switch (GET_CODE (XEXP (src, 1)))
1617                 {
1618                 case CONST_INT:
1619                   offset = INTVAL (XEXP (src, 1));
1620                   break;
1621                 case REG:
1622                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1623                               == cfa_temp.reg);
1624                   offset = cfa_temp.offset;
1625                   break;
1626                 default:
1627                   gcc_unreachable ();
1628                 }
1629
1630               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1631                 {
1632                   /* Restoring SP from FP in the epilogue.  */
1633                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1634                   cfa.reg = STACK_POINTER_REGNUM;
1635                 }
1636               else if (GET_CODE (src) == LO_SUM)
1637                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1638                 ;
1639               else
1640                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1641
1642               if (GET_CODE (src) != MINUS)
1643                 offset = -offset;
1644               if (cfa.reg == STACK_POINTER_REGNUM)
1645                 cfa.offset += offset;
1646               if (cfa_store.reg == STACK_POINTER_REGNUM)
1647                 cfa_store.offset += offset;
1648             }
1649           else if (dest == hard_frame_pointer_rtx)
1650             {
1651               /* Rule 3 */
1652               /* Either setting the FP from an offset of the SP,
1653                  or adjusting the FP */
1654               gcc_assert (frame_pointer_needed);
1655
1656               gcc_assert (REG_P (XEXP (src, 0))
1657                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1658                           && GET_CODE (XEXP (src, 1)) == CONST_INT);
1659               offset = INTVAL (XEXP (src, 1));
1660               if (GET_CODE (src) != MINUS)
1661                 offset = -offset;
1662               cfa.offset += offset;
1663               cfa.reg = HARD_FRAME_POINTER_REGNUM;
1664             }
1665           else
1666             {
1667               gcc_assert (GET_CODE (src) != MINUS);
1668
1669               /* Rule 4 */
1670               if (REG_P (XEXP (src, 0))
1671                   && REGNO (XEXP (src, 0)) == cfa.reg
1672                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1673                 {
1674                   /* Setting a temporary CFA register that will be copied
1675                      into the FP later on.  */
1676                   offset = - INTVAL (XEXP (src, 1));
1677                   cfa.offset += offset;
1678                   cfa.reg = REGNO (dest);
1679                   /* Or used to save regs to the stack.  */
1680                   cfa_temp.reg = cfa.reg;
1681                   cfa_temp.offset = cfa.offset;
1682                 }
1683
1684               /* Rule 5 */
1685               else if (REG_P (XEXP (src, 0))
1686                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1687                        && XEXP (src, 1) == stack_pointer_rtx)
1688                 {
1689                   /* Setting a scratch register that we will use instead
1690                      of SP for saving registers to the stack.  */
1691                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1692                   cfa_store.reg = REGNO (dest);
1693                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1694                 }
1695
1696               /* Rule 9 */
1697               else if (GET_CODE (src) == LO_SUM
1698                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1699                 {
1700                   cfa_temp.reg = REGNO (dest);
1701                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1702                 }
1703               else
1704                 gcc_unreachable ();
1705             }
1706           break;
1707
1708           /* Rule 6 */
1709         case CONST_INT:
1710           cfa_temp.reg = REGNO (dest);
1711           cfa_temp.offset = INTVAL (src);
1712           break;
1713
1714           /* Rule 7 */
1715         case IOR:
1716           gcc_assert (REG_P (XEXP (src, 0))
1717                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1718                       && GET_CODE (XEXP (src, 1)) == CONST_INT);
1719
1720           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1721             cfa_temp.reg = REGNO (dest);
1722           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1723           break;
1724
1725           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1726              which will fill in all of the bits.  */
1727           /* Rule 8 */
1728         case HIGH:
1729           break;
1730
1731           /* Rule 15 */
1732         case UNSPEC:
1733         case UNSPEC_VOLATILE:
1734           gcc_assert (targetm.dwarf_handle_frame_unspec);
1735           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1736           return;
1737
1738         default:
1739           gcc_unreachable ();
1740         }
1741
1742       def_cfa_1 (label, &cfa);
1743       break;
1744
1745     case MEM:
1746       gcc_assert (REG_P (src));
1747
1748       /* Saving a register to the stack.  Make sure dest is relative to the
1749          CFA register.  */
1750       switch (GET_CODE (XEXP (dest, 0)))
1751         {
1752           /* Rule 10 */
1753           /* With a push.  */
1754         case PRE_MODIFY:
1755           /* We can't handle variable size modifications.  */
1756           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1757                       == CONST_INT);
1758           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1759
1760           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1761                       && cfa_store.reg == STACK_POINTER_REGNUM);
1762
1763           cfa_store.offset += offset;
1764           if (cfa.reg == STACK_POINTER_REGNUM)
1765             cfa.offset = cfa_store.offset;
1766
1767           offset = -cfa_store.offset;
1768           break;
1769
1770           /* Rule 11 */
1771         case PRE_INC:
1772         case PRE_DEC:
1773           offset = GET_MODE_SIZE (GET_MODE (dest));
1774           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1775             offset = -offset;
1776
1777           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1778                       && cfa_store.reg == STACK_POINTER_REGNUM);
1779
1780           cfa_store.offset += offset;
1781           if (cfa.reg == STACK_POINTER_REGNUM)
1782             cfa.offset = cfa_store.offset;
1783
1784           offset = -cfa_store.offset;
1785           break;
1786
1787           /* Rule 12 */
1788           /* With an offset.  */
1789         case PLUS:
1790         case MINUS:
1791         case LO_SUM:
1792           {
1793             int regno;
1794
1795             gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1796                         && REG_P (XEXP (XEXP (dest, 0), 0)));
1797             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1798             if (GET_CODE (XEXP (dest, 0)) == MINUS)
1799               offset = -offset;
1800
1801             regno = REGNO (XEXP (XEXP (dest, 0), 0));
1802
1803             if (cfa_store.reg == (unsigned) regno)
1804               offset -= cfa_store.offset;
1805             else
1806               {
1807                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1808                 offset -= cfa_temp.offset;
1809               }
1810           }
1811           break;
1812
1813           /* Rule 13 */
1814           /* Without an offset.  */
1815         case REG:
1816           {
1817             int regno = REGNO (XEXP (dest, 0));
1818
1819             if (cfa_store.reg == (unsigned) regno)
1820               offset = -cfa_store.offset;
1821             else
1822               {
1823                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1824                 offset = -cfa_temp.offset;
1825               }
1826           }
1827           break;
1828
1829           /* Rule 14 */
1830         case POST_INC:
1831           gcc_assert (cfa_temp.reg
1832                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1833           offset = -cfa_temp.offset;
1834           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1835           break;
1836
1837         default:
1838           gcc_unreachable ();
1839         }
1840
1841       if (REGNO (src) != STACK_POINTER_REGNUM
1842           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1843           && (unsigned) REGNO (src) == cfa.reg)
1844         {
1845           /* We're storing the current CFA reg into the stack.  */
1846
1847           if (cfa.offset == 0)
1848             {
1849               /* If the source register is exactly the CFA, assume
1850                  we're saving SP like any other register; this happens
1851                  on the ARM.  */
1852               def_cfa_1 (label, &cfa);
1853               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1854               break;
1855             }
1856           else
1857             {
1858               /* Otherwise, we'll need to look in the stack to
1859                  calculate the CFA.  */
1860               rtx x = XEXP (dest, 0);
1861
1862               if (!REG_P (x))
1863                 x = XEXP (x, 0);
1864               gcc_assert (REG_P (x));
1865
1866               cfa.reg = REGNO (x);
1867               cfa.base_offset = offset;
1868               cfa.indirect = 1;
1869               def_cfa_1 (label, &cfa);
1870               break;
1871             }
1872         }
1873
1874       def_cfa_1 (label, &cfa);
1875       queue_reg_save (label, src, NULL_RTX, offset);
1876       break;
1877
1878     default:
1879       gcc_unreachable ();
1880     }
1881 }
1882
1883 /* Record call frame debugging information for INSN, which either
1884    sets SP or FP (adjusting how we calculate the frame address) or saves a
1885    register to the stack.  If INSN is NULL_RTX, initialize our state.
1886
1887    If AFTER_P is false, we're being called before the insn is emitted,
1888    otherwise after.  Call instructions get invoked twice.  */
1889
1890 void
1891 dwarf2out_frame_debug (rtx insn, bool after_p)
1892 {
1893   const char *label;
1894   rtx src;
1895
1896   if (insn == NULL_RTX)
1897     {
1898       size_t i;
1899
1900       /* Flush any queued register saves.  */
1901       flush_queued_reg_saves ();
1902
1903       /* Set up state for generating call frame debug info.  */
1904       lookup_cfa (&cfa);
1905       gcc_assert (cfa.reg
1906                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1907
1908       cfa.reg = STACK_POINTER_REGNUM;
1909       cfa_store = cfa;
1910       cfa_temp.reg = -1;
1911       cfa_temp.offset = 0;
1912
1913       for (i = 0; i < num_regs_saved_in_regs; i++)
1914         {
1915           regs_saved_in_regs[i].orig_reg = NULL_RTX;
1916           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1917         }
1918       num_regs_saved_in_regs = 0;
1919       return;
1920     }
1921
1922   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1923     flush_queued_reg_saves ();
1924
1925   if (! RTX_FRAME_RELATED_P (insn))
1926     {
1927       if (!ACCUMULATE_OUTGOING_ARGS)
1928         dwarf2out_stack_adjust (insn, after_p);
1929       return;
1930     }
1931
1932   label = dwarf2out_cfi_label ();
1933   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1934   if (src)
1935     insn = XEXP (src, 0);
1936   else
1937     insn = PATTERN (insn);
1938
1939   dwarf2out_frame_debug_expr (insn, label);
1940 }
1941
1942 #endif
1943
1944 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1945 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1946  (enum dwarf_call_frame_info cfi);
1947
1948 static enum dw_cfi_oprnd_type
1949 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1950 {
1951   switch (cfi)
1952     {
1953     case DW_CFA_nop:
1954     case DW_CFA_GNU_window_save:
1955       return dw_cfi_oprnd_unused;
1956
1957     case DW_CFA_set_loc:
1958     case DW_CFA_advance_loc1:
1959     case DW_CFA_advance_loc2:
1960     case DW_CFA_advance_loc4:
1961     case DW_CFA_MIPS_advance_loc8:
1962       return dw_cfi_oprnd_addr;
1963
1964     case DW_CFA_offset:
1965     case DW_CFA_offset_extended:
1966     case DW_CFA_def_cfa:
1967     case DW_CFA_offset_extended_sf:
1968     case DW_CFA_def_cfa_sf:
1969     case DW_CFA_restore_extended:
1970     case DW_CFA_undefined:
1971     case DW_CFA_same_value:
1972     case DW_CFA_def_cfa_register:
1973     case DW_CFA_register:
1974       return dw_cfi_oprnd_reg_num;
1975
1976     case DW_CFA_def_cfa_offset:
1977     case DW_CFA_GNU_args_size:
1978     case DW_CFA_def_cfa_offset_sf:
1979       return dw_cfi_oprnd_offset;
1980
1981     case DW_CFA_def_cfa_expression:
1982     case DW_CFA_expression:
1983       return dw_cfi_oprnd_loc;
1984
1985     default:
1986       gcc_unreachable ();
1987     }
1988 }
1989
1990 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1991 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1992  (enum dwarf_call_frame_info cfi);
1993
1994 static enum dw_cfi_oprnd_type
1995 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1996 {
1997   switch (cfi)
1998     {
1999     case DW_CFA_def_cfa:
2000     case DW_CFA_def_cfa_sf:
2001     case DW_CFA_offset:
2002     case DW_CFA_offset_extended_sf:
2003     case DW_CFA_offset_extended:
2004       return dw_cfi_oprnd_offset;
2005
2006     case DW_CFA_register:
2007       return dw_cfi_oprnd_reg_num;
2008
2009     default:
2010       return dw_cfi_oprnd_unused;
2011     }
2012 }
2013
2014 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2015
2016 /* Switch to eh_frame_section.  If we don't have an eh_frame_section,
2017    switch to the data section instead, and write out a synthetic label
2018    for collect2.  */
2019
2020 static void
2021 switch_to_eh_frame_section (void)
2022 {
2023   tree label;
2024
2025 #ifdef EH_FRAME_SECTION_NAME
2026   if (eh_frame_section == 0)
2027     {
2028       int flags;
2029
2030       if (EH_TABLES_CAN_BE_READ_ONLY)
2031         {
2032           int fde_encoding;
2033           int per_encoding;
2034           int lsda_encoding;
2035
2036           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2037                                                        /*global=*/0);
2038           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2039                                                        /*global=*/1);
2040           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2041                                                         /*global=*/0);
2042           flags = ((! flag_pic
2043                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2044                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
2045                         && (per_encoding & 0x70) != DW_EH_PE_absptr
2046                         && (per_encoding & 0x70) != DW_EH_PE_aligned
2047                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2048                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2049                    ? 0 : SECTION_WRITE);
2050         }
2051       else
2052         flags = SECTION_WRITE;
2053       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2054     }
2055 #endif
2056
2057   if (eh_frame_section)
2058     switch_to_section (eh_frame_section);
2059   else
2060     {
2061       /* We have no special eh_frame section.  Put the information in
2062          the data section and emit special labels to guide collect2.  */
2063       switch_to_section (data_section);
2064       label = get_file_function_name ("F");
2065       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2066       targetm.asm_out.globalize_label (asm_out_file,
2067                                        IDENTIFIER_POINTER (label));
2068       ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2069     }
2070 }
2071
2072 /* Output a Call Frame Information opcode and its operand(s).  */
2073
2074 static void
2075 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2076 {
2077   unsigned long r;
2078   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2079     dw2_asm_output_data (1, (cfi->dw_cfi_opc
2080                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2081                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2082                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
2083   else if (cfi->dw_cfi_opc == DW_CFA_offset)
2084     {
2085       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2086       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2087                            "DW_CFA_offset, column 0x%lx", r);
2088       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2089     }
2090   else if (cfi->dw_cfi_opc == DW_CFA_restore)
2091     {
2092       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2093       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2094                            "DW_CFA_restore, column 0x%lx", r);
2095     }
2096   else
2097     {
2098       dw2_asm_output_data (1, cfi->dw_cfi_opc,
2099                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2100
2101       switch (cfi->dw_cfi_opc)
2102         {
2103         case DW_CFA_set_loc:
2104           if (for_eh)
2105             dw2_asm_output_encoded_addr_rtx (
2106                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2107                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2108                 false, NULL);
2109           else
2110             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2111                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2112           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2113           break;
2114
2115         case DW_CFA_advance_loc1:
2116           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2117                                 fde->dw_fde_current_label, NULL);
2118           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2119           break;
2120
2121         case DW_CFA_advance_loc2:
2122           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2123                                 fde->dw_fde_current_label, NULL);
2124           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2125           break;
2126
2127         case DW_CFA_advance_loc4:
2128           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2129                                 fde->dw_fde_current_label, NULL);
2130           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2131           break;
2132
2133         case DW_CFA_MIPS_advance_loc8:
2134           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2135                                 fde->dw_fde_current_label, NULL);
2136           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2137           break;
2138
2139         case DW_CFA_offset_extended:
2140         case DW_CFA_def_cfa:
2141           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2142           dw2_asm_output_data_uleb128 (r, NULL);
2143           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2144           break;
2145
2146         case DW_CFA_offset_extended_sf:
2147         case DW_CFA_def_cfa_sf:
2148           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2149           dw2_asm_output_data_uleb128 (r, NULL);
2150           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2151           break;
2152
2153         case DW_CFA_restore_extended:
2154         case DW_CFA_undefined:
2155         case DW_CFA_same_value:
2156         case DW_CFA_def_cfa_register:
2157           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2158           dw2_asm_output_data_uleb128 (r, NULL);
2159           break;
2160
2161         case DW_CFA_register:
2162           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2163           dw2_asm_output_data_uleb128 (r, NULL);
2164           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2165           dw2_asm_output_data_uleb128 (r, NULL);
2166           break;
2167
2168         case DW_CFA_def_cfa_offset:
2169         case DW_CFA_GNU_args_size:
2170           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2171           break;
2172
2173         case DW_CFA_def_cfa_offset_sf:
2174           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2175           break;
2176
2177         case DW_CFA_GNU_window_save:
2178           break;
2179
2180         case DW_CFA_def_cfa_expression:
2181         case DW_CFA_expression:
2182           output_cfa_loc (cfi);
2183           break;
2184
2185         case DW_CFA_GNU_negative_offset_extended:
2186           /* Obsoleted by DW_CFA_offset_extended_sf.  */
2187           gcc_unreachable ();
2188
2189         default:
2190           break;
2191         }
2192     }
2193 }
2194
2195 /* Output the call frame information used to record information
2196    that relates to calculating the frame pointer, and records the
2197    location of saved registers.  */
2198
2199 static void
2200 output_call_frame_info (int for_eh)
2201 {
2202   unsigned int i;
2203   dw_fde_ref fde;
2204   dw_cfi_ref cfi;
2205   char l1[20], l2[20], section_start_label[20];
2206   bool any_lsda_needed = false;
2207   char augmentation[6];
2208   int augmentation_size;
2209   int fde_encoding = DW_EH_PE_absptr;
2210   int per_encoding = DW_EH_PE_absptr;
2211   int lsda_encoding = DW_EH_PE_absptr;
2212   int return_reg;
2213
2214   /* Don't emit a CIE if there won't be any FDEs.  */
2215   if (fde_table_in_use == 0)
2216     return;
2217
2218   /* If we make FDEs linkonce, we may have to emit an empty label for
2219      an FDE that wouldn't otherwise be emitted.  We want to avoid
2220      having an FDE kept around when the function it refers to is
2221      discarded.  Example where this matters: a primary function
2222      template in C++ requires EH information, but an explicit
2223      specialization doesn't.  */
2224   if (TARGET_USES_WEAK_UNWIND_INFO
2225       && ! flag_asynchronous_unwind_tables
2226       && for_eh)
2227     for (i = 0; i < fde_table_in_use; i++)
2228       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2229           && !fde_table[i].uses_eh_lsda
2230           && ! DECL_WEAK (fde_table[i].decl))
2231         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2232                                       for_eh, /* empty */ 1);
2233
2234   /* If we don't have any functions we'll want to unwind out of, don't
2235      emit any EH unwind information.  Note that if exceptions aren't
2236      enabled, we won't have collected nothrow information, and if we
2237      asked for asynchronous tables, we always want this info.  */
2238   if (for_eh)
2239     {
2240       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2241
2242       for (i = 0; i < fde_table_in_use; i++)
2243         if (fde_table[i].uses_eh_lsda)
2244           any_eh_needed = any_lsda_needed = true;
2245         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2246           any_eh_needed = true;
2247         else if (! fde_table[i].nothrow
2248                  && ! fde_table[i].all_throwers_are_sibcalls)
2249           any_eh_needed = true;
2250
2251       if (! any_eh_needed)
2252         return;
2253     }
2254
2255   /* We're going to be generating comments, so turn on app.  */
2256   if (flag_debug_asm)
2257     app_enable ();
2258
2259   if (for_eh)
2260     switch_to_eh_frame_section ();
2261   else
2262     {
2263       if (!debug_frame_section)
2264         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2265                                            SECTION_DEBUG, NULL);
2266       switch_to_section (debug_frame_section);
2267     }
2268
2269   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2270   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2271
2272   /* Output the CIE.  */
2273   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2274   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2275   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2276     dw2_asm_output_data (4, 0xffffffff,
2277       "Initial length escape value indicating 64-bit DWARF extension");
2278   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2279                         "Length of Common Information Entry");
2280   ASM_OUTPUT_LABEL (asm_out_file, l1);
2281
2282   /* Now that the CIE pointer is PC-relative for EH,
2283      use 0 to identify the CIE.  */
2284   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2285                        (for_eh ? 0 : DWARF_CIE_ID),
2286                        "CIE Identifier Tag");
2287
2288   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2289
2290   augmentation[0] = 0;
2291   augmentation_size = 0;
2292   if (for_eh)
2293     {
2294       char *p;
2295
2296       /* Augmentation:
2297          z      Indicates that a uleb128 is present to size the
2298                 augmentation section.
2299          L      Indicates the encoding (and thus presence) of
2300                 an LSDA pointer in the FDE augmentation.
2301          R      Indicates a non-default pointer encoding for
2302                 FDE code pointers.
2303          P      Indicates the presence of an encoding + language
2304                 personality routine in the CIE augmentation.  */
2305
2306       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2307       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2308       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2309
2310       p = augmentation + 1;
2311       if (eh_personality_libfunc)
2312         {
2313           *p++ = 'P';
2314           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2315           assemble_external_libcall (eh_personality_libfunc);
2316         }
2317       if (any_lsda_needed)
2318         {
2319           *p++ = 'L';
2320           augmentation_size += 1;
2321         }
2322       if (fde_encoding != DW_EH_PE_absptr)
2323         {
2324           *p++ = 'R';
2325           augmentation_size += 1;
2326         }
2327       if (p > augmentation + 1)
2328         {
2329           augmentation[0] = 'z';
2330           *p = '\0';
2331         }
2332
2333       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2334       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2335         {
2336           int offset = (  4             /* Length */
2337                         + 4             /* CIE Id */
2338                         + 1             /* CIE version */
2339                         + strlen (augmentation) + 1     /* Augmentation */
2340                         + size_of_uleb128 (1)           /* Code alignment */
2341                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2342                         + 1             /* RA column */
2343                         + 1             /* Augmentation size */
2344                         + 1             /* Personality encoding */ );
2345           int pad = -offset & (PTR_SIZE - 1);
2346
2347           augmentation_size += pad;
2348
2349           /* Augmentations should be small, so there's scarce need to
2350              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2351           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2352         }
2353     }
2354
2355   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2356   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2357   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2358                                "CIE Data Alignment Factor");
2359
2360   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2361   if (DW_CIE_VERSION == 1)
2362     dw2_asm_output_data (1, return_reg, "CIE RA Column");
2363   else
2364     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2365
2366   if (augmentation[0])
2367     {
2368       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2369       if (eh_personality_libfunc)
2370         {
2371           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2372                                eh_data_format_name (per_encoding));
2373           dw2_asm_output_encoded_addr_rtx (per_encoding,
2374                                            eh_personality_libfunc,
2375                                            true, NULL);
2376         }
2377
2378       if (any_lsda_needed)
2379         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2380                              eh_data_format_name (lsda_encoding));
2381
2382       if (fde_encoding != DW_EH_PE_absptr)
2383         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2384                              eh_data_format_name (fde_encoding));
2385     }
2386
2387   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2388     output_cfi (cfi, NULL, for_eh);
2389
2390   /* Pad the CIE out to an address sized boundary.  */
2391   ASM_OUTPUT_ALIGN (asm_out_file,
2392                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2393   ASM_OUTPUT_LABEL (asm_out_file, l2);
2394
2395   /* Loop through all of the FDE's.  */
2396   for (i = 0; i < fde_table_in_use; i++)
2397     {
2398       fde = &fde_table[i];
2399
2400       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2401       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2402           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2403           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2404           && !fde->uses_eh_lsda)
2405         continue;
2406
2407       targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2408       targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2409       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2410       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2411       if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2412         dw2_asm_output_data (4, 0xffffffff,
2413                              "Initial length escape value indicating 64-bit DWARF extension");
2414       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2415                             "FDE Length");
2416       ASM_OUTPUT_LABEL (asm_out_file, l1);
2417
2418       if (for_eh)
2419         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2420       else
2421         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2422                                debug_frame_section, "FDE CIE offset");
2423
2424       if (for_eh)
2425         {
2426           rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2427           SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2428           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2429                                            sym_ref,
2430                                            false,
2431                                            "FDE initial location");
2432           if (fde->dw_fde_switched_sections)
2433             {
2434               rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2435                                       fde->dw_fde_unlikely_section_label);
2436               rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2437                                       fde->dw_fde_hot_section_label);
2438               SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2439               SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2440               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2441                                                "FDE initial location");
2442               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2443                                     fde->dw_fde_hot_section_end_label,
2444                                     fde->dw_fde_hot_section_label,
2445                                     "FDE address range");
2446               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2447                                                "FDE initial location");
2448               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2449                                     fde->dw_fde_unlikely_section_end_label,
2450                                     fde->dw_fde_unlikely_section_label,
2451                                     "FDE address range");
2452             }
2453           else
2454             dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2455                                   fde->dw_fde_end, fde->dw_fde_begin,
2456                                   "FDE address range");
2457         }
2458       else
2459         {
2460           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2461                                "FDE initial location");
2462           if (fde->dw_fde_switched_sections)
2463             {
2464               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2465                                    fde->dw_fde_hot_section_label,
2466                                    "FDE initial location");
2467               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2468                                     fde->dw_fde_hot_section_end_label,
2469                                     fde->dw_fde_hot_section_label,
2470                                     "FDE address range");
2471               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2472                                    fde->dw_fde_unlikely_section_label,
2473                                    "FDE initial location");
2474               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2475                                     fde->dw_fde_unlikely_section_end_label,
2476                                     fde->dw_fde_unlikely_section_label,
2477                                     "FDE address range");
2478             }
2479           else
2480             dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2481                                   fde->dw_fde_end, fde->dw_fde_begin,
2482                                   "FDE address range");
2483         }
2484
2485       if (augmentation[0])
2486         {
2487           if (any_lsda_needed)
2488             {
2489               int size = size_of_encoded_value (lsda_encoding);
2490
2491               if (lsda_encoding == DW_EH_PE_aligned)
2492                 {
2493                   int offset = (  4             /* Length */
2494                                 + 4             /* CIE offset */
2495                                 + 2 * size_of_encoded_value (fde_encoding)
2496                                 + 1             /* Augmentation size */ );
2497                   int pad = -offset & (PTR_SIZE - 1);
2498
2499                   size += pad;
2500                   gcc_assert (size_of_uleb128 (size) == 1);
2501                 }
2502
2503               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2504
2505               if (fde->uses_eh_lsda)
2506                 {
2507                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2508                                                fde->funcdef_number);
2509                   dw2_asm_output_encoded_addr_rtx (
2510                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2511                         false, "Language Specific Data Area");
2512                 }
2513               else
2514                 {
2515                   if (lsda_encoding == DW_EH_PE_aligned)
2516                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2517                   dw2_asm_output_data
2518                     (size_of_encoded_value (lsda_encoding), 0,
2519                      "Language Specific Data Area (none)");
2520                 }
2521             }
2522           else
2523             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2524         }
2525
2526       /* Loop through the Call Frame Instructions associated with
2527          this FDE.  */
2528       fde->dw_fde_current_label = fde->dw_fde_begin;
2529       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2530         output_cfi (cfi, fde, for_eh);
2531
2532       /* Pad the FDE out to an address sized boundary.  */
2533       ASM_OUTPUT_ALIGN (asm_out_file,
2534                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2535       ASM_OUTPUT_LABEL (asm_out_file, l2);
2536     }
2537
2538   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2539     dw2_asm_output_data (4, 0, "End of Table");
2540 #ifdef MIPS_DEBUGGING_INFO
2541   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2542      get a value of 0.  Putting .align 0 after the label fixes it.  */
2543   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2544 #endif
2545
2546   /* Turn off app to make assembly quicker.  */
2547   if (flag_debug_asm)
2548     app_disable ();
2549 }
2550
2551 /* Output a marker (i.e. a label) for the beginning of a function, before
2552    the prologue.  */
2553
2554 void
2555 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2556                           const char *file ATTRIBUTE_UNUSED)
2557 {
2558   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2559   char * dup_label;
2560   dw_fde_ref fde;
2561
2562   current_function_func_begin_label = NULL;
2563
2564 #ifdef TARGET_UNWIND_INFO
2565   /* ??? current_function_func_begin_label is also used by except.c
2566      for call-site information.  We must emit this label if it might
2567      be used.  */
2568   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2569       && ! dwarf2out_do_frame ())
2570     return;
2571 #else
2572   if (! dwarf2out_do_frame ())
2573     return;
2574 #endif
2575
2576   switch_to_section (function_section (current_function_decl));
2577   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2578                                current_function_funcdef_no);
2579   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2580                           current_function_funcdef_no);
2581   dup_label = xstrdup (label);
2582   current_function_func_begin_label = dup_label;
2583
2584 #ifdef TARGET_UNWIND_INFO
2585   /* We can elide the fde allocation if we're not emitting debug info.  */
2586   if (! dwarf2out_do_frame ())
2587     return;
2588 #endif
2589
2590   /* Expand the fde table if necessary.  */
2591   if (fde_table_in_use == fde_table_allocated)
2592     {
2593       fde_table_allocated += FDE_TABLE_INCREMENT;
2594       fde_table = ggc_realloc (fde_table,
2595                                fde_table_allocated * sizeof (dw_fde_node));
2596       memset (fde_table + fde_table_in_use, 0,
2597               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2598     }
2599
2600   /* Record the FDE associated with this function.  */
2601   current_funcdef_fde = fde_table_in_use;
2602
2603   /* Add the new FDE at the end of the fde_table.  */
2604   fde = &fde_table[fde_table_in_use++];
2605   fde->decl = current_function_decl;
2606   fde->dw_fde_begin = dup_label;
2607   fde->dw_fde_current_label = dup_label;
2608   fde->dw_fde_hot_section_label = NULL;
2609   fde->dw_fde_hot_section_end_label = NULL;
2610   fde->dw_fde_unlikely_section_label = NULL;
2611   fde->dw_fde_unlikely_section_end_label = NULL;
2612   fde->dw_fde_switched_sections = false;
2613   fde->dw_fde_end = NULL;
2614   fde->dw_fde_cfi = NULL;
2615   fde->funcdef_number = current_function_funcdef_no;
2616   fde->nothrow = TREE_NOTHROW (current_function_decl);
2617   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2618   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2619
2620   args_size = old_args_size = 0;
2621
2622   /* We only want to output line number information for the genuine dwarf2
2623      prologue case, not the eh frame case.  */
2624 #ifdef DWARF2_DEBUGGING_INFO
2625   if (file)
2626     dwarf2out_source_line (line, file);
2627 #endif
2628 }
2629
2630 /* Output a marker (i.e. a label) for the absolute end of the generated code
2631    for a function definition.  This gets called *after* the epilogue code has
2632    been generated.  */
2633
2634 void
2635 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2636                         const char *file ATTRIBUTE_UNUSED)
2637 {
2638   dw_fde_ref fde;
2639   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2640
2641   /* Output a label to mark the endpoint of the code generated for this
2642      function.  */
2643   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2644                                current_function_funcdef_no);
2645   ASM_OUTPUT_LABEL (asm_out_file, label);
2646   fde = &fde_table[fde_table_in_use - 1];
2647   fde->dw_fde_end = xstrdup (label);
2648 }
2649
2650 void
2651 dwarf2out_frame_init (void)
2652 {
2653   /* Allocate the initial hunk of the fde_table.  */
2654   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2655   fde_table_allocated = FDE_TABLE_INCREMENT;
2656   fde_table_in_use = 0;
2657
2658   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2659      sake of lookup_cfa.  */
2660
2661   /* On entry, the Canonical Frame Address is at SP.  */
2662   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2663
2664 #ifdef DWARF2_UNWIND_INFO
2665   if (DWARF2_UNWIND_INFO)
2666     initial_return_save (INCOMING_RETURN_ADDR_RTX);
2667 #endif
2668 }
2669
2670 void
2671 dwarf2out_frame_finish (void)
2672 {
2673   /* Output call frame information.  */
2674   if (DWARF2_FRAME_INFO)
2675     output_call_frame_info (0);
2676
2677 #ifndef TARGET_UNWIND_INFO
2678   /* Output another copy for the unwinder.  */
2679   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2680     output_call_frame_info (1);
2681 #endif
2682 }
2683 #endif
2684 \f
2685 /* And now, the subset of the debugging information support code necessary
2686    for emitting location expressions.  */
2687
2688 /* Data about a single source file.  */
2689 struct dwarf_file_data GTY(())
2690 {
2691   const char * filename;
2692   int emitted_number;
2693 };
2694
2695 /* We need some way to distinguish DW_OP_addr with a direct symbol
2696    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2697 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2698
2699
2700 typedef struct dw_val_struct *dw_val_ref;
2701 typedef struct die_struct *dw_die_ref;
2702 typedef const struct die_struct *const_dw_die_ref;
2703 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2704 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2705
2706 /* Each DIE may have a series of attribute/value pairs.  Values
2707    can take on several forms.  The forms that are used in this
2708    implementation are listed below.  */
2709
2710 enum dw_val_class
2711 {
2712   dw_val_class_addr,
2713   dw_val_class_offset,
2714   dw_val_class_loc,
2715   dw_val_class_loc_list,
2716   dw_val_class_range_list,
2717   dw_val_class_const,
2718   dw_val_class_unsigned_const,
2719   dw_val_class_long_long,
2720   dw_val_class_vec,
2721   dw_val_class_flag,
2722   dw_val_class_die_ref,
2723   dw_val_class_fde_ref,
2724   dw_val_class_lbl_id,
2725   dw_val_class_lineptr,
2726   dw_val_class_str,
2727   dw_val_class_macptr,
2728   dw_val_class_file
2729 };
2730
2731 /* Describe a double word constant value.  */
2732 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2733
2734 typedef struct dw_long_long_struct GTY(())
2735 {
2736   unsigned long hi;
2737   unsigned long low;
2738 }
2739 dw_long_long_const;
2740
2741 /* Describe a floating point constant value, or a vector constant value.  */
2742
2743 typedef struct dw_vec_struct GTY(())
2744 {
2745   unsigned char * GTY((length ("%h.length"))) array;
2746   unsigned length;
2747   unsigned elt_size;
2748 }
2749 dw_vec_const;
2750
2751 /* The dw_val_node describes an attribute's value, as it is
2752    represented internally.  */
2753
2754 typedef struct dw_val_struct GTY(())
2755 {
2756   enum dw_val_class val_class;
2757   union dw_val_struct_union
2758     {
2759       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2760       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2761       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2762       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2763       HOST_WIDE_INT GTY ((default)) val_int;
2764       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2765       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2766       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2767       struct dw_val_die_union
2768         {
2769           dw_die_ref die;
2770           int external;
2771         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2772       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2773       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2774       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2775       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2776       struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
2777     }
2778   GTY ((desc ("%1.val_class"))) v;
2779 }
2780 dw_val_node;
2781
2782 /* Locations in memory are described using a sequence of stack machine
2783    operations.  */
2784
2785 typedef struct dw_loc_descr_struct GTY(())
2786 {
2787   dw_loc_descr_ref dw_loc_next;
2788   enum dwarf_location_atom dw_loc_opc;
2789   dw_val_node dw_loc_oprnd1;
2790   dw_val_node dw_loc_oprnd2;
2791   int dw_loc_addr;
2792 }
2793 dw_loc_descr_node;
2794
2795 /* Location lists are ranges + location descriptions for that range,
2796    so you can track variables that are in different places over
2797    their entire life.  */
2798 typedef struct dw_loc_list_struct GTY(())
2799 {
2800   dw_loc_list_ref dw_loc_next;
2801   const char *begin; /* Label for begin address of range */
2802   const char *end;  /* Label for end address of range */
2803   char *ll_symbol; /* Label for beginning of location list.
2804                       Only on head of list */
2805   const char *section; /* Section this loclist is relative to */
2806   dw_loc_descr_ref expr;
2807 } dw_loc_list_node;
2808
2809 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2810
2811 static const char *dwarf_stack_op_name (unsigned);
2812 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2813                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2814 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2815 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2816 static unsigned long size_of_locs (dw_loc_descr_ref);
2817 static void output_loc_operands (dw_loc_descr_ref);
2818 static void output_loc_sequence (dw_loc_descr_ref);
2819
2820 /* Convert a DWARF stack opcode into its string name.  */
2821
2822 static const char *
2823 dwarf_stack_op_name (unsigned int op)
2824 {
2825   switch (op)
2826     {
2827     case DW_OP_addr:
2828     case INTERNAL_DW_OP_tls_addr:
2829       return "DW_OP_addr";
2830     case DW_OP_deref:
2831       return "DW_OP_deref";
2832     case DW_OP_const1u:
2833       return "DW_OP_const1u";
2834     case DW_OP_const1s:
2835       return "DW_OP_const1s";
2836     case DW_OP_const2u:
2837       return "DW_OP_const2u";
2838     case DW_OP_const2s:
2839       return "DW_OP_const2s";
2840     case DW_OP_const4u:
2841       return "DW_OP_const4u";
2842     case DW_OP_const4s:
2843       return "DW_OP_const4s";
2844     case DW_OP_const8u:
2845       return "DW_OP_const8u";
2846     case DW_OP_const8s:
2847       return "DW_OP_const8s";
2848     case DW_OP_constu:
2849       return "DW_OP_constu";
2850     case DW_OP_consts:
2851       return "DW_OP_consts";
2852     case DW_OP_dup:
2853       return "DW_OP_dup";
2854     case DW_OP_drop:
2855       return "DW_OP_drop";
2856     case DW_OP_over:
2857       return "DW_OP_over";
2858     case DW_OP_pick:
2859       return "DW_OP_pick";
2860     case DW_OP_swap:
2861       return "DW_OP_swap";
2862     case DW_OP_rot:
2863       return "DW_OP_rot";
2864     case DW_OP_xderef:
2865       return "DW_OP_xderef";
2866     case DW_OP_abs:
2867       return "DW_OP_abs";
2868     case DW_OP_and:
2869       return "DW_OP_and";
2870     case DW_OP_div:
2871       return "DW_OP_div";
2872     case DW_OP_minus:
2873       return "DW_OP_minus";
2874     case DW_OP_mod:
2875       return "DW_OP_mod";
2876     case DW_OP_mul:
2877       return "DW_OP_mul";
2878     case DW_OP_neg:
2879       return "DW_OP_neg";
2880     case DW_OP_not:
2881       return "DW_OP_not";
2882     case DW_OP_or:
2883       return "DW_OP_or";
2884     case DW_OP_plus:
2885       return "DW_OP_plus";
2886     case DW_OP_plus_uconst:
2887       return "DW_OP_plus_uconst";
2888     case DW_OP_shl:
2889       return "DW_OP_shl";
2890     case DW_OP_shr:
2891       return "DW_OP_shr";
2892     case DW_OP_shra:
2893       return "DW_OP_shra";
2894     case DW_OP_xor:
2895       return "DW_OP_xor";
2896     case DW_OP_bra:
2897       return "DW_OP_bra";
2898     case DW_OP_eq:
2899       return "DW_OP_eq";
2900     case DW_OP_ge:
2901       return "DW_OP_ge";
2902     case DW_OP_gt:
2903       return "DW_OP_gt";
2904     case DW_OP_le:
2905       return "DW_OP_le";
2906     case DW_OP_lt:
2907       return "DW_OP_lt";
2908     case DW_OP_ne:
2909       return "DW_OP_ne";
2910     case DW_OP_skip:
2911       return "DW_OP_skip";
2912     case DW_OP_lit0:
2913       return "DW_OP_lit0";
2914     case DW_OP_lit1:
2915       return "DW_OP_lit1";
2916     case DW_OP_lit2:
2917       return "DW_OP_lit2";
2918     case DW_OP_lit3:
2919       return "DW_OP_lit3";
2920     case DW_OP_lit4:
2921       return "DW_OP_lit4";
2922     case DW_OP_lit5:
2923       return "DW_OP_lit5";
2924     case DW_OP_lit6:
2925       return "DW_OP_lit6";
2926     case DW_OP_lit7:
2927       return "DW_OP_lit7";
2928     case DW_OP_lit8:
2929       return "DW_OP_lit8";
2930     case DW_OP_lit9:
2931       return "DW_OP_lit9";
2932     case DW_OP_lit10:
2933       return "DW_OP_lit10";
2934     case DW_OP_lit11:
2935       return "DW_OP_lit11";
2936     case DW_OP_lit12:
2937       return "DW_OP_lit12";
2938     case DW_OP_lit13:
2939       return "DW_OP_lit13";
2940     case DW_OP_lit14:
2941       return "DW_OP_lit14";
2942     case DW_OP_lit15:
2943       return "DW_OP_lit15";
2944     case DW_OP_lit16:
2945       return "DW_OP_lit16";
2946     case DW_OP_lit17:
2947       return "DW_OP_lit17";
2948     case DW_OP_lit18:
2949       return "DW_OP_lit18";
2950     case DW_OP_lit19:
2951       return "DW_OP_lit19";
2952     case DW_OP_lit20:
2953       return "DW_OP_lit20";
2954     case DW_OP_lit21:
2955       return "DW_OP_lit21";
2956     case DW_OP_lit22:
2957       return "DW_OP_lit22";
2958     case DW_OP_lit23:
2959       return "DW_OP_lit23";
2960     case DW_OP_lit24:
2961       return "DW_OP_lit24";
2962     case DW_OP_lit25:
2963       return "DW_OP_lit25";
2964     case DW_OP_lit26:
2965       return "DW_OP_lit26";
2966     case DW_OP_lit27:
2967       return "DW_OP_lit27";
2968     case DW_OP_lit28:
2969       return "DW_OP_lit28";
2970     case DW_OP_lit29:
2971       return "DW_OP_lit29";
2972     case DW_OP_lit30:
2973       return "DW_OP_lit30";
2974     case DW_OP_lit31:
2975       return "DW_OP_lit31";
2976     case DW_OP_reg0:
2977       return "DW_OP_reg0";
2978     case DW_OP_reg1:
2979       return "DW_OP_reg1";
2980     case DW_OP_reg2:
2981       return "DW_OP_reg2";
2982     case DW_OP_reg3:
2983       return "DW_OP_reg3";
2984     case DW_OP_reg4:
2985       return "DW_OP_reg4";
2986     case DW_OP_reg5:
2987       return "DW_OP_reg5";
2988     case DW_OP_reg6:
2989       return "DW_OP_reg6";
2990     case DW_OP_reg7:
2991       return "DW_OP_reg7";
2992     case DW_OP_reg8:
2993       return "DW_OP_reg8";
2994     case DW_OP_reg9:
2995       return "DW_OP_reg9";
2996     case DW_OP_reg10:
2997       return "DW_OP_reg10";
2998     case DW_OP_reg11:
2999       return "DW_OP_reg11";
3000     case DW_OP_reg12:
3001       return "DW_OP_reg12";
3002     case DW_OP_reg13:
3003       return "DW_OP_reg13";
3004     case DW_OP_reg14:
3005       return "DW_OP_reg14";
3006     case DW_OP_reg15:
3007       return "DW_OP_reg15";
3008     case DW_OP_reg16:
3009       return "DW_OP_reg16";
3010     case DW_OP_reg17:
3011       return "DW_OP_reg17";
3012     case DW_OP_reg18:
3013       return "DW_OP_reg18";
3014     case DW_OP_reg19:
3015       return "DW_OP_reg19";
3016     case DW_OP_reg20:
3017       return "DW_OP_reg20";
3018     case DW_OP_reg21:
3019       return "DW_OP_reg21";
3020     case DW_OP_reg22:
3021       return "DW_OP_reg22";
3022     case DW_OP_reg23:
3023       return "DW_OP_reg23";
3024     case DW_OP_reg24:
3025       return "DW_OP_reg24";
3026     case DW_OP_reg25:
3027       return "DW_OP_reg25";
3028     case DW_OP_reg26:
3029       return "DW_OP_reg26";
3030     case DW_OP_reg27:
3031       return "DW_OP_reg27";
3032     case DW_OP_reg28:
3033       return "DW_OP_reg28";
3034     case DW_OP_reg29:
3035       return "DW_OP_reg29";
3036     case DW_OP_reg30:
3037       return "DW_OP_reg30";
3038     case DW_OP_reg31:
3039       return "DW_OP_reg31";
3040     case DW_OP_breg0:
3041       return "DW_OP_breg0";
3042     case DW_OP_breg1:
3043       return "DW_OP_breg1";
3044     case DW_OP_breg2:
3045       return "DW_OP_breg2";
3046     case DW_OP_breg3:
3047       return "DW_OP_breg3";
3048     case DW_OP_breg4:
3049       return "DW_OP_breg4";
3050     case DW_OP_breg5:
3051       return "DW_OP_breg5";
3052     case DW_OP_breg6:
3053       return "DW_OP_breg6";
3054     case DW_OP_breg7:
3055       return "DW_OP_breg7";
3056     case DW_OP_breg8:
3057       return "DW_OP_breg8";
3058     case DW_OP_breg9:
3059       return "DW_OP_breg9";
3060     case DW_OP_breg10:
3061       return "DW_OP_breg10";
3062     case DW_OP_breg11:
3063       return "DW_OP_breg11";
3064     case DW_OP_breg12:
3065       return "DW_OP_breg12";
3066     case DW_OP_breg13:
3067       return "DW_OP_breg13";
3068     case DW_OP_breg14:
3069       return "DW_OP_breg14";
3070     case DW_OP_breg15:
3071       return "DW_OP_breg15";
3072     case DW_OP_breg16:
3073       return "DW_OP_breg16";
3074     case DW_OP_breg17:
3075       return "DW_OP_breg17";
3076     case DW_OP_breg18:
3077       return "DW_OP_breg18";
3078     case DW_OP_breg19:
3079       return "DW_OP_breg19";
3080     case DW_OP_breg20:
3081       return "DW_OP_breg20";
3082     case DW_OP_breg21:
3083       return "DW_OP_breg21";
3084     case DW_OP_breg22:
3085       return "DW_OP_breg22";
3086     case DW_OP_breg23:
3087       return "DW_OP_breg23";
3088     case DW_OP_breg24:
3089       return "DW_OP_breg24";
3090     case DW_OP_breg25:
3091       return "DW_OP_breg25";
3092     case DW_OP_breg26:
3093       return "DW_OP_breg26";
3094     case DW_OP_breg27:
3095       return "DW_OP_breg27";
3096     case DW_OP_breg28:
3097       return "DW_OP_breg28";
3098     case DW_OP_breg29:
3099       return "DW_OP_breg29";
3100     case DW_OP_breg30:
3101       return "DW_OP_breg30";
3102     case DW_OP_breg31:
3103       return "DW_OP_breg31";
3104     case DW_OP_regx:
3105       return "DW_OP_regx";
3106     case DW_OP_fbreg:
3107       return "DW_OP_fbreg";
3108     case DW_OP_bregx:
3109       return "DW_OP_bregx";
3110     case DW_OP_piece:
3111       return "DW_OP_piece";
3112     case DW_OP_deref_size:
3113       return "DW_OP_deref_size";
3114     case DW_OP_xderef_size:
3115       return "DW_OP_xderef_size";
3116     case DW_OP_nop:
3117       return "DW_OP_nop";
3118     case DW_OP_push_object_address:
3119       return "DW_OP_push_object_address";
3120     case DW_OP_call2:
3121       return "DW_OP_call2";
3122     case DW_OP_call4:
3123       return "DW_OP_call4";
3124     case DW_OP_call_ref:
3125       return "DW_OP_call_ref";
3126     case DW_OP_GNU_push_tls_address:
3127       return "DW_OP_GNU_push_tls_address";
3128     case DW_OP_GNU_uninit:
3129       return "DW_OP_GNU_uninit";
3130     default:
3131       return "OP_<unknown>";
3132     }
3133 }
3134
3135 /* Return a pointer to a newly allocated location description.  Location
3136    descriptions are simple expression terms that can be strung
3137    together to form more complicated location (address) descriptions.  */
3138
3139 static inline dw_loc_descr_ref
3140 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3141                unsigned HOST_WIDE_INT oprnd2)
3142 {
3143   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3144
3145   descr->dw_loc_opc = op;
3146   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3147   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3148   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3149   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3150
3151   return descr;
3152 }
3153
3154 /* Add a location description term to a location description expression.  */
3155
3156 static inline void
3157 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3158 {
3159   dw_loc_descr_ref *d;
3160
3161   /* Find the end of the chain.  */
3162   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3163     ;
3164
3165   *d = descr;
3166 }
3167
3168 /* Return the size of a location descriptor.  */
3169
3170 static unsigned long
3171 size_of_loc_descr (dw_loc_descr_ref loc)
3172 {
3173   unsigned long size = 1;
3174
3175   switch (loc->dw_loc_opc)
3176     {
3177     case DW_OP_addr:
3178     case INTERNAL_DW_OP_tls_addr:
3179       size += DWARF2_ADDR_SIZE;
3180       break;
3181     case DW_OP_const1u:
3182     case DW_OP_const1s:
3183       size += 1;
3184       break;
3185     case DW_OP_const2u:
3186     case DW_OP_const2s:
3187       size += 2;
3188       break;
3189     case DW_OP_const4u:
3190     case DW_OP_const4s:
3191       size += 4;
3192       break;
3193     case DW_OP_const8u:
3194     case DW_OP_const8s:
3195       size += 8;
3196       break;
3197     case DW_OP_constu:
3198       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3199       break;
3200     case DW_OP_consts:
3201       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3202       break;
3203     case DW_OP_pick:
3204       size += 1;
3205       break;
3206     case DW_OP_plus_uconst:
3207       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3208       break;
3209     case DW_OP_skip:
3210     case DW_OP_bra:
3211       size += 2;
3212       break;
3213     case DW_OP_breg0:
3214     case DW_OP_breg1:
3215     case DW_OP_breg2:
3216     case DW_OP_breg3:
3217     case DW_OP_breg4:
3218     case DW_OP_breg5:
3219     case DW_OP_breg6:
3220     case DW_OP_breg7:
3221     case DW_OP_breg8:
3222     case DW_OP_breg9:
3223     case DW_OP_breg10:
3224     case DW_OP_breg11:
3225     case DW_OP_breg12:
3226     case DW_OP_breg13:
3227     case DW_OP_breg14:
3228     case DW_OP_breg15:
3229     case DW_OP_breg16:
3230     case DW_OP_breg17:
3231     case DW_OP_breg18:
3232     case DW_OP_breg19:
3233     case DW_OP_breg20:
3234     case DW_OP_breg21:
3235     case DW_OP_breg22:
3236     case DW_OP_breg23:
3237     case DW_OP_breg24:
3238     case DW_OP_breg25:
3239     case DW_OP_breg26:
3240     case DW_OP_breg27:
3241     case DW_OP_breg28:
3242     case DW_OP_breg29:
3243     case DW_OP_breg30:
3244     case DW_OP_breg31:
3245       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3246       break;
3247     case DW_OP_regx:
3248       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3249       break;
3250     case DW_OP_fbreg:
3251       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3252       break;
3253     case DW_OP_bregx:
3254       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3255       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3256       break;
3257     case DW_OP_piece:
3258       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3259       break;
3260     case DW_OP_deref_size:
3261     case DW_OP_xderef_size:
3262       size += 1;
3263       break;
3264     case DW_OP_call2:
3265       size += 2;
3266       break;
3267     case DW_OP_call4:
3268       size += 4;
3269       break;
3270     case DW_OP_call_ref:
3271       size += DWARF2_ADDR_SIZE;
3272       break;
3273     default:
3274       break;
3275     }
3276
3277   return size;
3278 }
3279
3280 /* Return the size of a series of location descriptors.  */
3281
3282 static unsigned long
3283 size_of_locs (dw_loc_descr_ref loc)
3284 {
3285   dw_loc_descr_ref l;
3286   unsigned long size;
3287
3288   /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
3289      field, to avoid writing to a PCH file.  */
3290   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3291     {
3292       if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
3293         break;
3294       size += size_of_loc_descr (l);
3295     }
3296   if (! l)
3297     return size;
3298
3299   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3300     {
3301       l->dw_loc_addr = size;
3302       size += size_of_loc_descr (l);
3303     }
3304
3305   return size;
3306 }
3307
3308 /* Output location description stack opcode's operands (if any).  */
3309
3310 static void
3311 output_loc_operands (dw_loc_descr_ref loc)
3312 {
3313   dw_val_ref val1 = &loc->dw_loc_oprnd1;
3314   dw_val_ref val2 = &loc->dw_loc_oprnd2;
3315
3316   switch (loc->dw_loc_opc)
3317     {
3318 #ifdef DWARF2_DEBUGGING_INFO
3319     case DW_OP_addr:
3320       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3321       break;
3322     case DW_OP_const2u:
3323     case DW_OP_const2s:
3324       dw2_asm_output_data (2, val1->v.val_int, NULL);
3325       break;
3326     case DW_OP_const4u:
3327     case DW_OP_const4s:
3328       dw2_asm_output_data (4, val1->v.val_int, NULL);
3329       break;
3330     case DW_OP_const8u:
3331     case DW_OP_const8s:
3332       gcc_assert (HOST_BITS_PER_LONG >= 64);
3333       dw2_asm_output_data (8, val1->v.val_int, NULL);
3334       break;
3335     case DW_OP_skip:
3336     case DW_OP_bra:
3337       {
3338         int offset;
3339
3340         gcc_assert (val1->val_class == dw_val_class_loc);
3341         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3342
3343         dw2_asm_output_data (2, offset, NULL);
3344       }
3345       break;
3346 #else
3347     case DW_OP_addr:
3348     case DW_OP_const2u:
3349     case DW_OP_const2s:
3350     case DW_OP_const4u:
3351     case DW_OP_const4s:
3352     case DW_OP_const8u:
3353     case DW_OP_const8s:
3354     case DW_OP_skip:
3355     case DW_OP_bra:
3356       /* We currently don't make any attempt to make sure these are
3357          aligned properly like we do for the main unwind info, so
3358          don't support emitting things larger than a byte if we're
3359          only doing unwinding.  */
3360       gcc_unreachable ();
3361 #endif
3362     case DW_OP_const1u:
3363     case DW_OP_const1s:
3364       dw2_asm_output_data (1, val1->v.val_int, NULL);
3365       break;
3366     case DW_OP_constu:
3367       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3368       break;
3369     case DW_OP_consts:
3370       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3371       break;
3372     case DW_OP_pick:
3373       dw2_asm_output_data (1, val1->v.val_int, NULL);
3374       break;
3375     case DW_OP_plus_uconst:
3376       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3377       break;
3378     case DW_OP_breg0:
3379     case DW_OP_breg1:
3380     case DW_OP_breg2:
3381     case DW_OP_breg3:
3382     case DW_OP_breg4:
3383     case DW_OP_breg5:
3384     case DW_OP_breg6:
3385     case DW_OP_breg7:
3386     case DW_OP_breg8:
3387     case DW_OP_breg9:
3388     case DW_OP_breg10:
3389     case DW_OP_breg11:
3390     case DW_OP_breg12:
3391     case DW_OP_breg13:
3392     case DW_OP_breg14:
3393     case DW_OP_breg15:
3394     case DW_OP_breg16:
3395     case DW_OP_breg17:
3396     case DW_OP_breg18:
3397     case DW_OP_breg19:
3398     case DW_OP_breg20:
3399     case DW_OP_breg21:
3400     case DW_OP_breg22:
3401     case DW_OP_breg23:
3402     case DW_OP_breg24:
3403     case DW_OP_breg25:
3404     case DW_OP_breg26:
3405     case DW_OP_breg27:
3406     case DW_OP_breg28:
3407     case DW_OP_breg29:
3408     case DW_OP_breg30:
3409     case DW_OP_breg31:
3410       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3411       break;
3412     case DW_OP_regx:
3413       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3414       break;
3415     case DW_OP_fbreg:
3416       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3417       break;
3418     case DW_OP_bregx:
3419       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3420       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3421       break;
3422     case DW_OP_piece:
3423       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3424       break;
3425     case DW_OP_deref_size:
3426     case DW_OP_xderef_size:
3427       dw2_asm_output_data (1, val1->v.val_int, NULL);
3428       break;
3429
3430     case INTERNAL_DW_OP_tls_addr:
3431       if (targetm.asm_out.output_dwarf_dtprel)
3432         {
3433           targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3434                                                DWARF2_ADDR_SIZE,
3435                                                val1->v.val_addr);
3436           fputc ('\n', asm_out_file);
3437         }
3438       else
3439         gcc_unreachable ();
3440       break;
3441
3442     default:
3443       /* Other codes have no operands.  */
3444       break;
3445     }
3446 }
3447
3448 /* Output a sequence of location operations.  */
3449
3450 static void
3451 output_loc_sequence (dw_loc_descr_ref loc)
3452 {
3453   for (; loc != NULL; loc = loc->dw_loc_next)
3454     {
3455       /* Output the opcode.  */
3456       dw2_asm_output_data (1, loc->dw_loc_opc,
3457                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3458
3459       /* Output the operand(s) (if any).  */
3460       output_loc_operands (loc);
3461     }
3462 }
3463
3464 /* This routine will generate the correct assembly data for a location
3465    description based on a cfi entry with a complex address.  */
3466
3467 static void
3468 output_cfa_loc (dw_cfi_ref cfi)
3469 {
3470   dw_loc_descr_ref loc;
3471   unsigned long size;
3472
3473   /* Output the size of the block.  */
3474   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3475   size = size_of_locs (loc);
3476   dw2_asm_output_data_uleb128 (size, NULL);
3477
3478   /* Now output the operations themselves.  */
3479   output_loc_sequence (loc);
3480 }
3481
3482 /* This function builds a dwarf location descriptor sequence from a
3483    dw_cfa_location, adding the given OFFSET to the result of the
3484    expression.  */
3485
3486 static struct dw_loc_descr_struct *
3487 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3488 {
3489   struct dw_loc_descr_struct *head, *tmp;
3490
3491   offset += cfa->offset;
3492
3493   if (cfa->indirect)
3494     {
3495       if (cfa->base_offset)
3496         {
3497           if (cfa->reg <= 31)
3498             head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3499           else
3500             head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3501         }
3502       else if (cfa->reg <= 31)
3503         head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3504       else
3505         head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3506
3507       head->dw_loc_oprnd1.val_class = dw_val_class_const;
3508       tmp = new_loc_descr (DW_OP_deref, 0, 0);
3509       add_loc_descr (&head, tmp);
3510       if (offset != 0)
3511         {
3512           tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3513           add_loc_descr (&head, tmp);
3514         }
3515     }
3516   else
3517     {
3518       if (offset == 0)
3519         if (cfa->reg <= 31)
3520           head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3521         else
3522           head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3523       else if (cfa->reg <= 31)
3524         head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3525       else
3526         head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3527     }
3528
3529   return head;
3530 }
3531
3532 /* This function fills in aa dw_cfa_location structure from a dwarf location
3533    descriptor sequence.  */
3534
3535 static void
3536 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3537 {
3538   struct dw_loc_descr_struct *ptr;
3539   cfa->offset = 0;
3540   cfa->base_offset = 0;
3541   cfa->indirect = 0;
3542   cfa->reg = -1;
3543
3544   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3545     {
3546       enum dwarf_location_atom op = ptr->dw_loc_opc;
3547
3548       switch (op)
3549         {
3550         case DW_OP_reg0:
3551         case DW_OP_reg1:
3552         case DW_OP_reg2:
3553         case DW_OP_reg3:
3554         case DW_OP_reg4:
3555         case DW_OP_reg5:
3556         case DW_OP_reg6:
3557         case DW_OP_reg7:
3558         case DW_OP_reg8:
3559         case DW_OP_reg9:
3560         case DW_OP_reg10:
3561         case DW_OP_reg11:
3562         case DW_OP_reg12:
3563         case DW_OP_reg13:
3564         case DW_OP_reg14:
3565         case DW_OP_reg15:
3566         case DW_OP_reg16:
3567         case DW_OP_reg17:
3568         case DW_OP_reg18:
3569         case DW_OP_reg19:
3570         case DW_OP_reg20:
3571         case DW_OP_reg21:
3572         case DW_OP_reg22:
3573         case DW_OP_reg23:
3574         case DW_OP_reg24:
3575         case DW_OP_reg25:
3576         case DW_OP_reg26:
3577         case DW_OP_reg27:
3578         case DW_OP_reg28:
3579         case DW_OP_reg29:
3580         case DW_OP_reg30:
3581         case DW_OP_reg31:
3582           cfa->reg = op - DW_OP_reg0;
3583           break;
3584         case DW_OP_regx:
3585           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3586           break;
3587         case DW_OP_breg0:
3588         case DW_OP_breg1:
3589         case DW_OP_breg2:
3590         case DW_OP_breg3:
3591         case DW_OP_breg4:
3592         case DW_OP_breg5:
3593         case DW_OP_breg6:
3594         case DW_OP_breg7:
3595         case DW_OP_breg8:
3596         case DW_OP_breg9:
3597         case DW_OP_breg10:
3598         case DW_OP_breg11:
3599         case DW_OP_breg12:
3600         case DW_OP_breg13:
3601         case DW_OP_breg14:
3602         case DW_OP_breg15:
3603         case DW_OP_breg16:
3604         case DW_OP_breg17:
3605         case DW_OP_breg18:
3606         case DW_OP_breg19:
3607         case DW_OP_breg20:
3608         case DW_OP_breg21:
3609         case DW_OP_breg22:
3610         case DW_OP_breg23:
3611         case DW_OP_breg24:
3612         case DW_OP_breg25:
3613         case DW_OP_breg26:
3614         case DW_OP_breg27:
3615         case DW_OP_breg28:
3616         case DW_OP_breg29:
3617         case DW_OP_breg30:
3618         case DW_OP_breg31:
3619           cfa->reg = op - DW_OP_breg0;
3620           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3621           break;
3622         case DW_OP_bregx:
3623           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3624           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3625           break;
3626         case DW_OP_deref:
3627           cfa->indirect = 1;
3628           break;
3629         case DW_OP_plus_uconst:
3630           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3631           break;
3632         default:
3633           internal_error ("DW_LOC_OP %s not implemented",
3634                           dwarf_stack_op_name (ptr->dw_loc_opc));
3635         }
3636     }
3637 }
3638 #endif /* .debug_frame support */
3639 \f
3640 /* And now, the support for symbolic debugging information.  */
3641 #ifdef DWARF2_DEBUGGING_INFO
3642
3643 /* .debug_str support.  */
3644 static int output_indirect_string (void **, void *);
3645
3646 static void dwarf2out_init (const char *);
3647 static void dwarf2out_finish (const char *);
3648 static void dwarf2out_define (unsigned int, const char *);
3649 static void dwarf2out_undef (unsigned int, const char *);
3650 static void dwarf2out_start_source_file (unsigned, const char *);
3651 static void dwarf2out_end_source_file (unsigned);
3652 static void dwarf2out_begin_block (unsigned, unsigned);
3653 static void dwarf2out_end_block (unsigned, unsigned);
3654 static bool dwarf2out_ignore_block (const_tree);
3655 static void dwarf2out_global_decl (tree);
3656 static void dwarf2out_type_decl (tree, int);
3657 static void dwarf2out_imported_module_or_decl (tree, tree);
3658 static void dwarf2out_abstract_function (tree);
3659 static void dwarf2out_var_location (rtx);
3660 static void dwarf2out_begin_function (tree);
3661 static void dwarf2out_switch_text_section (void);
3662
3663 /* The debug hooks structure.  */
3664
3665 const struct gcc_debug_hooks dwarf2_debug_hooks =
3666 {
3667   dwarf2out_init,
3668   dwarf2out_finish,
3669   dwarf2out_define,
3670   dwarf2out_undef,
3671   dwarf2out_start_source_file,
3672   dwarf2out_end_source_file,
3673   dwarf2out_begin_block,
3674   dwarf2out_end_block,
3675   dwarf2out_ignore_block,
3676   dwarf2out_source_line,
3677   dwarf2out_begin_prologue,
3678   debug_nothing_int_charstar,   /* end_prologue */
3679   dwarf2out_end_epilogue,
3680   dwarf2out_begin_function,
3681   debug_nothing_int,            /* end_function */
3682   dwarf2out_decl,               /* function_decl */
3683   dwarf2out_global_decl,
3684   dwarf2out_type_decl,          /* type_decl */
3685   dwarf2out_imported_module_or_decl,
3686   debug_nothing_tree,           /* deferred_inline_function */
3687   /* The DWARF 2 backend tries to reduce debugging bloat by not
3688      emitting the abstract description of inline functions until
3689      something tries to reference them.  */
3690   dwarf2out_abstract_function,  /* outlining_inline_function */
3691   debug_nothing_rtx,            /* label */
3692   debug_nothing_int,            /* handle_pch */
3693   dwarf2out_var_location,
3694   dwarf2out_switch_text_section,
3695   1                             /* start_end_main_source_file */
3696 };
3697 #endif
3698 \f
3699 /* NOTE: In the comments in this file, many references are made to
3700    "Debugging Information Entries".  This term is abbreviated as `DIE'
3701    throughout the remainder of this file.  */
3702
3703 /* An internal representation of the DWARF output is built, and then
3704    walked to generate the DWARF debugging info.  The walk of the internal
3705    representation is done after the entire program has been compiled.
3706    The types below are used to describe the internal representation.  */
3707
3708 /* Various DIE's use offsets relative to the beginning of the
3709    .debug_info section to refer to each other.  */
3710
3711 typedef long int dw_offset;
3712
3713 /* Define typedefs here to avoid circular dependencies.  */
3714
3715 typedef struct dw_attr_struct *dw_attr_ref;
3716 typedef struct dw_line_info_struct *dw_line_info_ref;
3717 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3718 typedef struct pubname_struct *pubname_ref;
3719 typedef struct dw_ranges_struct *dw_ranges_ref;
3720 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
3721
3722 /* Each entry in the line_info_table maintains the file and
3723    line number associated with the label generated for that
3724    entry.  The label gives the PC value associated with
3725    the line number entry.  */
3726
3727 typedef struct dw_line_info_struct GTY(())
3728 {
3729   unsigned long dw_file_num;
3730   unsigned long dw_line_num;
3731 }
3732 dw_line_info_entry;
3733
3734 /* Line information for functions in separate sections; each one gets its
3735    own sequence.  */
3736 typedef struct dw_separate_line_info_struct GTY(())
3737 {
3738   unsigned long dw_file_num;
3739   unsigned long dw_line_num;
3740   unsigned long function;
3741 }
3742 dw_separate_line_info_entry;
3743
3744 /* Each DIE attribute has a field specifying the attribute kind,
3745    a link to the next attribute in the chain, and an attribute value.
3746    Attributes are typically linked below the DIE they modify.  */
3747
3748 typedef struct dw_attr_struct GTY(())
3749 {
3750   enum dwarf_attribute dw_attr;
3751   dw_val_node dw_attr_val;
3752 }
3753 dw_attr_node;
3754
3755 DEF_VEC_O(dw_attr_node);
3756 DEF_VEC_ALLOC_O(dw_attr_node,gc);
3757
3758 /* The Debugging Information Entry (DIE) structure.  DIEs form a tree.
3759    The children of each node form a circular list linked by
3760    die_sib.  die_child points to the node *before* the "first" child node.  */
3761
3762 typedef struct die_struct GTY(())
3763 {
3764   enum dwarf_tag die_tag;
3765   char *die_symbol;
3766   VEC(dw_attr_node,gc) * die_attr;
3767   dw_die_ref die_parent;
3768   dw_die_ref die_child;
3769   dw_die_ref die_sib;
3770   dw_die_ref die_definition; /* ref from a specification to its definition */
3771   dw_offset die_offset;
3772   unsigned long die_abbrev;
3773   int die_mark;
3774   /* Die is used and must not be pruned as unused.  */
3775   int die_perennial_p;
3776   unsigned int decl_id;
3777 }
3778 die_node;
3779
3780 /* Evaluate 'expr' while 'c' is set to each child of DIE in order.  */
3781 #define FOR_EACH_CHILD(die, c, expr) do {       \
3782   c = die->die_child;                           \
3783   if (c) do {                                   \
3784     c = c->die_sib;                             \
3785     expr;                                       \
3786   } while (c != die->die_child);                \
3787 } while (0)
3788
3789 /* The pubname structure */
3790
3791 typedef struct pubname_struct GTY(())
3792 {
3793   dw_die_ref die;
3794   const char *name;
3795 }
3796 pubname_entry;
3797
3798 DEF_VEC_O(pubname_entry);
3799 DEF_VEC_ALLOC_O(pubname_entry, gc);
3800
3801 struct dw_ranges_struct GTY(())
3802 {
3803   /* If this is positive, it's a block number, otherwise it's a
3804      bitwise-negated index into dw_ranges_by_label.  */
3805   int num;
3806 };
3807
3808 struct dw_ranges_by_label_struct GTY(())
3809 {
3810   const char *begin;
3811   const char *end;
3812 };
3813
3814 /* The limbo die list structure.  */
3815 typedef struct limbo_die_struct GTY(())
3816 {
3817   dw_die_ref die;
3818   tree created_for;
3819   struct limbo_die_struct *next;
3820 }
3821 limbo_die_node;
3822
3823 /* How to start an assembler comment.  */
3824 #ifndef ASM_COMMENT_START
3825 #define ASM_COMMENT_START ";#"
3826 #endif
3827
3828 /* Define a macro which returns nonzero for a TYPE_DECL which was
3829    implicitly generated for a tagged type.
3830
3831    Note that unlike the gcc front end (which generates a NULL named
3832    TYPE_DECL node for each complete tagged type, each array type, and
3833    each function type node created) the g++ front end generates a
3834    _named_ TYPE_DECL node for each tagged type node created.
3835    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3836    generate a DW_TAG_typedef DIE for them.  */
3837
3838 #define TYPE_DECL_IS_STUB(decl)                         \
3839   (DECL_NAME (decl) == NULL_TREE                        \
3840    || (DECL_ARTIFICIAL (decl)                           \
3841        && is_tagged_type (TREE_TYPE (decl))             \
3842        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3843            /* This is necessary for stub decls that     \
3844               appear in nested inline functions.  */    \
3845            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3846                && (decl_ultimate_origin (decl)          \
3847                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3848
3849 /* Information concerning the compilation unit's programming
3850    language, and compiler version.  */
3851
3852 /* Fixed size portion of the DWARF compilation unit header.  */
3853 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3854   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3855
3856 /* Fixed size portion of public names info.  */
3857 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3858
3859 /* Fixed size portion of the address range info.  */
3860 #define DWARF_ARANGES_HEADER_SIZE                                       \
3861   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3862                 DWARF2_ADDR_SIZE * 2)                                   \
3863    - DWARF_INITIAL_LENGTH_SIZE)
3864
3865 /* Size of padding portion in the address range info.  It must be
3866    aligned to twice the pointer size.  */
3867 #define DWARF_ARANGES_PAD_SIZE \
3868   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3869                 DWARF2_ADDR_SIZE * 2)                              \
3870    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3871
3872 /* Use assembler line directives if available.  */
3873 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3874 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3875 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3876 #else
3877 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3878 #endif
3879 #endif
3880
3881 /* Minimum line offset in a special line info. opcode.
3882    This value was chosen to give a reasonable range of values.  */
3883 #define DWARF_LINE_BASE  -10
3884
3885 /* First special line opcode - leave room for the standard opcodes.  */
3886 #define DWARF_LINE_OPCODE_BASE  10
3887
3888 /* Range of line offsets in a special line info. opcode.  */
3889 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3890
3891 /* Flag that indicates the initial value of the is_stmt_start flag.
3892    In the present implementation, we do not mark any lines as
3893    the beginning of a source statement, because that information
3894    is not made available by the GCC front-end.  */
3895 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3896
3897 #ifdef DWARF2_DEBUGGING_INFO
3898 /* This location is used by calc_die_sizes() to keep track
3899    the offset of each DIE within the .debug_info section.  */
3900 static unsigned long next_die_offset;
3901 #endif
3902
3903 /* Record the root of the DIE's built for the current compilation unit.  */
3904 static GTY(()) dw_die_ref comp_unit_die;
3905
3906 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3907 static GTY(()) limbo_die_node *limbo_die_list;
3908
3909 /* Filenames referenced by this compilation unit.  */
3910 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
3911
3912 /* A hash table of references to DIE's that describe declarations.
3913    The key is a DECL_UID() which is a unique number identifying each decl.  */
3914 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3915
3916 /* Node of the variable location list.  */
3917 struct var_loc_node GTY ((chain_next ("%h.next")))
3918 {
3919   rtx GTY (()) var_loc_note;
3920   const char * GTY (()) label;
3921   const char * GTY (()) section_label;
3922   struct var_loc_node * GTY (()) next;
3923 };
3924
3925 /* Variable location list.  */
3926 struct var_loc_list_def GTY (())
3927 {
3928   struct var_loc_node * GTY (()) first;
3929
3930   /* Do not mark the last element of the chained list because
3931      it is marked through the chain.  */
3932   struct var_loc_node * GTY ((skip ("%h"))) last;
3933
3934   /* DECL_UID of the variable decl.  */
3935   unsigned int decl_id;
3936 };
3937 typedef struct var_loc_list_def var_loc_list;
3938
3939
3940 /* Table of decl location linked lists.  */
3941 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3942
3943 /* A pointer to the base of a list of references to DIE's that
3944    are uniquely identified by their tag, presence/absence of
3945    children DIE's, and list of attribute/value pairs.  */
3946 static GTY((length ("abbrev_die_table_allocated")))
3947   dw_die_ref *abbrev_die_table;
3948
3949 /* Number of elements currently allocated for abbrev_die_table.  */
3950 static GTY(()) unsigned abbrev_die_table_allocated;
3951
3952 /* Number of elements in type_die_table currently in use.  */
3953 static GTY(()) unsigned abbrev_die_table_in_use;
3954
3955 /* Size (in elements) of increments by which we may expand the
3956    abbrev_die_table.  */
3957 #define ABBREV_DIE_TABLE_INCREMENT 256
3958
3959 /* A pointer to the base of a table that contains line information
3960    for each source code line in .text in the compilation unit.  */
3961 static GTY((length ("line_info_table_allocated")))
3962      dw_line_info_ref line_info_table;
3963
3964 /* Number of elements currently allocated for line_info_table.  */
3965 static GTY(()) unsigned line_info_table_allocated;
3966
3967 /* Number of elements in line_info_table currently in use.  */
3968 static GTY(()) unsigned line_info_table_in_use;
3969
3970 /* True if the compilation unit places functions in more than one section.  */
3971 static GTY(()) bool have_multiple_function_sections = false;
3972
3973 /* A pointer to the base of a table that contains line information
3974    for each source code line outside of .text in the compilation unit.  */
3975 static GTY ((length ("separate_line_info_table_allocated")))
3976      dw_separate_line_info_ref separate_line_info_table;
3977
3978 /* Number of elements currently allocated for separate_line_info_table.  */
3979 static GTY(()) unsigned separate_line_info_table_allocated;
3980
3981 /* Number of elements in separate_line_info_table currently in use.  */
3982 static GTY(()) unsigned separate_line_info_table_in_use;
3983
3984 /* Size (in elements) of increments by which we may expand the
3985    line_info_table.  */
3986 #define LINE_INFO_TABLE_INCREMENT 1024
3987
3988 /* A pointer to the base of a table that contains a list of publicly
3989    accessible names.  */
3990 static GTY (()) VEC (pubname_entry, gc) *  pubname_table;
3991
3992 /* A pointer to the base of a table that contains a list of publicly
3993    accessible types.  */
3994 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3995
3996 /* Array of dies for which we should generate .debug_arange info.  */
3997 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3998
3999 /* Number of elements currently allocated for arange_table.  */
4000 static GTY(()) unsigned arange_table_allocated;
4001
4002 /* Number of elements in arange_table currently in use.  */
4003 static GTY(()) unsigned arange_table_in_use;
4004
4005 /* Size (in elements) of increments by which we may expand the
4006    arange_table.  */
4007 #define ARANGE_TABLE_INCREMENT 64
4008
4009 /* Array of dies for which we should generate .debug_ranges info.  */
4010 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
4011
4012 /* Number of elements currently allocated for ranges_table.  */
4013 static GTY(()) unsigned ranges_table_allocated;
4014
4015 /* Number of elements in ranges_table currently in use.  */
4016 static GTY(()) unsigned ranges_table_in_use;
4017
4018 /* Array of pairs of labels referenced in ranges_table.  */
4019 static GTY ((length ("ranges_by_label_allocated")))
4020      dw_ranges_by_label_ref ranges_by_label;
4021
4022 /* Number of elements currently allocated for ranges_by_label.  */
4023 static GTY(()) unsigned ranges_by_label_allocated;
4024
4025 /* Number of elements in ranges_by_label currently in use.  */
4026 static GTY(()) unsigned ranges_by_label_in_use;
4027
4028 /* Size (in elements) of increments by which we may expand the
4029    ranges_table.  */
4030 #define RANGES_TABLE_INCREMENT 64
4031
4032 /* Whether we have location lists that need outputting */
4033 static GTY(()) bool have_location_lists;
4034
4035 /* Unique label counter.  */
4036 static GTY(()) unsigned int loclabel_num;
4037
4038 #ifdef DWARF2_DEBUGGING_INFO
4039 /* Record whether the function being analyzed contains inlined functions.  */
4040 static int current_function_has_inlines;
4041 #endif
4042 #if 0 && defined (MIPS_DEBUGGING_INFO)
4043 static int comp_unit_has_inlines;
4044 #endif
4045
4046 /* The last file entry emitted by maybe_emit_file().  */
4047 static GTY(()) struct dwarf_file_data * last_emitted_file;
4048
4049 /* Number of internal labels generated by gen_internal_sym().  */
4050 static GTY(()) int label_num;
4051
4052 /* Cached result of previous call to lookup_filename.  */
4053 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4054
4055 /* Whether the default text and cold text sections have been used at
4056    all.  */
4057
4058 static GTY(()) bool text_section_used = false;
4059 static GTY(()) bool cold_text_section_used = false;
4060
4061 /* The default cold text section.  */
4062 static GTY(()) section *cold_text_section;
4063
4064 #ifdef DWARF2_DEBUGGING_INFO
4065
4066 /* Offset from the "steady-state frame pointer" to the frame base,
4067    within the current function.  */
4068 static HOST_WIDE_INT frame_pointer_fb_offset;
4069
4070 /* Forward declarations for functions defined in this file.  */
4071
4072 static int is_pseudo_reg (const_rtx);
4073 static tree type_main_variant (tree);
4074 static int is_tagged_type (const_tree);
4075 static const char *dwarf_tag_name (unsigned);
4076 static const char *dwarf_attr_name (unsigned);
4077 static const char *dwarf_form_name (unsigned);
4078 static tree decl_ultimate_origin (const_tree);
4079 static tree block_ultimate_origin (const_tree);
4080 static tree decl_class_context (tree);
4081 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4082 static inline enum dw_val_class AT_class (dw_attr_ref);
4083 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4084 static inline unsigned AT_flag (dw_attr_ref);
4085 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4086 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4087 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4088 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4089 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4090                               unsigned long);
4091 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4092                                unsigned int, unsigned char *);
4093 static hashval_t debug_str_do_hash (const void *);
4094 static int debug_str_eq (const void *, const void *);
4095 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4096 static inline const char *AT_string (dw_attr_ref);
4097 static int AT_string_form (dw_attr_ref);
4098 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4099 static void add_AT_specification (dw_die_ref, dw_die_ref);
4100 static inline dw_die_ref AT_ref (dw_attr_ref);
4101 static inline int AT_ref_external (dw_attr_ref);
4102 static inline void set_AT_ref_external (dw_attr_ref, int);
4103 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4104 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4105 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4106 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4107                              dw_loc_list_ref);
4108 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4109 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4110 static inline rtx AT_addr (dw_attr_ref);
4111 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4112 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4113 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4114 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4115                            unsigned HOST_WIDE_INT);
4116 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4117                                unsigned long);
4118 static inline const char *AT_lbl (dw_attr_ref);
4119 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
4120 static const char *get_AT_low_pc (dw_die_ref);
4121 static const char *get_AT_hi_pc (dw_die_ref);
4122 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
4123 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4124 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4125 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4126 static bool is_c_family (void);
4127 static bool is_cxx (void);
4128 static bool is_java (void);
4129 static bool is_fortran (void);
4130 static bool is_ada (void);
4131 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4132 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4133 static void add_child_die (dw_die_ref, dw_die_ref);
4134 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4135 static dw_die_ref lookup_type_die (tree);
4136 static void equate_type_number_to_die (tree, dw_die_ref);
4137 static hashval_t decl_die_table_hash (const void *);
4138 static int decl_die_table_eq (const void *, const void *);
4139 static dw_die_ref lookup_decl_die (tree);
4140 static hashval_t decl_loc_table_hash (const void *);
4141 static int decl_loc_table_eq (const void *, const void *);
4142 static var_loc_list *lookup_decl_loc (const_tree);
4143 static void equate_decl_number_to_die (tree, dw_die_ref);
4144 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4145 static void print_spaces (FILE *);
4146 static void print_die (dw_die_ref, FILE *);
4147 static void print_dwarf_line_table (FILE *);
4148 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4149 static dw_die_ref pop_compile_unit (dw_die_ref);
4150 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4151 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4152 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4153 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4154 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
4155 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4156 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4157 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4158 static void compute_section_prefix (dw_die_ref);
4159 static int is_type_die (dw_die_ref);
4160 static int is_comdat_die (dw_die_ref);
4161 static int is_symbol_die (dw_die_ref);
4162 static void assign_symbol_names (dw_die_ref);
4163 static void break_out_includes (dw_die_ref);
4164 static hashval_t htab_cu_hash (const void *);
4165 static int htab_cu_eq (const void *, const void *);
4166 static void htab_cu_del (void *);
4167 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4168 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4169 static void add_sibling_attributes (dw_die_ref);
4170 static void build_abbrev_table (dw_die_ref);
4171 static void output_location_lists (dw_die_ref);
4172 static int constant_size (long unsigned);
4173 static unsigned long size_of_die (dw_die_ref);
4174 static void calc_die_sizes (dw_die_ref);
4175 static void mark_dies (dw_die_ref);
4176 static void unmark_dies (dw_die_ref);
4177 static void unmark_all_dies (dw_die_ref);
4178 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
4179 static unsigned long size_of_aranges (void);
4180 static enum dwarf_form value_format (dw_attr_ref);
4181 static void output_value_format (dw_attr_ref);
4182 static void output_abbrev_section (void);
4183 static void output_die_symbol (dw_die_ref);
4184 static void output_die (dw_die_ref);
4185 static void output_compilation_unit_header (void);
4186 static void output_comp_unit (dw_die_ref, int);
4187 static const char *dwarf2_name (tree, int);
4188 static void add_pubname (tree, dw_die_ref);
4189 static void add_pubtype (tree, dw_die_ref);
4190 static void output_pubnames (VEC (pubname_entry,gc) *);
4191 static void add_arange (tree, dw_die_ref);
4192 static void output_aranges (void);
4193 static unsigned int add_ranges_num (int);
4194 static unsigned int add_ranges (const_tree);
4195 static unsigned int add_ranges_by_labels (const char *, const char *);
4196 static void output_ranges (void);
4197 static void output_line_info (void);
4198 static void output_file_names (void);
4199 static dw_die_ref base_type_die (tree);
4200 static int is_base_type (tree);
4201 static bool is_subrange_type (const_tree);
4202 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4203 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4204 static int type_is_enum (const_tree);
4205 static unsigned int dbx_reg_number (const_rtx);
4206 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4207 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
4208 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
4209                                                 enum var_init_status);
4210 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
4211                                                      enum var_init_status);
4212 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4213 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
4214                                          enum var_init_status);
4215 static int is_based_loc (const_rtx);
4216 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
4217                                             enum var_init_status);
4218 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
4219                                                enum var_init_status);
4220 static dw_loc_descr_ref loc_descriptor (rtx, enum var_init_status);
4221 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4222 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4223 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4224 static tree field_type (const_tree);
4225 static unsigned int simple_type_align_in_bits (const_tree);
4226 static unsigned int simple_decl_align_in_bits (const_tree);
4227 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
4228 static HOST_WIDE_INT field_byte_offset (const_tree);
4229 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4230                                          dw_loc_descr_ref);
4231 static void add_data_member_location_attribute (dw_die_ref, tree);
4232 static void add_const_value_attribute (dw_die_ref, rtx);
4233 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4234 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4235 static void insert_float (const_rtx, unsigned char *);
4236 static rtx rtl_for_decl_location (tree);
4237 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4238                                                    enum dwarf_attribute);
4239 static void tree_add_const_value_attribute (dw_die_ref, tree);
4240 static void add_name_attribute (dw_die_ref, const char *);
4241 static void add_comp_dir_attribute (dw_die_ref);
4242 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4243 static void add_subscript_info (dw_die_ref, tree);
4244 static void add_byte_size_attribute (dw_die_ref, tree);
4245 static void add_bit_offset_attribute (dw_die_ref, tree);
4246 static void add_bit_size_attribute (dw_die_ref, tree);
4247 static void add_prototyped_attribute (dw_die_ref, tree);
4248 static void add_abstract_origin_attribute (dw_die_ref, tree);
4249 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4250 static void add_src_coords_attributes (dw_die_ref, tree);
4251 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4252 static void push_decl_scope (tree);
4253 static void pop_decl_scope (void);
4254 static dw_die_ref scope_die_for (tree, dw_die_ref);
4255 static inline int local_scope_p (dw_die_ref);
4256 static inline int class_or_namespace_scope_p (dw_die_ref);
4257 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4258 static void add_calling_convention_attribute (dw_die_ref, tree);
4259 static const char *type_tag (const_tree);
4260 static tree member_declared_type (const_tree);
4261 #if 0
4262 static const char *decl_start_label (tree);
4263 #endif
4264 static void gen_array_type_die (tree, dw_die_ref);
4265 #if 0
4266 static void gen_entry_point_die (tree, dw_die_ref);
4267 #endif
4268 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4269 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4270 static void gen_inlined_union_type_die (tree, dw_die_ref);
4271 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4272 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4273 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4274 static void gen_formal_types_die (tree, dw_die_ref);
4275 static void gen_subprogram_die (tree, dw_die_ref);
4276 static void gen_variable_die (tree, dw_die_ref);
4277 static void gen_label_die (tree, dw_die_ref);
4278 static void gen_lexical_block_die (tree, dw_die_ref, int);
4279 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4280 static void gen_field_die (tree, dw_die_ref);
4281 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4282 static dw_die_ref gen_compile_unit_die (const char *);
4283 static void gen_inheritance_die (tree, tree, dw_die_ref);
4284 static void gen_member_die (tree, dw_die_ref);
4285 static void gen_struct_or_union_type_die (tree, dw_die_ref,
4286                                                 enum debug_info_usage);
4287 static void gen_subroutine_type_die (tree, dw_die_ref);
4288 static void gen_typedef_die (tree, dw_die_ref);
4289 static void gen_type_die (tree, dw_die_ref);
4290 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4291 static void gen_block_die (tree, dw_die_ref, int);
4292 static void decls_for_scope (tree, dw_die_ref, int);
4293 static int is_redundant_typedef (const_tree);
4294 static void gen_namespace_die (tree);
4295 static void gen_decl_die (tree, dw_die_ref);
4296 static dw_die_ref force_decl_die (tree);
4297 static dw_die_ref force_type_die (tree);
4298 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4299 static void declare_in_namespace (tree, dw_die_ref);
4300 static struct dwarf_file_data * lookup_filename (const char *);
4301 static void retry_incomplete_types (void);
4302 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4303 static void splice_child_die (dw_die_ref, dw_die_ref);
4304 static int file_info_cmp (const void *, const void *);
4305 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4306                                      const char *, const char *, unsigned);
4307 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4308                                        const char *, const char *,
4309                                        const char *);
4310 static void output_loc_list (dw_loc_list_ref);
4311 static char *gen_internal_sym (const char *);
4312
4313 static void prune_unmark_dies (dw_die_ref);
4314 static void prune_unused_types_mark (dw_die_ref, int);
4315 static void prune_unused_types_walk (dw_die_ref);
4316 static void prune_unused_types_walk_attribs (dw_die_ref);
4317 static void prune_unused_types_prune (dw_die_ref);
4318 static void prune_unused_types (void);
4319 static int maybe_emit_file (struct dwarf_file_data *fd);
4320
4321 /* Section names used to hold DWARF debugging information.  */
4322 #ifndef DEBUG_INFO_SECTION
4323 #define DEBUG_INFO_SECTION      ".debug_info"
4324 #endif
4325 #ifndef DEBUG_ABBREV_SECTION
4326 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4327 #endif
4328 #ifndef DEBUG_ARANGES_SECTION
4329 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4330 #endif
4331 #ifndef DEBUG_MACINFO_SECTION
4332 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4333 #endif
4334 #ifndef DEBUG_LINE_SECTION
4335 #define DEBUG_LINE_SECTION      ".debug_line"
4336 #endif
4337 #ifndef DEBUG_LOC_SECTION
4338 #define DEBUG_LOC_SECTION       ".debug_loc"
4339 #endif
4340 #ifndef DEBUG_PUBNAMES_SECTION
4341 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4342 #endif
4343 #ifndef DEBUG_STR_SECTION
4344 #define DEBUG_STR_SECTION       ".debug_str"
4345 #endif
4346 #ifndef DEBUG_RANGES_SECTION
4347 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4348 #endif
4349
4350 /* Standard ELF section names for compiled code and data.  */
4351 #ifndef TEXT_SECTION_NAME
4352 #define TEXT_SECTION_NAME       ".text"
4353 #endif
4354
4355 /* Section flags for .debug_str section.  */
4356 #define DEBUG_STR_SECTION_FLAGS \
4357   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4358    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4359    : SECTION_DEBUG)
4360
4361 /* Labels we insert at beginning sections we can reference instead of
4362    the section names themselves.  */
4363
4364 #ifndef TEXT_SECTION_LABEL
4365 #define TEXT_SECTION_LABEL              "Ltext"
4366 #endif
4367 #ifndef COLD_TEXT_SECTION_LABEL
4368 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4369 #endif
4370 #ifndef DEBUG_LINE_SECTION_LABEL
4371 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4372 #endif
4373 #ifndef DEBUG_INFO_SECTION_LABEL
4374 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4375 #endif
4376 #ifndef DEBUG_ABBREV_SECTION_LABEL
4377 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4378 #endif
4379 #ifndef DEBUG_LOC_SECTION_LABEL
4380 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4381 #endif
4382 #ifndef DEBUG_RANGES_SECTION_LABEL
4383 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4384 #endif
4385 #ifndef DEBUG_MACINFO_SECTION_LABEL
4386 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4387 #endif
4388
4389 /* Definitions of defaults for formats and names of various special
4390    (artificial) labels which may be generated within this file (when the -g
4391    options is used and DWARF2_DEBUGGING_INFO is in effect.
4392    If necessary, these may be overridden from within the tm.h file, but
4393    typically, overriding these defaults is unnecessary.  */
4394
4395 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4396 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4397 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4398 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4399 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4400 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4401 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4402 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4403 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4404 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4405
4406 #ifndef TEXT_END_LABEL
4407 #define TEXT_END_LABEL          "Letext"
4408 #endif
4409 #ifndef COLD_END_LABEL
4410 #define COLD_END_LABEL          "Letext_cold"
4411 #endif
4412 #ifndef BLOCK_BEGIN_LABEL
4413 #define BLOCK_BEGIN_LABEL       "LBB"
4414 #endif
4415 #ifndef BLOCK_END_LABEL
4416 #define BLOCK_END_LABEL         "LBE"
4417 #endif
4418 #ifndef LINE_CODE_LABEL
4419 #define LINE_CODE_LABEL         "LM"
4420 #endif
4421 #ifndef SEPARATE_LINE_CODE_LABEL
4422 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4423 #endif
4424
4425 \f
4426 /* We allow a language front-end to designate a function that is to be
4427    called to "demangle" any name before it is put into a DIE.  */
4428
4429 static const char *(*demangle_name_func) (const char *);
4430
4431 void
4432 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4433 {
4434   demangle_name_func = func;
4435 }
4436
4437 /* Test if rtl node points to a pseudo register.  */
4438
4439 static inline int
4440 is_pseudo_reg (const_rtx rtl)
4441 {
4442   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4443           || (GET_CODE (rtl) == SUBREG
4444               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4445 }
4446
4447 /* Return a reference to a type, with its const and volatile qualifiers
4448    removed.  */
4449
4450 static inline tree
4451 type_main_variant (tree type)
4452 {
4453   type = TYPE_MAIN_VARIANT (type);
4454
4455   /* ??? There really should be only one main variant among any group of
4456      variants of a given type (and all of the MAIN_VARIANT values for all
4457      members of the group should point to that one type) but sometimes the C
4458      front-end messes this up for array types, so we work around that bug
4459      here.  */
4460   if (TREE_CODE (type) == ARRAY_TYPE)
4461     while (type != TYPE_MAIN_VARIANT (type))
4462       type = TYPE_MAIN_VARIANT (type);
4463
4464   return type;
4465 }
4466
4467 /* Return nonzero if the given type node represents a tagged type.  */
4468
4469 static inline int
4470 is_tagged_type (const_tree type)
4471 {
4472   enum tree_code code = TREE_CODE (type);
4473
4474   return (code == RECORD_TYPE || code == UNION_TYPE
4475           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4476 }
4477
4478 /* Convert a DIE tag into its string name.  */
4479
4480 static const char *
4481 dwarf_tag_name (unsigned int tag)
4482 {
4483   switch (tag)
4484     {
4485     case DW_TAG_padding:
4486       return "DW_TAG_padding";
4487     case DW_TAG_array_type:
4488       return "DW_TAG_array_type";
4489     case DW_TAG_class_type:
4490       return "DW_TAG_class_type";
4491     case DW_TAG_entry_point:
4492       return "DW_TAG_entry_point";
4493     case DW_TAG_enumeration_type:
4494       return "DW_TAG_enumeration_type";
4495     case DW_TAG_formal_parameter:
4496       return "DW_TAG_formal_parameter";
4497     case DW_TAG_imported_declaration:
4498       return "DW_TAG_imported_declaration";
4499     case DW_TAG_label:
4500       return "DW_TAG_label";
4501     case DW_TAG_lexical_block:
4502       return "DW_TAG_lexical_block";
4503     case DW_TAG_member:
4504       return "DW_TAG_member";
4505     case DW_TAG_pointer_type:
4506       return "DW_TAG_pointer_type";
4507     case DW_TAG_reference_type:
4508       return "DW_TAG_reference_type";
4509     case DW_TAG_compile_unit:
4510       return "DW_TAG_compile_unit";
4511     case DW_TAG_string_type:
4512       return "DW_TAG_string_type";
4513     case DW_TAG_structure_type:
4514       return "DW_TAG_structure_type";
4515     case DW_TAG_subroutine_type:
4516       return "DW_TAG_subroutine_type";
4517     case DW_TAG_typedef:
4518       return "DW_TAG_typedef";
4519     case DW_TAG_union_type:
4520       return "DW_TAG_union_type";
4521     case DW_TAG_unspecified_parameters:
4522       return "DW_TAG_unspecified_parameters";
4523     case DW_TAG_variant:
4524       return "DW_TAG_variant";
4525     case DW_TAG_common_block:
4526       return "DW_TAG_common_block";
4527     case DW_TAG_common_inclusion:
4528       return "DW_TAG_common_inclusion";
4529     case DW_TAG_inheritance:
4530       return "DW_TAG_inheritance";
4531     case DW_TAG_inlined_subroutine:
4532       return "DW_TAG_inlined_subroutine";
4533     case DW_TAG_module:
4534       return "DW_TAG_module";
4535     case DW_TAG_ptr_to_member_type:
4536       return "DW_TAG_ptr_to_member_type";
4537     case DW_TAG_set_type:
4538       return "DW_TAG_set_type";
4539     case DW_TAG_subrange_type:
4540       return "DW_TAG_subrange_type";
4541     case DW_TAG_with_stmt:
4542       return "DW_TAG_with_stmt";
4543     case DW_TAG_access_declaration:
4544       return "DW_TAG_access_declaration";
4545     case DW_TAG_base_type:
4546       return "DW_TAG_base_type";
4547     case DW_TAG_catch_block:
4548       return "DW_TAG_catch_block";
4549     case DW_TAG_const_type:
4550       return "DW_TAG_const_type";
4551     case DW_TAG_constant:
4552       return "DW_TAG_constant";
4553     case DW_TAG_enumerator:
4554       return "DW_TAG_enumerator";
4555     case DW_TAG_file_type:
4556       return "DW_TAG_file_type";
4557     case DW_TAG_friend:
4558       return "DW_TAG_friend";
4559     case DW_TAG_namelist:
4560       return "DW_TAG_namelist";
4561     case DW_TAG_namelist_item:
4562       return "DW_TAG_namelist_item";
4563     case DW_TAG_namespace:
4564       return "DW_TAG_namespace";
4565     case DW_TAG_packed_type:
4566       return "DW_TAG_packed_type";
4567     case DW_TAG_subprogram:
4568       return "DW_TAG_subprogram";
4569     case DW_TAG_template_type_param:
4570       return "DW_TAG_template_type_param";
4571     case DW_TAG_template_value_param:
4572       return "DW_TAG_template_value_param";
4573     case DW_TAG_thrown_type:
4574       return "DW_TAG_thrown_type";
4575     case DW_TAG_try_block:
4576       return "DW_TAG_try_block";
4577     case DW_TAG_variant_part:
4578       return "DW_TAG_variant_part";
4579     case DW_TAG_variable:
4580       return "DW_TAG_variable";
4581     case DW_TAG_volatile_type:
4582       return "DW_TAG_volatile_type";
4583     case DW_TAG_imported_module:
4584       return "DW_TAG_imported_module";
4585     case DW_TAG_MIPS_loop:
4586       return "DW_TAG_MIPS_loop";
4587     case DW_TAG_format_label:
4588       return "DW_TAG_format_label";
4589     case DW_TAG_function_template:
4590       return "DW_TAG_function_template";
4591     case DW_TAG_class_template:
4592       return "DW_TAG_class_template";
4593     case DW_TAG_GNU_BINCL:
4594       return "DW_TAG_GNU_BINCL";
4595     case DW_TAG_GNU_EINCL:
4596       return "DW_TAG_GNU_EINCL";
4597     default:
4598       return "DW_TAG_<unknown>";
4599     }
4600 }
4601
4602 /* Convert a DWARF attribute code into its string name.  */
4603
4604 static const char *
4605 dwarf_attr_name (unsigned int attr)
4606 {
4607   switch (attr)
4608     {
4609     case DW_AT_sibling:
4610       return "DW_AT_sibling";
4611     case DW_AT_location:
4612       return "DW_AT_location";
4613     case DW_AT_name:
4614       return "DW_AT_name";
4615     case DW_AT_ordering:
4616       return "DW_AT_ordering";
4617     case DW_AT_subscr_data:
4618       return "DW_AT_subscr_data";
4619     case DW_AT_byte_size:
4620       return "DW_AT_byte_size";
4621     case DW_AT_bit_offset:
4622       return "DW_AT_bit_offset";
4623     case DW_AT_bit_size:
4624       return "DW_AT_bit_size";
4625     case DW_AT_element_list:
4626       return "DW_AT_element_list";
4627     case DW_AT_stmt_list:
4628       return "DW_AT_stmt_list";
4629     case DW_AT_low_pc:
4630       return "DW_AT_low_pc";
4631     case DW_AT_high_pc:
4632       return "DW_AT_high_pc";
4633     case DW_AT_language:
4634       return "DW_AT_language";
4635     case DW_AT_member:
4636       return "DW_AT_member";
4637     case DW_AT_discr:
4638       return "DW_AT_discr";
4639     case DW_AT_discr_value:
4640       return "DW_AT_discr_value";
4641     case DW_AT_visibility:
4642       return "DW_AT_visibility";
4643     case DW_AT_import:
4644       return "DW_AT_import";
4645     case DW_AT_string_length:
4646       return "DW_AT_string_length";
4647     case DW_AT_common_reference:
4648       return "DW_AT_common_reference";
4649     case DW_AT_comp_dir:
4650       return "DW_AT_comp_dir";
4651     case DW_AT_const_value:
4652       return "DW_AT_const_value";
4653     case DW_AT_containing_type:
4654       return "DW_AT_containing_type";
4655     case DW_AT_default_value:
4656       return "DW_AT_default_value";
4657     case DW_AT_inline:
4658       return "DW_AT_inline";
4659     case DW_AT_is_optional:
4660       return "DW_AT_is_optional";
4661     case DW_AT_lower_bound:
4662       return "DW_AT_lower_bound";
4663     case DW_AT_producer:
4664       return "DW_AT_producer";
4665     case DW_AT_prototyped:
4666       return "DW_AT_prototyped";
4667     case DW_AT_return_addr:
4668       return "DW_AT_return_addr";
4669     case DW_AT_start_scope:
4670       return "DW_AT_start_scope";
4671     case DW_AT_stride_size:
4672       return "DW_AT_stride_size";
4673     case DW_AT_upper_bound:
4674       return "DW_AT_upper_bound";
4675     case DW_AT_abstract_origin:
4676       return "DW_AT_abstract_origin";
4677     case DW_AT_accessibility:
4678       return "DW_AT_accessibility";
4679     case DW_AT_address_class:
4680       return "DW_AT_address_class";
4681     case DW_AT_artificial:
4682       return "DW_AT_artificial";
4683     case DW_AT_base_types:
4684       return "DW_AT_base_types";
4685     case DW_AT_calling_convention:
4686       return "DW_AT_calling_convention";
4687     case DW_AT_count:
4688       return "DW_AT_count";
4689     case DW_AT_data_member_location:
4690       return "DW_AT_data_member_location";
4691     case DW_AT_decl_column:
4692       return "DW_AT_decl_column";
4693     case DW_AT_decl_file:
4694       return "DW_AT_decl_file";
4695     case DW_AT_decl_line:
4696       return "DW_AT_decl_line";
4697     case DW_AT_declaration:
4698       return "DW_AT_declaration";
4699     case DW_AT_discr_list:
4700       return "DW_AT_discr_list";
4701     case DW_AT_encoding:
4702       return "DW_AT_encoding";
4703     case DW_AT_external:
4704       return "DW_AT_external";
4705     case DW_AT_frame_base:
4706       return "DW_AT_frame_base";
4707     case DW_AT_friend:
4708       return "DW_AT_friend";
4709     case DW_AT_identifier_case:
4710       return "DW_AT_identifier_case";
4711     case DW_AT_macro_info:
4712       return "DW_AT_macro_info";
4713     case DW_AT_namelist_items:
4714       return "DW_AT_namelist_items";
4715     case DW_AT_priority:
4716       return "DW_AT_priority";
4717     case DW_AT_segment:
4718       return "DW_AT_segment";
4719     case DW_AT_specification:
4720       return "DW_AT_specification";
4721     case DW_AT_static_link:
4722       return "DW_AT_static_link";
4723     case DW_AT_type:
4724       return "DW_AT_type";
4725     case DW_AT_use_location:
4726       return "DW_AT_use_location";
4727     case DW_AT_variable_parameter:
4728       return "DW_AT_variable_parameter";
4729     case DW_AT_virtuality:
4730       return "DW_AT_virtuality";
4731     case DW_AT_vtable_elem_location:
4732       return "DW_AT_vtable_elem_location";
4733
4734     case DW_AT_allocated:
4735       return "DW_AT_allocated";
4736     case DW_AT_associated:
4737       return "DW_AT_associated";
4738     case DW_AT_data_location:
4739       return "DW_AT_data_location";
4740     case DW_AT_stride:
4741       return "DW_AT_stride";
4742     case DW_AT_entry_pc:
4743       return "DW_AT_entry_pc";
4744     case DW_AT_use_UTF8:
4745       return "DW_AT_use_UTF8";
4746     case DW_AT_extension:
4747       return "DW_AT_extension";
4748     case DW_AT_ranges:
4749       return "DW_AT_ranges";
4750     case DW_AT_trampoline:
4751       return "DW_AT_trampoline";
4752     case DW_AT_call_column:
4753       return "DW_AT_call_column";
4754     case DW_AT_call_file:
4755       return "DW_AT_call_file";
4756     case DW_AT_call_line:
4757       return "DW_AT_call_line";
4758
4759     case DW_AT_MIPS_fde:
4760       return "DW_AT_MIPS_fde";
4761     case DW_AT_MIPS_loop_begin:
4762       return "DW_AT_MIPS_loop_begin";
4763     case DW_AT_MIPS_tail_loop_begin:
4764       return "DW_AT_MIPS_tail_loop_begin";
4765     case DW_AT_MIPS_epilog_begin:
4766       return "DW_AT_MIPS_epilog_begin";
4767     case DW_AT_MIPS_loop_unroll_factor:
4768       return "DW_AT_MIPS_loop_unroll_factor";
4769     case DW_AT_MIPS_software_pipeline_depth:
4770       return "DW_AT_MIPS_software_pipeline_depth";
4771     case DW_AT_MIPS_linkage_name:
4772       return "DW_AT_MIPS_linkage_name";
4773     case DW_AT_MIPS_stride:
4774       return "DW_AT_MIPS_stride";
4775     case DW_AT_MIPS_abstract_name:
4776       return "DW_AT_MIPS_abstract_name";
4777     case DW_AT_MIPS_clone_origin:
4778       return "DW_AT_MIPS_clone_origin";
4779     case DW_AT_MIPS_has_inlines:
4780       return "DW_AT_MIPS_has_inlines";
4781
4782     case DW_AT_sf_names:
4783       return "DW_AT_sf_names";
4784     case DW_AT_src_info:
4785       return "DW_AT_src_info";
4786     case DW_AT_mac_info:
4787       return "DW_AT_mac_info";
4788     case DW_AT_src_coords:
4789       return "DW_AT_src_coords";
4790     case DW_AT_body_begin:
4791       return "DW_AT_body_begin";
4792     case DW_AT_body_end:
4793       return "DW_AT_body_end";
4794     case DW_AT_GNU_vector:
4795       return "DW_AT_GNU_vector";
4796
4797     case DW_AT_VMS_rtnbeg_pd_address:
4798       return "DW_AT_VMS_rtnbeg_pd_address";
4799
4800     default:
4801       return "DW_AT_<unknown>";
4802     }
4803 }
4804
4805 /* Convert a DWARF value form code into its string name.  */
4806
4807 static const char *
4808 dwarf_form_name (unsigned int form)
4809 {
4810   switch (form)
4811     {
4812     case DW_FORM_addr:
4813       return "DW_FORM_addr";
4814     case DW_FORM_block2:
4815       return "DW_FORM_block2";
4816     case DW_FORM_block4:
4817       return "DW_FORM_block4";
4818     case DW_FORM_data2:
4819       return "DW_FORM_data2";
4820     case DW_FORM_data4:
4821       return "DW_FORM_data4";
4822     case DW_FORM_data8:
4823       return "DW_FORM_data8";
4824     case DW_FORM_string:
4825       return "DW_FORM_string";
4826     case DW_FORM_block:
4827       return "DW_FORM_block";
4828     case DW_FORM_block1:
4829       return "DW_FORM_block1";
4830     case DW_FORM_data1:
4831       return "DW_FORM_data1";
4832     case DW_FORM_flag:
4833       return "DW_FORM_flag";
4834     case DW_FORM_sdata:
4835       return "DW_FORM_sdata";
4836     case DW_FORM_strp:
4837       return "DW_FORM_strp";
4838     case DW_FORM_udata:
4839       return "DW_FORM_udata";
4840     case DW_FORM_ref_addr:
4841       return "DW_FORM_ref_addr";
4842     case DW_FORM_ref1:
4843       return "DW_FORM_ref1";
4844     case DW_FORM_ref2:
4845       return "DW_FORM_ref2";
4846     case DW_FORM_ref4:
4847       return "DW_FORM_ref4";
4848     case DW_FORM_ref8:
4849       return "DW_FORM_ref8";
4850     case DW_FORM_ref_udata:
4851       return "DW_FORM_ref_udata";
4852     case DW_FORM_indirect:
4853       return "DW_FORM_indirect";
4854     default:
4855       return "DW_FORM_<unknown>";
4856     }
4857 }
4858 \f
4859 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4860    instance of an inlined instance of a decl which is local to an inline
4861    function, so we have to trace all of the way back through the origin chain
4862    to find out what sort of node actually served as the original seed for the
4863    given block.  */
4864
4865 static tree
4866 decl_ultimate_origin (const_tree decl)
4867 {
4868   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4869     return NULL_TREE;
4870
4871   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4872      nodes in the function to point to themselves; ignore that if
4873      we're trying to output the abstract instance of this function.  */
4874   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4875     return NULL_TREE;
4876
4877   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4878      most distant ancestor, this should never happen.  */
4879   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4880
4881   return DECL_ABSTRACT_ORIGIN (decl);
4882 }
4883
4884 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4885    instance of an inlined instance of a block which is local to an inline
4886    function, so we have to trace all of the way back through the origin chain
4887    to find out what sort of node actually served as the original seed for the
4888    given block.  */
4889
4890 static tree
4891 block_ultimate_origin (const_tree block)
4892 {
4893   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4894
4895   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4896      nodes in the function to point to themselves; ignore that if
4897      we're trying to output the abstract instance of this function.  */
4898   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4899     return NULL_TREE;
4900
4901   if (immediate_origin == NULL_TREE)
4902     return NULL_TREE;
4903   else
4904     {
4905       tree ret_val;
4906       tree lookahead = immediate_origin;
4907
4908       do
4909         {
4910           ret_val = lookahead;
4911           lookahead = (TREE_CODE (ret_val) == BLOCK
4912                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4913         }
4914       while (lookahead != NULL && lookahead != ret_val);
4915
4916       /* The block's abstract origin chain may not be the *ultimate* origin of
4917          the block. It could lead to a DECL that has an abstract origin set.
4918          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4919          will give us if it has one).  Note that DECL's abstract origins are
4920          supposed to be the most distant ancestor (or so decl_ultimate_origin
4921          claims), so we don't need to loop following the DECL origins.  */
4922       if (DECL_P (ret_val))
4923         return DECL_ORIGIN (ret_val);
4924
4925       return ret_val;
4926     }
4927 }
4928
4929 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4930    of a virtual function may refer to a base class, so we check the 'this'
4931    parameter.  */
4932
4933 static tree
4934 decl_class_context (tree decl)
4935 {
4936   tree context = NULL_TREE;
4937
4938   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4939     context = DECL_CONTEXT (decl);
4940   else
4941     context = TYPE_MAIN_VARIANT
4942       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4943
4944   if (context && !TYPE_P (context))
4945     context = NULL_TREE;
4946
4947   return context;
4948 }
4949 \f
4950 /* Add an attribute/value pair to a DIE.  */
4951
4952 static inline void
4953 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4954 {
4955   /* Maybe this should be an assert?  */
4956   if (die == NULL)
4957     return;
4958
4959   if (die->die_attr == NULL)
4960     die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4961   VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4962 }
4963
4964 static inline enum dw_val_class
4965 AT_class (dw_attr_ref a)
4966 {
4967   return a->dw_attr_val.val_class;
4968 }
4969
4970 /* Add a flag value attribute to a DIE.  */
4971
4972 static inline void
4973 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4974 {
4975   dw_attr_node attr;
4976
4977   attr.dw_attr = attr_kind;
4978   attr.dw_attr_val.val_class = dw_val_class_flag;
4979   attr.dw_attr_val.v.val_flag = flag;
4980   add_dwarf_attr (die, &attr);
4981 }
4982
4983 static inline unsigned
4984 AT_flag (dw_attr_ref a)
4985 {
4986   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4987   return a->dw_attr_val.v.val_flag;
4988 }
4989
4990 /* Add a signed integer attribute value to a DIE.  */
4991
4992 static inline void
4993 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4994 {
4995   dw_attr_node attr;
4996
4997   attr.dw_attr = attr_kind;
4998   attr.dw_attr_val.val_class = dw_val_class_const;
4999   attr.dw_attr_val.v.val_int = int_val;
5000   add_dwarf_attr (die, &attr);
5001 }
5002
5003 static inline HOST_WIDE_INT
5004 AT_int (dw_attr_ref a)
5005 {
5006   gcc_assert (a && AT_class (a) == dw_val_class_const);
5007   return a->dw_attr_val.v.val_int;
5008 }
5009
5010 /* Add an unsigned integer attribute value to a DIE.  */
5011
5012 static inline void
5013 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
5014                  unsigned HOST_WIDE_INT unsigned_val)
5015 {
5016   dw_attr_node attr;
5017
5018   attr.dw_attr = attr_kind;
5019   attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
5020   attr.dw_attr_val.v.val_unsigned = unsigned_val;
5021   add_dwarf_attr (die, &attr);
5022 }
5023
5024 static inline unsigned HOST_WIDE_INT
5025 AT_unsigned (dw_attr_ref a)
5026 {
5027   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
5028   return a->dw_attr_val.v.val_unsigned;
5029 }
5030
5031 /* Add an unsigned double integer attribute value to a DIE.  */
5032
5033 static inline void
5034 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
5035                   long unsigned int val_hi, long unsigned int val_low)
5036 {
5037   dw_attr_node attr;
5038
5039   attr.dw_attr = attr_kind;
5040   attr.dw_attr_val.val_class = dw_val_class_long_long;
5041   attr.dw_attr_val.v.val_long_long.hi = val_hi;
5042   attr.dw_attr_val.v.val_long_long.low = val_low;
5043   add_dwarf_attr (die, &attr);
5044 }
5045
5046 /* Add a floating point attribute value to a DIE and return it.  */
5047
5048 static inline void
5049 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5050             unsigned int length, unsigned int elt_size, unsigned char *array)
5051 {
5052   dw_attr_node attr;
5053
5054   attr.dw_attr = attr_kind;
5055   attr.dw_attr_val.val_class = dw_val_class_vec;
5056   attr.dw_attr_val.v.val_vec.length = length;
5057   attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5058   attr.dw_attr_val.v.val_vec.array = array;
5059   add_dwarf_attr (die, &attr);
5060 }
5061
5062 /* Hash and equality functions for debug_str_hash.  */
5063
5064 static hashval_t
5065 debug_str_do_hash (const void *x)
5066 {
5067   return htab_hash_string (((const struct indirect_string_node *)x)->str);
5068 }
5069
5070 static int
5071 debug_str_eq (const void *x1, const void *x2)
5072 {
5073   return strcmp ((((const struct indirect_string_node *)x1)->str),
5074                  (const char *)x2) == 0;
5075 }
5076
5077 /* Add a string attribute value to a DIE.  */
5078
5079 static inline void
5080 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5081 {
5082   dw_attr_node attr;
5083   struct indirect_string_node *node;
5084   void **slot;
5085
5086   if (! debug_str_hash)
5087     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5088                                       debug_str_eq, NULL);
5089
5090   slot = htab_find_slot_with_hash (debug_str_hash, str,
5091                                    htab_hash_string (str), INSERT);
5092   if (*slot == NULL)
5093     {
5094       node = (struct indirect_string_node *)
5095                ggc_alloc_cleared (sizeof (struct indirect_string_node));
5096       node->str = ggc_strdup (str);
5097       *slot = node;
5098     }
5099   else
5100     node = (struct indirect_string_node *) *slot;
5101
5102   node->refcount++;
5103
5104   attr.dw_attr = attr_kind;
5105   attr.dw_attr_val.val_class = dw_val_class_str;
5106   attr.dw_attr_val.v.val_str = node;
5107   add_dwarf_attr (die, &attr);
5108 }
5109
5110 static inline const char *
5111 AT_string (dw_attr_ref a)
5112 {
5113   gcc_assert (a && AT_class (a) == dw_val_class_str);
5114   return a->dw_attr_val.v.val_str->str;
5115 }
5116
5117 /* Find out whether a string should be output inline in DIE
5118    or out-of-line in .debug_str section.  */
5119
5120 static int
5121 AT_string_form (dw_attr_ref a)
5122 {
5123   struct indirect_string_node *node;
5124   unsigned int len;
5125   char label[32];
5126
5127   gcc_assert (a && AT_class (a) == dw_val_class_str);
5128
5129   node = a->dw_attr_val.v.val_str;
5130   if (node->form)
5131     return node->form;
5132
5133   len = strlen (node->str) + 1;
5134
5135   /* If the string is shorter or equal to the size of the reference, it is
5136      always better to put it inline.  */
5137   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5138     return node->form = DW_FORM_string;
5139
5140   /* If we cannot expect the linker to merge strings in .debug_str
5141      section, only put it into .debug_str if it is worth even in this
5142      single module.  */
5143   if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5144       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5145     return node->form = DW_FORM_string;
5146
5147   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5148   ++dw2_string_counter;
5149   node->label = xstrdup (label);
5150
5151   return node->form = DW_FORM_strp;
5152 }
5153
5154 /* Add a DIE reference attribute value to a DIE.  */
5155
5156 static inline void
5157 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5158 {
5159   dw_attr_node attr;
5160
5161   attr.dw_attr = attr_kind;
5162   attr.dw_attr_val.val_class = dw_val_class_die_ref;
5163   attr.dw_attr_val.v.val_die_ref.die = targ_die;
5164   attr.dw_attr_val.v.val_die_ref.external = 0;
5165   add_dwarf_attr (die, &attr);
5166 }
5167
5168 /* Add an AT_specification attribute to a DIE, and also make the back
5169    pointer from the specification to the definition.  */
5170
5171 static inline void
5172 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5173 {
5174   add_AT_die_ref (die, DW_AT_specification, targ_die);
5175   gcc_assert (!targ_die->die_definition);
5176   targ_die->die_definition = die;
5177 }
5178
5179 static inline dw_die_ref
5180 AT_ref (dw_attr_ref a)
5181 {
5182   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5183   return a->dw_attr_val.v.val_die_ref.die;
5184 }
5185
5186 static inline int
5187 AT_ref_external (dw_attr_ref a)
5188 {
5189   if (a && AT_class (a) == dw_val_class_die_ref)
5190     return a->dw_attr_val.v.val_die_ref.external;
5191
5192   return 0;
5193 }
5194
5195 static inline void
5196 set_AT_ref_external (dw_attr_ref a, int i)
5197 {
5198   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5199   a->dw_attr_val.v.val_die_ref.external = i;
5200 }
5201
5202 /* Add an FDE reference attribute value to a DIE.  */
5203
5204 static inline void
5205 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5206 {
5207   dw_attr_node attr;
5208
5209   attr.dw_attr = attr_kind;
5210   attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5211   attr.dw_attr_val.v.val_fde_index = targ_fde;
5212   add_dwarf_attr (die, &attr);
5213 }
5214
5215 /* Add a location description attribute value to a DIE.  */
5216
5217 static inline void
5218 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5219 {
5220   dw_attr_node attr;
5221
5222   attr.dw_attr = attr_kind;
5223   attr.dw_attr_val.val_class = dw_val_class_loc;
5224   attr.dw_attr_val.v.val_loc = loc;
5225   add_dwarf_attr (die, &attr);
5226 }
5227
5228 static inline dw_loc_descr_ref
5229 AT_loc (dw_attr_ref a)
5230 {
5231   gcc_assert (a && AT_class (a) == dw_val_class_loc);
5232   return a->dw_attr_val.v.val_loc;
5233 }
5234
5235 static inline void
5236 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5237 {
5238   dw_attr_node attr;
5239
5240   attr.dw_attr = attr_kind;
5241   attr.dw_attr_val.val_class = dw_val_class_loc_list;
5242   attr.dw_attr_val.v.val_loc_list = loc_list;
5243   add_dwarf_attr (die, &attr);
5244   have_location_lists = true;
5245 }
5246
5247 static inline dw_loc_list_ref
5248 AT_loc_list (dw_attr_ref a)
5249 {
5250   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5251   return a->dw_attr_val.v.val_loc_list;
5252 }
5253
5254 /* Add an address constant attribute value to a DIE.  */
5255
5256 static inline void
5257 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5258 {
5259   dw_attr_node attr;
5260
5261   attr.dw_attr = attr_kind;
5262   attr.dw_attr_val.val_class = dw_val_class_addr;
5263   attr.dw_attr_val.v.val_addr = addr;
5264   add_dwarf_attr (die, &attr);
5265 }
5266
5267 /* Get the RTX from to an address DIE attribute.  */
5268
5269 static inline rtx
5270 AT_addr (dw_attr_ref a)
5271 {
5272   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5273   return a->dw_attr_val.v.val_addr;
5274 }
5275
5276 /* Add a file attribute value to a DIE.  */
5277
5278 static inline void
5279 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5280              struct dwarf_file_data *fd)
5281 {
5282   dw_attr_node attr;
5283
5284   attr.dw_attr = attr_kind;
5285   attr.dw_attr_val.val_class = dw_val_class_file;
5286   attr.dw_attr_val.v.val_file = fd;
5287   add_dwarf_attr (die, &attr);
5288 }
5289
5290 /* Get the dwarf_file_data from a file DIE attribute.  */
5291
5292 static inline struct dwarf_file_data *
5293 AT_file (dw_attr_ref a)
5294 {
5295   gcc_assert (a && AT_class (a) == dw_val_class_file);
5296   return a->dw_attr_val.v.val_file;
5297 }
5298
5299 /* Add a label identifier attribute value to a DIE.  */
5300
5301 static inline void
5302 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5303 {
5304   dw_attr_node attr;
5305
5306   attr.dw_attr = attr_kind;
5307   attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5308   attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5309   add_dwarf_attr (die, &attr);
5310 }
5311
5312 /* Add a section offset attribute value to a DIE, an offset into the
5313    debug_line section.  */
5314
5315 static inline void
5316 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5317                 const char *label)
5318 {
5319   dw_attr_node attr;
5320
5321   attr.dw_attr = attr_kind;
5322   attr.dw_attr_val.val_class = dw_val_class_lineptr;
5323   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5324   add_dwarf_attr (die, &attr);
5325 }
5326
5327 /* Add a section offset attribute value to a DIE, an offset into the
5328    debug_macinfo section.  */
5329
5330 static inline void
5331 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5332                const char *label)
5333 {
5334   dw_attr_node attr;
5335
5336   attr.dw_attr = attr_kind;
5337   attr.dw_attr_val.val_class = dw_val_class_macptr;
5338   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5339   add_dwarf_attr (die, &attr);
5340 }
5341
5342 /* Add an offset attribute value to a DIE.  */
5343
5344 static inline void
5345 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5346                unsigned HOST_WIDE_INT offset)
5347 {
5348   dw_attr_node attr;
5349
5350   attr.dw_attr = attr_kind;
5351   attr.dw_attr_val.val_class = dw_val_class_offset;
5352   attr.dw_attr_val.v.val_offset = offset;
5353   add_dwarf_attr (die, &attr);
5354 }
5355
5356 /* Add an range_list attribute value to a DIE.  */
5357
5358 static void
5359 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5360                    long unsigned int offset)
5361 {
5362   dw_attr_node attr;
5363
5364   attr.dw_attr = attr_kind;
5365   attr.dw_attr_val.val_class = dw_val_class_range_list;
5366   attr.dw_attr_val.v.val_offset = offset;
5367   add_dwarf_attr (die, &attr);
5368 }
5369
5370 static inline const char *
5371 AT_lbl (dw_attr_ref a)
5372 {
5373   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5374                     || AT_class (a) == dw_val_class_lineptr
5375                     || AT_class (a) == dw_val_class_macptr));
5376   return a->dw_attr_val.v.val_lbl_id;
5377 }
5378
5379 /* Get the attribute of type attr_kind.  */
5380
5381 static dw_attr_ref
5382 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5383 {
5384   dw_attr_ref a;
5385   unsigned ix;
5386   dw_die_ref spec = NULL;
5387
5388   if (! die)
5389     return NULL;
5390
5391   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5392     if (a->dw_attr == attr_kind)
5393       return a;
5394     else if (a->dw_attr == DW_AT_specification
5395              || a->dw_attr == DW_AT_abstract_origin)
5396       spec = AT_ref (a);
5397
5398   if (spec)
5399     return get_AT (spec, attr_kind);
5400
5401   return NULL;
5402 }
5403
5404 /* Return the "low pc" attribute value, typically associated with a subprogram
5405    DIE.  Return null if the "low pc" attribute is either not present, or if it
5406    cannot be represented as an assembler label identifier.  */
5407
5408 static inline const char *
5409 get_AT_low_pc (dw_die_ref die)
5410 {
5411   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5412
5413   return a ? AT_lbl (a) : NULL;
5414 }
5415
5416 /* Return the "high pc" attribute value, typically associated with a subprogram
5417    DIE.  Return null if the "high pc" attribute is either not present, or if it
5418    cannot be represented as an assembler label identifier.  */
5419
5420 static inline const char *
5421 get_AT_hi_pc (dw_die_ref die)
5422 {
5423   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5424
5425   return a ? AT_lbl (a) : NULL;
5426 }
5427
5428 /* Return the value of the string attribute designated by ATTR_KIND, or
5429    NULL if it is not present.  */
5430
5431 static inline const char *
5432 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5433 {
5434   dw_attr_ref a = get_AT (die, attr_kind);
5435
5436   return a ? AT_string (a) : NULL;
5437 }
5438
5439 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5440    if it is not present.  */
5441
5442 static inline int
5443 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5444 {
5445   dw_attr_ref a = get_AT (die, attr_kind);
5446
5447   return a ? AT_flag (a) : 0;
5448 }
5449
5450 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5451    if it is not present.  */
5452
5453 static inline unsigned
5454 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5455 {
5456   dw_attr_ref a = get_AT (die, attr_kind);
5457
5458   return a ? AT_unsigned (a) : 0;
5459 }
5460
5461 static inline dw_die_ref
5462 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5463 {
5464   dw_attr_ref a = get_AT (die, attr_kind);
5465
5466   return a ? AT_ref (a) : NULL;
5467 }
5468
5469 static inline struct dwarf_file_data *
5470 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5471 {
5472   dw_attr_ref a = get_AT (die, attr_kind);
5473
5474   return a ? AT_file (a) : NULL;
5475 }
5476
5477 /* Return TRUE if the language is C or C++.  */
5478
5479 static inline bool
5480 is_c_family (void)
5481 {
5482   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5483
5484   return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5485           || lang == DW_LANG_C99
5486           || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5487 }
5488
5489 /* Return TRUE if the language is C++.  */
5490
5491 static inline bool
5492 is_cxx (void)
5493 {
5494   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5495
5496   return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5497 }
5498
5499 /* Return TRUE if the language is Fortran.  */
5500
5501 static inline bool
5502 is_fortran (void)
5503 {
5504   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5505
5506   return (lang == DW_LANG_Fortran77
5507           || lang == DW_LANG_Fortran90
5508           || lang == DW_LANG_Fortran95);
5509 }
5510
5511 /* Return TRUE if the language is Java.  */
5512
5513 static inline bool
5514 is_java (void)
5515 {
5516   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5517
5518   return lang == DW_LANG_Java;
5519 }
5520
5521 /* Return TRUE if the language is Ada.  */
5522
5523 static inline bool
5524 is_ada (void)
5525 {
5526   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5527
5528   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5529 }
5530
5531 /* Remove the specified attribute if present.  */
5532
5533 static void
5534 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5535 {
5536   dw_attr_ref a;
5537   unsigned ix;
5538
5539   if (! die)
5540     return;
5541
5542   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5543     if (a->dw_attr == attr_kind)
5544       {
5545         if (AT_class (a) == dw_val_class_str)
5546           if (a->dw_attr_val.v.val_str->refcount)
5547             a->dw_attr_val.v.val_str->refcount--;
5548
5549         /* VEC_ordered_remove should help reduce the number of abbrevs
5550            that are needed.  */
5551         VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5552         return;
5553       }
5554 }
5555
5556 /* Remove CHILD from its parent.  PREV must have the property that
5557    PREV->DIE_SIB == CHILD.  Does not alter CHILD.  */
5558
5559 static void
5560 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5561 {
5562   gcc_assert (child->die_parent == prev->die_parent);
5563   gcc_assert (prev->die_sib == child);
5564   if (prev == child)
5565     {
5566       gcc_assert (child->die_parent->die_child == child);
5567       prev = NULL;
5568     }
5569   else
5570     prev->die_sib = child->die_sib;
5571   if (child->die_parent->die_child == child)
5572     child->die_parent->die_child = prev;
5573 }
5574
5575 /* Remove child DIE whose die_tag is TAG.  Do nothing if no child
5576    matches TAG.  */
5577
5578 static void
5579 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5580 {
5581   dw_die_ref c;
5582
5583   c = die->die_child;
5584   if (c) do {
5585     dw_die_ref prev = c;
5586     c = c->die_sib;
5587     while (c->die_tag == tag)
5588       {
5589         remove_child_with_prev (c, prev);
5590         /* Might have removed every child.  */
5591         if (c == c->die_sib)
5592           return;
5593         c = c->die_sib;
5594       }
5595   } while (c != die->die_child);
5596 }
5597
5598 /* Add a CHILD_DIE as the last child of DIE.  */
5599
5600 static void
5601 add_child_die (dw_die_ref die, dw_die_ref child_die)
5602 {
5603   /* FIXME this should probably be an assert.  */
5604   if (! die || ! child_die)
5605     return;
5606   gcc_assert (die != child_die);
5607
5608   child_die->die_parent = die;
5609   if (die->die_child)
5610     {
5611       child_die->die_sib = die->die_child->die_sib;
5612       die->die_child->die_sib = child_die;
5613     }
5614   else
5615     child_die->die_sib = child_die;
5616   die->die_child = child_die;
5617 }
5618
5619 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5620    is the specification, to the end of PARENT's list of children.
5621    This is done by removing and re-adding it.  */
5622
5623 static void
5624 splice_child_die (dw_die_ref parent, dw_die_ref child)
5625 {
5626   dw_die_ref p;
5627
5628   /* We want the declaration DIE from inside the class, not the
5629      specification DIE at toplevel.  */
5630   if (child->die_parent != parent)
5631     {
5632       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5633
5634       if (tmp)
5635         child = tmp;
5636     }
5637
5638   gcc_assert (child->die_parent == parent
5639               || (child->die_parent
5640                   == get_AT_ref (parent, DW_AT_specification)));
5641
5642   for (p = child->die_parent->die_child; ; p = p->die_sib)
5643     if (p->die_sib == child)
5644       {
5645         remove_child_with_prev (child, p);
5646         break;
5647       }
5648
5649   add_child_die (parent, child);
5650 }
5651
5652 /* Return a pointer to a newly created DIE node.  */
5653
5654 static inline dw_die_ref
5655 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5656 {
5657   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5658
5659   die->die_tag = tag_value;
5660
5661   if (parent_die != NULL)
5662     add_child_die (parent_die, die);
5663   else
5664     {
5665       limbo_die_node *limbo_node;
5666
5667       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5668       limbo_node->die = die;
5669       limbo_node->created_for = t;
5670       limbo_node->next = limbo_die_list;
5671       limbo_die_list = limbo_node;
5672     }
5673
5674   return die;
5675 }
5676
5677 /* Return the DIE associated with the given type specifier.  */
5678
5679 static inline dw_die_ref
5680 lookup_type_die (tree type)
5681 {
5682   return TYPE_SYMTAB_DIE (type);
5683 }
5684
5685 /* Equate a DIE to a given type specifier.  */
5686
5687 static inline void
5688 equate_type_number_to_die (tree type, dw_die_ref type_die)
5689 {
5690   TYPE_SYMTAB_DIE (type) = type_die;
5691 }
5692
5693 /* Returns a hash value for X (which really is a die_struct).  */
5694
5695 static hashval_t
5696 decl_die_table_hash (const void *x)
5697 {
5698   return (hashval_t) ((const_dw_die_ref) x)->decl_id;
5699 }
5700
5701 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5702
5703 static int
5704 decl_die_table_eq (const void *x, const void *y)
5705 {
5706   return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
5707 }
5708
5709 /* Return the DIE associated with a given declaration.  */
5710
5711 static inline dw_die_ref
5712 lookup_decl_die (tree decl)
5713 {
5714   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5715 }
5716
5717 /* Returns a hash value for X (which really is a var_loc_list).  */
5718
5719 static hashval_t
5720 decl_loc_table_hash (const void *x)
5721 {
5722   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5723 }
5724
5725 /* Return nonzero if decl_id of var_loc_list X is the same as
5726    UID of decl *Y.  */
5727
5728 static int
5729 decl_loc_table_eq (const void *x, const void *y)
5730 {
5731   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
5732 }
5733
5734 /* Return the var_loc list associated with a given declaration.  */
5735
5736 static inline var_loc_list *
5737 lookup_decl_loc (const_tree decl)
5738 {
5739   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5740 }
5741
5742 /* Equate a DIE to a particular declaration.  */
5743
5744 static void
5745 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5746 {
5747   unsigned int decl_id = DECL_UID (decl);
5748   void **slot;
5749
5750   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5751   *slot = decl_die;
5752   decl_die->decl_id = decl_id;
5753 }
5754
5755 /* Add a variable location node to the linked list for DECL.  */
5756
5757 static void
5758 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5759 {
5760   unsigned int decl_id = DECL_UID (decl);
5761   var_loc_list *temp;
5762   void **slot;
5763
5764   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5765   if (*slot == NULL)
5766     {
5767       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5768       temp->decl_id = decl_id;
5769       *slot = temp;
5770     }
5771   else
5772     temp = *slot;
5773
5774   if (temp->last)
5775     {
5776       /* If the current location is the same as the end of the list,
5777          and either both or neither of the locations is uninitialized,
5778          we have nothing to do.  */
5779       if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5780                          NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5781           || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
5782                != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
5783               && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
5784                    == VAR_INIT_STATUS_UNINITIALIZED)
5785                   || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
5786                       == VAR_INIT_STATUS_UNINITIALIZED))))
5787         {
5788           /* Add LOC to the end of list and update LAST.  */
5789           temp->last->next = loc;
5790           temp->last = loc;
5791         }
5792     }
5793   /* Do not add empty location to the beginning of the list.  */
5794   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5795     {
5796       temp->first = loc;
5797       temp->last = loc;
5798     }
5799 }
5800 \f
5801 /* Keep track of the number of spaces used to indent the
5802    output of the debugging routines that print the structure of
5803    the DIE internal representation.  */
5804 static int print_indent;
5805
5806 /* Indent the line the number of spaces given by print_indent.  */
5807
5808 static inline void
5809 print_spaces (FILE *outfile)
5810 {
5811   fprintf (outfile, "%*s", print_indent, "");
5812 }
5813
5814 /* Print the information associated with a given DIE, and its children.
5815    This routine is a debugging aid only.  */
5816
5817 static void
5818 print_die (dw_die_ref die, FILE *outfile)
5819 {
5820   dw_attr_ref a;
5821   dw_die_ref c;
5822   unsigned ix;
5823
5824   print_spaces (outfile);
5825   fprintf (outfile, "DIE %4ld: %s\n",
5826            die->die_offset, dwarf_tag_name (die->die_tag));
5827   print_spaces (outfile);
5828   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5829   fprintf (outfile, " offset: %ld\n", die->die_offset);
5830
5831   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5832     {
5833       print_spaces (outfile);
5834       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5835
5836       switch (AT_class (a))
5837         {
5838         case dw_val_class_addr:
5839           fprintf (outfile, "address");
5840           break;
5841         case dw_val_class_offset:
5842           fprintf (outfile, "offset");
5843           break;
5844         case dw_val_class_loc:
5845           fprintf (outfile, "location descriptor");
5846           break;
5847         case dw_val_class_loc_list:
5848           fprintf (outfile, "location list -> label:%s",
5849                    AT_loc_list (a)->ll_symbol);
5850           break;
5851         case dw_val_class_range_list:
5852           fprintf (outfile, "range list");
5853           break;
5854         case dw_val_class_const:
5855           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5856           break;
5857         case dw_val_class_unsigned_const:
5858           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5859           break;
5860         case dw_val_class_long_long:
5861           fprintf (outfile, "constant (%lu,%lu)",
5862                    a->dw_attr_val.v.val_long_long.hi,
5863                    a->dw_attr_val.v.val_long_long.low);
5864           break;
5865         case dw_val_class_vec:
5866           fprintf (outfile, "floating-point or vector constant");
5867           break;
5868         case dw_val_class_flag:
5869           fprintf (outfile, "%u", AT_flag (a));
5870           break;
5871         case dw_val_class_die_ref:
5872           if (AT_ref (a) != NULL)
5873             {
5874               if (AT_ref (a)->die_symbol)
5875                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5876               else
5877                 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
5878             }
5879           else
5880             fprintf (outfile, "die -> <null>");
5881           break;
5882         case dw_val_class_lbl_id:
5883         case dw_val_class_lineptr:
5884         case dw_val_class_macptr:
5885           fprintf (outfile, "label: %s", AT_lbl (a));
5886           break;
5887         case dw_val_class_str:
5888           if (AT_string (a) != NULL)
5889             fprintf (outfile, "\"%s\"", AT_string (a));
5890           else
5891             fprintf (outfile, "<null>");
5892           break;
5893         case dw_val_class_file:
5894           fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5895                    AT_file (a)->emitted_number);
5896           break;
5897         default:
5898           break;
5899         }
5900
5901       fprintf (outfile, "\n");
5902     }
5903
5904   if (die->die_child != NULL)
5905     {
5906       print_indent += 4;
5907       FOR_EACH_CHILD (die, c, print_die (c, outfile));
5908       print_indent -= 4;
5909     }
5910   if (print_indent == 0)
5911     fprintf (outfile, "\n");
5912 }
5913
5914 /* Print the contents of the source code line number correspondence table.
5915    This routine is a debugging aid only.  */
5916
5917 static void
5918 print_dwarf_line_table (FILE *outfile)
5919 {
5920   unsigned i;
5921   dw_line_info_ref line_info;
5922
5923   fprintf (outfile, "\n\nDWARF source line information\n");
5924   for (i = 1; i < line_info_table_in_use; i++)
5925     {
5926       line_info = &line_info_table[i];
5927       fprintf (outfile, "%5d: %4ld %6ld\n", i,
5928                line_info->dw_file_num,
5929                line_info->dw_line_num);
5930     }
5931
5932   fprintf (outfile, "\n\n");
5933 }
5934
5935 /* Print the information collected for a given DIE.  */
5936
5937 void
5938 debug_dwarf_die (dw_die_ref die)
5939 {
5940   print_die (die, stderr);
5941 }
5942
5943 /* Print all DWARF information collected for the compilation unit.
5944    This routine is a debugging aid only.  */
5945
5946 void
5947 debug_dwarf (void)
5948 {
5949   print_indent = 0;
5950   print_die (comp_unit_die, stderr);
5951   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5952     print_dwarf_line_table (stderr);
5953 }
5954 \f
5955 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5956    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5957    DIE that marks the start of the DIEs for this include file.  */
5958
5959 static dw_die_ref
5960 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5961 {
5962   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5963   dw_die_ref new_unit = gen_compile_unit_die (filename);
5964
5965   new_unit->die_sib = old_unit;
5966   return new_unit;
5967 }
5968
5969 /* Close an include-file CU and reopen the enclosing one.  */
5970
5971 static dw_die_ref
5972 pop_compile_unit (dw_die_ref old_unit)
5973 {
5974   dw_die_ref new_unit = old_unit->die_sib;
5975
5976   old_unit->die_sib = NULL;
5977   return new_unit;
5978 }
5979
5980 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5981 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5982
5983 /* Calculate the checksum of a location expression.  */
5984
5985 static inline void
5986 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5987 {
5988   CHECKSUM (loc->dw_loc_opc);
5989   CHECKSUM (loc->dw_loc_oprnd1);
5990   CHECKSUM (loc->dw_loc_oprnd2);
5991 }
5992
5993 /* Calculate the checksum of an attribute.  */
5994
5995 static void
5996 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5997 {
5998   dw_loc_descr_ref loc;
5999   rtx r;
6000
6001   CHECKSUM (at->dw_attr);
6002
6003   /* We don't care that this was compiled with a different compiler
6004      snapshot; if the output is the same, that's what matters.  */
6005   if (at->dw_attr == DW_AT_producer)
6006     return;
6007
6008   switch (AT_class (at))
6009     {
6010     case dw_val_class_const:
6011       CHECKSUM (at->dw_attr_val.v.val_int);
6012       break;
6013     case dw_val_class_unsigned_const:
6014       CHECKSUM (at->dw_attr_val.v.val_unsigned);
6015       break;
6016     case dw_val_class_long_long:
6017       CHECKSUM (at->dw_attr_val.v.val_long_long);
6018       break;
6019     case dw_val_class_vec:
6020       CHECKSUM (at->dw_attr_val.v.val_vec);
6021       break;
6022     case dw_val_class_flag:
6023       CHECKSUM (at->dw_attr_val.v.val_flag);
6024       break;
6025     case dw_val_class_str:
6026       CHECKSUM_STRING (AT_string (at));
6027       break;
6028
6029     case dw_val_class_addr:
6030       r = AT_addr (at);
6031       gcc_assert (GET_CODE (r) == SYMBOL_REF);
6032       CHECKSUM_STRING (XSTR (r, 0));
6033       break;
6034
6035     case dw_val_class_offset:
6036       CHECKSUM (at->dw_attr_val.v.val_offset);
6037       break;
6038
6039     case dw_val_class_loc:
6040       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6041         loc_checksum (loc, ctx);
6042       break;
6043
6044     case dw_val_class_die_ref:
6045       die_checksum (AT_ref (at), ctx, mark);
6046       break;
6047
6048     case dw_val_class_fde_ref:
6049     case dw_val_class_lbl_id:
6050     case dw_val_class_lineptr:
6051     case dw_val_class_macptr:
6052       break;
6053
6054     case dw_val_class_file:
6055       CHECKSUM_STRING (AT_file (at)->filename);
6056       break;
6057
6058     default:
6059       break;
6060     }
6061 }
6062
6063 /* Calculate the checksum of a DIE.  */
6064
6065 static void
6066 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6067 {
6068   dw_die_ref c;
6069   dw_attr_ref a;
6070   unsigned ix;
6071
6072   /* To avoid infinite recursion.  */
6073   if (die->die_mark)
6074     {
6075       CHECKSUM (die->die_mark);
6076       return;
6077     }
6078   die->die_mark = ++(*mark);
6079
6080   CHECKSUM (die->die_tag);
6081
6082   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6083     attr_checksum (a, ctx, mark);
6084
6085   FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6086 }
6087
6088 #undef CHECKSUM
6089 #undef CHECKSUM_STRING
6090
6091 /* Do the location expressions look same?  */
6092 static inline int
6093 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6094 {
6095   return loc1->dw_loc_opc == loc2->dw_loc_opc
6096          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6097          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6098 }
6099
6100 /* Do the values look the same?  */
6101 static int
6102 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6103 {
6104   dw_loc_descr_ref loc1, loc2;
6105   rtx r1, r2;
6106
6107   if (v1->val_class != v2->val_class)
6108     return 0;
6109
6110   switch (v1->val_class)
6111     {
6112     case dw_val_class_const:
6113       return v1->v.val_int == v2->v.val_int;
6114     case dw_val_class_unsigned_const:
6115       return v1->v.val_unsigned == v2->v.val_unsigned;
6116     case dw_val_class_long_long:
6117       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6118              && v1->v.val_long_long.low == v2->v.val_long_long.low;
6119     case dw_val_class_vec:
6120       if (v1->v.val_vec.length != v2->v.val_vec.length
6121           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6122         return 0;
6123       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6124                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
6125         return 0;
6126       return 1;
6127     case dw_val_class_flag:
6128       return v1->v.val_flag == v2->v.val_flag;
6129     case dw_val_class_str:
6130       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6131
6132     case dw_val_class_addr:
6133       r1 = v1->v.val_addr;
6134       r2 = v2->v.val_addr;
6135       if (GET_CODE (r1) != GET_CODE (r2))
6136         return 0;
6137       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6138       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6139
6140     case dw_val_class_offset:
6141       return v1->v.val_offset == v2->v.val_offset;
6142
6143     case dw_val_class_loc:
6144       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6145            loc1 && loc2;
6146            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6147         if (!same_loc_p (loc1, loc2, mark))
6148           return 0;
6149       return !loc1 && !loc2;
6150
6151     case dw_val_class_die_ref:
6152       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6153
6154     case dw_val_class_fde_ref:
6155     case dw_val_class_lbl_id:
6156     case dw_val_class_lineptr:
6157     case dw_val_class_macptr:
6158       return 1;
6159
6160     case dw_val_class_file:
6161       return v1->v.val_file == v2->v.val_file;
6162
6163     default:
6164       return 1;
6165     }
6166 }
6167
6168 /* Do the attributes look the same?  */
6169
6170 static int
6171 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6172 {
6173   if (at1->dw_attr != at2->dw_attr)
6174     return 0;
6175
6176   /* We don't care that this was compiled with a different compiler
6177      snapshot; if the output is the same, that's what matters. */
6178   if (at1->dw_attr == DW_AT_producer)
6179     return 1;
6180
6181   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6182 }
6183
6184 /* Do the dies look the same?  */
6185
6186 static int
6187 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6188 {
6189   dw_die_ref c1, c2;
6190   dw_attr_ref a1;
6191   unsigned ix;
6192
6193   /* To avoid infinite recursion.  */
6194   if (die1->die_mark)
6195     return die1->die_mark == die2->die_mark;
6196   die1->die_mark = die2->die_mark = ++(*mark);
6197
6198   if (die1->die_tag != die2->die_tag)
6199     return 0;
6200
6201   if (VEC_length (dw_attr_node, die1->die_attr)
6202       != VEC_length (dw_attr_node, die2->die_attr))
6203     return 0;
6204
6205   for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6206     if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6207       return 0;
6208
6209   c1 = die1->die_child;
6210   c2 = die2->die_child;
6211   if (! c1)
6212     {
6213       if (c2)
6214         return 0;
6215     }
6216   else
6217     for (;;)
6218       {
6219         if (!same_die_p (c1, c2, mark))
6220           return 0;
6221         c1 = c1->die_sib;
6222         c2 = c2->die_sib;
6223         if (c1 == die1->die_child)
6224           {
6225             if (c2 == die2->die_child)
6226               break;
6227             else
6228               return 0;
6229           }
6230     }
6231
6232   return 1;
6233 }
6234
6235 /* Do the dies look the same?  Wrapper around same_die_p.  */
6236
6237 static int
6238 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6239 {
6240   int mark = 0;
6241   int ret = same_die_p (die1, die2, &mark);
6242
6243   unmark_all_dies (die1);
6244   unmark_all_dies (die2);
6245
6246   return ret;
6247 }
6248
6249 /* The prefix to attach to symbols on DIEs in the current comdat debug
6250    info section.  */
6251 static char *comdat_symbol_id;
6252
6253 /* The index of the current symbol within the current comdat CU.  */
6254 static unsigned int comdat_symbol_number;
6255
6256 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6257    children, and set comdat_symbol_id accordingly.  */
6258
6259 static void
6260 compute_section_prefix (dw_die_ref unit_die)
6261 {
6262   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6263   const char *base = die_name ? lbasename (die_name) : "anonymous";
6264   char *name = alloca (strlen (base) + 64);
6265   char *p;
6266   int i, mark;
6267   unsigned char checksum[16];
6268   struct md5_ctx ctx;
6269
6270   /* Compute the checksum of the DIE, then append part of it as hex digits to
6271      the name filename of the unit.  */
6272
6273   md5_init_ctx (&ctx);
6274   mark = 0;
6275   die_checksum (unit_die, &ctx, &mark);
6276   unmark_all_dies (unit_die);
6277   md5_finish_ctx (&ctx, checksum);
6278
6279   sprintf (name, "%s.", base);
6280   clean_symbol_name (name);
6281
6282   p = name + strlen (name);
6283   for (i = 0; i < 4; i++)
6284     {
6285       sprintf (p, "%.2x", checksum[i]);
6286       p += 2;
6287     }
6288
6289   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6290   comdat_symbol_number = 0;
6291 }
6292
6293 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6294
6295 static int
6296 is_type_die (dw_die_ref die)
6297 {
6298   switch (die->die_tag)
6299     {
6300     case DW_TAG_array_type:
6301     case DW_TAG_class_type:
6302     case DW_TAG_enumeration_type:
6303     case DW_TAG_pointer_type:
6304     case DW_TAG_reference_type:
6305     case DW_TAG_string_type:
6306     case DW_TAG_structure_type:
6307     case DW_TAG_subroutine_type:
6308     case DW_TAG_union_type:
6309     case DW_TAG_ptr_to_member_type:
6310     case DW_TAG_set_type:
6311     case DW_TAG_subrange_type:
6312     case DW_TAG_base_type:
6313     case DW_TAG_const_type:
6314     case DW_TAG_file_type:
6315     case DW_TAG_packed_type:
6316     case DW_TAG_volatile_type:
6317     case DW_TAG_typedef:
6318       return 1;
6319     default:
6320       return 0;
6321     }
6322 }
6323
6324 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6325    Basically, we want to choose the bits that are likely to be shared between
6326    compilations (types) and leave out the bits that are specific to individual
6327    compilations (functions).  */
6328
6329 static int
6330 is_comdat_die (dw_die_ref c)
6331 {
6332   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6333      we do for stabs.  The advantage is a greater likelihood of sharing between
6334      objects that don't include headers in the same order (and therefore would
6335      put the base types in a different comdat).  jason 8/28/00 */
6336
6337   if (c->die_tag == DW_TAG_base_type)
6338     return 0;
6339
6340   if (c->die_tag == DW_TAG_pointer_type
6341       || c->die_tag == DW_TAG_reference_type
6342       || c->die_tag == DW_TAG_const_type
6343       || c->die_tag == DW_TAG_volatile_type)
6344     {
6345       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6346
6347       return t ? is_comdat_die (t) : 0;
6348     }
6349
6350   return is_type_die (c);
6351 }
6352
6353 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6354    compilation unit.  */
6355
6356 static int
6357 is_symbol_die (dw_die_ref c)
6358 {
6359   return (is_type_die (c)
6360           || (get_AT (c, DW_AT_declaration)
6361               && !get_AT (c, DW_AT_specification))
6362           || c->die_tag == DW_TAG_namespace);
6363 }
6364
6365 static char *
6366 gen_internal_sym (const char *prefix)
6367 {
6368   char buf[256];
6369
6370   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6371   return xstrdup (buf);
6372 }
6373
6374 /* Assign symbols to all worthy DIEs under DIE.  */
6375
6376 static void
6377 assign_symbol_names (dw_die_ref die)
6378 {
6379   dw_die_ref c;
6380
6381   if (is_symbol_die (die))
6382     {
6383       if (comdat_symbol_id)
6384         {
6385           char *p = alloca (strlen (comdat_symbol_id) + 64);
6386
6387           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6388                    comdat_symbol_id, comdat_symbol_number++);
6389           die->die_symbol = xstrdup (p);
6390         }
6391       else
6392         die->die_symbol = gen_internal_sym ("LDIE");
6393     }
6394
6395   FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6396 }
6397
6398 struct cu_hash_table_entry
6399 {
6400   dw_die_ref cu;
6401   unsigned min_comdat_num, max_comdat_num;
6402   struct cu_hash_table_entry *next;
6403 };
6404
6405 /* Routines to manipulate hash table of CUs.  */
6406 static hashval_t
6407 htab_cu_hash (const void *of)
6408 {
6409   const struct cu_hash_table_entry *entry = of;
6410
6411   return htab_hash_string (entry->cu->die_symbol);
6412 }
6413
6414 static int
6415 htab_cu_eq (const void *of1, const void *of2)
6416 {
6417   const struct cu_hash_table_entry *entry1 = of1;
6418   const struct die_struct *entry2 = of2;
6419
6420   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6421 }
6422
6423 static void
6424 htab_cu_del (void *what)
6425 {
6426   struct cu_hash_table_entry *next, *entry = what;
6427
6428   while (entry)
6429     {
6430       next = entry->next;
6431       free (entry);
6432       entry = next;
6433     }
6434 }
6435
6436 /* Check whether we have already seen this CU and set up SYM_NUM
6437    accordingly.  */
6438 static int
6439 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6440 {
6441   struct cu_hash_table_entry dummy;
6442   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6443
6444   dummy.max_comdat_num = 0;
6445
6446   slot = (struct cu_hash_table_entry **)
6447     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6448         INSERT);
6449   entry = *slot;
6450
6451   for (; entry; last = entry, entry = entry->next)
6452     {
6453       if (same_die_p_wrap (cu, entry->cu))
6454         break;
6455     }
6456
6457   if (entry)
6458     {
6459       *sym_num = entry->min_comdat_num;
6460       return 1;
6461     }
6462
6463   entry = XCNEW (struct cu_hash_table_entry);
6464   entry->cu = cu;
6465   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6466   entry->next = *slot;
6467   *slot = entry;
6468
6469   return 0;
6470 }
6471
6472 /* Record SYM_NUM to record of CU in HTABLE.  */
6473 static void
6474 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6475 {
6476   struct cu_hash_table_entry **slot, *entry;
6477
6478   slot = (struct cu_hash_table_entry **)
6479     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6480         NO_INSERT);
6481   entry = *slot;
6482
6483   entry->max_comdat_num = sym_num;
6484 }
6485
6486 /* Traverse the DIE (which is always comp_unit_die), and set up
6487    additional compilation units for each of the include files we see
6488    bracketed by BINCL/EINCL.  */
6489
6490 static void
6491 break_out_includes (dw_die_ref die)
6492 {
6493   dw_die_ref c;
6494   dw_die_ref unit = NULL;
6495   limbo_die_node *node, **pnode;
6496   htab_t cu_hash_table;
6497
6498   c = die->die_child;
6499   if (c) do {
6500     dw_die_ref prev = c;
6501     c = c->die_sib;
6502     while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6503            || (unit && is_comdat_die (c)))
6504       {
6505         dw_die_ref next = c->die_sib;
6506
6507         /* This DIE is for a secondary CU; remove it from the main one.  */
6508         remove_child_with_prev (c, prev);
6509
6510         if (c->die_tag == DW_TAG_GNU_BINCL)
6511           unit = push_new_compile_unit (unit, c);
6512         else if (c->die_tag == DW_TAG_GNU_EINCL)
6513           unit = pop_compile_unit (unit);
6514         else
6515           add_child_die (unit, c);
6516         c = next;
6517         if (c == die->die_child)
6518           break;
6519       }
6520   } while (c != die->die_child);
6521
6522 #if 0
6523   /* We can only use this in debugging, since the frontend doesn't check
6524      to make sure that we leave every include file we enter.  */
6525   gcc_assert (!unit);
6526 #endif
6527
6528   assign_symbol_names (die);
6529   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6530   for (node = limbo_die_list, pnode = &limbo_die_list;
6531        node;
6532        node = node->next)
6533     {
6534       int is_dupl;
6535
6536       compute_section_prefix (node->die);
6537       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6538                         &comdat_symbol_number);
6539       assign_symbol_names (node->die);
6540       if (is_dupl)
6541         *pnode = node->next;
6542       else
6543         {
6544           pnode = &node->next;
6545           record_comdat_symbol_number (node->die, cu_hash_table,
6546                 comdat_symbol_number);
6547         }
6548     }
6549   htab_delete (cu_hash_table);
6550 }
6551
6552 /* Traverse the DIE and add a sibling attribute if it may have the
6553    effect of speeding up access to siblings.  To save some space,
6554    avoid generating sibling attributes for DIE's without children.  */
6555
6556 static void
6557 add_sibling_attributes (dw_die_ref die)
6558 {
6559   dw_die_ref c;
6560
6561   if (! die->die_child)
6562     return;
6563
6564   if (die->die_parent && die != die->die_parent->die_child)
6565     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6566
6567   FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6568 }
6569
6570 /* Output all location lists for the DIE and its children.  */
6571
6572 static void
6573 output_location_lists (dw_die_ref die)
6574 {
6575   dw_die_ref c;
6576   dw_attr_ref a;
6577   unsigned ix;
6578
6579   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6580     if (AT_class (a) == dw_val_class_loc_list)
6581       output_loc_list (AT_loc_list (a));
6582
6583   FOR_EACH_CHILD (die, c, output_location_lists (c));
6584 }
6585
6586 /* The format of each DIE (and its attribute value pairs) is encoded in an
6587    abbreviation table.  This routine builds the abbreviation table and assigns
6588    a unique abbreviation id for each abbreviation entry.  The children of each
6589    die are visited recursively.  */
6590
6591 static void
6592 build_abbrev_table (dw_die_ref die)
6593 {
6594   unsigned long abbrev_id;
6595   unsigned int n_alloc;
6596   dw_die_ref c;
6597   dw_attr_ref a;
6598   unsigned ix;
6599
6600   /* Scan the DIE references, and mark as external any that refer to
6601      DIEs from other CUs (i.e. those which are not marked).  */
6602   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6603     if (AT_class (a) == dw_val_class_die_ref
6604         && AT_ref (a)->die_mark == 0)
6605       {
6606         gcc_assert (AT_ref (a)->die_symbol);
6607
6608         set_AT_ref_external (a, 1);
6609       }
6610
6611   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6612     {
6613       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6614       dw_attr_ref die_a, abbrev_a;
6615       unsigned ix;
6616       bool ok = true;
6617
6618       if (abbrev->die_tag != die->die_tag)
6619         continue;
6620       if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6621         continue;
6622
6623       if (VEC_length (dw_attr_node, abbrev->die_attr)
6624           != VEC_length (dw_attr_node, die->die_attr))
6625         continue;
6626
6627       for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6628         {
6629           abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6630           if ((abbrev_a->dw_attr != die_a->dw_attr)
6631               || (value_format (abbrev_a) != value_format (die_a)))
6632             {
6633               ok = false;
6634               break;
6635             }
6636         }
6637       if (ok)
6638         break;
6639     }
6640
6641   if (abbrev_id >= abbrev_die_table_in_use)
6642     {
6643       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6644         {
6645           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6646           abbrev_die_table = ggc_realloc (abbrev_die_table,
6647                                           sizeof (dw_die_ref) * n_alloc);
6648
6649           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6650                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6651           abbrev_die_table_allocated = n_alloc;
6652         }
6653
6654       ++abbrev_die_table_in_use;
6655       abbrev_die_table[abbrev_id] = die;
6656     }
6657
6658   die->die_abbrev = abbrev_id;
6659   FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6660 }
6661 \f
6662 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6663
6664 static int
6665 constant_size (long unsigned int value)
6666 {
6667   int log;
6668
6669   if (value == 0)
6670     log = 0;
6671   else
6672     log = floor_log2 (value);
6673
6674   log = log / 8;
6675   log = 1 << (floor_log2 (log) + 1);
6676
6677   return log;
6678 }
6679
6680 /* Return the size of a DIE as it is represented in the
6681    .debug_info section.  */
6682
6683 static unsigned long
6684 size_of_die (dw_die_ref die)
6685 {
6686   unsigned long size = 0;
6687   dw_attr_ref a;
6688   unsigned ix;
6689
6690   size += size_of_uleb128 (die->die_abbrev);
6691   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6692     {
6693       switch (AT_class (a))
6694         {
6695         case dw_val_class_addr:
6696           size += DWARF2_ADDR_SIZE;
6697           break;
6698         case dw_val_class_offset:
6699           size += DWARF_OFFSET_SIZE;
6700           break;
6701         case dw_val_class_loc:
6702           {
6703             unsigned long lsize = size_of_locs (AT_loc (a));
6704
6705             /* Block length.  */
6706             size += constant_size (lsize);
6707             size += lsize;
6708           }
6709           break;
6710         case dw_val_class_loc_list:
6711           size += DWARF_OFFSET_SIZE;
6712           break;
6713         case dw_val_class_range_list:
6714           size += DWARF_OFFSET_SIZE;
6715           break;
6716         case dw_val_class_const:
6717           size += size_of_sleb128 (AT_int (a));
6718           break;
6719         case dw_val_class_unsigned_const:
6720           size += constant_size (AT_unsigned (a));
6721           break;
6722         case dw_val_class_long_long:
6723           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6724           break;
6725         case dw_val_class_vec:
6726           size += 1 + (a->dw_attr_val.v.val_vec.length
6727                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6728           break;
6729         case dw_val_class_flag:
6730           size += 1;
6731           break;
6732         case dw_val_class_die_ref:
6733           if (AT_ref_external (a))
6734             size += DWARF2_ADDR_SIZE;
6735           else
6736             size += DWARF_OFFSET_SIZE;
6737           break;
6738         case dw_val_class_fde_ref:
6739           size += DWARF_OFFSET_SIZE;
6740           break;
6741         case dw_val_class_lbl_id:
6742           size += DWARF2_ADDR_SIZE;
6743           break;
6744         case dw_val_class_lineptr:
6745         case dw_val_class_macptr:
6746           size += DWARF_OFFSET_SIZE;
6747           break;
6748         case dw_val_class_str:
6749           if (AT_string_form (a) == DW_FORM_strp)
6750             size += DWARF_OFFSET_SIZE;
6751           else
6752             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6753           break;
6754         case dw_val_class_file:
6755           size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6756           break;
6757         default:
6758           gcc_unreachable ();
6759         }
6760     }
6761
6762   return size;
6763 }
6764
6765 /* Size the debugging information associated with a given DIE.  Visits the
6766    DIE's children recursively.  Updates the global variable next_die_offset, on
6767    each time through.  Uses the current value of next_die_offset to update the
6768    die_offset field in each DIE.  */
6769
6770 static void
6771 calc_die_sizes (dw_die_ref die)
6772 {
6773   dw_die_ref c;
6774
6775   die->die_offset = next_die_offset;
6776   next_die_offset += size_of_die (die);
6777
6778   FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6779
6780   if (die->die_child != NULL)
6781     /* Count the null byte used to terminate sibling lists.  */
6782     next_die_offset += 1;
6783 }
6784
6785 /* Set the marks for a die and its children.  We do this so
6786    that we know whether or not a reference needs to use FORM_ref_addr; only
6787    DIEs in the same CU will be marked.  We used to clear out the offset
6788    and use that as the flag, but ran into ordering problems.  */
6789
6790 static void
6791 mark_dies (dw_die_ref die)
6792 {
6793   dw_die_ref c;
6794
6795   gcc_assert (!die->die_mark);
6796
6797   die->die_mark = 1;
6798   FOR_EACH_CHILD (die, c, mark_dies (c));
6799 }
6800
6801 /* Clear the marks for a die and its children.  */
6802
6803 static void
6804 unmark_dies (dw_die_ref die)
6805 {
6806   dw_die_ref c;
6807
6808   gcc_assert (die->die_mark);
6809
6810   die->die_mark = 0;
6811   FOR_EACH_CHILD (die, c, unmark_dies (c));
6812 }
6813
6814 /* Clear the marks for a die, its children and referred dies.  */
6815
6816 static void
6817 unmark_all_dies (dw_die_ref die)
6818 {
6819   dw_die_ref c;
6820   dw_attr_ref a;
6821   unsigned ix;
6822
6823   if (!die->die_mark)
6824     return;
6825   die->die_mark = 0;
6826
6827   FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6828
6829   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6830     if (AT_class (a) == dw_val_class_die_ref)
6831       unmark_all_dies (AT_ref (a));
6832 }
6833
6834 /* Return the size of the .debug_pubnames or .debug_pubtypes table
6835    generated for the compilation unit.  */
6836
6837 static unsigned long
6838 size_of_pubnames (VEC (pubname_entry, gc) * names)
6839 {
6840   unsigned long size;
6841   unsigned i;
6842   pubname_ref p;
6843
6844   size = DWARF_PUBNAMES_HEADER_SIZE;
6845   for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
6846     if (names != pubtype_table
6847         || p->die->die_offset != 0
6848         || !flag_eliminate_unused_debug_types)
6849       size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
6850
6851   size += DWARF_OFFSET_SIZE;
6852   return size;
6853 }
6854
6855 /* Return the size of the information in the .debug_aranges section.  */
6856
6857 static unsigned long
6858 size_of_aranges (void)
6859 {
6860   unsigned long size;
6861
6862   size = DWARF_ARANGES_HEADER_SIZE;
6863
6864   /* Count the address/length pair for this compilation unit.  */
6865   if (text_section_used)
6866     size += 2 * DWARF2_ADDR_SIZE;
6867   if (cold_text_section_used)
6868     size += 2 * DWARF2_ADDR_SIZE;
6869   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6870
6871   /* Count the two zero words used to terminated the address range table.  */
6872   size += 2 * DWARF2_ADDR_SIZE;
6873   return size;
6874 }
6875 \f
6876 /* Select the encoding of an attribute value.  */
6877
6878 static enum dwarf_form
6879 value_format (dw_attr_ref a)
6880 {
6881   switch (a->dw_attr_val.val_class)
6882     {
6883     case dw_val_class_addr:
6884       return DW_FORM_addr;
6885     case dw_val_class_range_list:
6886     case dw_val_class_offset:
6887     case dw_val_class_loc_list:
6888       switch (DWARF_OFFSET_SIZE)
6889         {
6890         case 4:
6891           return DW_FORM_data4;
6892         case 8:
6893           return DW_FORM_data8;
6894         default:
6895           gcc_unreachable ();
6896         }
6897     case dw_val_class_loc:
6898       switch (constant_size (size_of_locs (AT_loc (a))))
6899         {
6900         case 1:
6901           return DW_FORM_block1;
6902         case 2:
6903           return DW_FORM_block2;
6904         default:
6905           gcc_unreachable ();
6906         }
6907     case dw_val_class_const:
6908       return DW_FORM_sdata;
6909     case dw_val_class_unsigned_const:
6910       switch (constant_size (AT_unsigned (a)))
6911         {
6912         case 1:
6913           return DW_FORM_data1;
6914         case 2:
6915           return DW_FORM_data2;
6916         case 4:
6917           return DW_FORM_data4;
6918         case 8:
6919           return DW_FORM_data8;
6920         default:
6921           gcc_unreachable ();
6922         }
6923     case dw_val_class_long_long:
6924       return DW_FORM_block1;
6925     case dw_val_class_vec:
6926       return DW_FORM_block1;
6927     case dw_val_class_flag:
6928       return DW_FORM_flag;
6929     case dw_val_class_die_ref:
6930       if (AT_ref_external (a))
6931         return DW_FORM_ref_addr;
6932       else
6933         return DW_FORM_ref;
6934     case dw_val_class_fde_ref:
6935       return DW_FORM_data;
6936     case dw_val_class_lbl_id:
6937       return DW_FORM_addr;
6938     case dw_val_class_lineptr:
6939     case dw_val_class_macptr:
6940       return DW_FORM_data;
6941     case dw_val_class_str:
6942       return AT_string_form (a);
6943     case dw_val_class_file:
6944       switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6945         {
6946         case 1:
6947           return DW_FORM_data1;
6948         case 2:
6949           return DW_FORM_data2;
6950         case 4:
6951           return DW_FORM_data4;
6952         default:
6953           gcc_unreachable ();
6954         }
6955
6956     default:
6957       gcc_unreachable ();
6958     }
6959 }
6960
6961 /* Output the encoding of an attribute value.  */
6962
6963 static void
6964 output_value_format (dw_attr_ref a)
6965 {
6966   enum dwarf_form form = value_format (a);
6967
6968   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6969 }
6970
6971 /* Output the .debug_abbrev section which defines the DIE abbreviation
6972    table.  */
6973
6974 static void
6975 output_abbrev_section (void)
6976 {
6977   unsigned long abbrev_id;
6978
6979   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6980     {
6981       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6982       unsigned ix;
6983       dw_attr_ref a_attr;
6984
6985       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6986       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6987                                    dwarf_tag_name (abbrev->die_tag));
6988
6989       if (abbrev->die_child != NULL)
6990         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6991       else
6992         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6993
6994       for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6995            ix++)
6996         {
6997           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6998                                        dwarf_attr_name (a_attr->dw_attr));
6999           output_value_format (a_attr);
7000         }
7001
7002       dw2_asm_output_data (1, 0, NULL);
7003       dw2_asm_output_data (1, 0, NULL);
7004     }
7005
7006   /* Terminate the table.  */
7007   dw2_asm_output_data (1, 0, NULL);
7008 }
7009
7010 /* Output a symbol we can use to refer to this DIE from another CU.  */
7011
7012 static inline void
7013 output_die_symbol (dw_die_ref die)
7014 {
7015   char *sym = die->die_symbol;
7016
7017   if (sym == 0)
7018     return;
7019
7020   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
7021     /* We make these global, not weak; if the target doesn't support
7022        .linkonce, it doesn't support combining the sections, so debugging
7023        will break.  */
7024     targetm.asm_out.globalize_label (asm_out_file, sym);
7025
7026   ASM_OUTPUT_LABEL (asm_out_file, sym);
7027 }
7028
7029 /* Return a new location list, given the begin and end range, and the
7030    expression. gensym tells us whether to generate a new internal symbol for
7031    this location list node, which is done for the head of the list only.  */
7032
7033 static inline dw_loc_list_ref
7034 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
7035               const char *section, unsigned int gensym)
7036 {
7037   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
7038
7039   retlist->begin = begin;
7040   retlist->end = end;
7041   retlist->expr = expr;
7042   retlist->section = section;
7043   if (gensym)
7044     retlist->ll_symbol = gen_internal_sym ("LLST");
7045
7046   return retlist;
7047 }
7048
7049 /* Add a location description expression to a location list.  */
7050
7051 static inline void
7052 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
7053                            const char *begin, const char *end,
7054                            const char *section)
7055 {
7056   dw_loc_list_ref *d;
7057
7058   /* Find the end of the chain.  */
7059   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
7060     ;
7061
7062   /* Add a new location list node to the list.  */
7063   *d = new_loc_list (descr, begin, end, section, 0);
7064 }
7065
7066 /* Note that the current function section is being used for code.  */
7067
7068 static void
7069 dwarf2out_note_section_used (void)
7070 {
7071   section *sec = current_function_section ();
7072   if (sec == text_section)
7073     text_section_used = true;
7074   else if (sec == cold_text_section)
7075     cold_text_section_used = true;
7076 }
7077
7078 static void
7079 dwarf2out_switch_text_section (void)
7080 {
7081   dw_fde_ref fde;
7082
7083   gcc_assert (cfun);
7084
7085   fde = &fde_table[fde_table_in_use - 1];
7086   fde->dw_fde_switched_sections = true;
7087   fde->dw_fde_hot_section_label = cfun->hot_section_label;
7088   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
7089   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
7090   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
7091   have_multiple_function_sections = true;
7092
7093   /* Reset the current label on switching text sections, so that we
7094      don't attempt to advance_loc4 between labels in different sections.  */
7095   fde->dw_fde_current_label = NULL;
7096
7097   dwarf2out_note_section_used ();
7098 }
7099
7100 /* Output the location list given to us.  */
7101
7102 static void
7103 output_loc_list (dw_loc_list_ref list_head)
7104 {
7105   dw_loc_list_ref curr = list_head;
7106
7107   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7108
7109   /* Walk the location list, and output each range + expression.  */
7110   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7111     {
7112       unsigned long size;
7113       /* Don't output an entry that starts and ends at the same address.  */
7114       if (strcmp (curr->begin, curr->end) == 0)
7115         continue;
7116       if (!have_multiple_function_sections)
7117         {
7118           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7119                                 "Location list begin address (%s)",
7120                                 list_head->ll_symbol);
7121           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7122                                 "Location list end address (%s)",
7123                                 list_head->ll_symbol);
7124         }
7125       else
7126         {
7127           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7128                                "Location list begin address (%s)",
7129                                list_head->ll_symbol);
7130           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7131                                "Location list end address (%s)",
7132                                list_head->ll_symbol);
7133         }
7134       size = size_of_locs (curr->expr);
7135
7136       /* Output the block length for this list of location operations.  */
7137       gcc_assert (size <= 0xffff);
7138       dw2_asm_output_data (2, size, "%s", "Location expression size");
7139
7140       output_loc_sequence (curr->expr);
7141     }
7142
7143   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7144                        "Location list terminator begin (%s)",
7145                        list_head->ll_symbol);
7146   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7147                        "Location list terminator end (%s)",
7148                        list_head->ll_symbol);
7149 }
7150
7151 /* Output the DIE and its attributes.  Called recursively to generate
7152    the definitions of each child DIE.  */
7153
7154 static void
7155 output_die (dw_die_ref die)
7156 {
7157   dw_attr_ref a;
7158   dw_die_ref c;
7159   unsigned long size;
7160   unsigned ix;
7161
7162   /* If someone in another CU might refer to us, set up a symbol for
7163      them to point to.  */
7164   if (die->die_symbol)
7165     output_die_symbol (die);
7166
7167   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7168                                (unsigned long)die->die_offset,
7169                                dwarf_tag_name (die->die_tag));
7170
7171   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7172     {
7173       const char *name = dwarf_attr_name (a->dw_attr);
7174
7175       switch (AT_class (a))
7176         {
7177         case dw_val_class_addr:
7178           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7179           break;
7180
7181         case dw_val_class_offset:
7182           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7183                                "%s", name);
7184           break;
7185
7186         case dw_val_class_range_list:
7187           {
7188             char *p = strchr (ranges_section_label, '\0');
7189
7190             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7191                      a->dw_attr_val.v.val_offset);
7192             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7193                                    debug_ranges_section, "%s", name);
7194             *p = '\0';
7195           }
7196           break;
7197
7198         case dw_val_class_loc:
7199           size = size_of_locs (AT_loc (a));
7200
7201           /* Output the block length for this list of location operations.  */
7202           dw2_asm_output_data (constant_size (size), size, "%s", name);
7203
7204           output_loc_sequence (AT_loc (a));
7205           break;
7206
7207         case dw_val_class_const:
7208           /* ??? It would be slightly more efficient to use a scheme like is
7209              used for unsigned constants below, but gdb 4.x does not sign
7210              extend.  Gdb 5.x does sign extend.  */
7211           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7212           break;
7213
7214         case dw_val_class_unsigned_const:
7215           dw2_asm_output_data (constant_size (AT_unsigned (a)),
7216                                AT_unsigned (a), "%s", name);
7217           break;
7218
7219         case dw_val_class_long_long:
7220           {
7221             unsigned HOST_WIDE_INT first, second;
7222
7223             dw2_asm_output_data (1,
7224                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7225                                  "%s", name);
7226
7227             if (WORDS_BIG_ENDIAN)
7228               {
7229                 first = a->dw_attr_val.v.val_long_long.hi;
7230                 second = a->dw_attr_val.v.val_long_long.low;
7231               }
7232             else
7233               {
7234                 first = a->dw_attr_val.v.val_long_long.low;
7235                 second = a->dw_attr_val.v.val_long_long.hi;
7236               }
7237
7238             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7239                                  first, "long long constant");
7240             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7241                                  second, NULL);
7242           }
7243           break;
7244
7245         case dw_val_class_vec:
7246           {
7247             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7248             unsigned int len = a->dw_attr_val.v.val_vec.length;
7249             unsigned int i;
7250             unsigned char *p;
7251
7252             dw2_asm_output_data (1, len * elt_size, "%s", name);
7253             if (elt_size > sizeof (HOST_WIDE_INT))
7254               {
7255                 elt_size /= 2;
7256                 len *= 2;
7257               }
7258             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7259                  i < len;
7260                  i++, p += elt_size)
7261               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7262                                    "fp or vector constant word %u", i);
7263             break;
7264           }
7265
7266         case dw_val_class_flag:
7267           dw2_asm_output_data (1, AT_flag (a), "%s", name);
7268           break;
7269
7270         case dw_val_class_loc_list:
7271           {
7272             char *sym = AT_loc_list (a)->ll_symbol;
7273
7274             gcc_assert (sym);
7275             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7276                                    "%s", name);
7277           }
7278           break;
7279
7280         case dw_val_class_die_ref:
7281           if (AT_ref_external (a))
7282             {
7283               char *sym = AT_ref (a)->die_symbol;
7284
7285               gcc_assert (sym);
7286               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7287                                      "%s", name);
7288             }
7289           else
7290             {
7291               gcc_assert (AT_ref (a)->die_offset);
7292               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7293                                    "%s", name);
7294             }
7295           break;
7296
7297         case dw_val_class_fde_ref:
7298           {
7299             char l1[20];
7300
7301             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7302                                          a->dw_attr_val.v.val_fde_index * 2);
7303             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7304                                    "%s", name);
7305           }
7306           break;
7307
7308         case dw_val_class_lbl_id:
7309           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7310           break;
7311
7312         case dw_val_class_lineptr:
7313           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7314                                  debug_line_section, "%s", name);
7315           break;
7316
7317         case dw_val_class_macptr:
7318           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7319                                  debug_macinfo_section, "%s", name);
7320           break;
7321
7322         case dw_val_class_str:
7323           if (AT_string_form (a) == DW_FORM_strp)
7324             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7325                                    a->dw_attr_val.v.val_str->label,
7326                                    debug_str_section,
7327                                    "%s: \"%s\"", name, AT_string (a));
7328           else
7329             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7330           break;
7331
7332         case dw_val_class_file:
7333           {
7334             int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7335
7336             dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7337                                  a->dw_attr_val.v.val_file->filename);
7338             break;
7339           }
7340
7341         default:
7342           gcc_unreachable ();
7343         }
7344     }
7345
7346   FOR_EACH_CHILD (die, c, output_die (c));
7347
7348   /* Add null byte to terminate sibling list.  */
7349   if (die->die_child != NULL)
7350     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7351                          (unsigned long) die->die_offset);
7352 }
7353
7354 /* Output the compilation unit that appears at the beginning of the
7355    .debug_info section, and precedes the DIE descriptions.  */
7356
7357 static void
7358 output_compilation_unit_header (void)
7359 {
7360   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7361     dw2_asm_output_data (4, 0xffffffff,
7362       "Initial length escape value indicating 64-bit DWARF extension");
7363   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7364                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7365                        "Length of Compilation Unit Info");
7366   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7367   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7368                          debug_abbrev_section,
7369                          "Offset Into Abbrev. Section");
7370   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7371 }
7372
7373 /* Output the compilation unit DIE and its children.  */
7374
7375 static void
7376 output_comp_unit (dw_die_ref die, int output_if_empty)
7377 {
7378   const char *secname;
7379   char *oldsym, *tmp;
7380
7381   /* Unless we are outputting main CU, we may throw away empty ones.  */
7382   if (!output_if_empty && die->die_child == NULL)
7383     return;
7384
7385   /* Even if there are no children of this DIE, we must output the information
7386      about the compilation unit.  Otherwise, on an empty translation unit, we
7387      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7388      will then complain when examining the file.  First mark all the DIEs in
7389      this CU so we know which get local refs.  */
7390   mark_dies (die);
7391
7392   build_abbrev_table (die);
7393
7394   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7395   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7396   calc_die_sizes (die);
7397
7398   oldsym = die->die_symbol;
7399   if (oldsym)
7400     {
7401       tmp = alloca (strlen (oldsym) + 24);
7402
7403       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7404       secname = tmp;
7405       die->die_symbol = NULL;
7406       switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7407     }
7408   else
7409     switch_to_section (debug_info_section);
7410
7411   /* Output debugging information.  */
7412   output_compilation_unit_header ();
7413   output_die (die);
7414
7415   /* Leave the marks on the main CU, so we can check them in
7416      output_pubnames.  */
7417   if (oldsym)
7418     {
7419       unmark_dies (die);
7420       die->die_symbol = oldsym;
7421     }
7422 }
7423
7424 /* Return the DWARF2/3 pubname associated with a decl.  */
7425
7426 static const char *
7427 dwarf2_name (tree decl, int scope)
7428 {
7429   return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7430 }
7431
7432 /* Add a new entry to .debug_pubnames if appropriate.  */
7433
7434 static void
7435 add_pubname (tree decl, dw_die_ref die)
7436 {
7437   pubname_entry e;
7438
7439   if (! TREE_PUBLIC (decl))
7440     return;
7441
7442   e.die = die;
7443   e.name = xstrdup (dwarf2_name (decl, 1));
7444   VEC_safe_push (pubname_entry, gc, pubname_table, &e);
7445 }
7446
7447 /* Add a new entry to .debug_pubtypes if appropriate.  */
7448
7449 static void
7450 add_pubtype (tree decl, dw_die_ref die)
7451 {
7452   pubname_entry e;
7453
7454   e.name = NULL;
7455   if ((TREE_PUBLIC (decl)
7456        || die->die_parent == comp_unit_die)
7457       && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
7458     {
7459       e.die = die;
7460       if (TYPE_P (decl))
7461         {
7462           if (TYPE_NAME (decl))
7463             {
7464               if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
7465                 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
7466               else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
7467                        && DECL_NAME (TYPE_NAME (decl)))
7468                 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
7469               else
7470                e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
7471             }
7472         }
7473       else
7474         e.name = xstrdup (dwarf2_name (decl, 1));
7475
7476       /* If we don't have a name for the type, there's no point in adding
7477          it to the table.  */
7478       if (e.name && e.name[0] != '\0')
7479         VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
7480     }
7481 }
7482
7483 /* Output the public names table used to speed up access to externally
7484    visible names; or the public types table used to find type definitions.  */
7485
7486 static void
7487 output_pubnames (VEC (pubname_entry, gc) * names)
7488 {
7489   unsigned i;
7490   unsigned long pubnames_length = size_of_pubnames (names);
7491   pubname_ref pub;
7492
7493   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7494     dw2_asm_output_data (4, 0xffffffff,
7495       "Initial length escape value indicating 64-bit DWARF extension");
7496   if (names == pubname_table)
7497     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7498                          "Length of Public Names Info");
7499   else
7500     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7501                          "Length of Public Type Names Info");
7502   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7503   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7504                          debug_info_section,
7505                          "Offset of Compilation Unit Info");
7506   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7507                        "Compilation Unit Length");
7508
7509   for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
7510     {
7511       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7512       if (names == pubname_table)
7513         gcc_assert (pub->die->die_mark);
7514
7515       if (names != pubtype_table
7516           || pub->die->die_offset != 0
7517           || !flag_eliminate_unused_debug_types)
7518         {
7519           dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7520                                "DIE offset");
7521
7522           dw2_asm_output_nstring (pub->name, -1, "external name");
7523         }
7524     }
7525
7526   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7527 }
7528
7529 /* Add a new entry to .debug_aranges if appropriate.  */
7530
7531 static void
7532 add_arange (tree decl, dw_die_ref die)
7533 {
7534   if (! DECL_SECTION_NAME (decl))
7535     return;
7536
7537   if (arange_table_in_use == arange_table_allocated)
7538     {
7539       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7540       arange_table = ggc_realloc (arange_table,
7541                                   (arange_table_allocated
7542                                    * sizeof (dw_die_ref)));
7543       memset (arange_table + arange_table_in_use, 0,
7544               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7545     }
7546
7547   arange_table[arange_table_in_use++] = die;
7548 }
7549
7550 /* Output the information that goes into the .debug_aranges table.
7551    Namely, define the beginning and ending address range of the
7552    text section generated for this compilation unit.  */
7553
7554 static void
7555 output_aranges (void)
7556 {
7557   unsigned i;
7558   unsigned long aranges_length = size_of_aranges ();
7559
7560   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7561     dw2_asm_output_data (4, 0xffffffff,
7562       "Initial length escape value indicating 64-bit DWARF extension");
7563   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7564                        "Length of Address Ranges Info");
7565   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7566   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7567                          debug_info_section,
7568                          "Offset of Compilation Unit Info");
7569   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7570   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7571
7572   /* We need to align to twice the pointer size here.  */
7573   if (DWARF_ARANGES_PAD_SIZE)
7574     {
7575       /* Pad using a 2 byte words so that padding is correct for any
7576          pointer size.  */
7577       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7578                            2 * DWARF2_ADDR_SIZE);
7579       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7580         dw2_asm_output_data (2, 0, NULL);
7581     }
7582
7583   /* It is necessary not to output these entries if the sections were
7584      not used; if the sections were not used, the length will be 0 and
7585      the address may end up as 0 if the section is discarded by ld
7586      --gc-sections, leaving an invalid (0, 0) entry that can be
7587      confused with the terminator.  */
7588   if (text_section_used)
7589     {
7590       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7591       dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7592                             text_section_label, "Length");
7593     }
7594   if (cold_text_section_used)
7595     {
7596       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7597                            "Address");
7598       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7599                             cold_text_section_label, "Length");
7600     }
7601
7602   for (i = 0; i < arange_table_in_use; i++)
7603     {
7604       dw_die_ref die = arange_table[i];
7605
7606       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7607       gcc_assert (die->die_mark);
7608
7609       if (die->die_tag == DW_TAG_subprogram)
7610         {
7611           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7612                                "Address");
7613           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7614                                 get_AT_low_pc (die), "Length");
7615         }
7616       else
7617         {
7618           /* A static variable; extract the symbol from DW_AT_location.
7619              Note that this code isn't currently hit, as we only emit
7620              aranges for functions (jason 9/23/99).  */
7621           dw_attr_ref a = get_AT (die, DW_AT_location);
7622           dw_loc_descr_ref loc;
7623
7624           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7625
7626           loc = AT_loc (a);
7627           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7628
7629           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7630                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7631           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7632                                get_AT_unsigned (die, DW_AT_byte_size),
7633                                "Length");
7634         }
7635     }
7636
7637   /* Output the terminator words.  */
7638   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7639   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7640 }
7641
7642 /* Add a new entry to .debug_ranges.  Return the offset at which it
7643    was placed.  */
7644
7645 static unsigned int
7646 add_ranges_num (int num)
7647 {
7648   unsigned int in_use = ranges_table_in_use;
7649
7650   if (in_use == ranges_table_allocated)
7651     {
7652       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7653       ranges_table
7654         = ggc_realloc (ranges_table, (ranges_table_allocated
7655                                       * sizeof (struct dw_ranges_struct)));
7656       memset (ranges_table + ranges_table_in_use, 0,
7657               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7658     }
7659
7660   ranges_table[in_use].num = num;
7661   ranges_table_in_use = in_use + 1;
7662
7663   return in_use * 2 * DWARF2_ADDR_SIZE;
7664 }
7665
7666 /* Add a new entry to .debug_ranges corresponding to a block, or a
7667    range terminator if BLOCK is NULL.  */
7668
7669 static unsigned int
7670 add_ranges (const_tree block)
7671 {
7672   return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
7673 }
7674
7675 /* Add a new entry to .debug_ranges corresponding to a pair of
7676    labels.  */
7677
7678 static unsigned int
7679 add_ranges_by_labels (const char *begin, const char *end)
7680 {
7681   unsigned int in_use = ranges_by_label_in_use;
7682
7683   if (in_use == ranges_by_label_allocated)
7684     {
7685       ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
7686       ranges_by_label
7687         = ggc_realloc (ranges_by_label,
7688                        (ranges_by_label_allocated
7689                         * sizeof (struct dw_ranges_by_label_struct)));
7690       memset (ranges_by_label + ranges_by_label_in_use, 0,
7691               RANGES_TABLE_INCREMENT
7692               * sizeof (struct dw_ranges_by_label_struct));
7693     }
7694
7695   ranges_by_label[in_use].begin = begin;
7696   ranges_by_label[in_use].end = end;
7697   ranges_by_label_in_use = in_use + 1;
7698
7699   return add_ranges_num (-(int)in_use - 1);
7700 }
7701
7702 static void
7703 output_ranges (void)
7704 {
7705   unsigned i;
7706   static const char *const start_fmt = "Offset 0x%x";
7707   const char *fmt = start_fmt;
7708
7709   for (i = 0; i < ranges_table_in_use; i++)
7710     {
7711       int block_num = ranges_table[i].num;
7712
7713       if (block_num > 0)
7714         {
7715           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7716           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7717
7718           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7719           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7720
7721           /* If all code is in the text section, then the compilation
7722              unit base address defaults to DW_AT_low_pc, which is the
7723              base of the text section.  */
7724           if (!have_multiple_function_sections)
7725             {
7726               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7727                                     text_section_label,
7728                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7729               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7730                                     text_section_label, NULL);
7731             }
7732
7733           /* Otherwise, the compilation unit base address is zero,
7734              which allows us to use absolute addresses, and not worry
7735              about whether the target supports cross-section
7736              arithmetic.  */
7737           else
7738             {
7739               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7740                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7741               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7742             }
7743
7744           fmt = NULL;
7745         }
7746
7747       /* Negative block_num stands for an index into ranges_by_label.  */
7748       else if (block_num < 0)
7749         {
7750           int lab_idx = - block_num - 1;
7751
7752           if (!have_multiple_function_sections)
7753             {
7754               gcc_unreachable ();
7755 #if 0
7756               /* If we ever use add_ranges_by_labels () for a single
7757                  function section, all we have to do is to take out
7758                  the #if 0 above.  */
7759               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
7760                                     ranges_by_label[lab_idx].begin,
7761                                     text_section_label,
7762                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7763               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
7764                                     ranges_by_label[lab_idx].end,
7765                                     text_section_label, NULL);
7766 #endif
7767             }
7768           else
7769             {
7770               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
7771                                    ranges_by_label[lab_idx].begin,
7772                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7773               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
7774                                    ranges_by_label[lab_idx].end,
7775                                    NULL);
7776             }
7777         }
7778       else
7779         {
7780           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7781           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7782           fmt = start_fmt;
7783         }
7784     }
7785 }
7786
7787 /* Data structure containing information about input files.  */
7788 struct file_info
7789 {
7790   const char *path;     /* Complete file name.  */
7791   const char *fname;    /* File name part.  */
7792   int length;           /* Length of entire string.  */
7793   struct dwarf_file_data * file_idx;    /* Index in input file table.  */
7794   int dir_idx;          /* Index in directory table.  */
7795 };
7796
7797 /* Data structure containing information about directories with source
7798    files.  */
7799 struct dir_info
7800 {
7801   const char *path;     /* Path including directory name.  */
7802   int length;           /* Path length.  */
7803   int prefix;           /* Index of directory entry which is a prefix.  */
7804   int count;            /* Number of files in this directory.  */
7805   int dir_idx;          /* Index of directory used as base.  */
7806 };
7807
7808 /* Callback function for file_info comparison.  We sort by looking at
7809    the directories in the path.  */
7810
7811 static int
7812 file_info_cmp (const void *p1, const void *p2)
7813 {
7814   const struct file_info *s1 = p1;
7815   const struct file_info *s2 = p2;
7816   const unsigned char *cp1;
7817   const unsigned char *cp2;
7818
7819   /* Take care of file names without directories.  We need to make sure that
7820      we return consistent values to qsort since some will get confused if
7821      we return the same value when identical operands are passed in opposite
7822      orders.  So if neither has a directory, return 0 and otherwise return
7823      1 or -1 depending on which one has the directory.  */
7824   if ((s1->path == s1->fname || s2->path == s2->fname))
7825     return (s2->path == s2->fname) - (s1->path == s1->fname);
7826
7827   cp1 = (const unsigned char *) s1->path;
7828   cp2 = (const unsigned char *) s2->path;
7829
7830   while (1)
7831     {
7832       ++cp1;
7833       ++cp2;
7834       /* Reached the end of the first path?  If so, handle like above.  */
7835       if ((cp1 == (const unsigned char *) s1->fname)
7836           || (cp2 == (const unsigned char *) s2->fname))
7837         return ((cp2 == (const unsigned char *) s2->fname)
7838                 - (cp1 == (const unsigned char *) s1->fname));
7839
7840       /* Character of current path component the same?  */
7841       else if (*cp1 != *cp2)
7842         return *cp1 - *cp2;
7843     }
7844 }
7845
7846 struct file_name_acquire_data
7847 {
7848   struct file_info *files;
7849   int used_files;
7850   int max_files;
7851 };
7852
7853 /* Traversal function for the hash table.  */
7854
7855 static int
7856 file_name_acquire (void ** slot, void *data)
7857 {
7858   struct file_name_acquire_data *fnad = data;
7859   struct dwarf_file_data *d = *slot;
7860   struct file_info *fi;
7861   const char *f;
7862
7863   gcc_assert (fnad->max_files >= d->emitted_number);
7864
7865   if (! d->emitted_number)
7866     return 1;
7867
7868   gcc_assert (fnad->max_files != fnad->used_files);
7869
7870   fi = fnad->files + fnad->used_files++;
7871
7872   /* Skip all leading "./".  */
7873   f = d->filename;
7874   while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
7875     f += 2;
7876
7877   /* Create a new array entry.  */
7878   fi->path = f;
7879   fi->length = strlen (f);
7880   fi->file_idx = d;
7881
7882   /* Search for the file name part.  */
7883   f = strrchr (f, DIR_SEPARATOR);
7884 #if defined (DIR_SEPARATOR_2)
7885   {
7886     char *g = strrchr (fi->path, DIR_SEPARATOR_2);
7887
7888     if (g != NULL)
7889       {
7890         if (f == NULL || f < g)
7891           f = g;
7892       }
7893   }
7894 #endif
7895
7896   fi->fname = f == NULL ? fi->path : f + 1;
7897   return 1;
7898 }
7899
7900 /* Output the directory table and the file name table.  We try to minimize
7901    the total amount of memory needed.  A heuristic is used to avoid large
7902    slowdowns with many input files.  */
7903
7904 static void
7905 output_file_names (void)
7906 {
7907   struct file_name_acquire_data fnad;
7908   int numfiles;
7909   struct file_info *files;
7910   struct dir_info *dirs;
7911   int *saved;
7912   int *savehere;
7913   int *backmap;
7914   int ndirs;
7915   int idx_offset;
7916   int i;
7917   int idx;
7918
7919   if (!last_emitted_file)
7920     {
7921       dw2_asm_output_data (1, 0, "End directory table");
7922       dw2_asm_output_data (1, 0, "End file name table");
7923       return;
7924     }
7925
7926   numfiles = last_emitted_file->emitted_number;
7927
7928   /* Allocate the various arrays we need.  */
7929   files = alloca (numfiles * sizeof (struct file_info));
7930   dirs = alloca (numfiles * sizeof (struct dir_info));
7931
7932   fnad.files = files;
7933   fnad.used_files = 0;
7934   fnad.max_files = numfiles;
7935   htab_traverse (file_table, file_name_acquire, &fnad);
7936   gcc_assert (fnad.used_files == fnad.max_files);
7937
7938   qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7939
7940   /* Find all the different directories used.  */
7941   dirs[0].path = files[0].path;
7942   dirs[0].length = files[0].fname - files[0].path;
7943   dirs[0].prefix = -1;
7944   dirs[0].count = 1;
7945   dirs[0].dir_idx = 0;
7946   files[0].dir_idx = 0;
7947   ndirs = 1;
7948
7949   for (i = 1; i < numfiles; i++)
7950     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7951         && memcmp (dirs[ndirs - 1].path, files[i].path,
7952                    dirs[ndirs - 1].length) == 0)
7953       {
7954         /* Same directory as last entry.  */
7955         files[i].dir_idx = ndirs - 1;
7956         ++dirs[ndirs - 1].count;
7957       }
7958     else
7959       {
7960         int j;
7961
7962         /* This is a new directory.  */
7963         dirs[ndirs].path = files[i].path;
7964         dirs[ndirs].length = files[i].fname - files[i].path;
7965         dirs[ndirs].count = 1;
7966         dirs[ndirs].dir_idx = ndirs;
7967         files[i].dir_idx = ndirs;
7968
7969         /* Search for a prefix.  */
7970         dirs[ndirs].prefix = -1;
7971         for (j = 0; j < ndirs; j++)
7972           if (dirs[j].length < dirs[ndirs].length
7973               && dirs[j].length > 1
7974               && (dirs[ndirs].prefix == -1
7975                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7976               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7977             dirs[ndirs].prefix = j;
7978
7979         ++ndirs;
7980       }
7981
7982   /* Now to the actual work.  We have to find a subset of the directories which
7983      allow expressing the file name using references to the directory table
7984      with the least amount of characters.  We do not do an exhaustive search
7985      where we would have to check out every combination of every single
7986      possible prefix.  Instead we use a heuristic which provides nearly optimal
7987      results in most cases and never is much off.  */
7988   saved = alloca (ndirs * sizeof (int));
7989   savehere = alloca (ndirs * sizeof (int));
7990
7991   memset (saved, '\0', ndirs * sizeof (saved[0]));
7992   for (i = 0; i < ndirs; i++)
7993     {
7994       int j;
7995       int total;
7996
7997       /* We can always save some space for the current directory.  But this
7998          does not mean it will be enough to justify adding the directory.  */
7999       savehere[i] = dirs[i].length;
8000       total = (savehere[i] - saved[i]) * dirs[i].count;
8001
8002       for (j = i + 1; j < ndirs; j++)
8003         {
8004           savehere[j] = 0;
8005           if (saved[j] < dirs[i].length)
8006             {
8007               /* Determine whether the dirs[i] path is a prefix of the
8008                  dirs[j] path.  */
8009               int k;
8010
8011               k = dirs[j].prefix;
8012               while (k != -1 && k != (int) i)
8013                 k = dirs[k].prefix;
8014
8015               if (k == (int) i)
8016                 {
8017                   /* Yes it is.  We can possibly save some memory by
8018                      writing the filenames in dirs[j] relative to
8019                      dirs[i].  */
8020                   savehere[j] = dirs[i].length;
8021                   total += (savehere[j] - saved[j]) * dirs[j].count;
8022                 }
8023             }
8024         }
8025
8026       /* Check whether we can save enough to justify adding the dirs[i]
8027          directory.  */
8028       if (total > dirs[i].length + 1)
8029         {
8030           /* It's worthwhile adding.  */
8031           for (j = i; j < ndirs; j++)
8032             if (savehere[j] > 0)
8033               {
8034                 /* Remember how much we saved for this directory so far.  */
8035                 saved[j] = savehere[j];
8036
8037                 /* Remember the prefix directory.  */
8038                 dirs[j].dir_idx = i;
8039               }
8040         }
8041     }
8042
8043   /* Emit the directory name table.  */
8044   idx = 1;
8045   idx_offset = dirs[0].length > 0 ? 1 : 0;
8046   for (i = 1 - idx_offset; i < ndirs; i++)
8047     dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
8048                             "Directory Entry: 0x%x", i + idx_offset);
8049
8050   dw2_asm_output_data (1, 0, "End directory table");
8051
8052   /* We have to emit them in the order of emitted_number since that's
8053      used in the debug info generation.  To do this efficiently we
8054      generate a back-mapping of the indices first.  */
8055   backmap = alloca (numfiles * sizeof (int));
8056   for (i = 0; i < numfiles; i++)
8057     backmap[files[i].file_idx->emitted_number - 1] = i;
8058
8059   /* Now write all the file names.  */
8060   for (i = 0; i < numfiles; i++)
8061     {
8062       int file_idx = backmap[i];
8063       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
8064
8065       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
8066                               "File Entry: 0x%x", (unsigned) i + 1);
8067
8068       /* Include directory index.  */
8069       dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
8070
8071       /* Modification time.  */
8072       dw2_asm_output_data_uleb128 (0, NULL);
8073
8074       /* File length in bytes.  */
8075       dw2_asm_output_data_uleb128 (0, NULL);
8076     }
8077
8078   dw2_asm_output_data (1, 0, "End file name table");
8079 }
8080
8081
8082 /* Output the source line number correspondence information.  This
8083    information goes into the .debug_line section.  */
8084
8085 static void
8086 output_line_info (void)
8087 {
8088   char l1[20], l2[20], p1[20], p2[20];
8089   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8090   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8091   unsigned opc;
8092   unsigned n_op_args;
8093   unsigned long lt_index;
8094   unsigned long current_line;
8095   long line_offset;
8096   long line_delta;
8097   unsigned long current_file;
8098   unsigned long function;
8099
8100   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
8101   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
8102   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
8103   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
8104
8105   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8106     dw2_asm_output_data (4, 0xffffffff,
8107       "Initial length escape value indicating 64-bit DWARF extension");
8108   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
8109                         "Length of Source Line Info");
8110   ASM_OUTPUT_LABEL (asm_out_file, l1);
8111
8112   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8113   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
8114   ASM_OUTPUT_LABEL (asm_out_file, p1);
8115
8116   /* Define the architecture-dependent minimum instruction length (in
8117    bytes).  In this implementation of DWARF, this field is used for
8118    information purposes only.  Since GCC generates assembly language,
8119    we have no a priori knowledge of how many instruction bytes are
8120    generated for each source line, and therefore can use only the
8121    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8122    commands.  Accordingly, we fix this as `1', which is "correct
8123    enough" for all architectures, and don't let the target override.  */
8124   dw2_asm_output_data (1, 1,
8125                        "Minimum Instruction Length");
8126
8127   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
8128                        "Default is_stmt_start flag");
8129   dw2_asm_output_data (1, DWARF_LINE_BASE,
8130                        "Line Base Value (Special Opcodes)");
8131   dw2_asm_output_data (1, DWARF_LINE_RANGE,
8132                        "Line Range Value (Special Opcodes)");
8133   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
8134                        "Special Opcode Base");
8135
8136   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
8137     {
8138       switch (opc)
8139         {
8140         case DW_LNS_advance_pc:
8141         case DW_LNS_advance_line:
8142         case DW_LNS_set_file:
8143         case DW_LNS_set_column:
8144         case DW_LNS_fixed_advance_pc:
8145           n_op_args = 1;
8146           break;
8147         default:
8148           n_op_args = 0;
8149           break;
8150         }
8151
8152       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
8153                            opc, n_op_args);
8154     }
8155
8156   /* Write out the information about the files we use.  */
8157   output_file_names ();
8158   ASM_OUTPUT_LABEL (asm_out_file, p2);
8159
8160   /* We used to set the address register to the first location in the text
8161      section here, but that didn't accomplish anything since we already
8162      have a line note for the opening brace of the first function.  */
8163
8164   /* Generate the line number to PC correspondence table, encoded as
8165      a series of state machine operations.  */
8166   current_file = 1;
8167   current_line = 1;
8168
8169   if (cfun && in_cold_section_p)
8170     strcpy (prev_line_label, cfun->cold_section_label);
8171   else
8172     strcpy (prev_line_label, text_section_label);
8173   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
8174     {
8175       dw_line_info_ref line_info = &line_info_table[lt_index];
8176
8177 #if 0
8178       /* Disable this optimization for now; GDB wants to see two line notes
8179          at the beginning of a function so it can find the end of the
8180          prologue.  */
8181
8182       /* Don't emit anything for redundant notes.  Just updating the
8183          address doesn't accomplish anything, because we already assume
8184          that anything after the last address is this line.  */
8185       if (line_info->dw_line_num == current_line
8186           && line_info->dw_file_num == current_file)
8187         continue;
8188 #endif
8189
8190       /* Emit debug info for the address of the current line.
8191
8192          Unfortunately, we have little choice here currently, and must always
8193          use the most general form.  GCC does not know the address delta
8194          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
8195          attributes which will give an upper bound on the address range.  We
8196          could perhaps use length attributes to determine when it is safe to
8197          use DW_LNS_fixed_advance_pc.  */
8198
8199       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
8200       if (0)
8201         {
8202           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
8203           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8204                                "DW_LNS_fixed_advance_pc");
8205           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8206         }
8207       else
8208         {
8209           /* This can handle any delta.  This takes
8210              4+DWARF2_ADDR_SIZE bytes.  */
8211           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8212           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8213           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8214           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8215         }
8216
8217       strcpy (prev_line_label, line_label);
8218
8219       /* Emit debug info for the source file of the current line, if
8220          different from the previous line.  */
8221       if (line_info->dw_file_num != current_file)
8222         {
8223           current_file = line_info->dw_file_num;
8224           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8225           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8226         }
8227
8228       /* Emit debug info for the current line number, choosing the encoding
8229          that uses the least amount of space.  */
8230       if (line_info->dw_line_num != current_line)
8231         {
8232           line_offset = line_info->dw_line_num - current_line;
8233           line_delta = line_offset - DWARF_LINE_BASE;
8234           current_line = line_info->dw_line_num;
8235           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8236             /* This can handle deltas from -10 to 234, using the current
8237                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
8238                takes 1 byte.  */
8239             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8240                                  "line %lu", current_line);
8241           else
8242             {
8243               /* This can handle any delta.  This takes at least 4 bytes,
8244                  depending on the value being encoded.  */
8245               dw2_asm_output_data (1, DW_LNS_advance_line,
8246                                    "advance to line %lu", current_line);
8247               dw2_asm_output_data_sleb128 (line_offset, NULL);
8248               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8249             }
8250         }
8251       else
8252         /* We still need to start a new row, so output a copy insn.  */
8253         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8254     }
8255
8256   /* Emit debug info for the address of the end of the function.  */
8257   if (0)
8258     {
8259       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8260                            "DW_LNS_fixed_advance_pc");
8261       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8262     }
8263   else
8264     {
8265       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8266       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8267       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8268       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8269     }
8270
8271   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8272   dw2_asm_output_data_uleb128 (1, NULL);
8273   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8274
8275   function = 0;
8276   current_file = 1;
8277   current_line = 1;
8278   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8279     {
8280       dw_separate_line_info_ref line_info
8281         = &separate_line_info_table[lt_index];
8282
8283 #if 0
8284       /* Don't emit anything for redundant notes.  */
8285       if (line_info->dw_line_num == current_line
8286           && line_info->dw_file_num == current_file
8287           && line_info->function == function)
8288         goto cont;
8289 #endif
8290
8291       /* Emit debug info for the address of the current line.  If this is
8292          a new function, or the first line of a function, then we need
8293          to handle it differently.  */
8294       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8295                                    lt_index);
8296       if (function != line_info->function)
8297         {
8298           function = line_info->function;
8299
8300           /* Set the address register to the first line in the function.  */
8301           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8302           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8303           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8304           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8305         }
8306       else
8307         {
8308           /* ??? See the DW_LNS_advance_pc comment above.  */
8309           if (0)
8310             {
8311               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8312                                    "DW_LNS_fixed_advance_pc");
8313               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8314             }
8315           else
8316             {
8317               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8318               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8319               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8320               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8321             }
8322         }
8323
8324       strcpy (prev_line_label, line_label);
8325
8326       /* Emit debug info for the source file of the current line, if
8327          different from the previous line.  */
8328       if (line_info->dw_file_num != current_file)
8329         {
8330           current_file = line_info->dw_file_num;
8331           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8332           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8333         }
8334
8335       /* Emit debug info for the current line number, choosing the encoding
8336          that uses the least amount of space.  */
8337       if (line_info->dw_line_num != current_line)
8338         {
8339           line_offset = line_info->dw_line_num - current_line;
8340           line_delta = line_offset - DWARF_LINE_BASE;
8341           current_line = line_info->dw_line_num;
8342           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8343             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8344                                  "line %lu", current_line);
8345           else
8346             {
8347               dw2_asm_output_data (1, DW_LNS_advance_line,
8348                                    "advance to line %lu", current_line);
8349               dw2_asm_output_data_sleb128 (line_offset, NULL);
8350               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8351             }
8352         }
8353       else
8354         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8355
8356 #if 0
8357     cont:
8358 #endif
8359
8360       lt_index++;
8361
8362       /* If we're done with a function, end its sequence.  */
8363       if (lt_index == separate_line_info_table_in_use
8364           || separate_line_info_table[lt_index].function != function)
8365         {
8366           current_file = 1;
8367           current_line = 1;
8368
8369           /* Emit debug info for the address of the end of the function.  */
8370           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8371           if (0)
8372             {
8373               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8374                                    "DW_LNS_fixed_advance_pc");
8375               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8376             }
8377           else
8378             {
8379               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8380               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8381               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8382               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8383             }
8384
8385           /* Output the marker for the end of this sequence.  */
8386           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8387           dw2_asm_output_data_uleb128 (1, NULL);
8388           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8389         }
8390     }
8391
8392   /* Output the marker for the end of the line number info.  */
8393   ASM_OUTPUT_LABEL (asm_out_file, l2);
8394 }
8395 \f
8396 /* Given a pointer to a tree node for some base type, return a pointer to
8397    a DIE that describes the given type.
8398
8399    This routine must only be called for GCC type nodes that correspond to
8400    Dwarf base (fundamental) types.  */
8401
8402 static dw_die_ref
8403 base_type_die (tree type)
8404 {
8405   dw_die_ref base_type_result;
8406   enum dwarf_type encoding;
8407
8408   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8409     return 0;
8410
8411   switch (TREE_CODE (type))
8412     {
8413     case INTEGER_TYPE:
8414       if (TYPE_STRING_FLAG (type))
8415         {
8416           if (TYPE_UNSIGNED (type))
8417             encoding = DW_ATE_unsigned_char;
8418           else
8419             encoding = DW_ATE_signed_char;
8420         }
8421       else if (TYPE_UNSIGNED (type))
8422         encoding = DW_ATE_unsigned;
8423       else
8424         encoding = DW_ATE_signed;
8425       break;
8426
8427     case REAL_TYPE:
8428       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8429         encoding = DW_ATE_decimal_float;
8430       else
8431         encoding = DW_ATE_float;
8432       break;
8433
8434     case FIXED_POINT_TYPE:
8435       if (TYPE_UNSIGNED (type))
8436         encoding = DW_ATE_signed_fixed;
8437       else
8438         encoding = DW_ATE_unsigned_fixed;
8439       break;
8440
8441       /* Dwarf2 doesn't know anything about complex ints, so use
8442          a user defined type for it.  */
8443     case COMPLEX_TYPE:
8444       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8445         encoding = DW_ATE_complex_float;
8446       else
8447         encoding = DW_ATE_lo_user;
8448       break;
8449
8450     case BOOLEAN_TYPE:
8451       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8452       encoding = DW_ATE_boolean;
8453       break;
8454
8455     default:
8456       /* No other TREE_CODEs are Dwarf fundamental types.  */
8457       gcc_unreachable ();
8458     }
8459
8460   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8461
8462   /* This probably indicates a bug.  */
8463   if (! TYPE_NAME (type))
8464     add_name_attribute (base_type_result, "__unknown__");
8465
8466   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8467                    int_size_in_bytes (type));
8468   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8469
8470   return base_type_result;
8471 }
8472
8473 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8474    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8475
8476 static inline int
8477 is_base_type (tree type)
8478 {
8479   switch (TREE_CODE (type))
8480     {
8481     case ERROR_MARK:
8482     case VOID_TYPE:
8483     case INTEGER_TYPE:
8484     case REAL_TYPE:
8485     case FIXED_POINT_TYPE:
8486     case COMPLEX_TYPE:
8487     case BOOLEAN_TYPE:
8488       return 1;
8489
8490     case ARRAY_TYPE:
8491     case RECORD_TYPE:
8492     case UNION_TYPE:
8493     case QUAL_UNION_TYPE:
8494     case ENUMERAL_TYPE:
8495     case FUNCTION_TYPE:
8496     case METHOD_TYPE:
8497     case POINTER_TYPE:
8498     case REFERENCE_TYPE:
8499     case OFFSET_TYPE:
8500     case LANG_TYPE:
8501     case VECTOR_TYPE:
8502       return 0;
8503
8504     default:
8505       gcc_unreachable ();
8506     }
8507
8508   return 0;
8509 }
8510
8511 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8512    node, return the size in bits for the type if it is a constant, or else
8513    return the alignment for the type if the type's size is not constant, or
8514    else return BITS_PER_WORD if the type actually turns out to be an
8515    ERROR_MARK node.  */
8516
8517 static inline unsigned HOST_WIDE_INT
8518 simple_type_size_in_bits (const_tree type)
8519 {
8520   if (TREE_CODE (type) == ERROR_MARK)
8521     return BITS_PER_WORD;
8522   else if (TYPE_SIZE (type) == NULL_TREE)
8523     return 0;
8524   else if (host_integerp (TYPE_SIZE (type), 1))
8525     return tree_low_cst (TYPE_SIZE (type), 1);
8526   else
8527     return TYPE_ALIGN (type);
8528 }
8529
8530 /* Return true if the debug information for the given type should be
8531    emitted as a subrange type.  */
8532
8533 static inline bool
8534 is_subrange_type (const_tree type)
8535 {
8536   tree subtype = TREE_TYPE (type);
8537
8538   /* Subrange types are identified by the fact that they are integer
8539      types, and that they have a subtype which is either an integer type
8540      or an enumeral type.  */
8541
8542   if (TREE_CODE (type) != INTEGER_TYPE
8543       || subtype == NULL_TREE)
8544     return false;
8545
8546   if (TREE_CODE (subtype) != INTEGER_TYPE
8547       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8548     return false;
8549
8550   if (TREE_CODE (type) == TREE_CODE (subtype)
8551       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8552       && TYPE_MIN_VALUE (type) != NULL
8553       && TYPE_MIN_VALUE (subtype) != NULL
8554       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8555       && TYPE_MAX_VALUE (type) != NULL
8556       && TYPE_MAX_VALUE (subtype) != NULL
8557       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8558     {
8559       /* The type and its subtype have the same representation.  If in
8560          addition the two types also have the same name, then the given
8561          type is not a subrange type, but rather a plain base type.  */
8562       /* FIXME: brobecker/2004-03-22:
8563          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8564          therefore be sufficient to check the TYPE_SIZE node pointers
8565          rather than checking the actual size.  Unfortunately, we have
8566          found some cases, such as in the Ada "integer" type, where
8567          this is not the case.  Until this problem is solved, we need to
8568          keep checking the actual size.  */
8569       tree type_name = TYPE_NAME (type);
8570       tree subtype_name = TYPE_NAME (subtype);
8571
8572       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8573         type_name = DECL_NAME (type_name);
8574
8575       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8576         subtype_name = DECL_NAME (subtype_name);
8577
8578       if (type_name == subtype_name)
8579         return false;
8580     }
8581
8582   return true;
8583 }
8584
8585 /*  Given a pointer to a tree node for a subrange type, return a pointer
8586     to a DIE that describes the given type.  */
8587
8588 static dw_die_ref
8589 subrange_type_die (tree type, dw_die_ref context_die)
8590 {
8591   dw_die_ref subrange_die;
8592   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8593
8594   if (context_die == NULL)
8595     context_die = comp_unit_die;
8596
8597   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8598
8599   if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8600     {
8601       /* The size of the subrange type and its base type do not match,
8602          so we need to generate a size attribute for the subrange type.  */
8603       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8604     }
8605
8606   if (TYPE_MIN_VALUE (type) != NULL)
8607     add_bound_info (subrange_die, DW_AT_lower_bound,
8608                     TYPE_MIN_VALUE (type));
8609   if (TYPE_MAX_VALUE (type) != NULL)
8610     add_bound_info (subrange_die, DW_AT_upper_bound,
8611                     TYPE_MAX_VALUE (type));
8612
8613   return subrange_die;
8614 }
8615
8616 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8617    entry that chains various modifiers in front of the given type.  */
8618
8619 static dw_die_ref
8620 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8621                    dw_die_ref context_die)
8622 {
8623   enum tree_code code = TREE_CODE (type);
8624   dw_die_ref mod_type_die;
8625   dw_die_ref sub_die = NULL;
8626   tree item_type = NULL;
8627   tree qualified_type;
8628   tree name;
8629
8630   if (code == ERROR_MARK)
8631     return NULL;
8632
8633   /* See if we already have the appropriately qualified variant of
8634      this type.  */
8635   qualified_type
8636     = get_qualified_type (type,
8637                           ((is_const_type ? TYPE_QUAL_CONST : 0)
8638                            | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8639
8640   /* If we do, then we can just use its DIE, if it exists.  */
8641   if (qualified_type)
8642     {
8643       mod_type_die = lookup_type_die (qualified_type);
8644       if (mod_type_die)
8645         return mod_type_die;
8646     }
8647
8648   name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8649
8650   /* Handle C typedef types.  */
8651   if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8652     {
8653       tree dtype = TREE_TYPE (name);
8654
8655       if (qualified_type == dtype)
8656         {
8657           /* For a named type, use the typedef.  */
8658           gen_type_die (qualified_type, context_die);
8659           return lookup_type_die (qualified_type);
8660         }
8661       else if (is_const_type < TYPE_READONLY (dtype)
8662                || is_volatile_type < TYPE_VOLATILE (dtype)
8663                || (is_const_type <= TYPE_READONLY (dtype)
8664                    && is_volatile_type <= TYPE_VOLATILE (dtype)
8665                    && DECL_ORIGINAL_TYPE (name) != type))
8666         /* cv-unqualified version of named type.  Just use the unnamed
8667            type to which it refers.  */
8668         return modified_type_die (DECL_ORIGINAL_TYPE (name),
8669                                   is_const_type, is_volatile_type,
8670                                   context_die);
8671       /* Else cv-qualified version of named type; fall through.  */
8672     }
8673
8674   if (is_const_type)
8675     {
8676       mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8677       sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8678     }
8679   else if (is_volatile_type)
8680     {
8681       mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8682       sub_die = modified_type_die (type, 0, 0, context_die);
8683     }
8684   else if (code == POINTER_TYPE)
8685     {
8686       mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8687       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8688                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8689       item_type = TREE_TYPE (type);
8690     }
8691   else if (code == REFERENCE_TYPE)
8692     {
8693       mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8694       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8695                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8696       item_type = TREE_TYPE (type);
8697     }
8698   else if (is_subrange_type (type))
8699     {
8700       mod_type_die = subrange_type_die (type, context_die);
8701       item_type = TREE_TYPE (type);
8702     }
8703   else if (is_base_type (type))
8704     mod_type_die = base_type_die (type);
8705   else
8706     {
8707       gen_type_die (type, context_die);
8708
8709       /* We have to get the type_main_variant here (and pass that to the
8710          `lookup_type_die' routine) because the ..._TYPE node we have
8711          might simply be a *copy* of some original type node (where the
8712          copy was created to help us keep track of typedef names) and
8713          that copy might have a different TYPE_UID from the original
8714          ..._TYPE node.  */
8715       if (TREE_CODE (type) != VECTOR_TYPE)
8716         return lookup_type_die (type_main_variant (type));
8717       else
8718         /* Vectors have the debugging information in the type,
8719            not the main variant.  */
8720         return lookup_type_die (type);
8721     }
8722
8723   /* Builtin types don't have a DECL_ORIGINAL_TYPE.  For those,
8724      don't output a DW_TAG_typedef, since there isn't one in the
8725      user's program; just attach a DW_AT_name to the type.  */
8726   if (name
8727       && (TREE_CODE (name) != TYPE_DECL
8728           || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
8729     {
8730       if (TREE_CODE (name) == TYPE_DECL)
8731         /* Could just call add_name_and_src_coords_attributes here,
8732            but since this is a builtin type it doesn't have any
8733            useful source coordinates anyway.  */
8734         name = DECL_NAME (name);
8735       add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8736     }
8737
8738   if (qualified_type)
8739     equate_type_number_to_die (qualified_type, mod_type_die);
8740
8741   if (item_type)
8742     /* We must do this after the equate_type_number_to_die call, in case
8743        this is a recursive type.  This ensures that the modified_type_die
8744        recursion will terminate even if the type is recursive.  Recursive
8745        types are possible in Ada.  */
8746     sub_die = modified_type_die (item_type,
8747                                  TYPE_READONLY (item_type),
8748                                  TYPE_VOLATILE (item_type),
8749                                  context_die);
8750
8751   if (sub_die != NULL)
8752     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8753
8754   return mod_type_die;
8755 }
8756
8757 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8758    an enumerated type.  */
8759
8760 static inline int
8761 type_is_enum (const_tree type)
8762 {
8763   return TREE_CODE (type) == ENUMERAL_TYPE;
8764 }
8765
8766 /* Return the DBX register number described by a given RTL node.  */
8767
8768 static unsigned int
8769 dbx_reg_number (const_rtx rtl)
8770 {
8771   unsigned regno = REGNO (rtl);
8772
8773   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8774
8775 #ifdef LEAF_REG_REMAP
8776   if (current_function_uses_only_leaf_regs)
8777     {
8778       int leaf_reg = LEAF_REG_REMAP (regno);
8779       if (leaf_reg != -1)
8780         regno = (unsigned) leaf_reg;
8781     }
8782 #endif
8783
8784   return DBX_REGISTER_NUMBER (regno);
8785 }
8786
8787 /* Optionally add a DW_OP_piece term to a location description expression.
8788    DW_OP_piece is only added if the location description expression already
8789    doesn't end with DW_OP_piece.  */
8790
8791 static void
8792 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8793 {
8794   dw_loc_descr_ref loc;
8795
8796   if (*list_head != NULL)
8797     {
8798       /* Find the end of the chain.  */
8799       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8800         ;
8801
8802       if (loc->dw_loc_opc != DW_OP_piece)
8803         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8804     }
8805 }
8806
8807 /* Return a location descriptor that designates a machine register or
8808    zero if there is none.  */
8809
8810 static dw_loc_descr_ref
8811 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
8812 {
8813   rtx regs;
8814
8815   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8816     return 0;
8817
8818   regs = targetm.dwarf_register_span (rtl);
8819
8820   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8821     return multiple_reg_loc_descriptor (rtl, regs, initialized);
8822   else
8823     return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
8824 }
8825
8826 /* Return a location descriptor that designates a machine register for
8827    a given hard register number.  */
8828
8829 static dw_loc_descr_ref
8830 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
8831 {
8832   dw_loc_descr_ref reg_loc_descr;
8833   if (regno <= 31)
8834     reg_loc_descr = new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8835   else
8836     reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
8837
8838   if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
8839     add_loc_descr (&reg_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
8840
8841   return reg_loc_descr;
8842 }
8843
8844 /* Given an RTL of a register, return a location descriptor that
8845    designates a value that spans more than one register.  */
8846
8847 static dw_loc_descr_ref
8848 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
8849                              enum var_init_status initialized)
8850 {
8851   int nregs, size, i;
8852   unsigned reg;
8853   dw_loc_descr_ref loc_result = NULL;
8854
8855   reg = REGNO (rtl);
8856 #ifdef LEAF_REG_REMAP
8857   if (current_function_uses_only_leaf_regs)
8858     {
8859       int leaf_reg = LEAF_REG_REMAP (reg);
8860       if (leaf_reg != -1)
8861         reg = (unsigned) leaf_reg;
8862     }
8863 #endif
8864   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8865   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8866
8867   /* Simple, contiguous registers.  */
8868   if (regs == NULL_RTX)
8869     {
8870       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8871
8872       loc_result = NULL;
8873       while (nregs--)
8874         {
8875           dw_loc_descr_ref t;
8876
8877           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
8878                                       VAR_INIT_STATUS_INITIALIZED);
8879           add_loc_descr (&loc_result, t);
8880           add_loc_descr_op_piece (&loc_result, size);
8881           ++reg;
8882         }
8883       return loc_result;
8884     }
8885
8886   /* Now onto stupid register sets in non contiguous locations.  */
8887
8888   gcc_assert (GET_CODE (regs) == PARALLEL);
8889
8890   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8891   loc_result = NULL;
8892
8893   for (i = 0; i < XVECLEN (regs, 0); ++i)
8894     {
8895       dw_loc_descr_ref t;
8896
8897       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
8898                                   VAR_INIT_STATUS_INITIALIZED);
8899       add_loc_descr (&loc_result, t);
8900       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8901       add_loc_descr_op_piece (&loc_result, size);
8902     }
8903
8904   if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
8905     add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
8906   return loc_result;
8907 }
8908
8909 /* Return a location descriptor that designates a constant.  */
8910
8911 static dw_loc_descr_ref
8912 int_loc_descriptor (HOST_WIDE_INT i)
8913 {
8914   enum dwarf_location_atom op;
8915
8916   /* Pick the smallest representation of a constant, rather than just
8917      defaulting to the LEB encoding.  */
8918   if (i >= 0)
8919     {
8920       if (i <= 31)
8921         op = DW_OP_lit0 + i;
8922       else if (i <= 0xff)
8923         op = DW_OP_const1u;
8924       else if (i <= 0xffff)
8925         op = DW_OP_const2u;
8926       else if (HOST_BITS_PER_WIDE_INT == 32
8927                || i <= 0xffffffff)
8928         op = DW_OP_const4u;
8929       else
8930         op = DW_OP_constu;
8931     }
8932   else
8933     {
8934       if (i >= -0x80)
8935         op = DW_OP_const1s;
8936       else if (i >= -0x8000)
8937         op = DW_OP_const2s;
8938       else if (HOST_BITS_PER_WIDE_INT == 32
8939                || i >= -0x80000000)
8940         op = DW_OP_const4s;
8941       else
8942         op = DW_OP_consts;
8943     }
8944
8945   return new_loc_descr (op, i, 0);
8946 }
8947
8948 /* Return a location descriptor that designates a base+offset location.  */
8949
8950 static dw_loc_descr_ref
8951 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
8952                  enum var_init_status initialized)
8953 {
8954   unsigned int regno;
8955   dw_loc_descr_ref result;
8956
8957   /* We only use "frame base" when we're sure we're talking about the
8958      post-prologue local stack frame.  We do this by *not* running
8959      register elimination until this point, and recognizing the special
8960      argument pointer and soft frame pointer rtx's.  */
8961   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8962     {
8963       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8964
8965       if (elim != reg)
8966         {
8967           if (GET_CODE (elim) == PLUS)
8968             {
8969               offset += INTVAL (XEXP (elim, 1));
8970               elim = XEXP (elim, 0);
8971             }
8972           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8973                       : stack_pointer_rtx));
8974           offset += frame_pointer_fb_offset;
8975
8976           return new_loc_descr (DW_OP_fbreg, offset, 0);
8977         }
8978     }
8979
8980   regno = dbx_reg_number (reg);
8981   if (regno <= 31)
8982     result = new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8983   else
8984     result = new_loc_descr (DW_OP_bregx, regno, offset);
8985
8986   if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
8987     add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
8988
8989   return result;
8990 }
8991
8992 /* Return true if this RTL expression describes a base+offset calculation.  */
8993
8994 static inline int
8995 is_based_loc (const_rtx rtl)
8996 {
8997   return (GET_CODE (rtl) == PLUS
8998           && ((REG_P (XEXP (rtl, 0))
8999                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
9000                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
9001 }
9002
9003 /* Return a descriptor that describes the concatenation of N locations
9004    used to form the address of a memory location.  */
9005
9006 static dw_loc_descr_ref
9007 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
9008                             enum var_init_status initialized)
9009 {
9010   unsigned int i;
9011   dw_loc_descr_ref cc_loc_result = NULL;
9012   unsigned int n = XVECLEN (concatn, 0);
9013
9014   for (i = 0; i < n; ++i)
9015     {
9016       dw_loc_descr_ref ref;
9017       rtx x = XVECEXP (concatn, 0, i);
9018
9019       ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
9020       if (ref == NULL)
9021         return NULL;
9022
9023       add_loc_descr (&cc_loc_result, ref);
9024       add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9025     }
9026
9027   if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9028     add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9029
9030   return cc_loc_result;
9031 }
9032
9033 /* The following routine converts the RTL for a variable or parameter
9034    (resident in memory) into an equivalent Dwarf representation of a
9035    mechanism for getting the address of that same variable onto the top of a
9036    hypothetical "address evaluation" stack.
9037
9038    When creating memory location descriptors, we are effectively transforming
9039    the RTL for a memory-resident object into its Dwarf postfix expression
9040    equivalent.  This routine recursively descends an RTL tree, turning
9041    it into Dwarf postfix code as it goes.
9042
9043    MODE is the mode of the memory reference, needed to handle some
9044    autoincrement addressing modes.
9045
9046    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9047    location list for RTL.
9048
9049    Return 0 if we can't represent the location.  */
9050
9051 static dw_loc_descr_ref
9052 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
9053                     enum var_init_status initialized)
9054 {
9055   dw_loc_descr_ref mem_loc_result = NULL;
9056   enum dwarf_location_atom op;
9057
9058   /* Note that for a dynamically sized array, the location we will generate a
9059      description of here will be the lowest numbered location which is
9060      actually within the array.  That's *not* necessarily the same as the
9061      zeroth element of the array.  */
9062
9063   rtl = targetm.delegitimize_address (rtl);
9064
9065   switch (GET_CODE (rtl))
9066     {
9067     case POST_INC:
9068     case POST_DEC:
9069     case POST_MODIFY:
9070       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
9071          just fall into the SUBREG code.  */
9072
9073       /* ... fall through ...  */
9074
9075     case SUBREG:
9076       /* The case of a subreg may arise when we have a local (register)
9077          variable or a formal (register) parameter which doesn't quite fill
9078          up an entire register.  For now, just assume that it is
9079          legitimate to make the Dwarf info refer to the whole register which
9080          contains the given subreg.  */
9081       rtl = XEXP (rtl, 0);
9082
9083       /* ... fall through ...  */
9084
9085     case REG:
9086       /* Whenever a register number forms a part of the description of the
9087          method for calculating the (dynamic) address of a memory resident
9088          object, DWARF rules require the register number be referred to as
9089          a "base register".  This distinction is not based in any way upon
9090          what category of register the hardware believes the given register
9091          belongs to.  This is strictly DWARF terminology we're dealing with
9092          here. Note that in cases where the location of a memory-resident
9093          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
9094          OP_CONST (0)) the actual DWARF location descriptor that we generate
9095          may just be OP_BASEREG (basereg).  This may look deceptively like
9096          the object in question was allocated to a register (rather than in
9097          memory) so DWARF consumers need to be aware of the subtle
9098          distinction between OP_REG and OP_BASEREG.  */
9099       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
9100         mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
9101       break;
9102
9103     case MEM:
9104       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
9105                                            VAR_INIT_STATUS_INITIALIZED);
9106       if (mem_loc_result != 0)
9107         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
9108       break;
9109
9110     case LO_SUM:
9111          rtl = XEXP (rtl, 1);
9112
9113       /* ... fall through ...  */
9114
9115     case LABEL_REF:
9116       /* Some ports can transform a symbol ref into a label ref, because
9117          the symbol ref is too far away and has to be dumped into a constant
9118          pool.  */
9119     case CONST:
9120     case SYMBOL_REF:
9121       /* Alternatively, the symbol in the constant pool might be referenced
9122          by a different symbol.  */
9123       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
9124         {
9125           bool marked;
9126           rtx tmp = get_pool_constant_mark (rtl, &marked);
9127
9128           if (GET_CODE (tmp) == SYMBOL_REF)
9129             {
9130               rtl = tmp;
9131               if (CONSTANT_POOL_ADDRESS_P (tmp))
9132                 get_pool_constant_mark (tmp, &marked);
9133               else
9134                 marked = true;
9135             }
9136
9137           /* If all references to this pool constant were optimized away,
9138              it was not output and thus we can't represent it.
9139              FIXME: might try to use DW_OP_const_value here, though
9140              DW_OP_piece complicates it.  */
9141           if (!marked)
9142             return 0;
9143         }
9144
9145       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
9146       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
9147       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
9148       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9149       break;
9150
9151     case PRE_MODIFY:
9152       /* Extract the PLUS expression nested inside and fall into
9153          PLUS code below.  */
9154       rtl = XEXP (rtl, 1);
9155       goto plus;
9156
9157     case PRE_INC:
9158     case PRE_DEC:
9159       /* Turn these into a PLUS expression and fall into the PLUS code
9160          below.  */
9161       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
9162                           GEN_INT (GET_CODE (rtl) == PRE_INC
9163                                    ? GET_MODE_UNIT_SIZE (mode)
9164                                    : -GET_MODE_UNIT_SIZE (mode)));
9165
9166       /* ... fall through ...  */
9167
9168     case PLUS:
9169     plus:
9170       if (is_based_loc (rtl))
9171         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
9172                                           INTVAL (XEXP (rtl, 1)),
9173                                           VAR_INIT_STATUS_INITIALIZED);
9174       else
9175         {
9176           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
9177                                                VAR_INIT_STATUS_INITIALIZED);
9178           if (mem_loc_result == 0)
9179             break;
9180
9181           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
9182               && INTVAL (XEXP (rtl, 1)) >= 0)
9183             add_loc_descr (&mem_loc_result,
9184                            new_loc_descr (DW_OP_plus_uconst,
9185                                           INTVAL (XEXP (rtl, 1)), 0));
9186           else
9187             {
9188               add_loc_descr (&mem_loc_result,
9189                              mem_loc_descriptor (XEXP (rtl, 1), mode,
9190                                                  VAR_INIT_STATUS_INITIALIZED));
9191               add_loc_descr (&mem_loc_result,
9192                              new_loc_descr (DW_OP_plus, 0, 0));
9193             }
9194         }
9195       break;
9196
9197     /* If a pseudo-reg is optimized away, it is possible for it to
9198        be replaced with a MEM containing a multiply or shift.  */
9199     case MULT:
9200       op = DW_OP_mul;
9201       goto do_binop;
9202
9203     case ASHIFT:
9204       op = DW_OP_shl;
9205       goto do_binop;
9206
9207     case ASHIFTRT:
9208       op = DW_OP_shra;
9209       goto do_binop;
9210
9211     case LSHIFTRT:
9212       op = DW_OP_shr;
9213       goto do_binop;
9214
9215     do_binop:
9216       {
9217         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
9218                                                    VAR_INIT_STATUS_INITIALIZED);
9219         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
9220                                                    VAR_INIT_STATUS_INITIALIZED);
9221
9222         if (op0 == 0 || op1 == 0)
9223           break;
9224
9225         mem_loc_result = op0;
9226         add_loc_descr (&mem_loc_result, op1);
9227         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
9228         break;
9229       }
9230
9231     case CONST_INT:
9232       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
9233       break;
9234
9235     case CONCATN:
9236       mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
9237                                                    VAR_INIT_STATUS_INITIALIZED);
9238       break;
9239
9240     default:
9241       gcc_unreachable ();
9242     }
9243
9244   if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9245     add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9246
9247   return mem_loc_result;
9248 }
9249
9250 /* Return a descriptor that describes the concatenation of two locations.
9251    This is typically a complex variable.  */
9252
9253 static dw_loc_descr_ref
9254 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
9255 {
9256   dw_loc_descr_ref cc_loc_result = NULL;
9257   dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
9258   dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
9259
9260   if (x0_ref == 0 || x1_ref == 0)
9261     return 0;
9262
9263   cc_loc_result = x0_ref;
9264   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
9265
9266   add_loc_descr (&cc_loc_result, x1_ref);
9267   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
9268
9269   if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9270     add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9271
9272   return cc_loc_result;
9273 }
9274
9275 /* Return a descriptor that describes the concatenation of N
9276    locations.  */
9277
9278 static dw_loc_descr_ref
9279 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
9280 {
9281   unsigned int i;
9282   dw_loc_descr_ref cc_loc_result = NULL;
9283   unsigned int n = XVECLEN (concatn, 0);
9284
9285   for (i = 0; i < n; ++i)
9286     {
9287       dw_loc_descr_ref ref;
9288       rtx x = XVECEXP (concatn, 0, i);
9289
9290       ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
9291       if (ref == NULL)
9292         return NULL;
9293
9294       add_loc_descr (&cc_loc_result, ref);
9295       add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9296     }
9297
9298   if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9299     add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9300
9301   return cc_loc_result;
9302 }
9303
9304 /* Output a proper Dwarf location descriptor for a variable or parameter
9305    which is either allocated in a register or in a memory location.  For a
9306    register, we just generate an OP_REG and the register number.  For a
9307    memory location we provide a Dwarf postfix expression describing how to
9308    generate the (dynamic) address of the object onto the address stack.
9309
9310    If we don't know how to describe it, return 0.  */
9311
9312 static dw_loc_descr_ref
9313 loc_descriptor (rtx rtl, enum var_init_status initialized)
9314 {
9315   dw_loc_descr_ref loc_result = NULL;
9316
9317   switch (GET_CODE (rtl))
9318     {
9319     case SUBREG:
9320       /* The case of a subreg may arise when we have a local (register)
9321          variable or a formal (register) parameter which doesn't quite fill
9322          up an entire register.  For now, just assume that it is
9323          legitimate to make the Dwarf info refer to the whole register which
9324          contains the given subreg.  */
9325       rtl = SUBREG_REG (rtl);
9326
9327       /* ... fall through ...  */
9328
9329     case REG:
9330       loc_result = reg_loc_descriptor (rtl, initialized);
9331       break;
9332
9333     case MEM:
9334       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
9335                                        initialized);
9336       break;
9337
9338     case CONCAT:
9339       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
9340                                           initialized);
9341       break;
9342
9343     case CONCATN:
9344       loc_result = concatn_loc_descriptor (rtl, initialized);
9345       break;
9346
9347     case VAR_LOCATION:
9348       /* Single part.  */
9349       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9350         {
9351           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
9352           break;
9353         }
9354
9355       rtl = XEXP (rtl, 1);
9356       /* FALLTHRU */
9357
9358     case PARALLEL:
9359       {
9360         rtvec par_elems = XVEC (rtl, 0);
9361         int num_elem = GET_NUM_ELEM (par_elems);
9362         enum machine_mode mode;
9363         int i;
9364
9365         /* Create the first one, so we have something to add to.  */
9366         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
9367                                      initialized);
9368         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9369         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9370         for (i = 1; i < num_elem; i++)
9371           {
9372             dw_loc_descr_ref temp;
9373
9374             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
9375                                    initialized);
9376             add_loc_descr (&loc_result, temp);
9377             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9378             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9379           }
9380       }
9381       break;
9382
9383     default:
9384       gcc_unreachable ();
9385     }
9386
9387   return loc_result;
9388 }
9389
9390 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
9391    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
9392    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9393    top-level invocation, and we require the address of LOC; is 0 if we require
9394    the value of LOC.  */
9395
9396 static dw_loc_descr_ref
9397 loc_descriptor_from_tree_1 (tree loc, int want_address)
9398 {
9399   dw_loc_descr_ref ret, ret1;
9400   int have_address = 0;
9401   enum dwarf_location_atom op;
9402
9403   /* ??? Most of the time we do not take proper care for sign/zero
9404      extending the values properly.  Hopefully this won't be a real
9405      problem...  */
9406
9407   switch (TREE_CODE (loc))
9408     {
9409     case ERROR_MARK:
9410       return 0;
9411
9412     case PLACEHOLDER_EXPR:
9413       /* This case involves extracting fields from an object to determine the
9414          position of other fields.  We don't try to encode this here.  The
9415          only user of this is Ada, which encodes the needed information using
9416          the names of types.  */
9417       return 0;
9418
9419     case CALL_EXPR:
9420       return 0;
9421
9422     case PREINCREMENT_EXPR:
9423     case PREDECREMENT_EXPR:
9424     case POSTINCREMENT_EXPR:
9425     case POSTDECREMENT_EXPR:
9426       /* There are no opcodes for these operations.  */
9427       return 0;
9428
9429     case ADDR_EXPR:
9430       /* If we already want an address, there's nothing we can do.  */
9431       if (want_address)
9432         return 0;
9433
9434       /* Otherwise, process the argument and look for the address.  */
9435       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9436
9437     case VAR_DECL:
9438       if (DECL_THREAD_LOCAL_P (loc))
9439         {
9440           rtx rtl;
9441
9442           /* If this is not defined, we have no way to emit the data.  */
9443           if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
9444             return 0;
9445
9446           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9447              look up addresses of objects in the current module.  */
9448           if (DECL_EXTERNAL (loc))
9449             return 0;
9450
9451           rtl = rtl_for_decl_location (loc);
9452           if (rtl == NULL_RTX)
9453             return 0;
9454
9455           if (!MEM_P (rtl))
9456             return 0;
9457           rtl = XEXP (rtl, 0);
9458           if (! CONSTANT_P (rtl))
9459             return 0;
9460
9461           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9462           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9463           ret->dw_loc_oprnd1.v.val_addr = rtl;
9464
9465           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9466           add_loc_descr (&ret, ret1);
9467
9468           have_address = 1;
9469           break;
9470         }
9471       /* FALLTHRU */
9472
9473     case PARM_DECL:
9474       if (DECL_HAS_VALUE_EXPR_P (loc))
9475         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9476                                            want_address);
9477       /* FALLTHRU */
9478
9479     case RESULT_DECL:
9480     case FUNCTION_DECL:
9481       {
9482         rtx rtl = rtl_for_decl_location (loc);
9483
9484         if (rtl == NULL_RTX)
9485           return 0;
9486         else if (GET_CODE (rtl) == CONST_INT)
9487           {
9488             HOST_WIDE_INT val = INTVAL (rtl);
9489             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9490               val &= GET_MODE_MASK (DECL_MODE (loc));
9491             ret = int_loc_descriptor (val);
9492           }
9493         else if (GET_CODE (rtl) == CONST_STRING)
9494           return 0;
9495         else if (CONSTANT_P (rtl))
9496           {
9497             ret = new_loc_descr (DW_OP_addr, 0, 0);
9498             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9499             ret->dw_loc_oprnd1.v.val_addr = rtl;
9500           }
9501         else
9502           {
9503             enum machine_mode mode;
9504
9505             /* Certain constructs can only be represented at top-level.  */
9506             if (want_address == 2)
9507               return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
9508
9509             mode = GET_MODE (rtl);
9510             if (MEM_P (rtl))
9511               {
9512                 rtl = XEXP (rtl, 0);
9513                 have_address = 1;
9514               }
9515             ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
9516           }
9517       }
9518       break;
9519
9520     case INDIRECT_REF:
9521       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9522       have_address = 1;
9523       break;
9524
9525     case COMPOUND_EXPR:
9526       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9527
9528     case NOP_EXPR:
9529     case CONVERT_EXPR:
9530     case NON_LVALUE_EXPR:
9531     case VIEW_CONVERT_EXPR:
9532     case SAVE_EXPR:
9533     case GIMPLE_MODIFY_STMT:
9534       return loc_descriptor_from_tree_1 (GENERIC_TREE_OPERAND (loc, 0),
9535                                          want_address);
9536
9537     case COMPONENT_REF:
9538     case BIT_FIELD_REF:
9539     case ARRAY_REF:
9540     case ARRAY_RANGE_REF:
9541       {
9542         tree obj, offset;
9543         HOST_WIDE_INT bitsize, bitpos, bytepos;
9544         enum machine_mode mode;
9545         int volatilep;
9546         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9547
9548         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9549                                    &unsignedp, &volatilep, false);
9550
9551         if (obj == loc)
9552           return 0;
9553
9554         ret = loc_descriptor_from_tree_1 (obj, 1);
9555         if (ret == 0
9556             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9557           return 0;
9558
9559         if (offset != NULL_TREE)
9560           {
9561             /* Variable offset.  */
9562             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9563             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9564           }
9565
9566         bytepos = bitpos / BITS_PER_UNIT;
9567         if (bytepos > 0)
9568           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9569         else if (bytepos < 0)
9570           {
9571             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9572             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9573           }
9574
9575         have_address = 1;
9576         break;
9577       }
9578
9579     case INTEGER_CST:
9580       if (host_integerp (loc, 0))
9581         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9582       else
9583         return 0;
9584       break;
9585
9586     case CONSTRUCTOR:
9587       {
9588         /* Get an RTL for this, if something has been emitted.  */
9589         rtx rtl = lookup_constant_def (loc);
9590         enum machine_mode mode;
9591
9592         if (!rtl || !MEM_P (rtl))
9593           return 0;
9594         mode = GET_MODE (rtl);
9595         rtl = XEXP (rtl, 0);
9596         ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
9597         have_address = 1;
9598         break;
9599       }
9600
9601     case TRUTH_AND_EXPR:
9602     case TRUTH_ANDIF_EXPR:
9603     case BIT_AND_EXPR:
9604       op = DW_OP_and;
9605       goto do_binop;
9606
9607     case TRUTH_XOR_EXPR:
9608     case BIT_XOR_EXPR:
9609       op = DW_OP_xor;
9610       goto do_binop;
9611
9612     case TRUTH_OR_EXPR:
9613     case TRUTH_ORIF_EXPR:
9614     case BIT_IOR_EXPR:
9615       op = DW_OP_or;
9616       goto do_binop;
9617
9618     case FLOOR_DIV_EXPR:
9619     case CEIL_DIV_EXPR:
9620     case ROUND_DIV_EXPR:
9621     case TRUNC_DIV_EXPR:
9622       op = DW_OP_div;
9623       goto do_binop;
9624
9625     case MINUS_EXPR:
9626       op = DW_OP_minus;
9627       goto do_binop;
9628
9629     case FLOOR_MOD_EXPR:
9630     case CEIL_MOD_EXPR:
9631     case ROUND_MOD_EXPR:
9632     case TRUNC_MOD_EXPR:
9633       op = DW_OP_mod;
9634       goto do_binop;
9635
9636     case MULT_EXPR:
9637       op = DW_OP_mul;
9638       goto do_binop;
9639
9640     case LSHIFT_EXPR:
9641       op = DW_OP_shl;
9642       goto do_binop;
9643
9644     case RSHIFT_EXPR:
9645       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9646       goto do_binop;
9647
9648     case POINTER_PLUS_EXPR:
9649     case PLUS_EXPR:
9650       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9651           && host_integerp (TREE_OPERAND (loc, 1), 0))
9652         {
9653           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9654           if (ret == 0)
9655             return 0;
9656
9657           add_loc_descr (&ret,
9658                          new_loc_descr (DW_OP_plus_uconst,
9659                                         tree_low_cst (TREE_OPERAND (loc, 1),
9660                                                       0),
9661                                         0));
9662           break;
9663         }
9664
9665       op = DW_OP_plus;
9666       goto do_binop;
9667
9668     case LE_EXPR:
9669       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9670         return 0;
9671
9672       op = DW_OP_le;
9673       goto do_binop;
9674
9675     case GE_EXPR:
9676       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9677         return 0;
9678
9679       op = DW_OP_ge;
9680       goto do_binop;
9681
9682     case LT_EXPR:
9683       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9684         return 0;
9685
9686       op = DW_OP_lt;
9687       goto do_binop;
9688
9689     case GT_EXPR:
9690       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9691         return 0;
9692
9693       op = DW_OP_gt;
9694       goto do_binop;
9695
9696     case EQ_EXPR:
9697       op = DW_OP_eq;
9698       goto do_binop;
9699
9700     case NE_EXPR:
9701       op = DW_OP_ne;
9702       goto do_binop;
9703
9704     do_binop:
9705       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9706       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9707       if (ret == 0 || ret1 == 0)
9708         return 0;
9709
9710       add_loc_descr (&ret, ret1);
9711       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9712       break;
9713
9714     case TRUTH_NOT_EXPR:
9715     case BIT_NOT_EXPR:
9716       op = DW_OP_not;
9717       goto do_unop;
9718
9719     case ABS_EXPR:
9720       op = DW_OP_abs;
9721       goto do_unop;
9722
9723     case NEGATE_EXPR:
9724       op = DW_OP_neg;
9725       goto do_unop;
9726
9727     do_unop:
9728       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9729       if (ret == 0)
9730         return 0;
9731
9732       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9733       break;
9734
9735     case MIN_EXPR:
9736     case MAX_EXPR:
9737       {
9738         const enum tree_code code =
9739           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9740
9741         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9742                       build2 (code, integer_type_node,
9743                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9744                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9745       }
9746
9747       /* ... fall through ...  */
9748
9749     case COND_EXPR:
9750       {
9751         dw_loc_descr_ref lhs
9752           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9753         dw_loc_descr_ref rhs
9754           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9755         dw_loc_descr_ref bra_node, jump_node, tmp;
9756
9757         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9758         if (ret == 0 || lhs == 0 || rhs == 0)
9759           return 0;
9760
9761         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9762         add_loc_descr (&ret, bra_node);
9763
9764         add_loc_descr (&ret, rhs);
9765         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9766         add_loc_descr (&ret, jump_node);
9767
9768         add_loc_descr (&ret, lhs);
9769         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9770         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9771
9772         /* ??? Need a node to point the skip at.  Use a nop.  */
9773         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9774         add_loc_descr (&ret, tmp);
9775         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9776         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9777       }
9778       break;
9779
9780     case FIX_TRUNC_EXPR:
9781       return 0;
9782
9783     default:
9784       /* Leave front-end specific codes as simply unknown.  This comes
9785          up, for instance, with the C STMT_EXPR.  */
9786       if ((unsigned int) TREE_CODE (loc)
9787           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9788         return 0;
9789
9790 #ifdef ENABLE_CHECKING
9791       /* Otherwise this is a generic code; we should just lists all of
9792          these explicitly.  We forgot one.  */
9793       gcc_unreachable ();
9794 #else
9795       /* In a release build, we want to degrade gracefully: better to
9796          generate incomplete debugging information than to crash.  */
9797       return NULL;
9798 #endif
9799     }
9800
9801   /* Show if we can't fill the request for an address.  */
9802   if (want_address && !have_address)
9803     return 0;
9804
9805   /* If we've got an address and don't want one, dereference.  */
9806   if (!want_address && have_address && ret)
9807     {
9808       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9809
9810       if (size > DWARF2_ADDR_SIZE || size == -1)
9811         return 0;
9812       else if (size == DWARF2_ADDR_SIZE)
9813         op = DW_OP_deref;
9814       else
9815         op = DW_OP_deref_size;
9816
9817       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9818     }
9819
9820   return ret;
9821 }
9822
9823 static inline dw_loc_descr_ref
9824 loc_descriptor_from_tree (tree loc)
9825 {
9826   return loc_descriptor_from_tree_1 (loc, 2);
9827 }
9828
9829 /* Given a value, round it up to the lowest multiple of `boundary'
9830    which is not less than the value itself.  */
9831
9832 static inline HOST_WIDE_INT
9833 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9834 {
9835   return (((value + boundary - 1) / boundary) * boundary);
9836 }
9837
9838 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9839    pointer to the declared type for the relevant field variable, or return
9840    `integer_type_node' if the given node turns out to be an
9841    ERROR_MARK node.  */
9842
9843 static inline tree
9844 field_type (const_tree decl)
9845 {
9846   tree type;
9847
9848   if (TREE_CODE (decl) == ERROR_MARK)
9849     return integer_type_node;
9850
9851   type = DECL_BIT_FIELD_TYPE (decl);
9852   if (type == NULL_TREE)
9853     type = TREE_TYPE (decl);
9854
9855   return type;
9856 }
9857
9858 /* Given a pointer to a tree node, return the alignment in bits for
9859    it, or else return BITS_PER_WORD if the node actually turns out to
9860    be an ERROR_MARK node.  */
9861
9862 static inline unsigned
9863 simple_type_align_in_bits (const_tree type)
9864 {
9865   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9866 }
9867
9868 static inline unsigned
9869 simple_decl_align_in_bits (const_tree decl)
9870 {
9871   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9872 }
9873
9874 /* Return the result of rounding T up to ALIGN.  */
9875
9876 static inline HOST_WIDE_INT
9877 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
9878 {
9879   /* We must be careful if T is negative because HOST_WIDE_INT can be
9880      either "above" or "below" unsigned int as per the C promotion
9881      rules, depending on the host, thus making the signedness of the
9882      direct multiplication and division unpredictable.  */
9883   unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
9884
9885   u += align - 1;
9886   u /= align;
9887   u *= align;
9888
9889   return (HOST_WIDE_INT) u;
9890 }
9891
9892 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9893    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9894    or return 0 if we are unable to determine what that offset is, either
9895    because the argument turns out to be a pointer to an ERROR_MARK node, or
9896    because the offset is actually variable.  (We can't handle the latter case
9897    just yet).  */
9898
9899 static HOST_WIDE_INT
9900 field_byte_offset (const_tree decl)
9901 {
9902   HOST_WIDE_INT object_offset_in_bits;
9903   HOST_WIDE_INT bitpos_int;
9904
9905   if (TREE_CODE (decl) == ERROR_MARK)
9906     return 0;
9907
9908   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9909
9910   /* We cannot yet cope with fields whose positions are variable, so
9911      for now, when we see such things, we simply return 0.  Someday, we may
9912      be able to handle such cases, but it will be damn difficult.  */
9913   if (! host_integerp (bit_position (decl), 0))
9914     return 0;
9915
9916   bitpos_int = int_bit_position (decl);
9917
9918 #ifdef PCC_BITFIELD_TYPE_MATTERS
9919   if (PCC_BITFIELD_TYPE_MATTERS)
9920     {
9921       tree type;
9922       tree field_size_tree;
9923       HOST_WIDE_INT deepest_bitpos;
9924       unsigned HOST_WIDE_INT field_size_in_bits;
9925       unsigned int type_align_in_bits;
9926       unsigned int decl_align_in_bits;
9927       unsigned HOST_WIDE_INT type_size_in_bits;
9928
9929       type = field_type (decl);
9930       field_size_tree = DECL_SIZE (decl);
9931
9932       /* The size could be unspecified if there was an error, or for
9933          a flexible array member.  */
9934       if (! field_size_tree)
9935         field_size_tree = bitsize_zero_node;
9936
9937       /* If we don't know the size of the field, pretend it's a full word.  */
9938       if (host_integerp (field_size_tree, 1))
9939         field_size_in_bits = tree_low_cst (field_size_tree, 1);
9940       else
9941         field_size_in_bits = BITS_PER_WORD;
9942
9943       type_size_in_bits = simple_type_size_in_bits (type);
9944       type_align_in_bits = simple_type_align_in_bits (type);
9945       decl_align_in_bits = simple_decl_align_in_bits (decl);
9946
9947       /* The GCC front-end doesn't make any attempt to keep track of the
9948          starting bit offset (relative to the start of the containing
9949          structure type) of the hypothetical "containing object" for a
9950          bit-field.  Thus, when computing the byte offset value for the
9951          start of the "containing object" of a bit-field, we must deduce
9952          this information on our own. This can be rather tricky to do in
9953          some cases.  For example, handling the following structure type
9954          definition when compiling for an i386/i486 target (which only
9955          aligns long long's to 32-bit boundaries) can be very tricky:
9956
9957          struct S { int field1; long long field2:31; };
9958
9959          Fortunately, there is a simple rule-of-thumb which can be used
9960          in such cases.  When compiling for an i386/i486, GCC will
9961          allocate 8 bytes for the structure shown above.  It decides to
9962          do this based upon one simple rule for bit-field allocation.
9963          GCC allocates each "containing object" for each bit-field at
9964          the first (i.e. lowest addressed) legitimate alignment boundary
9965          (based upon the required minimum alignment for the declared
9966          type of the field) which it can possibly use, subject to the
9967          condition that there is still enough available space remaining
9968          in the containing object (when allocated at the selected point)
9969          to fully accommodate all of the bits of the bit-field itself.
9970
9971          This simple rule makes it obvious why GCC allocates 8 bytes for
9972          each object of the structure type shown above.  When looking
9973          for a place to allocate the "containing object" for `field2',
9974          the compiler simply tries to allocate a 64-bit "containing
9975          object" at each successive 32-bit boundary (starting at zero)
9976          until it finds a place to allocate that 64- bit field such that
9977          at least 31 contiguous (and previously unallocated) bits remain
9978          within that selected 64 bit field.  (As it turns out, for the
9979          example above, the compiler finds it is OK to allocate the
9980          "containing object" 64-bit field at bit-offset zero within the
9981          structure type.)
9982
9983          Here we attempt to work backwards from the limited set of facts
9984          we're given, and we try to deduce from those facts, where GCC
9985          must have believed that the containing object started (within
9986          the structure type). The value we deduce is then used (by the
9987          callers of this routine) to generate DW_AT_location and
9988          DW_AT_bit_offset attributes for fields (both bit-fields and, in
9989          the case of DW_AT_location, regular fields as well).  */
9990
9991       /* Figure out the bit-distance from the start of the structure to
9992          the "deepest" bit of the bit-field.  */
9993       deepest_bitpos = bitpos_int + field_size_in_bits;
9994
9995       /* This is the tricky part.  Use some fancy footwork to deduce
9996          where the lowest addressed bit of the containing object must
9997          be.  */
9998       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9999
10000       /* Round up to type_align by default.  This works best for
10001          bitfields.  */
10002       object_offset_in_bits
10003         = round_up_to_align (object_offset_in_bits, type_align_in_bits);
10004
10005       if (object_offset_in_bits > bitpos_int)
10006         {
10007           object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10008
10009           /* Round up to decl_align instead.  */
10010           object_offset_in_bits
10011             = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
10012         }
10013     }
10014   else
10015 #endif
10016     object_offset_in_bits = bitpos_int;
10017
10018   return object_offset_in_bits / BITS_PER_UNIT;
10019 }
10020 \f
10021 /* The following routines define various Dwarf attributes and any data
10022    associated with them.  */
10023
10024 /* Add a location description attribute value to a DIE.
10025
10026    This emits location attributes suitable for whole variables and
10027    whole parameters.  Note that the location attributes for struct fields are
10028    generated by the routine `data_member_location_attribute' below.  */
10029
10030 static inline void
10031 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
10032                              dw_loc_descr_ref descr)
10033 {
10034   if (descr != 0)
10035     add_AT_loc (die, attr_kind, descr);
10036 }
10037
10038 /* Attach the specialized form of location attribute used for data members of
10039    struct and union types.  In the special case of a FIELD_DECL node which
10040    represents a bit-field, the "offset" part of this special location
10041    descriptor must indicate the distance in bytes from the lowest-addressed
10042    byte of the containing struct or union type to the lowest-addressed byte of
10043    the "containing object" for the bit-field.  (See the `field_byte_offset'
10044    function above).
10045
10046    For any given bit-field, the "containing object" is a hypothetical object
10047    (of some integral or enum type) within which the given bit-field lives.  The
10048    type of this hypothetical "containing object" is always the same as the
10049    declared type of the individual bit-field itself (for GCC anyway... the
10050    DWARF spec doesn't actually mandate this).  Note that it is the size (in
10051    bytes) of the hypothetical "containing object" which will be given in the
10052    DW_AT_byte_size attribute for this bit-field.  (See the
10053    `byte_size_attribute' function below.)  It is also used when calculating the
10054    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
10055    function below.)  */
10056
10057 static void
10058 add_data_member_location_attribute (dw_die_ref die, tree decl)
10059 {
10060   HOST_WIDE_INT offset;
10061   dw_loc_descr_ref loc_descr = 0;
10062
10063   if (TREE_CODE (decl) == TREE_BINFO)
10064     {
10065       /* We're working on the TAG_inheritance for a base class.  */
10066       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
10067         {
10068           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
10069              aren't at a fixed offset from all (sub)objects of the same
10070              type.  We need to extract the appropriate offset from our
10071              vtable.  The following dwarf expression means
10072
10073                BaseAddr = ObAddr + *((*ObAddr) - Offset)
10074
10075              This is specific to the V3 ABI, of course.  */
10076
10077           dw_loc_descr_ref tmp;
10078
10079           /* Make a copy of the object address.  */
10080           tmp = new_loc_descr (DW_OP_dup, 0, 0);
10081           add_loc_descr (&loc_descr, tmp);
10082
10083           /* Extract the vtable address.  */
10084           tmp = new_loc_descr (DW_OP_deref, 0, 0);
10085           add_loc_descr (&loc_descr, tmp);
10086
10087           /* Calculate the address of the offset.  */
10088           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
10089           gcc_assert (offset < 0);
10090
10091           tmp = int_loc_descriptor (-offset);
10092           add_loc_descr (&loc_descr, tmp);
10093           tmp = new_loc_descr (DW_OP_minus, 0, 0);
10094           add_loc_descr (&loc_descr, tmp);
10095
10096           /* Extract the offset.  */
10097           tmp = new_loc_descr (DW_OP_deref, 0, 0);
10098           add_loc_descr (&loc_descr, tmp);
10099
10100           /* Add it to the object address.  */
10101           tmp = new_loc_descr (DW_OP_plus, 0, 0);
10102           add_loc_descr (&loc_descr, tmp);
10103         }
10104       else
10105         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
10106     }
10107   else
10108     offset = field_byte_offset (decl);
10109
10110   if (! loc_descr)
10111     {
10112       enum dwarf_location_atom op;
10113
10114       /* The DWARF2 standard says that we should assume that the structure
10115          address is already on the stack, so we can specify a structure field
10116          address by using DW_OP_plus_uconst.  */
10117
10118 #ifdef MIPS_DEBUGGING_INFO
10119       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
10120          operator correctly.  It works only if we leave the offset on the
10121          stack.  */
10122       op = DW_OP_constu;
10123 #else
10124       op = DW_OP_plus_uconst;
10125 #endif
10126
10127       loc_descr = new_loc_descr (op, offset, 0);
10128     }
10129
10130   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
10131 }
10132
10133 /* Writes integer values to dw_vec_const array.  */
10134
10135 static void
10136 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
10137 {
10138   while (size != 0)
10139     {
10140       *dest++ = val & 0xff;
10141       val >>= 8;
10142       --size;
10143     }
10144 }
10145
10146 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
10147
10148 static HOST_WIDE_INT
10149 extract_int (const unsigned char *src, unsigned int size)
10150 {
10151   HOST_WIDE_INT val = 0;
10152
10153   src += size;
10154   while (size != 0)
10155     {
10156       val <<= 8;
10157       val |= *--src & 0xff;
10158       --size;
10159     }
10160   return val;
10161 }
10162
10163 /* Writes floating point values to dw_vec_const array.  */
10164
10165 static void
10166 insert_float (const_rtx rtl, unsigned char *array)
10167 {
10168   REAL_VALUE_TYPE rv;
10169   long val[4];
10170   int i;
10171
10172   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
10173   real_to_target (val, &rv, GET_MODE (rtl));
10174
10175   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
10176   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
10177     {
10178       insert_int (val[i], 4, array);
10179       array += 4;
10180     }
10181 }
10182
10183 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
10184    does not have a "location" either in memory or in a register.  These
10185    things can arise in GNU C when a constant is passed as an actual parameter
10186    to an inlined function.  They can also arise in C++ where declared
10187    constants do not necessarily get memory "homes".  */
10188
10189 static void
10190 add_const_value_attribute (dw_die_ref die, rtx rtl)
10191 {
10192   switch (GET_CODE (rtl))
10193     {
10194     case CONST_INT:
10195       {
10196         HOST_WIDE_INT val = INTVAL (rtl);
10197
10198         if (val < 0)
10199           add_AT_int (die, DW_AT_const_value, val);
10200         else
10201           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
10202       }
10203       break;
10204
10205     case CONST_DOUBLE:
10206       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
10207          floating-point constant.  A CONST_DOUBLE is used whenever the
10208          constant requires more than one word in order to be adequately
10209          represented.  We output CONST_DOUBLEs as blocks.  */
10210       {
10211         enum machine_mode mode = GET_MODE (rtl);
10212
10213         if (SCALAR_FLOAT_MODE_P (mode))
10214           {
10215             unsigned int length = GET_MODE_SIZE (mode);
10216             unsigned char *array = ggc_alloc (length);
10217
10218             insert_float (rtl, array);
10219             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
10220           }
10221         else
10222           {
10223             /* ??? We really should be using HOST_WIDE_INT throughout.  */
10224             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
10225
10226             add_AT_long_long (die, DW_AT_const_value,
10227                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
10228           }
10229       }
10230       break;
10231
10232     case CONST_VECTOR:
10233       {
10234         enum machine_mode mode = GET_MODE (rtl);
10235         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
10236         unsigned int length = CONST_VECTOR_NUNITS (rtl);
10237         unsigned char *array = ggc_alloc (length * elt_size);
10238         unsigned int i;
10239         unsigned char *p;
10240
10241         switch (GET_MODE_CLASS (mode))
10242           {
10243           case MODE_VECTOR_INT:
10244             for (i = 0, p = array; i < length; i++, p += elt_size)
10245               {
10246                 rtx elt = CONST_VECTOR_ELT (rtl, i);
10247                 HOST_WIDE_INT lo, hi;
10248
10249                 switch (GET_CODE (elt))
10250                   {
10251                   case CONST_INT:
10252                     lo = INTVAL (elt);
10253                     hi = -(lo < 0);
10254                     break;
10255
10256                   case CONST_DOUBLE:
10257                     lo = CONST_DOUBLE_LOW (elt);
10258                     hi = CONST_DOUBLE_HIGH (elt);
10259                     break;
10260
10261                   default:
10262                     gcc_unreachable ();
10263                   }
10264
10265                 if (elt_size <= sizeof (HOST_WIDE_INT))
10266                   insert_int (lo, elt_size, p);
10267                 else
10268                   {
10269                     unsigned char *p0 = p;
10270                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
10271
10272                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
10273                     if (WORDS_BIG_ENDIAN)
10274                       {
10275                         p0 = p1;
10276                         p1 = p;
10277                       }
10278                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
10279                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
10280                   }
10281               }
10282             break;
10283
10284           case MODE_VECTOR_FLOAT:
10285             for (i = 0, p = array; i < length; i++, p += elt_size)
10286               {
10287                 rtx elt = CONST_VECTOR_ELT (rtl, i);
10288                 insert_float (elt, p);
10289               }
10290             break;
10291
10292           default:
10293             gcc_unreachable ();
10294           }
10295
10296         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
10297       }
10298       break;
10299
10300     case CONST_STRING:
10301       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
10302       break;
10303
10304     case SYMBOL_REF:
10305     case LABEL_REF:
10306     case CONST:
10307       add_AT_addr (die, DW_AT_const_value, rtl);
10308       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10309       break;
10310
10311     case PLUS:
10312       /* In cases where an inlined instance of an inline function is passed
10313          the address of an `auto' variable (which is local to the caller) we
10314          can get a situation where the DECL_RTL of the artificial local
10315          variable (for the inlining) which acts as a stand-in for the
10316          corresponding formal parameter (of the inline function) will look
10317          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
10318          exactly a compile-time constant expression, but it isn't the address
10319          of the (artificial) local variable either.  Rather, it represents the
10320          *value* which the artificial local variable always has during its
10321          lifetime.  We currently have no way to represent such quasi-constant
10322          values in Dwarf, so for now we just punt and generate nothing.  */
10323       break;
10324
10325     default:
10326       /* No other kinds of rtx should be possible here.  */
10327       gcc_unreachable ();
10328     }
10329
10330 }
10331
10332 /* Determine whether the evaluation of EXPR references any variables
10333    or functions which aren't otherwise used (and therefore may not be
10334    output).  */
10335 static tree
10336 reference_to_unused (tree * tp, int * walk_subtrees,
10337                      void * data ATTRIBUTE_UNUSED)
10338 {
10339   if (! EXPR_P (*tp) && ! GIMPLE_STMT_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10340     *walk_subtrees = 0;
10341
10342   if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10343       && ! TREE_ASM_WRITTEN (*tp))
10344     return *tp;
10345   else if (!flag_unit_at_a_time)
10346     return NULL_TREE;
10347   else if (!cgraph_global_info_ready
10348            && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
10349     gcc_unreachable ();
10350   else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
10351     {
10352       struct varpool_node *node = varpool_node (*tp);
10353       if (!node->needed)
10354         return *tp;
10355     }
10356   else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
10357            && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
10358     {
10359       struct cgraph_node *node = cgraph_node (*tp);
10360       if (!node->output)
10361         return *tp;
10362     }
10363
10364   return NULL_TREE;
10365 }
10366
10367 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10368    for use in a later add_const_value_attribute call.  */
10369
10370 static rtx
10371 rtl_for_decl_init (tree init, tree type)
10372 {
10373   rtx rtl = NULL_RTX;
10374
10375   /* If a variable is initialized with a string constant without embedded
10376      zeros, build CONST_STRING.  */
10377   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10378     {
10379       tree enttype = TREE_TYPE (type);
10380       tree domain = TYPE_DOMAIN (type);
10381       enum machine_mode mode = TYPE_MODE (enttype);
10382
10383       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10384           && domain
10385           && integer_zerop (TYPE_MIN_VALUE (domain))
10386           && compare_tree_int (TYPE_MAX_VALUE (domain),
10387                                TREE_STRING_LENGTH (init) - 1) == 0
10388           && ((size_t) TREE_STRING_LENGTH (init)
10389               == strlen (TREE_STRING_POINTER (init)) + 1))
10390         rtl = gen_rtx_CONST_STRING (VOIDmode,
10391                                     ggc_strdup (TREE_STRING_POINTER (init)));
10392     }
10393   /* Other aggregates, and complex values, could be represented using
10394      CONCAT: FIXME!  */
10395   else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10396     ;
10397   /* Vectors only work if their mode is supported by the target.
10398      FIXME: generic vectors ought to work too.  */
10399   else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10400     ;
10401   /* If the initializer is something that we know will expand into an
10402      immediate RTL constant, expand it now.  We must be careful not to
10403      reference variables which won't be output.  */
10404   else if (initializer_constant_valid_p (init, type)
10405            && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10406     {
10407       /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
10408          possible.  */
10409       if (TREE_CODE (type) == VECTOR_TYPE)
10410         switch (TREE_CODE (init))
10411           {
10412           case VECTOR_CST:
10413             break;
10414           case CONSTRUCTOR:
10415             if (TREE_CONSTANT (init))
10416               {
10417                 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
10418                 bool constant_p = true;
10419                 tree value;
10420                 unsigned HOST_WIDE_INT ix;
10421
10422                 /* Even when ctor is constant, it might contain non-*_CST
10423                    elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
10424                    belong into VECTOR_CST nodes.  */
10425                 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
10426                   if (!CONSTANT_CLASS_P (value))
10427                     {
10428                       constant_p = false;
10429                       break;
10430                     }
10431
10432                 if (constant_p)
10433                   {
10434                     init = build_vector_from_ctor (type, elts);
10435                     break;
10436                   }
10437               }
10438             /* FALLTHRU */
10439
10440           default:
10441             return NULL;
10442           }
10443
10444       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10445
10446       /* If expand_expr returns a MEM, it wasn't immediate.  */
10447       gcc_assert (!rtl || !MEM_P (rtl));
10448     }
10449
10450   return rtl;
10451 }
10452
10453 /* Generate RTL for the variable DECL to represent its location.  */
10454
10455 static rtx
10456 rtl_for_decl_location (tree decl)
10457 {
10458   rtx rtl;
10459
10460   /* Here we have to decide where we are going to say the parameter "lives"
10461      (as far as the debugger is concerned).  We only have a couple of
10462      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10463
10464      DECL_RTL normally indicates where the parameter lives during most of the
10465      activation of the function.  If optimization is enabled however, this
10466      could be either NULL or else a pseudo-reg.  Both of those cases indicate
10467      that the parameter doesn't really live anywhere (as far as the code
10468      generation parts of GCC are concerned) during most of the function's
10469      activation.  That will happen (for example) if the parameter is never
10470      referenced within the function.
10471
10472      We could just generate a location descriptor here for all non-NULL
10473      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10474      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10475      where DECL_RTL is NULL or is a pseudo-reg.
10476
10477      Note however that we can only get away with using DECL_INCOMING_RTL as
10478      a backup substitute for DECL_RTL in certain limited cases.  In cases
10479      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10480      we can be sure that the parameter was passed using the same type as it is
10481      declared to have within the function, and that its DECL_INCOMING_RTL
10482      points us to a place where a value of that type is passed.
10483
10484      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10485      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10486      because in these cases DECL_INCOMING_RTL points us to a value of some
10487      type which is *different* from the type of the parameter itself.  Thus,
10488      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10489      such cases, the debugger would end up (for example) trying to fetch a
10490      `float' from a place which actually contains the first part of a
10491      `double'.  That would lead to really incorrect and confusing
10492      output at debug-time.
10493
10494      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10495      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
10496      are a couple of exceptions however.  On little-endian machines we can
10497      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10498      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10499      an integral type that is smaller than TREE_TYPE (decl). These cases arise
10500      when (on a little-endian machine) a non-prototyped function has a
10501      parameter declared to be of type `short' or `char'.  In such cases,
10502      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10503      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10504      passed `int' value.  If the debugger then uses that address to fetch
10505      a `short' or a `char' (on a little-endian machine) the result will be
10506      the correct data, so we allow for such exceptional cases below.
10507
10508      Note that our goal here is to describe the place where the given formal
10509      parameter lives during most of the function's activation (i.e. between the
10510      end of the prologue and the start of the epilogue).  We'll do that as best
10511      as we can. Note however that if the given formal parameter is modified
10512      sometime during the execution of the function, then a stack backtrace (at
10513      debug-time) will show the function as having been called with the *new*
10514      value rather than the value which was originally passed in.  This happens
10515      rarely enough that it is not a major problem, but it *is* a problem, and
10516      I'd like to fix it.
10517
10518      A future version of dwarf2out.c may generate two additional attributes for
10519      any given DW_TAG_formal_parameter DIE which will describe the "passed
10520      type" and the "passed location" for the given formal parameter in addition
10521      to the attributes we now generate to indicate the "declared type" and the
10522      "active location" for each parameter.  This additional set of attributes
10523      could be used by debuggers for stack backtraces. Separately, note that
10524      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10525      This happens (for example) for inlined-instances of inline function formal
10526      parameters which are never referenced.  This really shouldn't be
10527      happening.  All PARM_DECL nodes should get valid non-NULL
10528      DECL_INCOMING_RTL values.  FIXME.  */
10529
10530   /* Use DECL_RTL as the "location" unless we find something better.  */
10531   rtl = DECL_RTL_IF_SET (decl);
10532
10533   /* When generating abstract instances, ignore everything except
10534      constants, symbols living in memory, and symbols living in
10535      fixed registers.  */
10536   if (! reload_completed)
10537     {
10538       if (rtl
10539           && (CONSTANT_P (rtl)
10540               || (MEM_P (rtl)
10541                   && CONSTANT_P (XEXP (rtl, 0)))
10542               || (REG_P (rtl)
10543                   && TREE_CODE (decl) == VAR_DECL
10544                   && TREE_STATIC (decl))))
10545         {
10546           rtl = targetm.delegitimize_address (rtl);
10547           return rtl;
10548         }
10549       rtl = NULL_RTX;
10550     }
10551   else if (TREE_CODE (decl) == PARM_DECL)
10552     {
10553       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10554         {
10555           tree declared_type = TREE_TYPE (decl);
10556           tree passed_type = DECL_ARG_TYPE (decl);
10557           enum machine_mode dmode = TYPE_MODE (declared_type);
10558           enum machine_mode pmode = TYPE_MODE (passed_type);
10559
10560           /* This decl represents a formal parameter which was optimized out.
10561              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10562              all cases where (rtl == NULL_RTX) just below.  */
10563           if (dmode == pmode)
10564             rtl = DECL_INCOMING_RTL (decl);
10565           else if (SCALAR_INT_MODE_P (dmode)
10566                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10567                    && DECL_INCOMING_RTL (decl))
10568             {
10569               rtx inc = DECL_INCOMING_RTL (decl);
10570               if (REG_P (inc))
10571                 rtl = inc;
10572               else if (MEM_P (inc))
10573                 {
10574                   if (BYTES_BIG_ENDIAN)
10575                     rtl = adjust_address_nv (inc, dmode,
10576                                              GET_MODE_SIZE (pmode)
10577                                              - GET_MODE_SIZE (dmode));
10578                   else
10579                     rtl = inc;
10580                 }
10581             }
10582         }
10583
10584       /* If the parm was passed in registers, but lives on the stack, then
10585          make a big endian correction if the mode of the type of the
10586          parameter is not the same as the mode of the rtl.  */
10587       /* ??? This is the same series of checks that are made in dbxout.c before
10588          we reach the big endian correction code there.  It isn't clear if all
10589          of these checks are necessary here, but keeping them all is the safe
10590          thing to do.  */
10591       else if (MEM_P (rtl)
10592                && XEXP (rtl, 0) != const0_rtx
10593                && ! CONSTANT_P (XEXP (rtl, 0))
10594                /* Not passed in memory.  */
10595                && !MEM_P (DECL_INCOMING_RTL (decl))
10596                /* Not passed by invisible reference.  */
10597                && (!REG_P (XEXP (rtl, 0))
10598                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10599                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10600 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10601                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10602 #endif
10603                      )
10604                /* Big endian correction check.  */
10605                && BYTES_BIG_ENDIAN
10606                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10607                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10608                    < UNITS_PER_WORD))
10609         {
10610           int offset = (UNITS_PER_WORD
10611                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10612
10613           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10614                              plus_constant (XEXP (rtl, 0), offset));
10615         }
10616     }
10617   else if (TREE_CODE (decl) == VAR_DECL
10618            && rtl
10619            && MEM_P (rtl)
10620            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10621            && BYTES_BIG_ENDIAN)
10622     {
10623       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10624       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10625
10626       /* If a variable is declared "register" yet is smaller than
10627          a register, then if we store the variable to memory, it
10628          looks like we're storing a register-sized value, when in
10629          fact we are not.  We need to adjust the offset of the
10630          storage location to reflect the actual value's bytes,
10631          else gdb will not be able to display it.  */
10632       if (rsize > dsize)
10633         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10634                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10635     }
10636
10637   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10638      and will have been substituted directly into all expressions that use it.
10639      C does not have such a concept, but C++ and other languages do.  */
10640   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10641     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10642
10643   if (rtl)
10644     rtl = targetm.delegitimize_address (rtl);
10645
10646   /* If we don't look past the constant pool, we risk emitting a
10647      reference to a constant pool entry that isn't referenced from
10648      code, and thus is not emitted.  */
10649   if (rtl)
10650     rtl = avoid_constant_pool_reference (rtl);
10651
10652   return rtl;
10653 }
10654
10655 /* We need to figure out what section we should use as the base for the
10656    address ranges where a given location is valid.
10657    1. If this particular DECL has a section associated with it, use that.
10658    2. If this function has a section associated with it, use that.
10659    3. Otherwise, use the text section.
10660    XXX: If you split a variable across multiple sections, we won't notice.  */
10661
10662 static const char *
10663 secname_for_decl (const_tree decl)
10664 {
10665   const char *secname;
10666
10667   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10668     {
10669       tree sectree = DECL_SECTION_NAME (decl);
10670       secname = TREE_STRING_POINTER (sectree);
10671     }
10672   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10673     {
10674       tree sectree = DECL_SECTION_NAME (current_function_decl);
10675       secname = TREE_STRING_POINTER (sectree);
10676     }
10677   else if (cfun && in_cold_section_p)
10678     secname = cfun->cold_section_label;
10679   else
10680     secname = text_section_label;
10681
10682   return secname;
10683 }
10684
10685 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10686    data attribute for a variable or a parameter.  We generate the
10687    DW_AT_const_value attribute only in those cases where the given variable
10688    or parameter does not have a true "location" either in memory or in a
10689    register.  This can happen (for example) when a constant is passed as an
10690    actual argument in a call to an inline function.  (It's possible that
10691    these things can crop up in other ways also.)  Note that one type of
10692    constant value which can be passed into an inlined function is a constant
10693    pointer.  This can happen for example if an actual argument in an inlined
10694    function call evaluates to a compile-time constant address.  */
10695
10696 static void
10697 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10698                                        enum dwarf_attribute attr)
10699 {
10700   rtx rtl;
10701   dw_loc_descr_ref descr;
10702   var_loc_list *loc_list;
10703   struct var_loc_node *node;
10704   if (TREE_CODE (decl) == ERROR_MARK)
10705     return;
10706
10707   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10708               || TREE_CODE (decl) == RESULT_DECL);
10709
10710   /* See if we possibly have multiple locations for this variable.  */
10711   loc_list = lookup_decl_loc (decl);
10712
10713   /* If it truly has multiple locations, the first and last node will
10714      differ.  */
10715   if (loc_list && loc_list->first != loc_list->last)
10716     {
10717       const char *endname, *secname;
10718       dw_loc_list_ref list;
10719       rtx varloc;
10720       enum var_init_status initialized;
10721
10722       /* Now that we know what section we are using for a base,
10723          actually construct the list of locations.
10724          The first location information is what is passed to the
10725          function that creates the location list, and the remaining
10726          locations just get added on to that list.
10727          Note that we only know the start address for a location
10728          (IE location changes), so to build the range, we use
10729          the range [current location start, next location start].
10730          This means we have to special case the last node, and generate
10731          a range of [last location start, end of function label].  */
10732
10733       node = loc_list->first;
10734       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10735       secname = secname_for_decl (decl);
10736
10737       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
10738         initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
10739       else
10740         initialized = VAR_INIT_STATUS_INITIALIZED;
10741
10742       list = new_loc_list (loc_descriptor (varloc, initialized),
10743                            node->label, node->next->label, secname, 1);
10744       node = node->next;
10745
10746       for (; node->next; node = node->next)
10747         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10748           {
10749             /* The variable has a location between NODE->LABEL and
10750                NODE->NEXT->LABEL.  */
10751             enum var_init_status initialized =
10752               NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
10753             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10754             add_loc_descr_to_loc_list (&list,
10755                                        loc_descriptor (varloc, initialized),
10756                                        node->label, node->next->label, secname);
10757           }
10758
10759       /* If the variable has a location at the last label
10760          it keeps its location until the end of function.  */
10761       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10762         {
10763           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10764           enum var_init_status initialized =
10765             NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
10766
10767           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10768           if (!current_function_decl)
10769             endname = text_end_label;
10770           else
10771             {
10772               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10773                                            current_function_funcdef_no);
10774               endname = ggc_strdup (label_id);
10775             }
10776           add_loc_descr_to_loc_list (&list,
10777                                      loc_descriptor (varloc, initialized),
10778                                      node->label, endname, secname);
10779         }
10780
10781       /* Finally, add the location list to the DIE, and we are done.  */
10782       add_AT_loc_list (die, attr, list);
10783       return;
10784     }
10785
10786   /* Try to get some constant RTL for this decl, and use that as the value of
10787      the location.  */
10788
10789   rtl = rtl_for_decl_location (decl);
10790   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10791     {
10792       add_const_value_attribute (die, rtl);
10793       return;
10794     }
10795
10796   /* If we have tried to generate the location otherwise, and it
10797      didn't work out (we wouldn't be here if we did), and we have a one entry
10798      location list, try generating a location from that.  */
10799   if (loc_list && loc_list->first)
10800     {
10801       enum var_init_status status;
10802       node = loc_list->first;
10803       status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
10804       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
10805       if (descr)
10806         {
10807           add_AT_location_description (die, attr, descr);
10808           return;
10809         }
10810     }
10811
10812   /* We couldn't get any rtl, so try directly generating the location
10813      description from the tree.  */
10814   descr = loc_descriptor_from_tree (decl);
10815   if (descr)
10816     {
10817       add_AT_location_description (die, attr, descr);
10818       return;
10819     }
10820   /* None of that worked, so it must not really have a location;
10821      try adding a constant value attribute from the DECL_INITIAL.  */
10822   tree_add_const_value_attribute (die, decl);
10823 }
10824
10825 /* If we don't have a copy of this variable in memory for some reason (such
10826    as a C++ member constant that doesn't have an out-of-line definition),
10827    we should tell the debugger about the constant value.  */
10828
10829 static void
10830 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10831 {
10832   tree init = DECL_INITIAL (decl);
10833   tree type = TREE_TYPE (decl);
10834   rtx rtl;
10835
10836   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10837     /* OK */;
10838   else
10839     return;
10840
10841   rtl = rtl_for_decl_init (init, type);
10842   if (rtl)
10843     add_const_value_attribute (var_die, rtl);
10844 }
10845
10846 /* Convert the CFI instructions for the current function into a
10847    location list.  This is used for DW_AT_frame_base when we targeting
10848    a dwarf2 consumer that does not support the dwarf3
10849    DW_OP_call_frame_cfa.  OFFSET is a constant to be added to all CFA
10850    expressions.  */
10851
10852 static dw_loc_list_ref
10853 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10854 {
10855   dw_fde_ref fde;
10856   dw_loc_list_ref list, *list_tail;
10857   dw_cfi_ref cfi;
10858   dw_cfa_location last_cfa, next_cfa;
10859   const char *start_label, *last_label, *section;
10860
10861   fde = &fde_table[fde_table_in_use - 1];
10862
10863   section = secname_for_decl (current_function_decl);
10864   list_tail = &list;
10865   list = NULL;
10866
10867   next_cfa.reg = INVALID_REGNUM;
10868   next_cfa.offset = 0;
10869   next_cfa.indirect = 0;
10870   next_cfa.base_offset = 0;
10871
10872   start_label = fde->dw_fde_begin;
10873
10874   /* ??? Bald assumption that the CIE opcode list does not contain
10875      advance opcodes.  */
10876   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10877     lookup_cfa_1 (cfi, &next_cfa);
10878
10879   last_cfa = next_cfa;
10880   last_label = start_label;
10881
10882   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10883     switch (cfi->dw_cfi_opc)
10884       {
10885       case DW_CFA_set_loc:
10886       case DW_CFA_advance_loc1:
10887       case DW_CFA_advance_loc2:
10888       case DW_CFA_advance_loc4:
10889         if (!cfa_equal_p (&last_cfa, &next_cfa))
10890           {
10891             *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10892                                        start_label, last_label, section,
10893                                        list == NULL);
10894
10895             list_tail = &(*list_tail)->dw_loc_next;
10896             last_cfa = next_cfa;
10897             start_label = last_label;
10898           }
10899         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10900         break;
10901
10902       case DW_CFA_advance_loc:
10903         /* The encoding is complex enough that we should never emit this.  */
10904       case DW_CFA_remember_state:
10905       case DW_CFA_restore_state:
10906         /* We don't handle these two in this function.  It would be possible
10907            if it were to be required.  */
10908         gcc_unreachable ();
10909
10910       default:
10911         lookup_cfa_1 (cfi, &next_cfa);
10912         break;
10913       }
10914
10915   if (!cfa_equal_p (&last_cfa, &next_cfa))
10916     {
10917       *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10918                                  start_label, last_label, section,
10919                                  list == NULL);
10920       list_tail = &(*list_tail)->dw_loc_next;
10921       start_label = last_label;
10922     }
10923   *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10924                              start_label, fde->dw_fde_end, section,
10925                              list == NULL);
10926
10927   return list;
10928 }
10929
10930 /* Compute a displacement from the "steady-state frame pointer" to the
10931    frame base (often the same as the CFA), and store it in
10932    frame_pointer_fb_offset.  OFFSET is added to the displacement
10933    before the latter is negated.  */
10934
10935 static void
10936 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10937 {
10938   rtx reg, elim;
10939
10940 #ifdef FRAME_POINTER_CFA_OFFSET
10941   reg = frame_pointer_rtx;
10942   offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10943 #else
10944   reg = arg_pointer_rtx;
10945   offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10946 #endif
10947
10948   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10949   if (GET_CODE (elim) == PLUS)
10950     {
10951       offset += INTVAL (XEXP (elim, 1));
10952       elim = XEXP (elim, 0);
10953     }
10954   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10955                        : stack_pointer_rtx));
10956
10957   frame_pointer_fb_offset = -offset;
10958 }
10959
10960 /* Generate a DW_AT_name attribute given some string value to be included as
10961    the value of the attribute.  */
10962
10963 static void
10964 add_name_attribute (dw_die_ref die, const char *name_string)
10965 {
10966   if (name_string != NULL && *name_string != 0)
10967     {
10968       if (demangle_name_func)
10969         name_string = (*demangle_name_func) (name_string);
10970
10971       add_AT_string (die, DW_AT_name, name_string);
10972     }
10973 }
10974
10975 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10976
10977 static void
10978 add_comp_dir_attribute (dw_die_ref die)
10979 {
10980   const char *wd = get_src_pwd ();
10981   if (wd != NULL)
10982     add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
10983 }
10984
10985 /* Given a tree node describing an array bound (either lower or upper) output
10986    a representation for that bound.  */
10987
10988 static void
10989 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10990 {
10991   switch (TREE_CODE (bound))
10992     {
10993     case ERROR_MARK:
10994       return;
10995
10996     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10997     case INTEGER_CST:
10998       if (! host_integerp (bound, 0)
10999           || (bound_attr == DW_AT_lower_bound
11000               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
11001                   || (is_fortran () && integer_onep (bound)))))
11002         /* Use the default.  */
11003         ;
11004       else
11005         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
11006       break;
11007
11008     case CONVERT_EXPR:
11009     case NOP_EXPR:
11010     case NON_LVALUE_EXPR:
11011     case VIEW_CONVERT_EXPR:
11012       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
11013       break;
11014
11015     case SAVE_EXPR:
11016       break;
11017
11018     case VAR_DECL:
11019     case PARM_DECL:
11020     case RESULT_DECL:
11021       {
11022         dw_die_ref decl_die = lookup_decl_die (bound);
11023
11024         /* ??? Can this happen, or should the variable have been bound
11025            first?  Probably it can, since I imagine that we try to create
11026            the types of parameters in the order in which they exist in
11027            the list, and won't have created a forward reference to a
11028            later parameter.  */
11029         if (decl_die != NULL)
11030           add_AT_die_ref (subrange_die, bound_attr, decl_die);
11031         break;
11032       }
11033
11034     default:
11035       {
11036         /* Otherwise try to create a stack operation procedure to
11037            evaluate the value of the array bound.  */
11038
11039         dw_die_ref ctx, decl_die;
11040         dw_loc_descr_ref loc;
11041
11042         loc = loc_descriptor_from_tree (bound);
11043         if (loc == NULL)
11044           break;
11045
11046         if (current_function_decl == 0)
11047           ctx = comp_unit_die;
11048         else
11049           ctx = lookup_decl_die (current_function_decl);
11050
11051         decl_die = new_die (DW_TAG_variable, ctx, bound);
11052         add_AT_flag (decl_die, DW_AT_artificial, 1);
11053         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
11054         add_AT_loc (decl_die, DW_AT_location, loc);
11055
11056         add_AT_die_ref (subrange_die, bound_attr, decl_die);
11057         break;
11058       }
11059     }
11060 }
11061
11062 /* Note that the block of subscript information for an array type also
11063    includes information about the element type of type given array type.  */
11064
11065 static void
11066 add_subscript_info (dw_die_ref type_die, tree type)
11067 {
11068 #ifndef MIPS_DEBUGGING_INFO
11069   unsigned dimension_number;
11070 #endif
11071   tree lower, upper;
11072   dw_die_ref subrange_die;
11073
11074   /* The GNU compilers represent multidimensional array types as sequences of
11075      one dimensional array types whose element types are themselves array
11076      types.  Here we squish that down, so that each multidimensional array
11077      type gets only one array_type DIE in the Dwarf debugging info. The draft
11078      Dwarf specification say that we are allowed to do this kind of
11079      compression in C (because there is no difference between an array or
11080      arrays and a multidimensional array in C) but for other source languages
11081      (e.g. Ada) we probably shouldn't do this.  */
11082
11083   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11084      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11085      We work around this by disabling this feature.  See also
11086      gen_array_type_die.  */
11087 #ifndef MIPS_DEBUGGING_INFO
11088   for (dimension_number = 0;
11089        TREE_CODE (type) == ARRAY_TYPE;
11090        type = TREE_TYPE (type), dimension_number++)
11091 #endif
11092     {
11093       tree domain = TYPE_DOMAIN (type);
11094
11095       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
11096          and (in GNU C only) variable bounds.  Handle all three forms
11097          here.  */
11098       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
11099       if (domain)
11100         {
11101           /* We have an array type with specified bounds.  */
11102           lower = TYPE_MIN_VALUE (domain);
11103           upper = TYPE_MAX_VALUE (domain);
11104
11105           /* Define the index type.  */
11106           if (TREE_TYPE (domain))
11107             {
11108               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
11109                  TREE_TYPE field.  We can't emit debug info for this
11110                  because it is an unnamed integral type.  */
11111               if (TREE_CODE (domain) == INTEGER_TYPE
11112                   && TYPE_NAME (domain) == NULL_TREE
11113                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
11114                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
11115                 ;
11116               else
11117                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
11118                                     type_die);
11119             }
11120
11121           /* ??? If upper is NULL, the array has unspecified length,
11122              but it does have a lower bound.  This happens with Fortran
11123                dimension arr(N:*)
11124              Since the debugger is definitely going to need to know N
11125              to produce useful results, go ahead and output the lower
11126              bound solo, and hope the debugger can cope.  */
11127
11128           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
11129           if (upper)
11130             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
11131         }
11132
11133       /* Otherwise we have an array type with an unspecified length.  The
11134          DWARF-2 spec does not say how to handle this; let's just leave out the
11135          bounds.  */
11136     }
11137 }
11138
11139 static void
11140 add_byte_size_attribute (dw_die_ref die, tree tree_node)
11141 {
11142   unsigned size;
11143
11144   switch (TREE_CODE (tree_node))
11145     {
11146     case ERROR_MARK:
11147       size = 0;
11148       break;
11149     case ENUMERAL_TYPE:
11150     case RECORD_TYPE:
11151     case UNION_TYPE:
11152     case QUAL_UNION_TYPE:
11153       size = int_size_in_bytes (tree_node);
11154       break;
11155     case FIELD_DECL:
11156       /* For a data member of a struct or union, the DW_AT_byte_size is
11157          generally given as the number of bytes normally allocated for an
11158          object of the *declared* type of the member itself.  This is true
11159          even for bit-fields.  */
11160       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
11161       break;
11162     default:
11163       gcc_unreachable ();
11164     }
11165
11166   /* Note that `size' might be -1 when we get to this point.  If it is, that
11167      indicates that the byte size of the entity in question is variable.  We
11168      have no good way of expressing this fact in Dwarf at the present time,
11169      so just let the -1 pass on through.  */
11170   add_AT_unsigned (die, DW_AT_byte_size, size);
11171 }
11172
11173 /* For a FIELD_DECL node which represents a bit-field, output an attribute
11174    which specifies the distance in bits from the highest order bit of the
11175    "containing object" for the bit-field to the highest order bit of the
11176    bit-field itself.
11177
11178    For any given bit-field, the "containing object" is a hypothetical object
11179    (of some integral or enum type) within which the given bit-field lives.  The
11180    type of this hypothetical "containing object" is always the same as the
11181    declared type of the individual bit-field itself.  The determination of the
11182    exact location of the "containing object" for a bit-field is rather
11183    complicated.  It's handled by the `field_byte_offset' function (above).
11184
11185    Note that it is the size (in bytes) of the hypothetical "containing object"
11186    which will be given in the DW_AT_byte_size attribute for this bit-field.
11187    (See `byte_size_attribute' above).  */
11188
11189 static inline void
11190 add_bit_offset_attribute (dw_die_ref die, tree decl)
11191 {
11192   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
11193   tree type = DECL_BIT_FIELD_TYPE (decl);
11194   HOST_WIDE_INT bitpos_int;
11195   HOST_WIDE_INT highest_order_object_bit_offset;
11196   HOST_WIDE_INT highest_order_field_bit_offset;
11197   HOST_WIDE_INT unsigned bit_offset;
11198
11199   /* Must be a field and a bit field.  */
11200   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
11201
11202   /* We can't yet handle bit-fields whose offsets are variable, so if we
11203      encounter such things, just return without generating any attribute
11204      whatsoever.  Likewise for variable or too large size.  */
11205   if (! host_integerp (bit_position (decl), 0)
11206       || ! host_integerp (DECL_SIZE (decl), 1))
11207     return;
11208
11209   bitpos_int = int_bit_position (decl);
11210
11211   /* Note that the bit offset is always the distance (in bits) from the
11212      highest-order bit of the "containing object" to the highest-order bit of
11213      the bit-field itself.  Since the "high-order end" of any object or field
11214      is different on big-endian and little-endian machines, the computation
11215      below must take account of these differences.  */
11216   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
11217   highest_order_field_bit_offset = bitpos_int;
11218
11219   if (! BYTES_BIG_ENDIAN)
11220     {
11221       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
11222       highest_order_object_bit_offset += simple_type_size_in_bits (type);
11223     }
11224
11225   bit_offset
11226     = (! BYTES_BIG_ENDIAN
11227        ? highest_order_object_bit_offset - highest_order_field_bit_offset
11228        : highest_order_field_bit_offset - highest_order_object_bit_offset);
11229
11230   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
11231 }
11232
11233 /* For a FIELD_DECL node which represents a bit field, output an attribute
11234    which specifies the length in bits of the given field.  */
11235
11236 static inline void
11237 add_bit_size_attribute (dw_die_ref die, tree decl)
11238 {
11239   /* Must be a field and a bit field.  */
11240   gcc_assert (TREE_CODE (decl) == FIELD_DECL
11241               && DECL_BIT_FIELD_TYPE (decl));
11242
11243   if (host_integerp (DECL_SIZE (decl), 1))
11244     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
11245 }
11246
11247 /* If the compiled language is ANSI C, then add a 'prototyped'
11248    attribute, if arg types are given for the parameters of a function.  */
11249
11250 static inline void
11251 add_prototyped_attribute (dw_die_ref die, tree func_type)
11252 {
11253   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
11254       && TYPE_ARG_TYPES (func_type) != NULL)
11255     add_AT_flag (die, DW_AT_prototyped, 1);
11256 }
11257
11258 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
11259    by looking in either the type declaration or object declaration
11260    equate table.  */
11261
11262 static inline void
11263 add_abstract_origin_attribute (dw_die_ref die, tree origin)
11264 {
11265   dw_die_ref origin_die = NULL;
11266
11267   if (TREE_CODE (origin) != FUNCTION_DECL)
11268     {
11269       /* We may have gotten separated from the block for the inlined
11270          function, if we're in an exception handler or some such; make
11271          sure that the abstract function has been written out.
11272
11273          Doing this for nested functions is wrong, however; functions are
11274          distinct units, and our context might not even be inline.  */
11275       tree fn = origin;
11276
11277       if (TYPE_P (fn))
11278         fn = TYPE_STUB_DECL (fn);
11279
11280       fn = decl_function_context (fn);
11281       if (fn)
11282         dwarf2out_abstract_function (fn);
11283     }
11284
11285   if (DECL_P (origin))
11286     origin_die = lookup_decl_die (origin);
11287   else if (TYPE_P (origin))
11288     origin_die = lookup_type_die (origin);
11289
11290   /* XXX: Functions that are never lowered don't always have correct block
11291      trees (in the case of java, they simply have no block tree, in some other
11292      languages).  For these functions, there is nothing we can really do to
11293      output correct debug info for inlined functions in all cases.  Rather
11294      than die, we'll just produce deficient debug info now, in that we will
11295      have variables without a proper abstract origin.  In the future, when all
11296      functions are lowered, we should re-add a gcc_assert (origin_die)
11297      here.  */
11298
11299   if (origin_die)
11300       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
11301 }
11302
11303 /* We do not currently support the pure_virtual attribute.  */
11304
11305 static inline void
11306 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
11307 {
11308   if (DECL_VINDEX (func_decl))
11309     {
11310       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11311
11312       if (host_integerp (DECL_VINDEX (func_decl), 0))
11313         add_AT_loc (die, DW_AT_vtable_elem_location,
11314                     new_loc_descr (DW_OP_constu,
11315                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
11316                                    0));
11317
11318       /* GNU extension: Record what type this method came from originally.  */
11319       if (debug_info_level > DINFO_LEVEL_TERSE)
11320         add_AT_die_ref (die, DW_AT_containing_type,
11321                         lookup_type_die (DECL_CONTEXT (func_decl)));
11322     }
11323 }
11324 \f
11325 /* Add source coordinate attributes for the given decl.  */
11326
11327 static void
11328 add_src_coords_attributes (dw_die_ref die, tree decl)
11329 {
11330   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11331
11332   add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
11333   add_AT_unsigned (die, DW_AT_decl_line, s.line);
11334 }
11335
11336 /* Add a DW_AT_name attribute and source coordinate attribute for the
11337    given decl, but only if it actually has a name.  */
11338
11339 static void
11340 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
11341 {
11342   tree decl_name;
11343
11344   decl_name = DECL_NAME (decl);
11345   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
11346     {
11347       add_name_attribute (die, dwarf2_name (decl, 0));
11348       if (! DECL_ARTIFICIAL (decl))
11349         add_src_coords_attributes (die, decl);
11350
11351       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
11352           && TREE_PUBLIC (decl)
11353           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
11354           && !DECL_ABSTRACT (decl)
11355           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
11356         add_AT_string (die, DW_AT_MIPS_linkage_name,
11357                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
11358     }
11359
11360 #ifdef VMS_DEBUGGING_INFO
11361   /* Get the function's name, as described by its RTL.  This may be different
11362      from the DECL_NAME name used in the source file.  */
11363   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
11364     {
11365       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
11366                    XEXP (DECL_RTL (decl), 0));
11367       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
11368     }
11369 #endif
11370 }
11371
11372 /* Push a new declaration scope.  */
11373
11374 static void
11375 push_decl_scope (tree scope)
11376 {
11377   VEC_safe_push (tree, gc, decl_scope_table, scope);
11378 }
11379
11380 /* Pop a declaration scope.  */
11381
11382 static inline void
11383 pop_decl_scope (void)
11384 {
11385   VEC_pop (tree, decl_scope_table);
11386 }
11387
11388 /* Return the DIE for the scope that immediately contains this type.
11389    Non-named types get global scope.  Named types nested in other
11390    types get their containing scope if it's open, or global scope
11391    otherwise.  All other types (i.e. function-local named types) get
11392    the current active scope.  */
11393
11394 static dw_die_ref
11395 scope_die_for (tree t, dw_die_ref context_die)
11396 {
11397   dw_die_ref scope_die = NULL;
11398   tree containing_scope;
11399   int i;
11400
11401   /* Non-types always go in the current scope.  */
11402   gcc_assert (TYPE_P (t));
11403
11404   containing_scope = TYPE_CONTEXT (t);
11405
11406   /* Use the containing namespace if it was passed in (for a declaration).  */
11407   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11408     {
11409       if (context_die == lookup_decl_die (containing_scope))
11410         /* OK */;
11411       else
11412         containing_scope = NULL_TREE;
11413     }
11414
11415   /* Ignore function type "scopes" from the C frontend.  They mean that
11416      a tagged type is local to a parmlist of a function declarator, but
11417      that isn't useful to DWARF.  */
11418   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11419     containing_scope = NULL_TREE;
11420
11421   if (containing_scope == NULL_TREE)
11422     scope_die = comp_unit_die;
11423   else if (TYPE_P (containing_scope))
11424     {
11425       /* For types, we can just look up the appropriate DIE.  But
11426          first we check to see if we're in the middle of emitting it
11427          so we know where the new DIE should go.  */
11428       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11429         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11430           break;
11431
11432       if (i < 0)
11433         {
11434           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11435                       || TREE_ASM_WRITTEN (containing_scope));
11436
11437           /* If none of the current dies are suitable, we get file scope.  */
11438           scope_die = comp_unit_die;
11439         }
11440       else
11441         scope_die = lookup_type_die (containing_scope);
11442     }
11443   else
11444     scope_die = context_die;
11445
11446   return scope_die;
11447 }
11448
11449 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
11450
11451 static inline int
11452 local_scope_p (dw_die_ref context_die)
11453 {
11454   for (; context_die; context_die = context_die->die_parent)
11455     if (context_die->die_tag == DW_TAG_inlined_subroutine
11456         || context_die->die_tag == DW_TAG_subprogram)
11457       return 1;
11458
11459   return 0;
11460 }
11461
11462 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11463    whether or not to treat a DIE in this context as a declaration.  */
11464
11465 static inline int
11466 class_or_namespace_scope_p (dw_die_ref context_die)
11467 {
11468   return (context_die
11469           && (context_die->die_tag == DW_TAG_structure_type
11470               || context_die->die_tag == DW_TAG_union_type
11471               || context_die->die_tag == DW_TAG_namespace));
11472 }
11473
11474 /* Many forms of DIEs require a "type description" attribute.  This
11475    routine locates the proper "type descriptor" die for the type given
11476    by 'type', and adds a DW_AT_type attribute below the given die.  */
11477
11478 static void
11479 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11480                     int decl_volatile, dw_die_ref context_die)
11481 {
11482   enum tree_code code  = TREE_CODE (type);
11483   dw_die_ref type_die  = NULL;
11484
11485   /* ??? If this type is an unnamed subrange type of an integral, floating-point
11486      or fixed-point type, use the inner type.  This is because we have no
11487      support for unnamed types in base_type_die.  This can happen if this is
11488      an Ada subrange type.  Correct solution is emit a subrange type die.  */
11489   if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
11490       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11491     type = TREE_TYPE (type), code = TREE_CODE (type);
11492
11493   if (code == ERROR_MARK
11494       /* Handle a special case.  For functions whose return type is void, we
11495          generate *no* type attribute.  (Note that no object may have type
11496          `void', so this only applies to function return types).  */
11497       || code == VOID_TYPE)
11498     return;
11499
11500   type_die = modified_type_die (type,
11501                                 decl_const || TYPE_READONLY (type),
11502                                 decl_volatile || TYPE_VOLATILE (type),
11503                                 context_die);
11504
11505   if (type_die != NULL)
11506     add_AT_die_ref (object_die, DW_AT_type, type_die);
11507 }
11508
11509 /* Given an object die, add the calling convention attribute for the
11510    function call type.  */
11511 static void
11512 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11513 {
11514   enum dwarf_calling_convention value = DW_CC_normal;
11515
11516   value = targetm.dwarf_calling_convention (type);
11517
11518   /* Only add the attribute if the backend requests it, and
11519      is not DW_CC_normal.  */
11520   if (value && (value != DW_CC_normal))
11521     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11522 }
11523
11524 /* Given a tree pointer to a struct, class, union, or enum type node, return
11525    a pointer to the (string) tag name for the given type, or zero if the type
11526    was declared without a tag.  */
11527
11528 static const char *
11529 type_tag (const_tree type)
11530 {
11531   const char *name = 0;
11532
11533   if (TYPE_NAME (type) != 0)
11534     {
11535       tree t = 0;
11536
11537       /* Find the IDENTIFIER_NODE for the type name.  */
11538       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11539         t = TYPE_NAME (type);
11540
11541       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11542          a TYPE_DECL node, regardless of whether or not a `typedef' was
11543          involved.  */
11544       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11545                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11546         {
11547           /* We want to be extra verbose.  Don't call dwarf_name if
11548              DECL_NAME isn't set.  The default hook for decl_printable_name
11549              doesn't like that, and in this context it's correct to return
11550              0, instead of "<anonymous>" or the like.  */
11551           if (DECL_NAME (TYPE_NAME (type)))
11552             name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
11553         }
11554
11555       /* Now get the name as a string, or invent one.  */
11556       if (!name && t != 0)
11557         name = IDENTIFIER_POINTER (t);
11558     }
11559
11560   return (name == 0 || *name == '\0') ? 0 : name;
11561 }
11562
11563 /* Return the type associated with a data member, make a special check
11564    for bit field types.  */
11565
11566 static inline tree
11567 member_declared_type (const_tree member)
11568 {
11569   return (DECL_BIT_FIELD_TYPE (member)
11570           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11571 }
11572
11573 /* Get the decl's label, as described by its RTL. This may be different
11574    from the DECL_NAME name used in the source file.  */
11575
11576 #if 0
11577 static const char *
11578 decl_start_label (tree decl)
11579 {
11580   rtx x;
11581   const char *fnname;
11582
11583   x = DECL_RTL (decl);
11584   gcc_assert (MEM_P (x));
11585
11586   x = XEXP (x, 0);
11587   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11588
11589   fnname = XSTR (x, 0);
11590   return fnname;
11591 }
11592 #endif
11593 \f
11594 /* These routines generate the internal representation of the DIE's for
11595    the compilation unit.  Debugging information is collected by walking
11596    the declaration trees passed in from dwarf2out_decl().  */
11597
11598 static void
11599 gen_array_type_die (tree type, dw_die_ref context_die)
11600 {
11601   dw_die_ref scope_die = scope_die_for (type, context_die);
11602   dw_die_ref array_die;
11603   tree element_type;
11604
11605   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11606      the inner array type comes before the outer array type.  Thus we must
11607      call gen_type_die before we call new_die.  See below also.  */
11608 #ifdef MIPS_DEBUGGING_INFO
11609   gen_type_die (TREE_TYPE (type), context_die);
11610 #endif
11611
11612   array_die = new_die (DW_TAG_array_type, scope_die, type);
11613   add_name_attribute (array_die, type_tag (type));
11614   equate_type_number_to_die (type, array_die);
11615
11616   if (TREE_CODE (type) == VECTOR_TYPE)
11617     {
11618       /* The frontend feeds us a representation for the vector as a struct
11619          containing an array.  Pull out the array type.  */
11620       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11621       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11622     }
11623
11624 #if 0
11625   /* We default the array ordering.  SDB will probably do
11626      the right things even if DW_AT_ordering is not present.  It's not even
11627      an issue until we start to get into multidimensional arrays anyway.  If
11628      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11629      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11630      and when we find out that we need to put these in, we will only do so
11631      for multidimensional arrays.  */
11632   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11633 #endif
11634
11635 #ifdef MIPS_DEBUGGING_INFO
11636   /* The SGI compilers handle arrays of unknown bound by setting
11637      AT_declaration and not emitting any subrange DIEs.  */
11638   if (! TYPE_DOMAIN (type))
11639     add_AT_flag (array_die, DW_AT_declaration, 1);
11640   else
11641 #endif
11642     add_subscript_info (array_die, type);
11643
11644   /* Add representation of the type of the elements of this array type.  */
11645   element_type = TREE_TYPE (type);
11646
11647   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11648      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11649      We work around this by disabling this feature.  See also
11650      add_subscript_info.  */
11651 #ifndef MIPS_DEBUGGING_INFO
11652   while (TREE_CODE (element_type) == ARRAY_TYPE)
11653     element_type = TREE_TYPE (element_type);
11654
11655   gen_type_die (element_type, context_die);
11656 #endif
11657
11658   add_type_attribute (array_die, element_type, 0, 0, context_die);
11659
11660   if (get_AT (array_die, DW_AT_name))
11661     add_pubtype (type, array_die);
11662 }
11663
11664 #if 0
11665 static void
11666 gen_entry_point_die (tree decl, dw_die_ref context_die)
11667 {
11668   tree origin = decl_ultimate_origin (decl);
11669   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11670
11671   if (origin != NULL)
11672     add_abstract_origin_attribute (decl_die, origin);
11673   else
11674     {
11675       add_name_and_src_coords_attributes (decl_die, decl);
11676       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11677                           0, 0, context_die);
11678     }
11679
11680   if (DECL_ABSTRACT (decl))
11681     equate_decl_number_to_die (decl, decl_die);
11682   else
11683     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11684 }
11685 #endif
11686
11687 /* Walk through the list of incomplete types again, trying once more to
11688    emit full debugging info for them.  */
11689
11690 static void
11691 retry_incomplete_types (void)
11692 {
11693   int i;
11694
11695   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11696     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11697 }
11698
11699 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11700
11701 static void
11702 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11703 {
11704   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11705
11706   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11707      be incomplete and such types are not marked.  */
11708   add_abstract_origin_attribute (type_die, type);
11709 }
11710
11711 /* Generate a DIE to represent an inlined instance of a structure type.  */
11712
11713 static void
11714 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11715 {
11716   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11717
11718   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11719      be incomplete and such types are not marked.  */
11720   add_abstract_origin_attribute (type_die, type);
11721 }
11722
11723 /* Generate a DIE to represent an inlined instance of a union type.  */
11724
11725 static void
11726 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11727 {
11728   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11729
11730   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11731      be incomplete and such types are not marked.  */
11732   add_abstract_origin_attribute (type_die, type);
11733 }
11734
11735 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11736    include all of the information about the enumeration values also. Each
11737    enumerated type name/value is listed as a child of the enumerated type
11738    DIE.  */
11739
11740 static dw_die_ref
11741 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11742 {
11743   dw_die_ref type_die = lookup_type_die (type);
11744
11745   if (type_die == NULL)
11746     {
11747       type_die = new_die (DW_TAG_enumeration_type,
11748                           scope_die_for (type, context_die), type);
11749       equate_type_number_to_die (type, type_die);
11750       add_name_attribute (type_die, type_tag (type));
11751     }
11752   else if (! TYPE_SIZE (type))
11753     return type_die;
11754   else
11755     remove_AT (type_die, DW_AT_declaration);
11756
11757   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11758      given enum type is incomplete, do not generate the DW_AT_byte_size
11759      attribute or the DW_AT_element_list attribute.  */
11760   if (TYPE_SIZE (type))
11761     {
11762       tree link;
11763
11764       TREE_ASM_WRITTEN (type) = 1;
11765       add_byte_size_attribute (type_die, type);
11766       if (TYPE_STUB_DECL (type) != NULL_TREE)
11767         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11768
11769       /* If the first reference to this type was as the return type of an
11770          inline function, then it may not have a parent.  Fix this now.  */
11771       if (type_die->die_parent == NULL)
11772         add_child_die (scope_die_for (type, context_die), type_die);
11773
11774       for (link = TYPE_VALUES (type);
11775            link != NULL; link = TREE_CHAIN (link))
11776         {
11777           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11778           tree value = TREE_VALUE (link);
11779
11780           add_name_attribute (enum_die,
11781                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11782
11783           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11784             /* DWARF2 does not provide a way of indicating whether or
11785                not enumeration constants are signed or unsigned.  GDB
11786                always assumes the values are signed, so we output all
11787                values as if they were signed.  That means that
11788                enumeration constants with very large unsigned values
11789                will appear to have negative values in the debugger.  */
11790             add_AT_int (enum_die, DW_AT_const_value,
11791                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11792         }
11793     }
11794   else
11795     add_AT_flag (type_die, DW_AT_declaration, 1);
11796
11797   if (get_AT (type_die, DW_AT_name))
11798     add_pubtype (type, type_die);
11799
11800   return type_die;
11801 }
11802
11803 /* Generate a DIE to represent either a real live formal parameter decl or to
11804    represent just the type of some formal parameter position in some function
11805    type.
11806
11807    Note that this routine is a bit unusual because its argument may be a
11808    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11809    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11810    node.  If it's the former then this function is being called to output a
11811    DIE to represent a formal parameter object (or some inlining thereof).  If
11812    it's the latter, then this function is only being called to output a
11813    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11814    argument type of some subprogram type.  */
11815
11816 static dw_die_ref
11817 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11818 {
11819   dw_die_ref parm_die
11820     = new_die (DW_TAG_formal_parameter, context_die, node);
11821   tree origin;
11822
11823   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11824     {
11825     case tcc_declaration:
11826       origin = decl_ultimate_origin (node);
11827       if (origin != NULL)
11828         add_abstract_origin_attribute (parm_die, origin);
11829       else
11830         {
11831           add_name_and_src_coords_attributes (parm_die, node);
11832           add_type_attribute (parm_die, TREE_TYPE (node),
11833                               TREE_READONLY (node),
11834                               TREE_THIS_VOLATILE (node),
11835                               context_die);
11836           if (DECL_ARTIFICIAL (node))
11837             add_AT_flag (parm_die, DW_AT_artificial, 1);
11838         }
11839
11840       equate_decl_number_to_die (node, parm_die);
11841       if (! DECL_ABSTRACT (node))
11842         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11843
11844       break;
11845
11846     case tcc_type:
11847       /* We were called with some kind of a ..._TYPE node.  */
11848       add_type_attribute (parm_die, node, 0, 0, context_die);
11849       break;
11850
11851     default:
11852       gcc_unreachable ();
11853     }
11854
11855   return parm_die;
11856 }
11857
11858 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11859    at the end of an (ANSI prototyped) formal parameters list.  */
11860
11861 static void
11862 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11863 {
11864   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11865 }
11866
11867 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11868    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11869    parameters as specified in some function type specification (except for
11870    those which appear as part of a function *definition*).  */
11871
11872 static void
11873 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11874 {
11875   tree link;
11876   tree formal_type = NULL;
11877   tree first_parm_type;
11878   tree arg;
11879
11880   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11881     {
11882       arg = DECL_ARGUMENTS (function_or_method_type);
11883       function_or_method_type = TREE_TYPE (function_or_method_type);
11884     }
11885   else
11886     arg = NULL_TREE;
11887
11888   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11889
11890   /* Make our first pass over the list of formal parameter types and output a
11891      DW_TAG_formal_parameter DIE for each one.  */
11892   for (link = first_parm_type; link; )
11893     {
11894       dw_die_ref parm_die;
11895
11896       formal_type = TREE_VALUE (link);
11897       if (formal_type == void_type_node)
11898         break;
11899
11900       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11901       parm_die = gen_formal_parameter_die (formal_type, context_die);
11902       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11903            && link == first_parm_type)
11904           || (arg && DECL_ARTIFICIAL (arg)))
11905         add_AT_flag (parm_die, DW_AT_artificial, 1);
11906
11907       link = TREE_CHAIN (link);
11908       if (arg)
11909         arg = TREE_CHAIN (arg);
11910     }
11911
11912   /* If this function type has an ellipsis, add a
11913      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11914   if (formal_type != void_type_node)
11915     gen_unspecified_parameters_die (function_or_method_type, context_die);
11916
11917   /* Make our second (and final) pass over the list of formal parameter types
11918      and output DIEs to represent those types (as necessary).  */
11919   for (link = TYPE_ARG_TYPES (function_or_method_type);
11920        link && TREE_VALUE (link);
11921        link = TREE_CHAIN (link))
11922     gen_type_die (TREE_VALUE (link), context_die);
11923 }
11924
11925 /* We want to generate the DIE for TYPE so that we can generate the
11926    die for MEMBER, which has been defined; we will need to refer back
11927    to the member declaration nested within TYPE.  If we're trying to
11928    generate minimal debug info for TYPE, processing TYPE won't do the
11929    trick; we need to attach the member declaration by hand.  */
11930
11931 static void
11932 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11933 {
11934   gen_type_die (type, context_die);
11935
11936   /* If we're trying to avoid duplicate debug info, we may not have
11937      emitted the member decl for this function.  Emit it now.  */
11938   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11939       && ! lookup_decl_die (member))
11940     {
11941       dw_die_ref type_die;
11942       gcc_assert (!decl_ultimate_origin (member));
11943
11944       push_decl_scope (type);
11945       type_die = lookup_type_die (type);
11946       if (TREE_CODE (member) == FUNCTION_DECL)
11947         gen_subprogram_die (member, type_die);
11948       else if (TREE_CODE (member) == FIELD_DECL)
11949         {
11950           /* Ignore the nameless fields that are used to skip bits but handle
11951              C++ anonymous unions and structs.  */
11952           if (DECL_NAME (member) != NULL_TREE
11953               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11954               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11955             {
11956               gen_type_die (member_declared_type (member), type_die);
11957               gen_field_die (member, type_die);
11958             }
11959         }
11960       else
11961         gen_variable_die (member, type_die);
11962
11963       pop_decl_scope ();
11964     }
11965 }
11966
11967 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11968    may later generate inlined and/or out-of-line instances of.  */
11969
11970 static void
11971 dwarf2out_abstract_function (tree decl)
11972 {
11973   dw_die_ref old_die;
11974   tree save_fn;
11975   tree context;
11976   int was_abstract = DECL_ABSTRACT (decl);
11977
11978   /* Make sure we have the actual abstract inline, not a clone.  */
11979   decl = DECL_ORIGIN (decl);
11980
11981   old_die = lookup_decl_die (decl);
11982   if (old_die && get_AT (old_die, DW_AT_inline))
11983     /* We've already generated the abstract instance.  */
11984     return;
11985
11986   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11987      we don't get confused by DECL_ABSTRACT.  */
11988   if (debug_info_level > DINFO_LEVEL_TERSE)
11989     {
11990       context = decl_class_context (decl);
11991       if (context)
11992         gen_type_die_for_member
11993           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11994     }
11995
11996   /* Pretend we've just finished compiling this function.  */
11997   save_fn = current_function_decl;
11998   current_function_decl = decl;
11999   push_cfun (DECL_STRUCT_FUNCTION (decl));
12000
12001   set_decl_abstract_flags (decl, 1);
12002   dwarf2out_decl (decl);
12003   if (! was_abstract)
12004     set_decl_abstract_flags (decl, 0);
12005
12006   current_function_decl = save_fn;
12007   pop_cfun ();
12008 }
12009
12010 /* Helper function of premark_used_types() which gets called through
12011    htab_traverse_resize().
12012
12013    Marks the DIE of a given type in *SLOT as perennial, so it never gets
12014    marked as unused by prune_unused_types.  */
12015 static int
12016 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
12017 {
12018   tree type;
12019   dw_die_ref die;
12020
12021   type = *slot;
12022   die = lookup_type_die (type);
12023   if (die != NULL)
12024     die->die_perennial_p = 1;
12025   return 1;
12026 }
12027
12028 /* Mark all members of used_types_hash as perennial.  */
12029 static void
12030 premark_used_types (void)
12031 {
12032   if (cfun && cfun->used_types_hash)
12033     htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
12034 }
12035
12036 /* Generate a DIE to represent a declared function (either file-scope or
12037    block-local).  */
12038
12039 static void
12040 gen_subprogram_die (tree decl, dw_die_ref context_die)
12041 {
12042   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
12043   tree origin = decl_ultimate_origin (decl);
12044   dw_die_ref subr_die;
12045   tree fn_arg_types;
12046   tree outer_scope;
12047   dw_die_ref old_die = lookup_decl_die (decl);
12048   int declaration = (current_function_decl != decl
12049                      || class_or_namespace_scope_p (context_die));
12050
12051   premark_used_types ();
12052
12053   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
12054      started to generate the abstract instance of an inline, decided to output
12055      its containing class, and proceeded to emit the declaration of the inline
12056      from the member list for the class.  If so, DECLARATION takes priority;
12057      we'll get back to the abstract instance when done with the class.  */
12058
12059   /* The class-scope declaration DIE must be the primary DIE.  */
12060   if (origin && declaration && class_or_namespace_scope_p (context_die))
12061     {
12062       origin = NULL;
12063       gcc_assert (!old_die);
12064     }
12065
12066   /* Now that the C++ front end lazily declares artificial member fns, we
12067      might need to retrofit the declaration into its class.  */
12068   if (!declaration && !origin && !old_die
12069       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
12070       && !class_or_namespace_scope_p (context_die)
12071       && debug_info_level > DINFO_LEVEL_TERSE)
12072     old_die = force_decl_die (decl);
12073
12074   if (origin != NULL)
12075     {
12076       gcc_assert (!declaration || local_scope_p (context_die));
12077
12078       /* Fixup die_parent for the abstract instance of a nested
12079          inline function.  */
12080       if (old_die && old_die->die_parent == NULL)
12081         add_child_die (context_die, old_die);
12082
12083       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
12084       add_abstract_origin_attribute (subr_die, origin);
12085     }
12086   else if (old_die)
12087     {
12088       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12089       struct dwarf_file_data * file_index = lookup_filename (s.file);
12090
12091       if (!get_AT_flag (old_die, DW_AT_declaration)
12092           /* We can have a normal definition following an inline one in the
12093              case of redefinition of GNU C extern inlines.
12094              It seems reasonable to use AT_specification in this case.  */
12095           && !get_AT (old_die, DW_AT_inline))
12096         {
12097           /* Detect and ignore this case, where we are trying to output
12098              something we have already output.  */
12099           return;
12100         }
12101
12102       /* If the definition comes from the same place as the declaration,
12103          maybe use the old DIE.  We always want the DIE for this function
12104          that has the *_pc attributes to be under comp_unit_die so the
12105          debugger can find it.  We also need to do this for abstract
12106          instances of inlines, since the spec requires the out-of-line copy
12107          to have the same parent.  For local class methods, this doesn't
12108          apply; we just use the old DIE.  */
12109       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
12110           && (DECL_ARTIFICIAL (decl)
12111               || (get_AT_file (old_die, DW_AT_decl_file) == file_index
12112                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
12113                       == (unsigned) s.line))))
12114         {
12115           subr_die = old_die;
12116
12117           /* Clear out the declaration attribute and the formal parameters.
12118              Do not remove all children, because it is possible that this
12119              declaration die was forced using force_decl_die(). In such
12120              cases die that forced declaration die (e.g. TAG_imported_module)
12121              is one of the children that we do not want to remove.  */
12122           remove_AT (subr_die, DW_AT_declaration);
12123           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
12124         }
12125       else
12126         {
12127           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
12128           add_AT_specification (subr_die, old_die);
12129           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12130             add_AT_file (subr_die, DW_AT_decl_file, file_index);
12131           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12132             add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
12133         }
12134     }
12135   else
12136     {
12137       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
12138
12139       if (TREE_PUBLIC (decl))
12140         add_AT_flag (subr_die, DW_AT_external, 1);
12141
12142       add_name_and_src_coords_attributes (subr_die, decl);
12143       if (debug_info_level > DINFO_LEVEL_TERSE)
12144         {
12145           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
12146           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
12147                               0, 0, context_die);
12148         }
12149
12150       add_pure_or_virtual_attribute (subr_die, decl);
12151       if (DECL_ARTIFICIAL (decl))
12152         add_AT_flag (subr_die, DW_AT_artificial, 1);
12153
12154       if (TREE_PROTECTED (decl))
12155         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
12156       else if (TREE_PRIVATE (decl))
12157         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
12158     }
12159
12160   if (declaration)
12161     {
12162       if (!old_die || !get_AT (old_die, DW_AT_inline))
12163         {
12164           add_AT_flag (subr_die, DW_AT_declaration, 1);
12165
12166           /* The first time we see a member function, it is in the context of
12167              the class to which it belongs.  We make sure of this by emitting
12168              the class first.  The next time is the definition, which is
12169              handled above.  The two may come from the same source text.
12170
12171              Note that force_decl_die() forces function declaration die. It is
12172              later reused to represent definition.  */
12173           equate_decl_number_to_die (decl, subr_die);
12174         }
12175     }
12176   else if (DECL_ABSTRACT (decl))
12177     {
12178       if (DECL_DECLARED_INLINE_P (decl))
12179         {
12180           if (cgraph_function_possibly_inlined_p (decl))
12181             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
12182           else
12183             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
12184         }
12185       else
12186         {
12187           if (cgraph_function_possibly_inlined_p (decl))
12188             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
12189           else
12190             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
12191         }
12192
12193       equate_decl_number_to_die (decl, subr_die);
12194     }
12195   else if (!DECL_EXTERNAL (decl))
12196     {
12197       HOST_WIDE_INT cfa_fb_offset;
12198
12199       if (!old_die || !get_AT (old_die, DW_AT_inline))
12200         equate_decl_number_to_die (decl, subr_die);
12201
12202       if (!flag_reorder_blocks_and_partition)
12203         {
12204           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
12205                                        current_function_funcdef_no);
12206           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
12207           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
12208                                        current_function_funcdef_no);
12209           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
12210
12211           add_pubname (decl, subr_die);
12212           add_arange (decl, subr_die);
12213         }
12214       else
12215         {  /* Do nothing for now; maybe need to duplicate die, one for
12216               hot section and ond for cold section, then use the hot/cold
12217               section begin/end labels to generate the aranges...  */
12218           /*
12219             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
12220             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
12221             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
12222             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
12223
12224             add_pubname (decl, subr_die);
12225             add_arange (decl, subr_die);
12226             add_arange (decl, subr_die);
12227            */
12228         }
12229
12230 #ifdef MIPS_DEBUGGING_INFO
12231       /* Add a reference to the FDE for this routine.  */
12232       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
12233 #endif
12234
12235       cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
12236
12237       /* We define the "frame base" as the function's CFA.  This is more
12238          convenient for several reasons: (1) It's stable across the prologue
12239          and epilogue, which makes it better than just a frame pointer,
12240          (2) With dwarf3, there exists a one-byte encoding that allows us
12241          to reference the .debug_frame data by proxy, but failing that,
12242          (3) We can at least reuse the code inspection and interpretation
12243          code that determines the CFA position at various points in the
12244          function.  */
12245       /* ??? Use some command-line or configury switch to enable the use
12246          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
12247          consumers that understand it; fall back to "pure" dwarf2 and
12248          convert the CFA data into a location list.  */
12249       {
12250         dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
12251         if (list->dw_loc_next)
12252           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
12253         else
12254           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
12255       }
12256
12257       /* Compute a displacement from the "steady-state frame pointer" to
12258          the CFA.  The former is what all stack slots and argument slots
12259          will reference in the rtl; the later is what we've told the
12260          debugger about.  We'll need to adjust all frame_base references
12261          by this displacement.  */
12262       compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
12263
12264       if (cfun->static_chain_decl)
12265         add_AT_location_description (subr_die, DW_AT_static_link,
12266                  loc_descriptor_from_tree (cfun->static_chain_decl));
12267     }
12268
12269   /* Now output descriptions of the arguments for this function. This gets
12270      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
12271      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
12272      `...' at the end of the formal parameter list.  In order to find out if
12273      there was a trailing ellipsis or not, we must instead look at the type
12274      associated with the FUNCTION_DECL.  This will be a node of type
12275      FUNCTION_TYPE. If the chain of type nodes hanging off of this
12276      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
12277      an ellipsis at the end.  */
12278
12279   /* In the case where we are describing a mere function declaration, all we
12280      need to do here (and all we *can* do here) is to describe the *types* of
12281      its formal parameters.  */
12282   if (debug_info_level <= DINFO_LEVEL_TERSE)
12283     ;
12284   else if (declaration)
12285     gen_formal_types_die (decl, subr_die);
12286   else
12287     {
12288       /* Generate DIEs to represent all known formal parameters.  */
12289       tree arg_decls = DECL_ARGUMENTS (decl);
12290       tree parm;
12291
12292       /* When generating DIEs, generate the unspecified_parameters DIE
12293          instead if we come across the arg "__builtin_va_alist" */
12294       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
12295         if (TREE_CODE (parm) == PARM_DECL)
12296           {
12297             if (DECL_NAME (parm)
12298                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
12299                             "__builtin_va_alist"))
12300               gen_unspecified_parameters_die (parm, subr_die);
12301             else
12302               gen_decl_die (parm, subr_die);
12303           }
12304
12305       /* Decide whether we need an unspecified_parameters DIE at the end.
12306          There are 2 more cases to do this for: 1) the ansi ... declaration -
12307          this is detectable when the end of the arg list is not a
12308          void_type_node 2) an unprototyped function declaration (not a
12309          definition).  This just means that we have no info about the
12310          parameters at all.  */
12311       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
12312       if (fn_arg_types != NULL)
12313         {
12314           /* This is the prototyped case, check for....  */
12315           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
12316             gen_unspecified_parameters_die (decl, subr_die);
12317         }
12318       else if (DECL_INITIAL (decl) == NULL_TREE)
12319         gen_unspecified_parameters_die (decl, subr_die);
12320     }
12321
12322   /* Output Dwarf info for all of the stuff within the body of the function
12323      (if it has one - it may be just a declaration).  */
12324   outer_scope = DECL_INITIAL (decl);
12325
12326   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
12327      a function.  This BLOCK actually represents the outermost binding contour
12328      for the function, i.e. the contour in which the function's formal
12329      parameters and labels get declared. Curiously, it appears that the front
12330      end doesn't actually put the PARM_DECL nodes for the current function onto
12331      the BLOCK_VARS list for this outer scope, but are strung off of the
12332      DECL_ARGUMENTS list for the function instead.
12333
12334      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
12335      the LABEL_DECL nodes for the function however, and we output DWARF info
12336      for those in decls_for_scope.  Just within the `outer_scope' there will be
12337      a BLOCK node representing the function's outermost pair of curly braces,
12338      and any blocks used for the base and member initializers of a C++
12339      constructor function.  */
12340   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
12341     {
12342       /* Emit a DW_TAG_variable DIE for a named return value.  */
12343       if (DECL_NAME (DECL_RESULT (decl)))
12344         gen_decl_die (DECL_RESULT (decl), subr_die);
12345
12346       current_function_has_inlines = 0;
12347       decls_for_scope (outer_scope, subr_die, 0);
12348
12349 #if 0 && defined (MIPS_DEBUGGING_INFO)
12350       if (current_function_has_inlines)
12351         {
12352           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
12353           if (! comp_unit_has_inlines)
12354             {
12355               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
12356               comp_unit_has_inlines = 1;
12357             }
12358         }
12359 #endif
12360     }
12361   /* Add the calling convention attribute if requested.  */
12362   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
12363
12364 }
12365
12366 /* Generate a DIE to represent a declared data object.  */
12367
12368 static void
12369 gen_variable_die (tree decl, dw_die_ref context_die)
12370 {
12371   tree origin = decl_ultimate_origin (decl);
12372   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
12373
12374   dw_die_ref old_die = lookup_decl_die (decl);
12375   int declaration = (DECL_EXTERNAL (decl)
12376                      /* If DECL is COMDAT and has not actually been
12377                         emitted, we cannot take its address; there
12378                         might end up being no definition anywhere in
12379                         the program.  For example, consider the C++
12380                         test case:
12381
12382                           template <class T>
12383                           struct S { static const int i = 7; };
12384
12385                           template <class T>
12386                           const int S<T>::i;
12387
12388                           int f() { return S<int>::i; }
12389
12390                         Here, S<int>::i is not DECL_EXTERNAL, but no
12391                         definition is required, so the compiler will
12392                         not emit a definition.  */
12393                      || (TREE_CODE (decl) == VAR_DECL
12394                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
12395                      || class_or_namespace_scope_p (context_die));
12396
12397   if (origin != NULL)
12398     add_abstract_origin_attribute (var_die, origin);
12399
12400   /* Loop unrolling can create multiple blocks that refer to the same
12401      static variable, so we must test for the DW_AT_declaration flag.
12402
12403      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12404      copy decls and set the DECL_ABSTRACT flag on them instead of
12405      sharing them.
12406
12407      ??? Duplicated blocks have been rewritten to use .debug_ranges.
12408
12409      ??? The declare_in_namespace support causes us to get two DIEs for one
12410      variable, both of which are declarations.  We want to avoid considering
12411      one to be a specification, so we must test that this DIE is not a
12412      declaration.  */
12413   else if (old_die && TREE_STATIC (decl) && ! declaration
12414            && get_AT_flag (old_die, DW_AT_declaration) == 1)
12415     {
12416       /* This is a definition of a C++ class level static.  */
12417       add_AT_specification (var_die, old_die);
12418       if (DECL_NAME (decl))
12419         {
12420           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12421           struct dwarf_file_data * file_index = lookup_filename (s.file);
12422
12423           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12424             add_AT_file (var_die, DW_AT_decl_file, file_index);
12425
12426           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12427             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12428         }
12429     }
12430   else
12431     {
12432       add_name_and_src_coords_attributes (var_die, decl);
12433       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12434                           TREE_THIS_VOLATILE (decl), context_die);
12435
12436       if (TREE_PUBLIC (decl))
12437         add_AT_flag (var_die, DW_AT_external, 1);
12438
12439       if (DECL_ARTIFICIAL (decl))
12440         add_AT_flag (var_die, DW_AT_artificial, 1);
12441
12442       if (TREE_PROTECTED (decl))
12443         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12444       else if (TREE_PRIVATE (decl))
12445         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12446     }
12447
12448   if (declaration)
12449     add_AT_flag (var_die, DW_AT_declaration, 1);
12450
12451   if (DECL_ABSTRACT (decl) || declaration)
12452     equate_decl_number_to_die (decl, var_die);
12453
12454   if (! declaration && ! DECL_ABSTRACT (decl))
12455     {
12456       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12457       add_pubname (decl, var_die);
12458     }
12459   else
12460     tree_add_const_value_attribute (var_die, decl);
12461 }
12462
12463 /* Generate a DIE to represent a label identifier.  */
12464
12465 static void
12466 gen_label_die (tree decl, dw_die_ref context_die)
12467 {
12468   tree origin = decl_ultimate_origin (decl);
12469   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12470   rtx insn;
12471   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12472
12473   if (origin != NULL)
12474     add_abstract_origin_attribute (lbl_die, origin);
12475   else
12476     add_name_and_src_coords_attributes (lbl_die, decl);
12477
12478   if (DECL_ABSTRACT (decl))
12479     equate_decl_number_to_die (decl, lbl_die);
12480   else
12481     {
12482       insn = DECL_RTL_IF_SET (decl);
12483
12484       /* Deleted labels are programmer specified labels which have been
12485          eliminated because of various optimizations.  We still emit them
12486          here so that it is possible to put breakpoints on them.  */
12487       if (insn
12488           && (LABEL_P (insn)
12489               || ((NOTE_P (insn)
12490                    && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
12491         {
12492           /* When optimization is enabled (via -O) some parts of the compiler
12493              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12494              represent source-level labels which were explicitly declared by
12495              the user.  This really shouldn't be happening though, so catch
12496              it if it ever does happen.  */
12497           gcc_assert (!INSN_DELETED_P (insn));
12498
12499           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12500           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12501         }
12502     }
12503 }
12504
12505 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
12506    attributes to the DIE for a block STMT, to describe where the inlined
12507    function was called from.  This is similar to add_src_coords_attributes.  */
12508
12509 static inline void
12510 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12511 {
12512   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12513
12514   add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12515   add_AT_unsigned (die, DW_AT_call_line, s.line);
12516 }
12517
12518
12519 /* If STMT's abstract origin is a function declaration and STMT's
12520    first subblock's abstract origin is the function's outermost block,
12521    then we're looking at the main entry point.  */
12522 static bool
12523 is_inlined_entry_point (const_tree stmt)
12524 {
12525   tree decl, block;
12526
12527   if (!stmt || TREE_CODE (stmt) != BLOCK)
12528     return false;
12529
12530   decl = block_ultimate_origin (stmt);
12531
12532   if (!decl || TREE_CODE (decl) != FUNCTION_DECL)
12533     return false;
12534
12535   block = BLOCK_SUBBLOCKS (stmt);
12536
12537   if (block)
12538     {
12539       if (TREE_CODE (block) != BLOCK)
12540         return false;
12541
12542       block = block_ultimate_origin (block);
12543     }
12544
12545   return block == DECL_INITIAL (decl);
12546 }
12547
12548 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12549    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
12550
12551 static inline void
12552 add_high_low_attributes (tree stmt, dw_die_ref die)
12553 {
12554   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12555
12556   if (BLOCK_FRAGMENT_CHAIN (stmt))
12557     {
12558       tree chain;
12559
12560       if (is_inlined_entry_point (stmt))
12561         {
12562           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12563                                        BLOCK_NUMBER (stmt));
12564           add_AT_lbl_id (die, DW_AT_entry_pc, label);
12565         }
12566
12567       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12568
12569       chain = BLOCK_FRAGMENT_CHAIN (stmt);
12570       do
12571         {
12572           add_ranges (chain);
12573           chain = BLOCK_FRAGMENT_CHAIN (chain);
12574         }
12575       while (chain);
12576       add_ranges (NULL);
12577     }
12578   else
12579     {
12580       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12581                                    BLOCK_NUMBER (stmt));
12582       add_AT_lbl_id (die, DW_AT_low_pc, label);
12583       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12584                                    BLOCK_NUMBER (stmt));
12585       add_AT_lbl_id (die, DW_AT_high_pc, label);
12586     }
12587 }
12588
12589 /* Generate a DIE for a lexical block.  */
12590
12591 static void
12592 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12593 {
12594   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12595
12596   if (! BLOCK_ABSTRACT (stmt))
12597     add_high_low_attributes (stmt, stmt_die);
12598
12599   decls_for_scope (stmt, stmt_die, depth);
12600 }
12601
12602 /* Generate a DIE for an inlined subprogram.  */
12603
12604 static void
12605 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12606 {
12607   tree decl = block_ultimate_origin (stmt);
12608
12609   /* Emit info for the abstract instance first, if we haven't yet.  We
12610      must emit this even if the block is abstract, otherwise when we
12611      emit the block below (or elsewhere), we may end up trying to emit
12612      a die whose origin die hasn't been emitted, and crashing.  */
12613   dwarf2out_abstract_function (decl);
12614
12615   if (! BLOCK_ABSTRACT (stmt))
12616     {
12617       dw_die_ref subr_die
12618         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12619
12620       add_abstract_origin_attribute (subr_die, decl);
12621       add_high_low_attributes (stmt, subr_die);
12622       add_call_src_coords_attributes (stmt, subr_die);
12623
12624       decls_for_scope (stmt, subr_die, depth);
12625       current_function_has_inlines = 1;
12626     }
12627   else
12628     /* We may get here if we're the outer block of function A that was
12629        inlined into function B that was inlined into function C.  When
12630        generating debugging info for C, dwarf2out_abstract_function(B)
12631        would mark all inlined blocks as abstract, including this one.
12632        So, we wouldn't (and shouldn't) expect labels to be generated
12633        for this one.  Instead, just emit debugging info for
12634        declarations within the block.  This is particularly important
12635        in the case of initializers of arguments passed from B to us:
12636        if they're statement expressions containing declarations, we
12637        wouldn't generate dies for their abstract variables, and then,
12638        when generating dies for the real variables, we'd die (pun
12639        intended :-)  */
12640     gen_lexical_block_die (stmt, context_die, depth);
12641 }
12642
12643 /* Generate a DIE for a field in a record, or structure.  */
12644
12645 static void
12646 gen_field_die (tree decl, dw_die_ref context_die)
12647 {
12648   dw_die_ref decl_die;
12649
12650   if (TREE_TYPE (decl) == error_mark_node)
12651     return;
12652
12653   decl_die = new_die (DW_TAG_member, context_die, decl);
12654   add_name_and_src_coords_attributes (decl_die, decl);
12655   add_type_attribute (decl_die, member_declared_type (decl),
12656                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12657                       context_die);
12658
12659   if (DECL_BIT_FIELD_TYPE (decl))
12660     {
12661       add_byte_size_attribute (decl_die, decl);
12662       add_bit_size_attribute (decl_die, decl);
12663       add_bit_offset_attribute (decl_die, decl);
12664     }
12665
12666   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12667     add_data_member_location_attribute (decl_die, decl);
12668
12669   if (DECL_ARTIFICIAL (decl))
12670     add_AT_flag (decl_die, DW_AT_artificial, 1);
12671
12672   if (TREE_PROTECTED (decl))
12673     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12674   else if (TREE_PRIVATE (decl))
12675     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12676
12677   /* Equate decl number to die, so that we can look up this decl later on.  */
12678   equate_decl_number_to_die (decl, decl_die);
12679 }
12680
12681 #if 0
12682 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12683    Use modified_type_die instead.
12684    We keep this code here just in case these types of DIEs may be needed to
12685    represent certain things in other languages (e.g. Pascal) someday.  */
12686
12687 static void
12688 gen_pointer_type_die (tree type, dw_die_ref context_die)
12689 {
12690   dw_die_ref ptr_die
12691     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12692
12693   equate_type_number_to_die (type, ptr_die);
12694   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12695   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12696 }
12697
12698 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12699    Use modified_type_die instead.
12700    We keep this code here just in case these types of DIEs may be needed to
12701    represent certain things in other languages (e.g. Pascal) someday.  */
12702
12703 static void
12704 gen_reference_type_die (tree type, dw_die_ref context_die)
12705 {
12706   dw_die_ref ref_die
12707     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12708
12709   equate_type_number_to_die (type, ref_die);
12710   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12711   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12712 }
12713 #endif
12714
12715 /* Generate a DIE for a pointer to a member type.  */
12716
12717 static void
12718 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12719 {
12720   dw_die_ref ptr_die
12721     = new_die (DW_TAG_ptr_to_member_type,
12722                scope_die_for (type, context_die), type);
12723
12724   equate_type_number_to_die (type, ptr_die);
12725   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12726                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12727   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12728 }
12729
12730 /* Generate the DIE for the compilation unit.  */
12731
12732 static dw_die_ref
12733 gen_compile_unit_die (const char *filename)
12734 {
12735   dw_die_ref die;
12736   char producer[250];
12737   const char *language_string = lang_hooks.name;
12738   int language;
12739
12740   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12741
12742   if (filename)
12743     {
12744       add_name_attribute (die, filename);
12745       /* Don't add cwd for <built-in>.  */
12746       if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
12747         add_comp_dir_attribute (die);
12748     }
12749
12750   sprintf (producer, "%s %s", language_string, version_string);
12751
12752 #ifdef MIPS_DEBUGGING_INFO
12753   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12754      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12755      not appear in the producer string, the debugger reaches the conclusion
12756      that the object file is stripped and has no debugging information.
12757      To get the MIPS/SGI debugger to believe that there is debugging
12758      information in the object file, we add a -g to the producer string.  */
12759   if (debug_info_level > DINFO_LEVEL_TERSE)
12760     strcat (producer, " -g");
12761 #endif
12762
12763   add_AT_string (die, DW_AT_producer, producer);
12764
12765   if (strcmp (language_string, "GNU C++") == 0)
12766     language = DW_LANG_C_plus_plus;
12767   else if (strcmp (language_string, "GNU Ada") == 0)
12768     language = DW_LANG_Ada95;
12769   else if (strcmp (language_string, "GNU F77") == 0)
12770     language = DW_LANG_Fortran77;
12771   else if (strcmp (language_string, "GNU F95") == 0)
12772     language = DW_LANG_Fortran95;
12773   else if (strcmp (language_string, "GNU Pascal") == 0)
12774     language = DW_LANG_Pascal83;
12775   else if (strcmp (language_string, "GNU Java") == 0)
12776     language = DW_LANG_Java;
12777   else if (strcmp (language_string, "GNU Objective-C") == 0)
12778     language = DW_LANG_ObjC;
12779   else if (strcmp (language_string, "GNU Objective-C++") == 0)
12780     language = DW_LANG_ObjC_plus_plus;
12781   else
12782     language = DW_LANG_C89;
12783
12784   add_AT_unsigned (die, DW_AT_language, language);
12785   return die;
12786 }
12787
12788 /* Generate the DIE for a base class.  */
12789
12790 static void
12791 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12792 {
12793   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12794
12795   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12796   add_data_member_location_attribute (die, binfo);
12797
12798   if (BINFO_VIRTUAL_P (binfo))
12799     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12800
12801   if (access == access_public_node)
12802     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12803   else if (access == access_protected_node)
12804     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12805 }
12806
12807 /* Generate a DIE for a class member.  */
12808
12809 static void
12810 gen_member_die (tree type, dw_die_ref context_die)
12811 {
12812   tree member;
12813   tree binfo = TYPE_BINFO (type);
12814   dw_die_ref child;
12815
12816   /* If this is not an incomplete type, output descriptions of each of its
12817      members. Note that as we output the DIEs necessary to represent the
12818      members of this record or union type, we will also be trying to output
12819      DIEs to represent the *types* of those members. However the `type'
12820      function (above) will specifically avoid generating type DIEs for member
12821      types *within* the list of member DIEs for this (containing) type except
12822      for those types (of members) which are explicitly marked as also being
12823      members of this (containing) type themselves.  The g++ front- end can
12824      force any given type to be treated as a member of some other (containing)
12825      type by setting the TYPE_CONTEXT of the given (member) type to point to
12826      the TREE node representing the appropriate (containing) type.  */
12827
12828   /* First output info about the base classes.  */
12829   if (binfo)
12830     {
12831       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12832       int i;
12833       tree base;
12834
12835       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12836         gen_inheritance_die (base,
12837                              (accesses ? VEC_index (tree, accesses, i)
12838                               : access_public_node), context_die);
12839     }
12840
12841   /* Now output info about the data members and type members.  */
12842   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12843     {
12844       /* If we thought we were generating minimal debug info for TYPE
12845          and then changed our minds, some of the member declarations
12846          may have already been defined.  Don't define them again, but
12847          do put them in the right order.  */
12848
12849       child = lookup_decl_die (member);
12850       if (child)
12851         splice_child_die (context_die, child);
12852       else
12853         gen_decl_die (member, context_die);
12854     }
12855
12856   /* Now output info about the function members (if any).  */
12857   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12858     {
12859       /* Don't include clones in the member list.  */
12860       if (DECL_ABSTRACT_ORIGIN (member))
12861         continue;
12862
12863       child = lookup_decl_die (member);
12864       if (child)
12865         splice_child_die (context_die, child);
12866       else
12867         gen_decl_die (member, context_die);
12868     }
12869 }
12870
12871 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12872    is set, we pretend that the type was never defined, so we only get the
12873    member DIEs needed by later specification DIEs.  */
12874
12875 static void
12876 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
12877                                 enum debug_info_usage usage)
12878 {
12879   dw_die_ref type_die = lookup_type_die (type);
12880   dw_die_ref scope_die = 0;
12881   int nested = 0;
12882   int complete = (TYPE_SIZE (type)
12883                   && (! TYPE_STUB_DECL (type)
12884                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12885   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12886   complete = complete && should_emit_struct_debug (type, usage);
12887
12888   if (type_die && ! complete)
12889     return;
12890
12891   if (TYPE_CONTEXT (type) != NULL_TREE
12892       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12893           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12894     nested = 1;
12895
12896   scope_die = scope_die_for (type, context_die);
12897
12898   if (! type_die || (nested && scope_die == comp_unit_die))
12899     /* First occurrence of type or toplevel definition of nested class.  */
12900     {
12901       dw_die_ref old_die = type_die;
12902
12903       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12904                           ? DW_TAG_structure_type : DW_TAG_union_type,
12905                           scope_die, type);
12906       equate_type_number_to_die (type, type_die);
12907       if (old_die)
12908         add_AT_specification (type_die, old_die);
12909       else
12910         add_name_attribute (type_die, type_tag (type));
12911     }
12912   else
12913     remove_AT (type_die, DW_AT_declaration);
12914
12915   /* If this type has been completed, then give it a byte_size attribute and
12916      then give a list of members.  */
12917   if (complete && !ns_decl)
12918     {
12919       /* Prevent infinite recursion in cases where the type of some member of
12920          this type is expressed in terms of this type itself.  */
12921       TREE_ASM_WRITTEN (type) = 1;
12922       add_byte_size_attribute (type_die, type);
12923       if (TYPE_STUB_DECL (type) != NULL_TREE)
12924         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12925
12926       /* If the first reference to this type was as the return type of an
12927          inline function, then it may not have a parent.  Fix this now.  */
12928       if (type_die->die_parent == NULL)
12929         add_child_die (scope_die, type_die);
12930
12931       push_decl_scope (type);
12932       gen_member_die (type, type_die);
12933       pop_decl_scope ();
12934
12935       /* GNU extension: Record what type our vtable lives in.  */
12936       if (TYPE_VFIELD (type))
12937         {
12938           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12939
12940           gen_type_die (vtype, context_die);
12941           add_AT_die_ref (type_die, DW_AT_containing_type,
12942                           lookup_type_die (vtype));
12943         }
12944     }
12945   else
12946     {
12947       add_AT_flag (type_die, DW_AT_declaration, 1);
12948
12949       /* We don't need to do this for function-local types.  */
12950       if (TYPE_STUB_DECL (type)
12951           && ! decl_function_context (TYPE_STUB_DECL (type)))
12952         VEC_safe_push (tree, gc, incomplete_types, type);
12953     }
12954
12955   if (get_AT (type_die, DW_AT_name))
12956     add_pubtype (type, type_die);
12957 }
12958
12959 /* Generate a DIE for a subroutine _type_.  */
12960
12961 static void
12962 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12963 {
12964   tree return_type = TREE_TYPE (type);
12965   dw_die_ref subr_die
12966     = new_die (DW_TAG_subroutine_type,
12967                scope_die_for (type, context_die), type);
12968
12969   equate_type_number_to_die (type, subr_die);
12970   add_prototyped_attribute (subr_die, type);
12971   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12972   gen_formal_types_die (type, subr_die);
12973
12974   if (get_AT (subr_die, DW_AT_name))
12975     add_pubtype (type, subr_die);
12976 }
12977
12978 /* Generate a DIE for a type definition.  */
12979
12980 static void
12981 gen_typedef_die (tree decl, dw_die_ref context_die)
12982 {
12983   dw_die_ref type_die;
12984   tree origin;
12985
12986   if (TREE_ASM_WRITTEN (decl))
12987     return;
12988
12989   TREE_ASM_WRITTEN (decl) = 1;
12990   type_die = new_die (DW_TAG_typedef, context_die, decl);
12991   origin = decl_ultimate_origin (decl);
12992   if (origin != NULL)
12993     add_abstract_origin_attribute (type_die, origin);
12994   else
12995     {
12996       tree type;
12997
12998       add_name_and_src_coords_attributes (type_die, decl);
12999       if (DECL_ORIGINAL_TYPE (decl))
13000         {
13001           type = DECL_ORIGINAL_TYPE (decl);
13002
13003           gcc_assert (type != TREE_TYPE (decl));
13004           equate_type_number_to_die (TREE_TYPE (decl), type_die);
13005         }
13006       else
13007         type = TREE_TYPE (decl);
13008
13009       add_type_attribute (type_die, type, TREE_READONLY (decl),
13010                           TREE_THIS_VOLATILE (decl), context_die);
13011     }
13012
13013   if (DECL_ABSTRACT (decl))
13014     equate_decl_number_to_die (decl, type_die);
13015
13016   if (get_AT (type_die, DW_AT_name))
13017     add_pubtype (decl, type_die);
13018 }
13019
13020 /* Generate a type description DIE.  */
13021
13022 static void
13023 gen_type_die_with_usage (tree type, dw_die_ref context_die,
13024                                 enum debug_info_usage usage)
13025 {
13026   int need_pop;
13027
13028   if (type == NULL_TREE || type == error_mark_node)
13029     return;
13030
13031   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
13032       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
13033     {
13034       if (TREE_ASM_WRITTEN (type))
13035         return;
13036
13037       /* Prevent broken recursion; we can't hand off to the same type.  */
13038       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
13039
13040       TREE_ASM_WRITTEN (type) = 1;
13041       gen_decl_die (TYPE_NAME (type), context_die);
13042       return;
13043     }
13044
13045   /* We are going to output a DIE to represent the unqualified version
13046      of this type (i.e. without any const or volatile qualifiers) so
13047      get the main variant (i.e. the unqualified version) of this type
13048      now.  (Vectors are special because the debugging info is in the
13049      cloned type itself).  */
13050   if (TREE_CODE (type) != VECTOR_TYPE)
13051     type = type_main_variant (type);
13052
13053   if (TREE_ASM_WRITTEN (type))
13054     return;
13055
13056   switch (TREE_CODE (type))
13057     {
13058     case ERROR_MARK:
13059       break;
13060
13061     case POINTER_TYPE:
13062     case REFERENCE_TYPE:
13063       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
13064          ensures that the gen_type_die recursion will terminate even if the
13065          type is recursive.  Recursive types are possible in Ada.  */
13066       /* ??? We could perhaps do this for all types before the switch
13067          statement.  */
13068       TREE_ASM_WRITTEN (type) = 1;
13069
13070       /* For these types, all that is required is that we output a DIE (or a
13071          set of DIEs) to represent the "basis" type.  */
13072       gen_type_die_with_usage (TREE_TYPE (type), context_die,
13073                                 DINFO_USAGE_IND_USE);
13074       break;
13075
13076     case OFFSET_TYPE:
13077       /* This code is used for C++ pointer-to-data-member types.
13078          Output a description of the relevant class type.  */
13079       gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
13080                                         DINFO_USAGE_IND_USE);
13081
13082       /* Output a description of the type of the object pointed to.  */
13083       gen_type_die_with_usage (TREE_TYPE (type), context_die,
13084                                         DINFO_USAGE_IND_USE);
13085
13086       /* Now output a DIE to represent this pointer-to-data-member type
13087          itself.  */
13088       gen_ptr_to_mbr_type_die (type, context_die);
13089       break;
13090
13091     case FUNCTION_TYPE:
13092       /* Force out return type (in case it wasn't forced out already).  */
13093       gen_type_die_with_usage (TREE_TYPE (type), context_die,
13094                                         DINFO_USAGE_DIR_USE);
13095       gen_subroutine_type_die (type, context_die);
13096       break;
13097
13098     case METHOD_TYPE:
13099       /* Force out return type (in case it wasn't forced out already).  */
13100       gen_type_die_with_usage (TREE_TYPE (type), context_die,
13101                                         DINFO_USAGE_DIR_USE);
13102       gen_subroutine_type_die (type, context_die);
13103       break;
13104
13105     case ARRAY_TYPE:
13106       gen_array_type_die (type, context_die);
13107       break;
13108
13109     case VECTOR_TYPE:
13110       gen_array_type_die (type, context_die);
13111       break;
13112
13113     case ENUMERAL_TYPE:
13114     case RECORD_TYPE:
13115     case UNION_TYPE:
13116     case QUAL_UNION_TYPE:
13117       /* If this is a nested type whose containing class hasn't been written
13118          out yet, writing it out will cover this one, too.  This does not apply
13119          to instantiations of member class templates; they need to be added to
13120          the containing class as they are generated.  FIXME: This hurts the
13121          idea of combining type decls from multiple TUs, since we can't predict
13122          what set of template instantiations we'll get.  */
13123       if (TYPE_CONTEXT (type)
13124           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
13125           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
13126         {
13127           gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
13128
13129           if (TREE_ASM_WRITTEN (type))
13130             return;
13131
13132           /* If that failed, attach ourselves to the stub.  */
13133           push_decl_scope (TYPE_CONTEXT (type));
13134           context_die = lookup_type_die (TYPE_CONTEXT (type));
13135           need_pop = 1;
13136         }
13137       else
13138         {
13139           declare_in_namespace (type, context_die);
13140           need_pop = 0;
13141         }
13142
13143       if (TREE_CODE (type) == ENUMERAL_TYPE)
13144         {
13145           /* This might have been written out by the call to
13146              declare_in_namespace.  */
13147           if (!TREE_ASM_WRITTEN (type))
13148             gen_enumeration_type_die (type, context_die);
13149         }
13150       else
13151         gen_struct_or_union_type_die (type, context_die, usage);
13152
13153       if (need_pop)
13154         pop_decl_scope ();
13155
13156       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
13157          it up if it is ever completed.  gen_*_type_die will set it for us
13158          when appropriate.  */
13159       return;
13160
13161     case VOID_TYPE:
13162     case INTEGER_TYPE:
13163     case REAL_TYPE:
13164     case FIXED_POINT_TYPE:
13165     case COMPLEX_TYPE:
13166     case BOOLEAN_TYPE:
13167       /* No DIEs needed for fundamental types.  */
13168       break;
13169
13170     case LANG_TYPE:
13171       /* No Dwarf representation currently defined.  */
13172       break;
13173
13174     default:
13175       gcc_unreachable ();
13176     }
13177
13178   TREE_ASM_WRITTEN (type) = 1;
13179 }
13180
13181 static void
13182 gen_type_die (tree type, dw_die_ref context_die)
13183 {
13184   gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
13185 }
13186
13187 /* Generate a DIE for a tagged type instantiation.  */
13188
13189 static void
13190 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
13191 {
13192   if (type == NULL_TREE || type == error_mark_node)
13193     return;
13194
13195   /* We are going to output a DIE to represent the unqualified version of
13196      this type (i.e. without any const or volatile qualifiers) so make sure
13197      that we have the main variant (i.e. the unqualified version) of this
13198      type now.  */
13199   gcc_assert (type == type_main_variant (type));
13200
13201   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
13202      an instance of an unresolved type.  */
13203
13204   switch (TREE_CODE (type))
13205     {
13206     case ERROR_MARK:
13207       break;
13208
13209     case ENUMERAL_TYPE:
13210       gen_inlined_enumeration_type_die (type, context_die);
13211       break;
13212
13213     case RECORD_TYPE:
13214       gen_inlined_structure_type_die (type, context_die);
13215       break;
13216
13217     case UNION_TYPE:
13218     case QUAL_UNION_TYPE:
13219       gen_inlined_union_type_die (type, context_die);
13220       break;
13221
13222     default:
13223       gcc_unreachable ();
13224     }
13225 }
13226
13227 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
13228    things which are local to the given block.  */
13229
13230 static void
13231 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
13232 {
13233   int must_output_die = 0;
13234   tree origin;
13235   tree decl;
13236   enum tree_code origin_code;
13237
13238   /* Ignore blocks that are NULL.  */
13239   if (stmt == NULL_TREE)
13240     return;
13241
13242   /* If the block is one fragment of a non-contiguous block, do not
13243      process the variables, since they will have been done by the
13244      origin block.  Do process subblocks.  */
13245   if (BLOCK_FRAGMENT_ORIGIN (stmt))
13246     {
13247       tree sub;
13248
13249       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
13250         gen_block_die (sub, context_die, depth + 1);
13251
13252       return;
13253     }
13254
13255   /* Determine the "ultimate origin" of this block.  This block may be an
13256      inlined instance of an inlined instance of inline function, so we have
13257      to trace all of the way back through the origin chain to find out what
13258      sort of node actually served as the original seed for the creation of
13259      the current block.  */
13260   origin = block_ultimate_origin (stmt);
13261   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
13262
13263   /* Determine if we need to output any Dwarf DIEs at all to represent this
13264      block.  */
13265   if (origin_code == FUNCTION_DECL)
13266     /* The outer scopes for inlinings *must* always be represented.  We
13267        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
13268     must_output_die = 1;
13269   else
13270     {
13271       /* In the case where the current block represents an inlining of the
13272          "body block" of an inline function, we must *NOT* output any DIE for
13273          this block because we have already output a DIE to represent the whole
13274          inlined function scope and the "body block" of any function doesn't
13275          really represent a different scope according to ANSI C rules.  So we
13276          check here to make sure that this block does not represent a "body
13277          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
13278       if (! is_body_block (origin ? origin : stmt))
13279         {
13280           /* Determine if this block directly contains any "significant"
13281              local declarations which we will need to output DIEs for.  */
13282           if (debug_info_level > DINFO_LEVEL_TERSE)
13283             /* We are not in terse mode so *any* local declaration counts
13284                as being a "significant" one.  */
13285             must_output_die = (BLOCK_VARS (stmt) != NULL
13286                                && (TREE_USED (stmt)
13287                                    || TREE_ASM_WRITTEN (stmt)
13288                                    || BLOCK_ABSTRACT (stmt)));
13289           else
13290             /* We are in terse mode, so only local (nested) function
13291                definitions count as "significant" local declarations.  */
13292             for (decl = BLOCK_VARS (stmt);
13293                  decl != NULL; decl = TREE_CHAIN (decl))
13294               if (TREE_CODE (decl) == FUNCTION_DECL
13295                   && DECL_INITIAL (decl))
13296                 {
13297                   must_output_die = 1;
13298                   break;
13299                 }
13300         }
13301     }
13302
13303   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
13304      DIE for any block which contains no significant local declarations at
13305      all.  Rather, in such cases we just call `decls_for_scope' so that any
13306      needed Dwarf info for any sub-blocks will get properly generated. Note
13307      that in terse mode, our definition of what constitutes a "significant"
13308      local declaration gets restricted to include only inlined function
13309      instances and local (nested) function definitions.  */
13310   if (must_output_die)
13311     {
13312       if (origin_code == FUNCTION_DECL)
13313         gen_inlined_subroutine_die (stmt, context_die, depth);
13314       else
13315         gen_lexical_block_die (stmt, context_die, depth);
13316     }
13317   else
13318     decls_for_scope (stmt, context_die, depth);
13319 }
13320
13321 /* Generate all of the decls declared within a given scope and (recursively)
13322    all of its sub-blocks.  */
13323
13324 static void
13325 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
13326 {
13327   tree decl;
13328   tree subblocks;
13329
13330   /* Ignore NULL blocks.  */
13331   if (stmt == NULL_TREE)
13332     return;
13333
13334   if (TREE_USED (stmt))
13335     {
13336       /* Output the DIEs to represent all of the data objects and typedefs
13337          declared directly within this block but not within any nested
13338          sub-blocks.  Also, nested function and tag DIEs have been
13339          generated with a parent of NULL; fix that up now.  */
13340       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
13341         {
13342           dw_die_ref die;
13343
13344           if (TREE_CODE (decl) == FUNCTION_DECL)
13345             die = lookup_decl_die (decl);
13346           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
13347             die = lookup_type_die (TREE_TYPE (decl));
13348           else
13349             die = NULL;
13350
13351           if (die != NULL && die->die_parent == NULL)
13352             add_child_die (context_die, die);
13353           /* Do not produce debug information for static variables since
13354              these might be optimized out.  We are called for these later
13355              in varpool_analyze_pending_decls. */
13356           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
13357             ;
13358           else
13359             gen_decl_die (decl, context_die);
13360         }
13361     }
13362
13363   /* If we're at -g1, we're not interested in subblocks.  */
13364   if (debug_info_level <= DINFO_LEVEL_TERSE)
13365     return;
13366
13367   /* Output the DIEs to represent all sub-blocks (and the items declared
13368      therein) of this block.  */
13369   for (subblocks = BLOCK_SUBBLOCKS (stmt);
13370        subblocks != NULL;
13371        subblocks = BLOCK_CHAIN (subblocks))
13372     gen_block_die (subblocks, context_die, depth + 1);
13373 }
13374
13375 /* Is this a typedef we can avoid emitting?  */
13376
13377 static inline int
13378 is_redundant_typedef (const_tree decl)
13379 {
13380   if (TYPE_DECL_IS_STUB (decl))
13381     return 1;
13382
13383   if (DECL_ARTIFICIAL (decl)
13384       && DECL_CONTEXT (decl)
13385       && is_tagged_type (DECL_CONTEXT (decl))
13386       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
13387       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
13388     /* Also ignore the artificial member typedef for the class name.  */
13389     return 1;
13390
13391   return 0;
13392 }
13393
13394 /* Returns the DIE for decl.  A DIE will always be returned.  */
13395
13396 static dw_die_ref
13397 force_decl_die (tree decl)
13398 {
13399   dw_die_ref decl_die;
13400   unsigned saved_external_flag;
13401   tree save_fn = NULL_TREE;
13402   decl_die = lookup_decl_die (decl);
13403   if (!decl_die)
13404     {
13405       dw_die_ref context_die;
13406       tree decl_context = DECL_CONTEXT (decl);
13407       if (decl_context)
13408         {
13409           /* Find die that represents this context.  */
13410           if (TYPE_P (decl_context))
13411             context_die = force_type_die (decl_context);
13412           else
13413             context_die = force_decl_die (decl_context);
13414         }
13415       else
13416         context_die = comp_unit_die;
13417
13418       decl_die = lookup_decl_die (decl);
13419       if (decl_die)
13420         return decl_die;
13421
13422       switch (TREE_CODE (decl))
13423         {
13424         case FUNCTION_DECL:
13425           /* Clear current_function_decl, so that gen_subprogram_die thinks
13426              that this is a declaration. At this point, we just want to force
13427              declaration die.  */
13428           save_fn = current_function_decl;
13429           current_function_decl = NULL_TREE;
13430           gen_subprogram_die (decl, context_die);
13431           current_function_decl = save_fn;
13432           break;
13433
13434         case VAR_DECL:
13435           /* Set external flag to force declaration die. Restore it after
13436            gen_decl_die() call.  */
13437           saved_external_flag = DECL_EXTERNAL (decl);
13438           DECL_EXTERNAL (decl) = 1;
13439           gen_decl_die (decl, context_die);
13440           DECL_EXTERNAL (decl) = saved_external_flag;
13441           break;
13442
13443         case NAMESPACE_DECL:
13444           dwarf2out_decl (decl);
13445           break;
13446
13447         default:
13448           gcc_unreachable ();
13449         }
13450
13451       /* We should be able to find the DIE now.  */
13452       if (!decl_die)
13453         decl_die = lookup_decl_die (decl);
13454       gcc_assert (decl_die);
13455     }
13456
13457   return decl_die;
13458 }
13459
13460 /* Returns the DIE for TYPE, that must not be a base type.  A DIE is
13461    always returned.  */
13462
13463 static dw_die_ref
13464 force_type_die (tree type)
13465 {
13466   dw_die_ref type_die;
13467
13468   type_die = lookup_type_die (type);
13469   if (!type_die)
13470     {
13471       dw_die_ref context_die;
13472       if (TYPE_CONTEXT (type))
13473         {
13474           if (TYPE_P (TYPE_CONTEXT (type)))
13475             context_die = force_type_die (TYPE_CONTEXT (type));
13476           else
13477             context_die = force_decl_die (TYPE_CONTEXT (type));
13478         }
13479       else
13480         context_die = comp_unit_die;
13481
13482       type_die = lookup_type_die (type);
13483       if (type_die)
13484         return type_die;
13485       gen_type_die (type, context_die);
13486       type_die = lookup_type_die (type);
13487       gcc_assert (type_die);
13488     }
13489   return type_die;
13490 }
13491
13492 /* Force out any required namespaces to be able to output DECL,
13493    and return the new context_die for it, if it's changed.  */
13494
13495 static dw_die_ref
13496 setup_namespace_context (tree thing, dw_die_ref context_die)
13497 {
13498   tree context = (DECL_P (thing)
13499                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13500   if (context && TREE_CODE (context) == NAMESPACE_DECL)
13501     /* Force out the namespace.  */
13502     context_die = force_decl_die (context);
13503
13504   return context_die;
13505 }
13506
13507 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
13508    type) within its namespace, if appropriate.
13509
13510    For compatibility with older debuggers, namespace DIEs only contain
13511    declarations; all definitions are emitted at CU scope.  */
13512
13513 static void
13514 declare_in_namespace (tree thing, dw_die_ref context_die)
13515 {
13516   dw_die_ref ns_context;
13517
13518   if (debug_info_level <= DINFO_LEVEL_TERSE)
13519     return;
13520
13521   /* If this decl is from an inlined function, then don't try to emit it in its
13522      namespace, as we will get confused.  It would have already been emitted
13523      when the abstract instance of the inline function was emitted anyways.  */
13524   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13525     return;
13526
13527   ns_context = setup_namespace_context (thing, context_die);
13528
13529   if (ns_context != context_die)
13530     {
13531       if (DECL_P (thing))
13532         gen_decl_die (thing, ns_context);
13533       else
13534         gen_type_die (thing, ns_context);
13535     }
13536 }
13537
13538 /* Generate a DIE for a namespace or namespace alias.  */
13539
13540 static void
13541 gen_namespace_die (tree decl)
13542 {
13543   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13544
13545   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13546      they are an alias of.  */
13547   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13548     {
13549       /* Output a real namespace.  */
13550       dw_die_ref namespace_die
13551         = new_die (DW_TAG_namespace, context_die, decl);
13552       add_name_and_src_coords_attributes (namespace_die, decl);
13553       equate_decl_number_to_die (decl, namespace_die);
13554     }
13555   else
13556     {
13557       /* Output a namespace alias.  */
13558
13559       /* Force out the namespace we are an alias of, if necessary.  */
13560       dw_die_ref origin_die
13561         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13562
13563       /* Now create the namespace alias DIE.  */
13564       dw_die_ref namespace_die
13565         = new_die (DW_TAG_imported_declaration, context_die, decl);
13566       add_name_and_src_coords_attributes (namespace_die, decl);
13567       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13568       equate_decl_number_to_die (decl, namespace_die);
13569     }
13570 }
13571
13572 /* Generate Dwarf debug information for a decl described by DECL.  */
13573
13574 static void
13575 gen_decl_die (tree decl, dw_die_ref context_die)
13576 {
13577   tree origin;
13578
13579   if (DECL_P (decl) && DECL_IGNORED_P (decl))
13580     return;
13581
13582   switch (TREE_CODE (decl))
13583     {
13584     case ERROR_MARK:
13585       break;
13586
13587     case CONST_DECL:
13588       /* The individual enumerators of an enum type get output when we output
13589          the Dwarf representation of the relevant enum type itself.  */
13590       break;
13591
13592     case FUNCTION_DECL:
13593       /* Don't output any DIEs to represent mere function declarations,
13594          unless they are class members or explicit block externs.  */
13595       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13596           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13597         break;
13598
13599 #if 0
13600       /* FIXME */
13601       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13602          on local redeclarations of global functions.  That seems broken.  */
13603       if (current_function_decl != decl)
13604         /* This is only a declaration.  */;
13605 #endif
13606
13607       /* If we're emitting a clone, emit info for the abstract instance.  */
13608       if (DECL_ORIGIN (decl) != decl)
13609         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13610
13611       /* If we're emitting an out-of-line copy of an inline function,
13612          emit info for the abstract instance and set up to refer to it.  */
13613       else if (cgraph_function_possibly_inlined_p (decl)
13614                && ! DECL_ABSTRACT (decl)
13615                && ! class_or_namespace_scope_p (context_die)
13616                /* dwarf2out_abstract_function won't emit a die if this is just
13617                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
13618                   that case, because that works only if we have a die.  */
13619                && DECL_INITIAL (decl) != NULL_TREE)
13620         {
13621           dwarf2out_abstract_function (decl);
13622           set_decl_origin_self (decl);
13623         }
13624
13625       /* Otherwise we're emitting the primary DIE for this decl.  */
13626       else if (debug_info_level > DINFO_LEVEL_TERSE)
13627         {
13628           /* Before we describe the FUNCTION_DECL itself, make sure that we
13629              have described its return type.  */
13630           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13631
13632           /* And its virtual context.  */
13633           if (DECL_VINDEX (decl) != NULL_TREE)
13634             gen_type_die (DECL_CONTEXT (decl), context_die);
13635
13636           /* And its containing type.  */
13637           origin = decl_class_context (decl);
13638           if (origin != NULL_TREE)
13639             gen_type_die_for_member (origin, decl, context_die);
13640
13641           /* And its containing namespace.  */
13642           declare_in_namespace (decl, context_die);
13643         }
13644
13645       /* Now output a DIE to represent the function itself.  */
13646       gen_subprogram_die (decl, context_die);
13647       break;
13648
13649     case TYPE_DECL:
13650       /* If we are in terse mode, don't generate any DIEs to represent any
13651          actual typedefs.  */
13652       if (debug_info_level <= DINFO_LEVEL_TERSE)
13653         break;
13654
13655       /* In the special case of a TYPE_DECL node representing the declaration
13656          of some type tag, if the given TYPE_DECL is marked as having been
13657          instantiated from some other (original) TYPE_DECL node (e.g. one which
13658          was generated within the original definition of an inline function) we
13659          have to generate a special (abbreviated) DW_TAG_structure_type,
13660          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13661       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
13662           && is_tagged_type (TREE_TYPE (decl)))
13663         {
13664           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13665           break;
13666         }
13667
13668       if (is_redundant_typedef (decl))
13669         gen_type_die (TREE_TYPE (decl), context_die);
13670       else
13671         /* Output a DIE to represent the typedef itself.  */
13672         gen_typedef_die (decl, context_die);
13673       break;
13674
13675     case LABEL_DECL:
13676       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13677         gen_label_die (decl, context_die);
13678       break;
13679
13680     case VAR_DECL:
13681     case RESULT_DECL:
13682       /* If we are in terse mode, don't generate any DIEs to represent any
13683          variable declarations or definitions.  */
13684       if (debug_info_level <= DINFO_LEVEL_TERSE)
13685         break;
13686
13687       /* Output any DIEs that are needed to specify the type of this data
13688          object.  */
13689       gen_type_die (TREE_TYPE (decl), context_die);
13690
13691       /* And its containing type.  */
13692       origin = decl_class_context (decl);
13693       if (origin != NULL_TREE)
13694         gen_type_die_for_member (origin, decl, context_die);
13695
13696       /* And its containing namespace.  */
13697       declare_in_namespace (decl, context_die);
13698
13699       /* Now output the DIE to represent the data object itself.  This gets
13700          complicated because of the possibility that the VAR_DECL really
13701          represents an inlined instance of a formal parameter for an inline
13702          function.  */
13703       origin = decl_ultimate_origin (decl);
13704       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13705         gen_formal_parameter_die (decl, context_die);
13706       else
13707         gen_variable_die (decl, context_die);
13708       break;
13709
13710     case FIELD_DECL:
13711       /* Ignore the nameless fields that are used to skip bits but handle C++
13712          anonymous unions and structs.  */
13713       if (DECL_NAME (decl) != NULL_TREE
13714           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13715           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13716         {
13717           gen_type_die (member_declared_type (decl), context_die);
13718           gen_field_die (decl, context_die);
13719         }
13720       break;
13721
13722     case PARM_DECL:
13723       gen_type_die (TREE_TYPE (decl), context_die);
13724       gen_formal_parameter_die (decl, context_die);
13725       break;
13726
13727     case NAMESPACE_DECL:
13728       gen_namespace_die (decl);
13729       break;
13730
13731     default:
13732       /* Probably some frontend-internal decl.  Assume we don't care.  */
13733       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13734       break;
13735     }
13736 }
13737 \f
13738 /* Output debug information for global decl DECL.  Called from toplev.c after
13739    compilation proper has finished.  */
13740
13741 static void
13742 dwarf2out_global_decl (tree decl)
13743 {
13744   /* Output DWARF2 information for file-scope tentative data object
13745      declarations, file-scope (extern) function declarations (which had no
13746      corresponding body) and file-scope tagged type declarations and
13747      definitions which have not yet been forced out.  */
13748   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13749     dwarf2out_decl (decl);
13750 }
13751
13752 /* Output debug information for type decl DECL.  Called from toplev.c
13753    and from language front ends (to record built-in types).  */
13754 static void
13755 dwarf2out_type_decl (tree decl, int local)
13756 {
13757   if (!local)
13758     dwarf2out_decl (decl);
13759 }
13760
13761 /* Output debug information for imported module or decl.  */
13762
13763 static void
13764 dwarf2out_imported_module_or_decl (tree decl, tree context)
13765 {
13766   dw_die_ref imported_die, at_import_die;
13767   dw_die_ref scope_die;
13768   expanded_location xloc;
13769
13770   if (debug_info_level <= DINFO_LEVEL_TERSE)
13771     return;
13772
13773   gcc_assert (decl);
13774
13775   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13776      We need decl DIE for reference and scope die. First, get DIE for the decl
13777      itself.  */
13778
13779   /* Get the scope die for decl context. Use comp_unit_die for global module
13780      or decl. If die is not found for non globals, force new die.  */
13781   if (!context)
13782     scope_die = comp_unit_die;
13783   else if (TYPE_P (context))
13784     {
13785       if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
13786         return;
13787     scope_die = force_type_die (context);
13788     }
13789   else
13790     scope_die = force_decl_die (context);
13791
13792   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13793   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13794     {
13795       if (is_base_type (TREE_TYPE (decl)))
13796         at_import_die = base_type_die (TREE_TYPE (decl));
13797       else
13798         at_import_die = force_type_die (TREE_TYPE (decl));
13799     }
13800   else
13801     {
13802       at_import_die = lookup_decl_die (decl);
13803       if (!at_import_die)
13804         {
13805           /* If we're trying to avoid duplicate debug info, we may not have
13806              emitted the member decl for this field.  Emit it now.  */
13807           if (TREE_CODE (decl) == FIELD_DECL)
13808             {
13809               tree type = DECL_CONTEXT (decl);
13810               dw_die_ref type_context_die;
13811
13812               if (TYPE_CONTEXT (type))
13813                 if (TYPE_P (TYPE_CONTEXT (type)))
13814                   {
13815                     if (!should_emit_struct_debug (TYPE_CONTEXT (type),
13816                                                    DINFO_USAGE_DIR_USE))
13817                       return;
13818                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13819                   }
13820               else
13821                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13822               else
13823                 type_context_die = comp_unit_die;
13824               gen_type_die_for_member (type, decl, type_context_die);
13825             }
13826           at_import_die = force_decl_die (decl);
13827         }
13828     }
13829
13830   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13831   if (TREE_CODE (decl) == NAMESPACE_DECL)
13832     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13833   else
13834     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13835
13836   xloc = expand_location (input_location);
13837   add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13838   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13839   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13840 }
13841
13842 /* Write the debugging output for DECL.  */
13843
13844 void
13845 dwarf2out_decl (tree decl)
13846 {
13847   dw_die_ref context_die = comp_unit_die;
13848
13849   switch (TREE_CODE (decl))
13850     {
13851     case ERROR_MARK:
13852       return;
13853
13854     case FUNCTION_DECL:
13855       /* What we would really like to do here is to filter out all mere
13856          file-scope declarations of file-scope functions which are never
13857          referenced later within this translation unit (and keep all of ones
13858          that *are* referenced later on) but we aren't clairvoyant, so we have
13859          no idea which functions will be referenced in the future (i.e. later
13860          on within the current translation unit). So here we just ignore all
13861          file-scope function declarations which are not also definitions.  If
13862          and when the debugger needs to know something about these functions,
13863          it will have to hunt around and find the DWARF information associated
13864          with the definition of the function.
13865
13866          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13867          nodes represent definitions and which ones represent mere
13868          declarations.  We have to check DECL_INITIAL instead. That's because
13869          the C front-end supports some weird semantics for "extern inline"
13870          function definitions.  These can get inlined within the current
13871          translation unit (and thus, we need to generate Dwarf info for their
13872          abstract instances so that the Dwarf info for the concrete inlined
13873          instances can have something to refer to) but the compiler never
13874          generates any out-of-lines instances of such things (despite the fact
13875          that they *are* definitions).
13876
13877          The important point is that the C front-end marks these "extern
13878          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13879          them anyway. Note that the C++ front-end also plays some similar games
13880          for inline function definitions appearing within include files which
13881          also contain `#pragma interface' pragmas.  */
13882       if (DECL_INITIAL (decl) == NULL_TREE)
13883         return;
13884
13885       /* If we're a nested function, initially use a parent of NULL; if we're
13886          a plain function, this will be fixed up in decls_for_scope.  If
13887          we're a method, it will be ignored, since we already have a DIE.  */
13888       if (decl_function_context (decl)
13889           /* But if we're in terse mode, we don't care about scope.  */
13890           && debug_info_level > DINFO_LEVEL_TERSE)
13891         context_die = NULL;
13892       break;
13893
13894     case VAR_DECL:
13895       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13896          declaration and if the declaration was never even referenced from
13897          within this entire compilation unit.  We suppress these DIEs in
13898          order to save space in the .debug section (by eliminating entries
13899          which are probably useless).  Note that we must not suppress
13900          block-local extern declarations (whether used or not) because that
13901          would screw-up the debugger's name lookup mechanism and cause it to
13902          miss things which really ought to be in scope at a given point.  */
13903       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13904         return;
13905
13906       /* For local statics lookup proper context die.  */
13907       if (TREE_STATIC (decl) && decl_function_context (decl))
13908         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13909
13910       /* If we are in terse mode, don't generate any DIEs to represent any
13911          variable declarations or definitions.  */
13912       if (debug_info_level <= DINFO_LEVEL_TERSE)
13913         return;
13914       break;
13915
13916     case NAMESPACE_DECL:
13917       if (debug_info_level <= DINFO_LEVEL_TERSE)
13918         return;
13919       if (lookup_decl_die (decl) != NULL)
13920         return;
13921       break;
13922
13923     case TYPE_DECL:
13924       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13925       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13926         return;
13927
13928       /* Don't bother trying to generate any DIEs to represent any of the
13929          normal built-in types for the language we are compiling.  */
13930       if (DECL_IS_BUILTIN (decl))
13931         {
13932           /* OK, we need to generate one for `bool' so GDB knows what type
13933              comparisons have.  */
13934           if (is_cxx ()
13935               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13936               && ! DECL_IGNORED_P (decl))
13937             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13938
13939           return;
13940         }
13941
13942       /* If we are in terse mode, don't generate any DIEs for types.  */
13943       if (debug_info_level <= DINFO_LEVEL_TERSE)
13944         return;
13945
13946       /* If we're a function-scope tag, initially use a parent of NULL;
13947          this will be fixed up in decls_for_scope.  */
13948       if (decl_function_context (decl))
13949         context_die = NULL;
13950
13951       break;
13952
13953     default:
13954       return;
13955     }
13956
13957   gen_decl_die (decl, context_die);
13958 }
13959
13960 /* Output a marker (i.e. a label) for the beginning of the generated code for
13961    a lexical block.  */
13962
13963 static void
13964 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13965                        unsigned int blocknum)
13966 {
13967   switch_to_section (current_function_section ());
13968   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13969 }
13970
13971 /* Output a marker (i.e. a label) for the end of the generated code for a
13972    lexical block.  */
13973
13974 static void
13975 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13976 {
13977   switch_to_section (current_function_section ());
13978   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13979 }
13980
13981 /* Returns nonzero if it is appropriate not to emit any debugging
13982    information for BLOCK, because it doesn't contain any instructions.
13983
13984    Don't allow this for blocks with nested functions or local classes
13985    as we would end up with orphans, and in the presence of scheduling
13986    we may end up calling them anyway.  */
13987
13988 static bool
13989 dwarf2out_ignore_block (const_tree block)
13990 {
13991   tree decl;
13992
13993   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13994     if (TREE_CODE (decl) == FUNCTION_DECL
13995         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13996       return 0;
13997
13998   return 1;
13999 }
14000
14001 /* Hash table routines for file_hash.  */
14002
14003 static int
14004 file_table_eq (const void *p1_p, const void *p2_p)
14005 {
14006   const struct dwarf_file_data * p1 = p1_p;
14007   const char * p2 = p2_p;
14008   return strcmp (p1->filename, p2) == 0;
14009 }
14010
14011 static hashval_t
14012 file_table_hash (const void *p_p)
14013 {
14014   const struct dwarf_file_data * p = p_p;
14015   return htab_hash_string (p->filename);
14016 }
14017
14018 /* Lookup FILE_NAME (in the list of filenames that we know about here in
14019    dwarf2out.c) and return its "index".  The index of each (known) filename is
14020    just a unique number which is associated with only that one filename.  We
14021    need such numbers for the sake of generating labels (in the .debug_sfnames
14022    section) and references to those files numbers (in the .debug_srcinfo
14023    and.debug_macinfo sections).  If the filename given as an argument is not
14024    found in our current list, add it to the list and assign it the next
14025    available unique index number.  In order to speed up searches, we remember
14026    the index of the filename was looked up last.  This handles the majority of
14027    all searches.  */
14028
14029 static struct dwarf_file_data *
14030 lookup_filename (const char *file_name)
14031 {
14032   void ** slot;
14033   struct dwarf_file_data * created;
14034
14035   /* Check to see if the file name that was searched on the previous
14036      call matches this file name.  If so, return the index.  */
14037   if (file_table_last_lookup
14038       && (file_name == file_table_last_lookup->filename
14039           || strcmp (file_table_last_lookup->filename, file_name) == 0))
14040     return file_table_last_lookup;
14041
14042   /* Didn't match the previous lookup, search the table.  */
14043   slot = htab_find_slot_with_hash (file_table, file_name,
14044                                    htab_hash_string (file_name), INSERT);
14045   if (*slot)
14046     return *slot;
14047
14048   created = ggc_alloc (sizeof (struct dwarf_file_data));
14049   created->filename = file_name;
14050   created->emitted_number = 0;
14051   *slot = created;
14052   return created;
14053 }
14054
14055 /* If the assembler will construct the file table, then translate the compiler
14056    internal file table number into the assembler file table number, and emit
14057    a .file directive if we haven't already emitted one yet.  The file table
14058    numbers are different because we prune debug info for unused variables and
14059    types, which may include filenames.  */
14060
14061 static int
14062 maybe_emit_file (struct dwarf_file_data * fd)
14063 {
14064   if (! fd->emitted_number)
14065     {
14066       if (last_emitted_file)
14067         fd->emitted_number = last_emitted_file->emitted_number + 1;
14068       else
14069         fd->emitted_number = 1;
14070       last_emitted_file = fd;
14071
14072       if (DWARF2_ASM_LINE_DEBUG_INFO)
14073         {
14074           fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
14075           output_quoted_string (asm_out_file,
14076                                 remap_debug_filename (fd->filename));
14077           fputc ('\n', asm_out_file);
14078         }
14079     }
14080
14081   return fd->emitted_number;
14082 }
14083
14084 /* Called by the final INSN scan whenever we see a var location.  We
14085    use it to drop labels in the right places, and throw the location in
14086    our lookup table.  */
14087
14088 static void
14089 dwarf2out_var_location (rtx loc_note)
14090 {
14091   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
14092   struct var_loc_node *newloc;
14093   rtx prev_insn;
14094   static rtx last_insn;
14095   static const char *last_label;
14096   tree decl;
14097
14098   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
14099     return;
14100   prev_insn = PREV_INSN (loc_note);
14101
14102   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
14103   /* If the insn we processed last time is the previous insn
14104      and it is also a var location note, use the label we emitted
14105      last time.  */
14106   if (last_insn != NULL_RTX
14107       && last_insn == prev_insn
14108       && NOTE_P (prev_insn)
14109       && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
14110     {
14111       newloc->label = last_label;
14112     }
14113   else
14114     {
14115       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
14116       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
14117       loclabel_num++;
14118       newloc->label = ggc_strdup (loclabel);
14119     }
14120   newloc->var_loc_note = loc_note;
14121   newloc->next = NULL;
14122
14123   if (cfun && in_cold_section_p)
14124     newloc->section_label = cfun->cold_section_label;
14125   else
14126     newloc->section_label = text_section_label;
14127
14128   last_insn = loc_note;
14129   last_label = newloc->label;
14130   decl = NOTE_VAR_LOCATION_DECL (loc_note);
14131   add_var_loc_to_decl (decl, newloc);
14132 }
14133
14134 /* We need to reset the locations at the beginning of each
14135    function. We can't do this in the end_function hook, because the
14136    declarations that use the locations won't have been output when
14137    that hook is called.  Also compute have_multiple_function_sections here.  */
14138
14139 static void
14140 dwarf2out_begin_function (tree fun)
14141 {
14142   htab_empty (decl_loc_table);
14143
14144   if (function_section (fun) != text_section)
14145     have_multiple_function_sections = true;
14146
14147   dwarf2out_note_section_used ();
14148 }
14149
14150 /* Output a label to mark the beginning of a source code line entry
14151    and record information relating to this source line, in
14152    'line_info_table' for later output of the .debug_line section.  */
14153
14154 static void
14155 dwarf2out_source_line (unsigned int line, const char *filename)
14156 {
14157   if (debug_info_level >= DINFO_LEVEL_NORMAL
14158       && line != 0)
14159     {
14160       int file_num = maybe_emit_file (lookup_filename (filename));
14161
14162       switch_to_section (current_function_section ());
14163
14164       /* If requested, emit something human-readable.  */
14165       if (flag_debug_asm)
14166         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
14167                  filename, line);
14168
14169       if (DWARF2_ASM_LINE_DEBUG_INFO)
14170         {
14171           /* Emit the .loc directive understood by GNU as.  */
14172           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
14173
14174           /* Indicate that line number info exists.  */
14175           line_info_table_in_use++;
14176         }
14177       else if (function_section (current_function_decl) != text_section)
14178         {
14179           dw_separate_line_info_ref line_info;
14180           targetm.asm_out.internal_label (asm_out_file,
14181                                           SEPARATE_LINE_CODE_LABEL,
14182                                           separate_line_info_table_in_use);
14183
14184           /* Expand the line info table if necessary.  */
14185           if (separate_line_info_table_in_use
14186               == separate_line_info_table_allocated)
14187             {
14188               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
14189               separate_line_info_table
14190                 = ggc_realloc (separate_line_info_table,
14191                                separate_line_info_table_allocated
14192                                * sizeof (dw_separate_line_info_entry));
14193               memset (separate_line_info_table
14194                        + separate_line_info_table_in_use,
14195                       0,
14196                       (LINE_INFO_TABLE_INCREMENT
14197                        * sizeof (dw_separate_line_info_entry)));
14198             }
14199
14200           /* Add the new entry at the end of the line_info_table.  */
14201           line_info
14202             = &separate_line_info_table[separate_line_info_table_in_use++];
14203           line_info->dw_file_num = file_num;
14204           line_info->dw_line_num = line;
14205           line_info->function = current_function_funcdef_no;
14206         }
14207       else
14208         {
14209           dw_line_info_ref line_info;
14210
14211           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
14212                                      line_info_table_in_use);
14213
14214           /* Expand the line info table if necessary.  */
14215           if (line_info_table_in_use == line_info_table_allocated)
14216             {
14217               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
14218               line_info_table
14219                 = ggc_realloc (line_info_table,
14220                                (line_info_table_allocated
14221                                 * sizeof (dw_line_info_entry)));
14222               memset (line_info_table + line_info_table_in_use, 0,
14223                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
14224             }
14225
14226           /* Add the new entry at the end of the line_info_table.  */
14227           line_info = &line_info_table[line_info_table_in_use++];
14228           line_info->dw_file_num = file_num;
14229           line_info->dw_line_num = line;
14230         }
14231     }
14232 }
14233
14234 /* Record the beginning of a new source file.  */
14235
14236 static void
14237 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
14238 {
14239   if (flag_eliminate_dwarf2_dups)
14240     {
14241       /* Record the beginning of the file for break_out_includes.  */
14242       dw_die_ref bincl_die;
14243
14244       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
14245       add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
14246     }
14247
14248   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14249     {
14250       int file_num = maybe_emit_file (lookup_filename (filename));
14251
14252       switch_to_section (debug_macinfo_section);
14253       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
14254       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
14255                                    lineno);
14256
14257       dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
14258     }
14259 }
14260
14261 /* Record the end of a source file.  */
14262
14263 static void
14264 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
14265 {
14266   if (flag_eliminate_dwarf2_dups)
14267     /* Record the end of the file for break_out_includes.  */
14268     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
14269
14270   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14271     {
14272       switch_to_section (debug_macinfo_section);
14273       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
14274     }
14275 }
14276
14277 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
14278    the tail part of the directive line, i.e. the part which is past the
14279    initial whitespace, #, whitespace, directive-name, whitespace part.  */
14280
14281 static void
14282 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
14283                   const char *buffer ATTRIBUTE_UNUSED)
14284 {
14285   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14286     {
14287       switch_to_section (debug_macinfo_section);
14288       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
14289       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
14290       dw2_asm_output_nstring (buffer, -1, "The macro");
14291     }
14292 }
14293
14294 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
14295    the tail part of the directive line, i.e. the part which is past the
14296    initial whitespace, #, whitespace, directive-name, whitespace part.  */
14297
14298 static void
14299 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
14300                  const char *buffer ATTRIBUTE_UNUSED)
14301 {
14302   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14303     {
14304       switch_to_section (debug_macinfo_section);
14305       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
14306       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
14307       dw2_asm_output_nstring (buffer, -1, "The macro");
14308     }
14309 }
14310
14311 /* Set up for Dwarf output at the start of compilation.  */
14312
14313 static void
14314 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
14315 {
14316   /* Allocate the file_table.  */
14317   file_table = htab_create_ggc (50, file_table_hash,
14318                                 file_table_eq, NULL);
14319
14320   /* Allocate the decl_die_table.  */
14321   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
14322                                     decl_die_table_eq, NULL);
14323
14324   /* Allocate the decl_loc_table.  */
14325   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
14326                                     decl_loc_table_eq, NULL);
14327
14328   /* Allocate the initial hunk of the decl_scope_table.  */
14329   decl_scope_table = VEC_alloc (tree, gc, 256);
14330
14331   /* Allocate the initial hunk of the abbrev_die_table.  */
14332   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
14333                                         * sizeof (dw_die_ref));
14334   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
14335   /* Zero-th entry is allocated, but unused.  */
14336   abbrev_die_table_in_use = 1;
14337
14338   /* Allocate the initial hunk of the line_info_table.  */
14339   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
14340                                        * sizeof (dw_line_info_entry));
14341   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
14342
14343   /* Zero-th entry is allocated, but unused.  */
14344   line_info_table_in_use = 1;
14345
14346   /* Allocate the pubtypes and pubnames vectors.  */
14347   pubname_table = VEC_alloc (pubname_entry, gc, 32);
14348   pubtype_table = VEC_alloc (pubname_entry, gc, 32);
14349
14350   /* Generate the initial DIE for the .debug section.  Note that the (string)
14351      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
14352      will (typically) be a relative pathname and that this pathname should be
14353      taken as being relative to the directory from which the compiler was
14354      invoked when the given (base) source file was compiled.  We will fill
14355      in this value in dwarf2out_finish.  */
14356   comp_unit_die = gen_compile_unit_die (NULL);
14357
14358   incomplete_types = VEC_alloc (tree, gc, 64);
14359
14360   used_rtx_array = VEC_alloc (rtx, gc, 32);
14361
14362   debug_info_section = get_section (DEBUG_INFO_SECTION,
14363                                     SECTION_DEBUG, NULL);
14364   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
14365                                       SECTION_DEBUG, NULL);
14366   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
14367                                        SECTION_DEBUG, NULL);
14368   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
14369                                        SECTION_DEBUG, NULL);
14370   debug_line_section = get_section (DEBUG_LINE_SECTION,
14371                                     SECTION_DEBUG, NULL);
14372   debug_loc_section = get_section (DEBUG_LOC_SECTION,
14373                                    SECTION_DEBUG, NULL);
14374   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
14375                                         SECTION_DEBUG, NULL);
14376 #ifdef DEBUG_PUBTYPES_SECTION
14377   debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
14378                                         SECTION_DEBUG, NULL);
14379 #endif
14380   debug_str_section = get_section (DEBUG_STR_SECTION,
14381                                    DEBUG_STR_SECTION_FLAGS, NULL);
14382   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
14383                                       SECTION_DEBUG, NULL);
14384   debug_frame_section = get_section (DEBUG_FRAME_SECTION,
14385                                      SECTION_DEBUG, NULL);
14386
14387   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
14388   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
14389                                DEBUG_ABBREV_SECTION_LABEL, 0);
14390   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
14391   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
14392                                COLD_TEXT_SECTION_LABEL, 0);
14393   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
14394
14395   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
14396                                DEBUG_INFO_SECTION_LABEL, 0);
14397   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
14398                                DEBUG_LINE_SECTION_LABEL, 0);
14399   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
14400                                DEBUG_RANGES_SECTION_LABEL, 0);
14401   switch_to_section (debug_abbrev_section);
14402   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
14403   switch_to_section (debug_info_section);
14404   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
14405   switch_to_section (debug_line_section);
14406   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
14407
14408   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14409     {
14410       switch_to_section (debug_macinfo_section);
14411       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
14412                                    DEBUG_MACINFO_SECTION_LABEL, 0);
14413       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
14414     }
14415
14416   switch_to_section (text_section);
14417   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
14418   if (flag_reorder_blocks_and_partition)
14419     {
14420       cold_text_section = unlikely_text_section ();
14421       switch_to_section (cold_text_section);
14422       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
14423     }
14424 }
14425
14426 /* A helper function for dwarf2out_finish called through
14427    ht_forall.  Emit one queued .debug_str string.  */
14428
14429 static int
14430 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
14431 {
14432   struct indirect_string_node *node = (struct indirect_string_node *) *h;
14433
14434   if (node->form == DW_FORM_strp)
14435     {
14436       switch_to_section (debug_str_section);
14437       ASM_OUTPUT_LABEL (asm_out_file, node->label);
14438       assemble_string (node->str, strlen (node->str) + 1);
14439     }
14440
14441   return 1;
14442 }
14443
14444 #if ENABLE_ASSERT_CHECKING
14445 /* Verify that all marks are clear.  */
14446
14447 static void
14448 verify_marks_clear (dw_die_ref die)
14449 {
14450   dw_die_ref c;
14451
14452   gcc_assert (! die->die_mark);
14453   FOR_EACH_CHILD (die, c, verify_marks_clear (c));
14454 }
14455 #endif /* ENABLE_ASSERT_CHECKING */
14456
14457 /* Clear the marks for a die and its children.
14458    Be cool if the mark isn't set.  */
14459
14460 static void
14461 prune_unmark_dies (dw_die_ref die)
14462 {
14463   dw_die_ref c;
14464
14465   if (die->die_mark)
14466     die->die_mark = 0;
14467   FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
14468 }
14469
14470 /* Given DIE that we're marking as used, find any other dies
14471    it references as attributes and mark them as used.  */
14472
14473 static void
14474 prune_unused_types_walk_attribs (dw_die_ref die)
14475 {
14476   dw_attr_ref a;
14477   unsigned ix;
14478
14479   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14480     {
14481       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14482         {
14483           /* A reference to another DIE.
14484              Make sure that it will get emitted.  */
14485           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14486         }
14487       /* Set the string's refcount to 0 so that prune_unused_types_mark
14488          accounts properly for it.  */
14489       if (AT_class (a) == dw_val_class_str)
14490         a->dw_attr_val.v.val_str->refcount = 0;
14491     }
14492 }
14493
14494
14495 /* Mark DIE as being used.  If DOKIDS is true, then walk down
14496    to DIE's children.  */
14497
14498 static void
14499 prune_unused_types_mark (dw_die_ref die, int dokids)
14500 {
14501   dw_die_ref c;
14502
14503   if (die->die_mark == 0)
14504     {
14505       /* We haven't done this node yet.  Mark it as used.  */
14506       die->die_mark = 1;
14507
14508       /* We also have to mark its parents as used.
14509          (But we don't want to mark our parents' kids due to this.)  */
14510       if (die->die_parent)
14511         prune_unused_types_mark (die->die_parent, 0);
14512
14513       /* Mark any referenced nodes.  */
14514       prune_unused_types_walk_attribs (die);
14515
14516       /* If this node is a specification,
14517          also mark the definition, if it exists.  */
14518       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14519         prune_unused_types_mark (die->die_definition, 1);
14520     }
14521
14522   if (dokids && die->die_mark != 2)
14523     {
14524       /* We need to walk the children, but haven't done so yet.
14525          Remember that we've walked the kids.  */
14526       die->die_mark = 2;
14527
14528       /* If this is an array type, we need to make sure our
14529          kids get marked, even if they're types.  */
14530       if (die->die_tag == DW_TAG_array_type)
14531         FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14532       else
14533         FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14534     }
14535 }
14536
14537
14538 /* Walk the tree DIE and mark types that we actually use.  */
14539
14540 static void
14541 prune_unused_types_walk (dw_die_ref die)
14542 {
14543   dw_die_ref c;
14544
14545   /* Don't do anything if this node is already marked.  */
14546   if (die->die_mark)
14547     return;
14548
14549   switch (die->die_tag)
14550     {
14551     case DW_TAG_const_type:
14552     case DW_TAG_packed_type:
14553     case DW_TAG_pointer_type:
14554     case DW_TAG_reference_type:
14555     case DW_TAG_volatile_type:
14556     case DW_TAG_typedef:
14557     case DW_TAG_array_type:
14558     case DW_TAG_structure_type:
14559     case DW_TAG_union_type:
14560     case DW_TAG_class_type:
14561     case DW_TAG_friend:
14562     case DW_TAG_variant_part:
14563     case DW_TAG_enumeration_type:
14564     case DW_TAG_subroutine_type:
14565     case DW_TAG_string_type:
14566     case DW_TAG_set_type:
14567     case DW_TAG_subrange_type:
14568     case DW_TAG_ptr_to_member_type:
14569     case DW_TAG_file_type:
14570       if (die->die_perennial_p)
14571         break;
14572
14573       /* It's a type node --- don't mark it.  */
14574       return;
14575
14576     default:
14577       /* Mark everything else.  */
14578       break;
14579   }
14580
14581   die->die_mark = 1;
14582
14583   /* Now, mark any dies referenced from here.  */
14584   prune_unused_types_walk_attribs (die);
14585
14586   /* Mark children.  */
14587   FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14588 }
14589
14590 /* Increment the string counts on strings referred to from DIE's
14591    attributes.  */
14592
14593 static void
14594 prune_unused_types_update_strings (dw_die_ref die)
14595 {
14596   dw_attr_ref a;
14597   unsigned ix;
14598
14599   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14600     if (AT_class (a) == dw_val_class_str)
14601       {
14602         struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14603         s->refcount++;
14604         /* Avoid unnecessarily putting strings that are used less than
14605            twice in the hash table.  */
14606         if (s->refcount
14607             == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14608           {
14609             void ** slot;
14610             slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14611                                              htab_hash_string (s->str),
14612                                              INSERT);
14613             gcc_assert (*slot == NULL);
14614             *slot = s;
14615           }
14616       }
14617 }
14618
14619 /* Remove from the tree DIE any dies that aren't marked.  */
14620
14621 static void
14622 prune_unused_types_prune (dw_die_ref die)
14623 {
14624   dw_die_ref c;
14625
14626   gcc_assert (die->die_mark);
14627   prune_unused_types_update_strings (die);
14628
14629   if (! die->die_child)
14630     return;
14631
14632   c = die->die_child;
14633   do {
14634     dw_die_ref prev = c;
14635     for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14636       if (c == die->die_child)
14637         {
14638           /* No marked children between 'prev' and the end of the list.  */
14639           if (prev == c)
14640             /* No marked children at all.  */
14641             die->die_child = NULL;
14642           else
14643             {
14644               prev->die_sib = c->die_sib;
14645               die->die_child = prev;
14646             }
14647           return;
14648         }
14649
14650     if (c != prev->die_sib)
14651       prev->die_sib = c;
14652     prune_unused_types_prune (c);
14653   } while (c != die->die_child);
14654 }
14655
14656
14657 /* Remove dies representing declarations that we never use.  */
14658
14659 static void
14660 prune_unused_types (void)
14661 {
14662   unsigned int i;
14663   limbo_die_node *node;
14664   pubname_ref pub;
14665
14666 #if ENABLE_ASSERT_CHECKING
14667   /* All the marks should already be clear.  */
14668   verify_marks_clear (comp_unit_die);
14669   for (node = limbo_die_list; node; node = node->next)
14670     verify_marks_clear (node->die);
14671 #endif /* ENABLE_ASSERT_CHECKING */
14672
14673   /* Set the mark on nodes that are actually used.  */
14674   prune_unused_types_walk (comp_unit_die);
14675   for (node = limbo_die_list; node; node = node->next)
14676     prune_unused_types_walk (node->die);
14677
14678   /* Also set the mark on nodes referenced from the
14679      pubname_table or arange_table.  */
14680   for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
14681     prune_unused_types_mark (pub->die, 1);
14682   for (i = 0; i < arange_table_in_use; i++)
14683     prune_unused_types_mark (arange_table[i], 1);
14684
14685   /* Get rid of nodes that aren't marked; and update the string counts.  */
14686   if (debug_str_hash)
14687     htab_empty (debug_str_hash);
14688   prune_unused_types_prune (comp_unit_die);
14689   for (node = limbo_die_list; node; node = node->next)
14690     prune_unused_types_prune (node->die);
14691
14692   /* Leave the marks clear.  */
14693   prune_unmark_dies (comp_unit_die);
14694   for (node = limbo_die_list; node; node = node->next)
14695     prune_unmark_dies (node->die);
14696 }
14697
14698 /* Set the parameter to true if there are any relative pathnames in
14699    the file table.  */
14700 static int
14701 file_table_relative_p (void ** slot, void *param)
14702 {
14703   bool *p = param;
14704   struct dwarf_file_data *d = *slot;
14705   if (!IS_ABSOLUTE_PATH (d->filename))
14706     {
14707       *p = true;
14708       return 0;
14709     }
14710   return 1;
14711 }
14712
14713 /* Output stuff that dwarf requires at the end of every file,
14714    and generate the DWARF-2 debugging info.  */
14715
14716 static void
14717 dwarf2out_finish (const char *filename)
14718 {
14719   limbo_die_node *node, *next_node;
14720   dw_die_ref die = 0;
14721
14722   /* Add the name for the main input file now.  We delayed this from
14723      dwarf2out_init to avoid complications with PCH.  */
14724   add_name_attribute (comp_unit_die, remap_debug_filename (filename));
14725   if (!IS_ABSOLUTE_PATH (filename))
14726     add_comp_dir_attribute (comp_unit_die);
14727   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14728     {
14729       bool p = false;
14730       htab_traverse (file_table, file_table_relative_p, &p);
14731       if (p)
14732         add_comp_dir_attribute (comp_unit_die);
14733     }
14734
14735   /* Traverse the limbo die list, and add parent/child links.  The only
14736      dies without parents that should be here are concrete instances of
14737      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14738      For concrete instances, we can get the parent die from the abstract
14739      instance.  */
14740   for (node = limbo_die_list; node; node = next_node)
14741     {
14742       next_node = node->next;
14743       die = node->die;
14744
14745       if (die->die_parent == NULL)
14746         {
14747           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14748
14749           if (origin)
14750             add_child_die (origin->die_parent, die);
14751           else if (die == comp_unit_die)
14752             ;
14753           else if (errorcount > 0 || sorrycount > 0)
14754             /* It's OK to be confused by errors in the input.  */
14755             add_child_die (comp_unit_die, die);
14756           else
14757             {
14758               /* In certain situations, the lexical block containing a
14759                  nested function can be optimized away, which results
14760                  in the nested function die being orphaned.  Likewise
14761                  with the return type of that nested function.  Force
14762                  this to be a child of the containing function.
14763
14764                  It may happen that even the containing function got fully
14765                  inlined and optimized out.  In that case we are lost and
14766                  assign the empty child.  This should not be big issue as
14767                  the function is likely unreachable too.  */
14768               tree context = NULL_TREE;
14769
14770               gcc_assert (node->created_for);
14771
14772               if (DECL_P (node->created_for))
14773                 context = DECL_CONTEXT (node->created_for);
14774               else if (TYPE_P (node->created_for))
14775                 context = TYPE_CONTEXT (node->created_for);
14776
14777               gcc_assert (context
14778                           && (TREE_CODE (context) == FUNCTION_DECL
14779                               || TREE_CODE (context) == NAMESPACE_DECL));
14780
14781               origin = lookup_decl_die (context);
14782               if (origin)
14783                 add_child_die (origin, die);
14784               else
14785                 add_child_die (comp_unit_die, die);
14786             }
14787         }
14788     }
14789
14790   limbo_die_list = NULL;
14791
14792   /* Walk through the list of incomplete types again, trying once more to
14793      emit full debugging info for them.  */
14794   retry_incomplete_types ();
14795
14796   if (flag_eliminate_unused_debug_types)
14797     prune_unused_types ();
14798
14799   /* Generate separate CUs for each of the include files we've seen.
14800      They will go into limbo_die_list.  */
14801   if (flag_eliminate_dwarf2_dups)
14802     break_out_includes (comp_unit_die);
14803
14804   /* Traverse the DIE's and add add sibling attributes to those DIE's
14805      that have children.  */
14806   add_sibling_attributes (comp_unit_die);
14807   for (node = limbo_die_list; node; node = node->next)
14808     add_sibling_attributes (node->die);
14809
14810   /* Output a terminator label for the .text section.  */
14811   switch_to_section (text_section);
14812   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14813   if (flag_reorder_blocks_and_partition)
14814     {
14815       switch_to_section (unlikely_text_section ());
14816       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14817     }
14818
14819   /* We can only use the low/high_pc attributes if all of the code was
14820      in .text.  */
14821   if (!have_multiple_function_sections)
14822     {
14823       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14824       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14825     }
14826
14827   else
14828     {
14829       unsigned fde_idx = 0;
14830
14831       /* We need to give .debug_loc and .debug_ranges an appropriate
14832          "base address".  Use zero so that these addresses become
14833          absolute.  Historically, we've emitted the unexpected
14834          DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
14835          Emit both to give time for other tools to adapt.  */
14836       add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
14837       add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14838
14839       add_AT_range_list (comp_unit_die, DW_AT_ranges,
14840                          add_ranges_by_labels (text_section_label,
14841                                                text_end_label));
14842       if (flag_reorder_blocks_and_partition)
14843         add_ranges_by_labels (cold_text_section_label,
14844                               cold_end_label);
14845
14846       for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
14847         {
14848           dw_fde_ref fde = &fde_table[fde_idx];
14849
14850           if (fde->dw_fde_switched_sections)
14851             {
14852               add_ranges_by_labels (fde->dw_fde_hot_section_label,
14853                                     fde->dw_fde_hot_section_end_label);
14854               add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
14855                                     fde->dw_fde_unlikely_section_end_label);
14856             }
14857           else
14858             add_ranges_by_labels (fde->dw_fde_begin,
14859                                   fde->dw_fde_end);
14860         }
14861
14862       add_ranges (NULL);
14863     }
14864
14865   /* Output location list section if necessary.  */
14866   if (have_location_lists)
14867     {
14868       /* Output the location lists info.  */
14869       switch_to_section (debug_loc_section);
14870       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14871                                    DEBUG_LOC_SECTION_LABEL, 0);
14872       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14873       output_location_lists (die);
14874     }
14875
14876   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14877     add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14878                     debug_line_section_label);
14879
14880   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14881     add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14882
14883   /* Output all of the compilation units.  We put the main one last so that
14884      the offsets are available to output_pubnames.  */
14885   for (node = limbo_die_list; node; node = node->next)
14886     output_comp_unit (node->die, 0);
14887
14888   output_comp_unit (comp_unit_die, 0);
14889
14890   /* Output the abbreviation table.  */
14891   switch_to_section (debug_abbrev_section);
14892   output_abbrev_section ();
14893
14894   /* Output public names table if necessary.  */
14895   if (!VEC_empty (pubname_entry, pubname_table))
14896     {
14897       switch_to_section (debug_pubnames_section);
14898       output_pubnames (pubname_table);
14899     }
14900
14901 #ifdef DEBUG_PUBTYPES_SECTION
14902   /* Output public types table if necessary.  */
14903   if (!VEC_empty (pubname_entry, pubtype_table))
14904     {
14905       switch_to_section (debug_pubtypes_section);
14906       output_pubnames (pubtype_table);
14907     }
14908 #endif
14909
14910   /* Output the address range information.  We only put functions in the arange
14911      table, so don't write it out if we don't have any.  */
14912   if (fde_table_in_use)
14913     {
14914       switch_to_section (debug_aranges_section);
14915       output_aranges ();
14916     }
14917
14918   /* Output ranges section if necessary.  */
14919   if (ranges_table_in_use)
14920     {
14921       switch_to_section (debug_ranges_section);
14922       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14923       output_ranges ();
14924     }
14925
14926   /* Output the source line correspondence table.  We must do this
14927      even if there is no line information.  Otherwise, on an empty
14928      translation unit, we will generate a present, but empty,
14929      .debug_info section.  IRIX 6.5 `nm' will then complain when
14930      examining the file.  This is done late so that any filenames
14931      used by the debug_info section are marked as 'used'.  */
14932   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14933     {
14934       switch_to_section (debug_line_section);
14935       output_line_info ();
14936     }
14937
14938   /* Have to end the macro section.  */
14939   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14940     {
14941       switch_to_section (debug_macinfo_section);
14942       dw2_asm_output_data (1, 0, "End compilation unit");
14943     }
14944
14945   /* If we emitted any DW_FORM_strp form attribute, output the string
14946      table too.  */
14947   if (debug_str_hash)
14948     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14949 }
14950 #else
14951
14952 /* This should never be used, but its address is needed for comparisons.  */
14953 const struct gcc_debug_hooks dwarf2_debug_hooks;
14954
14955 #endif /* DWARF2_DEBUGGING_INFO */
14956
14957 #include "gt-dwarf2out.h"