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 2, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to the Free
  22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  23 02110-1301, USA.  */
  24
  25 /* TODO: Emit .debug_line header even when there are no functions, since
  26            the file numbers are used by .debug_info.  Alternately, leave
  27            out locations for types and decls.
  28          Avoid talking about ctors and op= for PODs.
  29          Factor out common prologue sequences into multiple CIEs.  */
  30
  31 /* The first part of this file deals with the DWARF 2 frame unwind
  32    information, which is also used by the GCC efficient exception handling
  33    mechanism.  The second part, controlled only by an #ifdef
  34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  35    information.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "coretypes.h"
  40 #include "tm.h"
  41 #include "tree.h"
  42 #include "version.h"
  43 #include "flags.h"
  44 #include "real.h"
  45 #include "rtl.h"
  46 #include "hard-reg-set.h"
  47 #include "regs.h"
  48 #include "insn-config.h"
  49 #include "reload.h"
  50 #include "function.h"
  51 #include "output.h"
  52 #include "expr.h"
  53 #include "libfuncs.h"
  54 #include "except.h"
  55 #include "dwarf2.h"
  56 #include "dwarf2out.h"
  57 #include "dwarf2asm.h"
  58 #include "toplev.h"
  59 #include "varray.h"
  60 #include "ggc.h"
  61 #include "md5.h"
  62 #include "tm_p.h"
  63 #include "diagnostic.h"
  64 #include "debug.h"
  65 #include "target.h"
  66 #include "langhooks.h"
  67 #include "hashtab.h"
  68 #include "cgraph.h"
  69 #include "input.h"
  70
  71 #ifdef DWARF2_DEBUGGING_INFO
  72 static void dwarf2out_source_line (unsigned int, const char *);
  73 #endif
  74
  75 /* DWARF2 Abbreviation Glossary:
  76    CFA = Canonical Frame Address
  77            a fixed address on the stack which identifies a call frame.
  78            We define it to be the value of SP just before the call insn.
  79            The CFA register and offset, which may change during the course
  80            of the function, are used to calculate its value at runtime.
  81    CFI = Call Frame Instruction
  82            an instruction for the DWARF2 abstract machine
  83    CIE = Common Information Entry
  84            information describing information common to one or more FDEs
  85    DIE = Debugging Information Entry
  86    FDE = Frame Description Entry
  87            information describing the stack call frame, in particular,
  88            how to restore registers
  89
  90    DW_CFA_... = DWARF2 CFA call frame instruction
  91    DW_TAG_... = DWARF2 DIE tag */
  92
  93 #ifndef DWARF2_FRAME_INFO
  94 # ifdef DWARF2_DEBUGGING_INFO
  95 #  define DWARF2_FRAME_INFO \
  96   (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
  97 # else
  98 #  define DWARF2_FRAME_INFO 0
  99 # endif
 100 #endif
 101
 102 /* Map register numbers held in the call frame info that gcc has
 103    collected using DWARF_FRAME_REGNUM to those that should be output in
 104    .debug_frame and .eh_frame.  */
 105 #ifndef DWARF2_FRAME_REG_OUT
 106 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
 107 #endif
 108
 109 /* Decide whether we want to emit frame unwind information for the current
 110    translation unit.  */
 111
 112 int
 113 dwarf2out_do_frame (void)
 114 {
 115   /* We want to emit correct CFA location expressions or lists, so we
 116      have to return true if we're going to output debug info, even if
 117      we're not going to output frame or unwind info.  */
 118   return (write_symbols == DWARF2_DEBUG
 119           || write_symbols == VMS_AND_DWARF2_DEBUG
 120           || DWARF2_FRAME_INFO
 121 #ifdef DWARF2_UNWIND_INFO
 122           || (DWARF2_UNWIND_INFO
 123               && (flag_unwind_tables
 124                   || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
 125 #endif
 126           );
 127 }
 128
 129 /* The size of the target's pointer type.  */
 130 #ifndef PTR_SIZE
 131 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 132 #endif
 133
 134 /* Array of RTXes referenced by the debugging information, which therefore
 135    must be kept around forever.  */
 136 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 137
 138 /* A pointer to the base of a list of incomplete types which might be
 139    completed at some later time.  incomplete_types_list needs to be a
 140    VEC(tree,gc) because we want to tell the garbage collector about
 141    it.  */
 142 static GTY(()) VEC(tree,gc) *incomplete_types;
 143
 144 /* A pointer to the base of a table of references to declaration
 145    scopes.  This table is a display which tracks the nesting
 146    of declaration scopes at the current scope and containing
 147    scopes.  This table is used to find the proper place to
 148    define type declaration DIE's.  */
 149 static GTY(()) VEC(tree,gc) *decl_scope_table;
 150
 151 /* Pointers to various DWARF2 sections.  */
 152 static GTY(()) section *debug_info_section;
 153 static GTY(()) section *debug_abbrev_section;
 154 static GTY(()) section *debug_aranges_section;
 155 static GTY(()) section *debug_macinfo_section;
 156 static GTY(()) section *debug_line_section;
 157 static GTY(()) section *debug_loc_section;
 158 static GTY(()) section *debug_pubnames_section;
 159 static GTY(()) section *debug_pubtypes_section;
 160 static GTY(()) section *debug_str_section;
 161 static GTY(()) section *debug_ranges_section;
 162 static GTY(()) section *debug_frame_section;
 163
 164 /* How to start an assembler comment.  */
 165 #ifndef ASM_COMMENT_START
 166 #define ASM_COMMENT_START ";#"
 167 #endif
 168
 169 typedef struct dw_cfi_struct *dw_cfi_ref;
 170 typedef struct dw_fde_struct *dw_fde_ref;
 171 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 172
 173 /* Call frames are described using a sequence of Call Frame
 174    Information instructions.  The register number, offset
 175    and address fields are provided as possible operands;
 176    their use is selected by the opcode field.  */
 177
 178 enum dw_cfi_oprnd_type {
 179   dw_cfi_oprnd_unused,
 180   dw_cfi_oprnd_reg_num,
 181   dw_cfi_oprnd_offset,
 182   dw_cfi_oprnd_addr,
 183   dw_cfi_oprnd_loc
 184 };
 185
 186 typedef union dw_cfi_oprnd_struct GTY(())
 187 {
 188   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 189   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 190   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 191   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 192 }
 193 dw_cfi_oprnd;
 194
 195 typedef struct dw_cfi_struct GTY(())
 196 {
 197   dw_cfi_ref dw_cfi_next;
 198   enum dwarf_call_frame_info dw_cfi_opc;
 199   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 200     dw_cfi_oprnd1;
 201   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 202     dw_cfi_oprnd2;
 203 }
 204 dw_cfi_node;
 205
 206 /* This is how we define the location of the CFA. We use to handle it
 207    as REG + OFFSET all the time,  but now it can be more complex.
 208    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 209    Instead of passing around REG and OFFSET, we pass a copy
 210    of this structure.  */
 211 typedef struct cfa_loc GTY(())
 212 {
 213   HOST_WIDE_INT offset;
 214   HOST_WIDE_INT base_offset;
 215   unsigned int reg;
 216   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 217 } dw_cfa_location;
 218
 219 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 220    refer to a single Common Information Entry (CIE), defined at
 221    the beginning of the .debug_frame section.  This use of a single
 222    CIE obviates the need to keep track of multiple CIE's
 223    in the DWARF generation routines below.  */
 224
 225 typedef struct dw_fde_struct GTY(())
 226 {
 227   tree decl;
 228   const char *dw_fde_begin;
 229   const char *dw_fde_current_label;
 230   const char *dw_fde_end;
 231   const char *dw_fde_hot_section_label;
 232   const char *dw_fde_hot_section_end_label;
 233   const char *dw_fde_unlikely_section_label;
 234   const char *dw_fde_unlikely_section_end_label;
 235   bool dw_fde_switched_sections;
 236   dw_cfi_ref dw_fde_cfi;
 237   unsigned funcdef_number;
 238   unsigned all_throwers_are_sibcalls : 1;
 239   unsigned nothrow : 1;
 240   unsigned uses_eh_lsda : 1;
 241 }
 242 dw_fde_node;
 243
 244 /* Maximum size (in bytes) of an artificially generated label.  */
 245 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 246
 247 /* The size of addresses as they appear in the Dwarf 2 data.
 248    Some architectures use word addresses to refer to code locations,
 249    but Dwarf 2 info always uses byte addresses.  On such machines,
 250    Dwarf 2 addresses need to be larger than the architecture's
 251    pointers.  */
 252 #ifndef DWARF2_ADDR_SIZE
 253 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 254 #endif
 255
 256 /* The size in bytes of a DWARF field indicating an offset or length
 257    relative to a debug info section, specified to be 4 bytes in the
 258    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 259    as PTR_SIZE.  */
 260
 261 #ifndef DWARF_OFFSET_SIZE
 262 #define DWARF_OFFSET_SIZE 4
 263 #endif
 264
 265 /* According to the (draft) DWARF 3 specification, the initial length
 266    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 267    bytes are 0xffffffff, followed by the length stored in the next 8
 268    bytes.
 269
 270    However, the SGI/MIPS ABI uses an initial length which is equal to
 271    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 272
 273 #ifndef DWARF_INITIAL_LENGTH_SIZE
 274 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 275 #endif
 276
 277 #define DWARF_VERSION 2
 278
 279 /* Round SIZE up to the nearest BOUNDARY.  */
 280 #define DWARF_ROUND(SIZE,BOUNDARY) \
 281   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 282
 283 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 284 #ifndef DWARF_CIE_DATA_ALIGNMENT
 285 #ifdef STACK_GROWS_DOWNWARD
 286 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 287 #else
 288 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 289 #endif
 290 #endif
 291
 292 /* CIE identifier.  */
 293 #if HOST_BITS_PER_WIDE_INT >= 64
 294 #define DWARF_CIE_ID \
 295   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
 296 #else
 297 #define DWARF_CIE_ID DW_CIE_ID
 298 #endif
 299
 300 /* A pointer to the base of a table that contains frame description
 301    information for each routine.  */
 302 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 303
 304 /* Number of elements currently allocated for fde_table.  */
 305 static GTY(()) unsigned fde_table_allocated;
 306
 307 /* Number of elements in fde_table currently in use.  */
 308 static GTY(()) unsigned fde_table_in_use;
 309
 310 /* Size (in elements) of increments by which we may expand the
 311    fde_table.  */
 312 #define FDE_TABLE_INCREMENT 256
 313
 314 /* A list of call frame insns for the CIE.  */
 315 static GTY(()) dw_cfi_ref cie_cfi_head;
 316
 317 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 318 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 319    attribute that accelerates the lookup of the FDE associated
 320    with the subprogram.  This variable holds the table index of the FDE
 321    associated with the current function (body) definition.  */
 322 static unsigned current_funcdef_fde;
 323 #endif
 324
 325 struct indirect_string_node GTY(())
 326 {
 327   const char *str;
 328   unsigned int refcount;
 329   unsigned int form;
 330   char *label;
 331 };
 332
 333 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 334
 335 static GTY(()) int dw2_string_counter;
 336 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 337
 338 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 339
 340 /* Forward declarations for functions defined in this file.  */
 341
 342 static char *stripattributes (const char *);
 343 static const char *dwarf_cfi_name (unsigned);
 344 static dw_cfi_ref new_cfi (void);
 345 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 346 static void add_fde_cfi (const char *, dw_cfi_ref);
 347 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
 348 static void lookup_cfa (dw_cfa_location *);
 349 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 350 static void initial_return_save (rtx);
 351 static HOST_WIDE_INT stack_adjust_offset (rtx);
 352 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 353 static void output_call_frame_info (int);
 354 static void dwarf2out_stack_adjust (rtx, bool);
 355 static void flush_queued_reg_saves (void);
 356 static bool clobbers_queued_reg_save (rtx);
 357 static void dwarf2out_frame_debug_expr (rtx, const char *);
 358
 359 /* Support for complex CFA locations.  */
 360 static void output_cfa_loc (dw_cfi_ref);
 361 static void get_cfa_from_loc_descr (dw_cfa_location *,
 362                                     struct dw_loc_descr_struct *);
 363 static struct dw_loc_descr_struct *build_cfa_loc
 364   (dw_cfa_location *, HOST_WIDE_INT);
 365 static void def_cfa_1 (const char *, dw_cfa_location *);
 366
 367 /* How to start an assembler comment.  */
 368 #ifndef ASM_COMMENT_START
 369 #define ASM_COMMENT_START ";#"
 370 #endif
 371
 372 /* Data and reference forms for relocatable data.  */
 373 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 374 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 375
 376 #ifndef DEBUG_FRAME_SECTION
 377 #define DEBUG_FRAME_SECTION     ".debug_frame"
 378 #endif
 379
 380 #ifndef FUNC_BEGIN_LABEL
 381 #define FUNC_BEGIN_LABEL        "LFB"
 382 #endif
 383
 384 #ifndef FUNC_END_LABEL
 385 #define FUNC_END_LABEL          "LFE"
 386 #endif
 387
 388 #ifndef FRAME_BEGIN_LABEL
 389 #define FRAME_BEGIN_LABEL       "Lframe"
 390 #endif
 391 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 392 #define CIE_END_LABEL           "LECIE"
 393 #define FDE_LABEL               "LSFDE"
 394 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 395 #define FDE_END_LABEL           "LEFDE"
 396 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 397 #define LINE_NUMBER_END_LABEL   "LELT"
 398 #define LN_PROLOG_AS_LABEL      "LASLTP"
 399 #define LN_PROLOG_END_LABEL     "LELTP"
 400 #define DIE_LABEL_PREFIX        "DW"
 401
 402 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 403    is the column for PC, or the first column after all of the hard
 404    registers.  */
 405 #ifndef DWARF_FRAME_RETURN_COLUMN
 406 #ifdef PC_REGNUM
 407 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 408 #else
 409 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 410 #endif
 411 #endif
 412
 413 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 414    default, we just provide columns for all registers.  */
 415 #ifndef DWARF_FRAME_REGNUM
 416 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 417 #endif
 418 \f
 419 /* Hook used by __throw.  */
 420
 421 rtx
 422 expand_builtin_dwarf_sp_column (void)
 423 {
 424   unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
 425   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
 426 }
 427
 428 /* Return a pointer to a copy of the section string name S with all
 429    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 430
 431 static inline char *
 432 stripattributes (const char *s)
 433 {
 434   char *stripped = XNEWVEC (char, strlen (s) + 2);
 435   char *p = stripped;
 436
 437   *p++ = '*';
 438
 439   while (*s && *s != ',')
 440     *p++ = *s++;
 441
 442   *p = '\0';
 443   return stripped;
 444 }
 445
 446 /* MEM is a memory reference for the register size table, each element of
 447    which has mode MODE.  Initialize column C as a return address column.  */
 448
 449 static void
 450 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
 451 {
 452   HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
 453   HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
 454   emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 455 }
 456
 457 /* Generate code to initialize the register size table.  */
 458
 459 void
 460 expand_builtin_init_dwarf_reg_sizes (tree address)
 461 {
 462   unsigned int i;
 463   enum machine_mode mode = TYPE_MODE (char_type_node);
 464   rtx addr = expand_normal (address);
 465   rtx mem = gen_rtx_MEM (BLKmode, addr);
 466   bool wrote_return_column = false;
 467
 468   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 469     {
 470       int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
 471
 472       if (rnum < DWARF_FRAME_REGISTERS)
 473         {
 474           HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
 475           enum machine_mode save_mode = reg_raw_mode[i];
 476           HOST_WIDE_INT size;
 477
 478           if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 479             save_mode = choose_hard_reg_mode (i, 1, true);
 480           if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 481             {
 482               if (save_mode == VOIDmode)
 483                 continue;
 484               wrote_return_column = true;
 485             }
 486           size = GET_MODE_SIZE (save_mode);
 487           if (offset < 0)
 488             continue;
 489
 490           emit_move_insn (adjust_address (mem, mode, offset),
 491                           gen_int_mode (size, mode));
 492         }
 493     }
 494
 495   if (!wrote_return_column)
 496     init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
 497
 498 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 499   init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
 500 #endif
 501 }
 502
 503 /* Convert a DWARF call frame info. operation to its string name */
 504
 505 static const char *
 506 dwarf_cfi_name (unsigned int cfi_opc)
 507 {
 508   switch (cfi_opc)
 509     {
 510     case DW_CFA_advance_loc:
 511       return "DW_CFA_advance_loc";
 512     case DW_CFA_offset:
 513       return "DW_CFA_offset";
 514     case DW_CFA_restore:
 515       return "DW_CFA_restore";
 516     case DW_CFA_nop:
 517       return "DW_CFA_nop";
 518     case DW_CFA_set_loc:
 519       return "DW_CFA_set_loc";
 520     case DW_CFA_advance_loc1:
 521       return "DW_CFA_advance_loc1";
 522     case DW_CFA_advance_loc2:
 523       return "DW_CFA_advance_loc2";
 524     case DW_CFA_advance_loc4:
 525       return "DW_CFA_advance_loc4";
 526     case DW_CFA_offset_extended:
 527       return "DW_CFA_offset_extended";
 528     case DW_CFA_restore_extended:
 529       return "DW_CFA_restore_extended";
 530     case DW_CFA_undefined:
 531       return "DW_CFA_undefined";
 532     case DW_CFA_same_value:
 533       return "DW_CFA_same_value";
 534     case DW_CFA_register:
 535       return "DW_CFA_register";
 536     case DW_CFA_remember_state:
 537       return "DW_CFA_remember_state";
 538     case DW_CFA_restore_state:
 539       return "DW_CFA_restore_state";
 540     case DW_CFA_def_cfa:
 541       return "DW_CFA_def_cfa";
 542     case DW_CFA_def_cfa_register:
 543       return "DW_CFA_def_cfa_register";
 544     case DW_CFA_def_cfa_offset:
 545       return "DW_CFA_def_cfa_offset";
 546
 547     /* DWARF 3 */
 548     case DW_CFA_def_cfa_expression:
 549       return "DW_CFA_def_cfa_expression";
 550     case DW_CFA_expression:
 551       return "DW_CFA_expression";
 552     case DW_CFA_offset_extended_sf:
 553       return "DW_CFA_offset_extended_sf";
 554     case DW_CFA_def_cfa_sf:
 555       return "DW_CFA_def_cfa_sf";
 556     case DW_CFA_def_cfa_offset_sf:
 557       return "DW_CFA_def_cfa_offset_sf";
 558
 559     /* SGI/MIPS specific */
 560     case DW_CFA_MIPS_advance_loc8:
 561       return "DW_CFA_MIPS_advance_loc8";
 562
 563     /* GNU extensions */
 564     case DW_CFA_GNU_window_save:
 565       return "DW_CFA_GNU_window_save";
 566     case DW_CFA_GNU_args_size:
 567       return "DW_CFA_GNU_args_size";
 568     case DW_CFA_GNU_negative_offset_extended:
 569       return "DW_CFA_GNU_negative_offset_extended";
 570
 571     default:
 572       return "DW_CFA_<unknown>";
 573     }
 574 }
 575
 576 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 577
 578 static inline dw_cfi_ref
 579 new_cfi (void)
 580 {
 581   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
 582
 583   cfi->dw_cfi_next = NULL;
 584   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 585   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 586
 587   return cfi;
 588 }
 589
 590 /* Add a Call Frame Instruction to list of instructions.  */
 591
 592 static inline void
 593 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 594 {
 595   dw_cfi_ref *p;
 596
 597   /* Find the end of the chain.  */
 598   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 599     ;
 600
 601   *p = cfi;
 602 }
 603
 604 /* Generate a new label for the CFI info to refer to.  */
 605
 606 char *
 607 dwarf2out_cfi_label (void)
 608 {
 609   static char label[20];
 610
 611   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 612   ASM_OUTPUT_LABEL (asm_out_file, label);
 613   return label;
 614 }
 615
 616 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 617    or to the CIE if LABEL is NULL.  */
 618
 619 static void
 620 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 621 {
 622   if (label)
 623     {
 624       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 625
 626       if (*label == 0)
 627         label = dwarf2out_cfi_label ();
 628
 629       if (fde->dw_fde_current_label == NULL
 630           || strcmp (label, fde->dw_fde_current_label) != 0)
 631         {
 632           dw_cfi_ref xcfi;
 633
 634           label = xstrdup (label);
 635
 636           /* Set the location counter to the new label.  */
 637           xcfi = new_cfi ();
 638           /* If we have a current label, advance from there, otherwise
 639              set the location directly using set_loc.  */
 640           xcfi->dw_cfi_opc = fde->dw_fde_current_label
 641                              ? DW_CFA_advance_loc4
 642                              : DW_CFA_set_loc;
 643           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 644           add_cfi (&fde->dw_fde_cfi, xcfi);
 645
 646           fde->dw_fde_current_label = label;
 647         }
 648
 649       add_cfi (&fde->dw_fde_cfi, cfi);
 650     }
 651
 652   else
 653     add_cfi (&cie_cfi_head, cfi);
 654 }
 655
 656 /* Subroutine of lookup_cfa.  */
 657
 658 static void
 659 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
 660 {
 661   switch (cfi->dw_cfi_opc)
 662     {
 663     case DW_CFA_def_cfa_offset:
 664       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 665       break;
 666     case DW_CFA_def_cfa_offset_sf:
 667       loc->offset
 668         = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 669       break;
 670     case DW_CFA_def_cfa_register:
 671       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 672       break;
 673     case DW_CFA_def_cfa:
 674       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 675       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 676       break;
 677     case DW_CFA_def_cfa_sf:
 678       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 679       loc->offset
 680         = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 681       break;
 682     case DW_CFA_def_cfa_expression:
 683       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 684       break;
 685     default:
 686       break;
 687     }
 688 }
 689
 690 /* Find the previous value for the CFA.  */
 691
 692 static void
 693 lookup_cfa (dw_cfa_location *loc)
 694 {
 695   dw_cfi_ref cfi;
 696
 697   loc->reg = INVALID_REGNUM;
 698   loc->offset = 0;
 699   loc->indirect = 0;
 700   loc->base_offset = 0;
 701
 702   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 703     lookup_cfa_1 (cfi, loc);
 704
 705   if (fde_table_in_use)
 706     {
 707       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 708       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 709         lookup_cfa_1 (cfi, loc);
 710     }
 711 }
 712
 713 /* The current rule for calculating the DWARF2 canonical frame address.  */
 714 static dw_cfa_location cfa;
 715
 716 /* The register used for saving registers to the stack, and its offset
 717    from the CFA.  */
 718 static dw_cfa_location cfa_store;
 719
 720 /* The running total of the size of arguments pushed onto the stack.  */
 721 static HOST_WIDE_INT args_size;
 722
 723 /* The last args_size we actually output.  */
 724 static HOST_WIDE_INT old_args_size;
 725
 726 /* Entry point to update the canonical frame address (CFA).
 727    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 728    calculated from REG+OFFSET.  */
 729
 730 void
 731 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 732 {
 733   dw_cfa_location loc;
 734   loc.indirect = 0;
 735   loc.base_offset = 0;
 736   loc.reg = reg;
 737   loc.offset = offset;
 738   def_cfa_1 (label, &loc);
 739 }
 740
 741 /* Determine if two dw_cfa_location structures define the same data.  */
 742
 743 static bool
 744 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
 745 {
 746   return (loc1->reg == loc2->reg
 747           && loc1->offset == loc2->offset
 748           && loc1->indirect == loc2->indirect
 749           && (loc1->indirect == 0
 750               || loc1->base_offset == loc2->base_offset));
 751 }
 752
 753 /* This routine does the actual work.  The CFA is now calculated from
 754    the dw_cfa_location structure.  */
 755
 756 static void
 757 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
 758 {
 759   dw_cfi_ref cfi;
 760   dw_cfa_location old_cfa, loc;
 761
 762   cfa = *loc_p;
 763   loc = *loc_p;
 764
 765   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 766     cfa_store.offset = loc.offset;
 767
 768   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 769   lookup_cfa (&old_cfa);
 770
 771   /* If nothing changed, no need to issue any call frame instructions.  */
 772   if (cfa_equal_p (&loc, &old_cfa))
 773     return;
 774
 775   cfi = new_cfi ();
 776
 777   if (loc.reg == old_cfa.reg && !loc.indirect)
 778     {
 779       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
 780          the CFA register did not change but the offset did.  */
 781       if (loc.offset < 0)
 782         {
 783           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 784           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 785
 786           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
 787           cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
 788         }
 789       else
 790         {
 791           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 792           cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 793         }
 794     }
 795
 796 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 797   else if (loc.offset == old_cfa.offset
 798            && old_cfa.reg != INVALID_REGNUM
 799            && !loc.indirect)
 800     {
 801       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 802          indicating the CFA register has changed to <register> but the
 803          offset has not changed.  */
 804       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 805       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 806     }
 807 #endif
 808
 809   else if (loc.indirect == 0)
 810     {
 811       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 812          indicating the CFA register has changed to <register> with
 813          the specified offset.  */
 814       if (loc.offset < 0)
 815         {
 816           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 817           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 818
 819           cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
 820           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 821           cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
 822         }
 823       else
 824         {
 825           cfi->dw_cfi_opc = DW_CFA_def_cfa;
 826           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 827           cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 828         }
 829     }
 830   else
 831     {
 832       /* Construct a DW_CFA_def_cfa_expression instruction to
 833          calculate the CFA using a full location expression since no
 834          register-offset pair is available.  */
 835       struct dw_loc_descr_struct *loc_list;
 836
 837       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 838       loc_list = build_cfa_loc (&loc, 0);
 839       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 840     }
 841
 842   add_fde_cfi (label, cfi);
 843 }
 844
 845 /* Add the CFI for saving a register.  REG is the CFA column number.
 846    LABEL is passed to add_fde_cfi.
 847    If SREG is -1, the register is saved at OFFSET from the CFA;
 848    otherwise it is saved in SREG.  */
 849
 850 static void
 851 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
 852 {
 853   dw_cfi_ref cfi = new_cfi ();
 854
 855   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 856
 857   if (sreg == INVALID_REGNUM)
 858     {
 859       if (reg & ~0x3f)
 860         /* The register number won't fit in 6 bits, so we have to use
 861            the long form.  */
 862         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 863       else
 864         cfi->dw_cfi_opc = DW_CFA_offset;
 865
 866 #ifdef ENABLE_CHECKING
 867       {
 868         /* If we get an offset that is not a multiple of
 869            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 870            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 871            description.  */
 872         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 873
 874         gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
 875       }
 876 #endif
 877       offset /= DWARF_CIE_DATA_ALIGNMENT;
 878       if (offset < 0)
 879         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 880
 881       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 882     }
 883   else if (sreg == reg)
 884     cfi->dw_cfi_opc = DW_CFA_same_value;
 885   else
 886     {
 887       cfi->dw_cfi_opc = DW_CFA_register;
 888       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 889     }
 890
 891   add_fde_cfi (label, cfi);
 892 }
 893
 894 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 895    This CFI tells the unwinder that it needs to restore the window registers
 896    from the previous frame's window save area.
 897
 898    ??? Perhaps we should note in the CIE where windows are saved (instead of
 899    assuming 0(cfa)) and what registers are in the window.  */
 900
 901 void
 902 dwarf2out_window_save (const char *label)
 903 {
 904   dw_cfi_ref cfi = new_cfi ();
 905
 906   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 907   add_fde_cfi (label, cfi);
 908 }
 909
 910 /* Add a CFI to update the running total of the size of arguments
 911    pushed onto the stack.  */
 912
 913 void
 914 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
 915 {
 916   dw_cfi_ref cfi;
 917
 918   if (size == old_args_size)
 919     return;
 920
 921   old_args_size = size;
 922
 923   cfi = new_cfi ();
 924   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 925   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 926   add_fde_cfi (label, cfi);
 927 }
 928
 929 /* Entry point for saving a register to the stack.  REG is the GCC register
 930    number.  LABEL and OFFSET are passed to reg_save.  */
 931
 932 void
 933 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 934 {
 935   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
 936 }
 937
 938 /* Entry point for saving the return address in the stack.
 939    LABEL and OFFSET are passed to reg_save.  */
 940
 941 void
 942 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
 943 {
 944   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
 945 }
 946
 947 /* Entry point for saving the return address in a register.
 948    LABEL and SREG are passed to reg_save.  */
 949
 950 void
 951 dwarf2out_return_reg (const char *label, unsigned int sreg)
 952 {
 953   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
 954 }
 955
 956 /* Record the initial position of the return address.  RTL is
 957    INCOMING_RETURN_ADDR_RTX.  */
 958
 959 static void
 960 initial_return_save (rtx rtl)
 961 {
 962   unsigned int reg = INVALID_REGNUM;
 963   HOST_WIDE_INT offset = 0;
 964
 965   switch (GET_CODE (rtl))
 966     {
 967     case REG:
 968       /* RA is in a register.  */
 969       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 970       break;
 971
 972     case MEM:
 973       /* RA is on the stack.  */
 974       rtl = XEXP (rtl, 0);
 975       switch (GET_CODE (rtl))
 976         {
 977         case REG:
 978           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
 979           offset = 0;
 980           break;
 981
 982         case PLUS:
 983           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 984           offset = INTVAL (XEXP (rtl, 1));
 985           break;
 986
 987         case MINUS:
 988           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 989           offset = -INTVAL (XEXP (rtl, 1));
 990           break;
 991
 992         default:
 993           gcc_unreachable ();
 994         }
 995
 996       break;
 997
 998     case PLUS:
 999       /* The return address is at some offset from any value we can
1000          actually load.  For instance, on the SPARC it is in %i7+8. Just
1001          ignore the offset for now; it doesn't matter for unwinding frames.  */
1002       gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1003       initial_return_save (XEXP (rtl, 0));
1004       return;
1005
1006     default:
1007       gcc_unreachable ();
1008     }
1009
1010   if (reg != DWARF_FRAME_RETURN_COLUMN)
1011     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1012 }
1013
1014 /* Given a SET, calculate the amount of stack adjustment it
1015    contains.  */
1016
1017 static HOST_WIDE_INT
1018 stack_adjust_offset (rtx pattern)
1019 {
1020   rtx src = SET_SRC (pattern);
1021   rtx dest = SET_DEST (pattern);
1022   HOST_WIDE_INT offset = 0;
1023   enum rtx_code code;
1024
1025   if (dest == stack_pointer_rtx)
1026     {
1027       /* (set (reg sp) (plus (reg sp) (const_int))) */
1028       code = GET_CODE (src);
1029       if (! (code == PLUS || code == MINUS)
1030           || XEXP (src, 0) != stack_pointer_rtx
1031           || GET_CODE (XEXP (src, 1)) != CONST_INT)
1032         return 0;
1033
1034       offset = INTVAL (XEXP (src, 1));
1035       if (code == PLUS)
1036         offset = -offset;
1037     }
1038   else if (MEM_P (dest))
1039     {
1040       /* (set (mem (pre_dec (reg sp))) (foo)) */
1041       src = XEXP (dest, 0);
1042       code = GET_CODE (src);
1043
1044       switch (code)
1045         {
1046         case PRE_MODIFY:
1047         case POST_MODIFY:
1048           if (XEXP (src, 0) == stack_pointer_rtx)
1049             {
1050               rtx val = XEXP (XEXP (src, 1), 1);
1051               /* We handle only adjustments by constant amount.  */
1052               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1053                           && GET_CODE (val) == CONST_INT);
1054               offset = -INTVAL (val);
1055               break;
1056             }
1057           return 0;
1058
1059         case PRE_DEC:
1060         case POST_DEC:
1061           if (XEXP (src, 0) == stack_pointer_rtx)
1062             {
1063               offset = GET_MODE_SIZE (GET_MODE (dest));
1064               break;
1065             }
1066           return 0;
1067
1068         case PRE_INC:
1069         case POST_INC:
1070           if (XEXP (src, 0) == stack_pointer_rtx)
1071             {
1072               offset = -GET_MODE_SIZE (GET_MODE (dest));
1073               break;
1074             }
1075           return 0;
1076
1077         default:
1078           return 0;
1079         }
1080     }
1081   else
1082     return 0;
1083
1084   return offset;
1085 }
1086
1087 /* Check INSN to see if it looks like a push or a stack adjustment, and
1088    make a note of it if it does.  EH uses this information to find out how
1089    much extra space it needs to pop off the stack.  */
1090
1091 static void
1092 dwarf2out_stack_adjust (rtx insn, bool after_p)
1093 {
1094   HOST_WIDE_INT offset;
1095   const char *label;
1096   int i;
1097
1098   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1099      with this function.  Proper support would require all frame-related
1100      insns to be marked, and to be able to handle saving state around
1101      epilogues textually in the middle of the function.  */
1102   if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1103     return;
1104
1105   /* If only calls can throw, and we have a frame pointer,
1106      save up adjustments until we see the CALL_INSN.  */
1107   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1108     {
1109       if (CALL_P (insn) && !after_p)
1110         {
1111           /* Extract the size of the args from the CALL rtx itself.  */
1112           insn = PATTERN (insn);
1113           if (GET_CODE (insn) == PARALLEL)
1114             insn = XVECEXP (insn, 0, 0);
1115           if (GET_CODE (insn) == SET)
1116             insn = SET_SRC (insn);
1117           gcc_assert (GET_CODE (insn) == CALL);
1118           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1119         }
1120       return;
1121     }
1122
1123   if (CALL_P (insn) && !after_p)
1124     {
1125       if (!flag_asynchronous_unwind_tables)
1126         dwarf2out_args_size ("", args_size);
1127       return;
1128     }
1129   else if (BARRIER_P (insn))
1130     {
1131       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1132          the compiler will have already emitted a stack adjustment, but
1133          doesn't bother for calls to noreturn functions.  */
1134 #ifdef STACK_GROWS_DOWNWARD
1135       offset = -args_size;
1136 #else
1137       offset = args_size;
1138 #endif
1139     }
1140   else if (GET_CODE (PATTERN (insn)) == SET)
1141     offset = stack_adjust_offset (PATTERN (insn));
1142   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1143            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1144     {
1145       /* There may be stack adjustments inside compound insns.  Search
1146          for them.  */
1147       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1148         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1149           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1150     }
1151   else
1152     return;
1153
1154   if (offset == 0)
1155     return;
1156
1157   if (cfa.reg == STACK_POINTER_REGNUM)
1158     cfa.offset += offset;
1159
1160 #ifndef STACK_GROWS_DOWNWARD
1161   offset = -offset;
1162 #endif
1163
1164   args_size += offset;
1165   if (args_size < 0)
1166     args_size = 0;
1167
1168   label = dwarf2out_cfi_label ();
1169   def_cfa_1 (label, &cfa);
1170   if (flag_asynchronous_unwind_tables)
1171     dwarf2out_args_size (label, args_size);
1172 }
1173
1174 #endif
1175
1176 /* We delay emitting a register save until either (a) we reach the end
1177    of the prologue or (b) the register is clobbered.  This clusters
1178    register saves so that there are fewer pc advances.  */
1179
1180 struct queued_reg_save GTY(())
1181 {
1182   struct queued_reg_save *next;
1183   rtx reg;
1184   HOST_WIDE_INT cfa_offset;
1185   rtx saved_reg;
1186 };
1187
1188 static GTY(()) struct queued_reg_save *queued_reg_saves;
1189
1190 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1191 struct reg_saved_in_data GTY(()) {
1192   rtx orig_reg;
1193   rtx saved_in_reg;
1194 };
1195
1196 /* A list of registers saved in other registers.
1197    The list intentionally has a small maximum capacity of 4; if your
1198    port needs more than that, you might consider implementing a
1199    more efficient data structure.  */
1200 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1201 static GTY(()) size_t num_regs_saved_in_regs;
1202
1203 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1204 static const char *last_reg_save_label;
1205
1206 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1207    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1208
1209 static void
1210 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1211 {
1212   struct queued_reg_save *q;
1213
1214   /* Duplicates waste space, but it's also necessary to remove them
1215      for correctness, since the queue gets output in reverse
1216      order.  */
1217   for (q = queued_reg_saves; q != NULL; q = q->next)
1218     if (REGNO (q->reg) == REGNO (reg))
1219       break;
1220
1221   if (q == NULL)
1222     {
1223       q = ggc_alloc (sizeof (*q));
1224       q->next = queued_reg_saves;
1225       queued_reg_saves = q;
1226     }
1227
1228   q->reg = reg;
1229   q->cfa_offset = offset;
1230   q->saved_reg = sreg;
1231
1232   last_reg_save_label = label;
1233 }
1234
1235 /* Output all the entries in QUEUED_REG_SAVES.  */
1236
1237 static void
1238 flush_queued_reg_saves (void)
1239 {
1240   struct queued_reg_save *q;
1241
1242   for (q = queued_reg_saves; q; q = q->next)
1243     {
1244       size_t i;
1245       unsigned int reg, sreg;
1246
1247       for (i = 0; i < num_regs_saved_in_regs; i++)
1248         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1249           break;
1250       if (q->saved_reg && i == num_regs_saved_in_regs)
1251         {
1252           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1253           num_regs_saved_in_regs++;
1254         }
1255       if (i != num_regs_saved_in_regs)
1256         {
1257           regs_saved_in_regs[i].orig_reg = q->reg;
1258           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1259         }
1260
1261       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1262       if (q->saved_reg)
1263         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1264       else
1265         sreg = INVALID_REGNUM;
1266       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1267     }
1268
1269   queued_reg_saves = NULL;
1270   last_reg_save_label = NULL;
1271 }
1272
1273 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1274    location for?  Or, does it clobber a register which we've previously
1275    said that some other register is saved in, and for which we now
1276    have a new location for?  */
1277
1278 static bool
1279 clobbers_queued_reg_save (rtx insn)
1280 {
1281   struct queued_reg_save *q;
1282
1283   for (q = queued_reg_saves; q; q = q->next)
1284     {
1285       size_t i;
1286       if (modified_in_p (q->reg, insn))
1287         return true;
1288       for (i = 0; i < num_regs_saved_in_regs; i++)
1289         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1290             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1291           return true;
1292     }
1293
1294   return false;
1295 }
1296
1297 /* Entry point for saving the first register into the second.  */
1298
1299 void
1300 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1301 {
1302   size_t i;
1303   unsigned int regno, sregno;
1304
1305   for (i = 0; i < num_regs_saved_in_regs; i++)
1306     if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1307       break;
1308   if (i == num_regs_saved_in_regs)
1309     {
1310       gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1311       num_regs_saved_in_regs++;
1312     }
1313   regs_saved_in_regs[i].orig_reg = reg;
1314   regs_saved_in_regs[i].saved_in_reg = sreg;
1315
1316   regno = DWARF_FRAME_REGNUM (REGNO (reg));
1317   sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1318   reg_save (label, regno, sregno, 0);
1319 }
1320
1321 /* What register, if any, is currently saved in REG?  */
1322
1323 static rtx
1324 reg_saved_in (rtx reg)
1325 {
1326   unsigned int regn = REGNO (reg);
1327   size_t i;
1328   struct queued_reg_save *q;
1329
1330   for (q = queued_reg_saves; q; q = q->next)
1331     if (q->saved_reg && regn == REGNO (q->saved_reg))
1332       return q->reg;
1333
1334   for (i = 0; i < num_regs_saved_in_regs; i++)
1335     if (regs_saved_in_regs[i].saved_in_reg
1336         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1337       return regs_saved_in_regs[i].orig_reg;
1338
1339   return NULL_RTX;
1340 }
1341
1342
1343 /* A temporary register holding an integral value used in adjusting SP
1344    or setting up the store_reg.  The "offset" field holds the integer
1345    value, not an offset.  */
1346 static dw_cfa_location cfa_temp;
1347
1348 /* Record call frame debugging information for an expression EXPR,
1349    which either sets SP or FP (adjusting how we calculate the frame
1350    address) or saves a register to the stack or another register.
1351    LABEL indicates the address of EXPR.
1352
1353    This function encodes a state machine mapping rtxes to actions on
1354    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1355    users need not read the source code.
1356
1357   The High-Level Picture
1358
1359   Changes in the register we use to calculate the CFA: Currently we
1360   assume that if you copy the CFA register into another register, we
1361   should take the other one as the new CFA register; this seems to
1362   work pretty well.  If it's wrong for some target, it's simple
1363   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1364
1365   Changes in the register we use for saving registers to the stack:
1366   This is usually SP, but not always.  Again, we deduce that if you
1367   copy SP into another register (and SP is not the CFA register),
1368   then the new register is the one we will be using for register
1369   saves.  This also seems to work.
1370
1371   Register saves: There's not much guesswork about this one; if
1372   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1373   register save, and the register used to calculate the destination
1374   had better be the one we think we're using for this purpose.
1375   It's also assumed that a copy from a call-saved register to another
1376   register is saving that register if RTX_FRAME_RELATED_P is set on
1377   that instruction.  If the copy is from a call-saved register to
1378   the *same* register, that means that the register is now the same
1379   value as in the caller.
1380
1381   Except: If the register being saved is the CFA register, and the
1382   offset is nonzero, we are saving the CFA, so we assume we have to
1383   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1384   the intent is to save the value of SP from the previous frame.
1385
1386   In addition, if a register has previously been saved to a different
1387   register,
1388
1389   Invariants / Summaries of Rules
1390
1391   cfa          current rule for calculating the CFA.  It usually
1392                consists of a register and an offset.
1393   cfa_store    register used by prologue code to save things to the stack
1394                cfa_store.offset is the offset from the value of
1395                cfa_store.reg to the actual CFA
1396   cfa_temp     register holding an integral value.  cfa_temp.offset
1397                stores the value, which will be used to adjust the
1398                stack pointer.  cfa_temp is also used like cfa_store,
1399                to track stores to the stack via fp or a temp reg.
1400
1401   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1402                with cfa.reg as the first operand changes the cfa.reg and its
1403                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1404                cfa_temp.offset.
1405
1406   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1407                expression yielding a constant.  This sets cfa_temp.reg
1408                and cfa_temp.offset.
1409
1410   Rule 5:      Create a new register cfa_store used to save items to the
1411                stack.
1412
1413   Rules 10-14: Save a register to the stack.  Define offset as the
1414                difference of the original location and cfa_store's
1415                location (or cfa_temp's location if cfa_temp is used).
1416
1417   The Rules
1418
1419   "{a,b}" indicates a choice of a xor b.
1420   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1421
1422   Rule 1:
1423   (set <reg1> <reg2>:cfa.reg)
1424   effects: cfa.reg = <reg1>
1425            cfa.offset unchanged
1426            cfa_temp.reg = <reg1>
1427            cfa_temp.offset = cfa.offset
1428
1429   Rule 2:
1430   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1431                               {<const_int>,<reg>:cfa_temp.reg}))
1432   effects: cfa.reg = sp if fp used
1433            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1434            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1435              if cfa_store.reg==sp
1436
1437   Rule 3:
1438   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1439   effects: cfa.reg = fp
1440            cfa_offset += +/- <const_int>
1441
1442   Rule 4:
1443   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1444   constraints: <reg1> != fp
1445                <reg1> != sp
1446   effects: cfa.reg = <reg1>
1447            cfa_temp.reg = <reg1>
1448            cfa_temp.offset = cfa.offset
1449
1450   Rule 5:
1451   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1452   constraints: <reg1> != fp
1453                <reg1> != sp
1454   effects: cfa_store.reg = <reg1>
1455            cfa_store.offset = cfa.offset - cfa_temp.offset
1456
1457   Rule 6:
1458   (set <reg> <const_int>)
1459   effects: cfa_temp.reg = <reg>
1460            cfa_temp.offset = <const_int>
1461
1462   Rule 7:
1463   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1464   effects: cfa_temp.reg = <reg1>
1465            cfa_temp.offset |= <const_int>
1466
1467   Rule 8:
1468   (set <reg> (high <exp>))
1469   effects: none
1470
1471   Rule 9:
1472   (set <reg> (lo_sum <exp> <const_int>))
1473   effects: cfa_temp.reg = <reg>
1474            cfa_temp.offset = <const_int>
1475
1476   Rule 10:
1477   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1478   effects: cfa_store.offset -= <const_int>
1479            cfa.offset = cfa_store.offset if cfa.reg == sp
1480            cfa.reg = sp
1481            cfa.base_offset = -cfa_store.offset
1482
1483   Rule 11:
1484   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1485   effects: cfa_store.offset += -/+ mode_size(mem)
1486            cfa.offset = cfa_store.offset if cfa.reg == sp
1487            cfa.reg = sp
1488            cfa.base_offset = -cfa_store.offset
1489
1490   Rule 12:
1491   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1492
1493        <reg2>)
1494   effects: cfa.reg = <reg1>
1495            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1496
1497   Rule 13:
1498   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1499   effects: cfa.reg = <reg1>
1500            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1501
1502   Rule 14:
1503   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1504   effects: cfa.reg = <reg1>
1505            cfa.base_offset = -cfa_temp.offset
1506            cfa_temp.offset -= mode_size(mem)
1507
1508   Rule 15:
1509   (set <reg> {unspec, unspec_volatile})
1510   effects: target-dependent  */
1511
1512 static void
1513 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1514 {
1515   rtx src, dest;
1516   HOST_WIDE_INT offset;
1517
1518   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1519      the PARALLEL independently. The first element is always processed if
1520      it is a SET. This is for backward compatibility.   Other elements
1521      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1522      flag is set in them.  */
1523   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1524     {
1525       int par_index;
1526       int limit = XVECLEN (expr, 0);
1527       rtx elem;
1528
1529       /* PARALLELs have strict read-modify-write semantics, so we
1530          ought to evaluate every rvalue before changing any lvalue.
1531          It's cumbersome to do that in general, but there's an
1532          easy approximation that is enough for all current users:
1533          handle register saves before register assignments.  */
1534       if (GET_CODE (expr) == PARALLEL)
1535         for (par_index = 0; par_index < limit; par_index++)
1536           {
1537             elem = XVECEXP (expr, 0, par_index);
1538             if (GET_CODE (elem) == SET
1539                 && MEM_P (SET_DEST (elem))
1540                 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1541               dwarf2out_frame_debug_expr (elem, label);
1542           }
1543
1544       for (par_index = 0; par_index < limit; par_index++)
1545         {
1546           elem = XVECEXP (expr, 0, par_index);
1547           if (GET_CODE (elem) == SET
1548               && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
1549               && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1550             dwarf2out_frame_debug_expr (elem, label);
1551         }
1552       return;
1553     }
1554
1555   gcc_assert (GET_CODE (expr) == SET);
1556
1557   src = SET_SRC (expr);
1558   dest = SET_DEST (expr);
1559
1560   if (REG_P (src))
1561     {
1562       rtx rsi = reg_saved_in (src);
1563       if (rsi)
1564         src = rsi;
1565     }
1566
1567   switch (GET_CODE (dest))
1568     {
1569     case REG:
1570       switch (GET_CODE (src))
1571         {
1572           /* Setting FP from SP.  */
1573         case REG:
1574           if (cfa.reg == (unsigned) REGNO (src))
1575             {
1576               /* Rule 1 */
1577               /* Update the CFA rule wrt SP or FP.  Make sure src is
1578                  relative to the current CFA register.
1579
1580                  We used to require that dest be either SP or FP, but the
1581                  ARM copies SP to a temporary register, and from there to
1582                  FP.  So we just rely on the backends to only set
1583                  RTX_FRAME_RELATED_P on appropriate insns.  */
1584               cfa.reg = REGNO (dest);
1585               cfa_temp.reg = cfa.reg;
1586               cfa_temp.offset = cfa.offset;
1587             }
1588           else
1589             {
1590               /* Saving a register in a register.  */
1591               gcc_assert (!fixed_regs [REGNO (dest)]
1592                           /* For the SPARC and its register window.  */
1593                           || (DWARF_FRAME_REGNUM (REGNO (src))
1594                               == DWARF_FRAME_RETURN_COLUMN));
1595               queue_reg_save (label, src, dest, 0);
1596             }
1597           break;
1598
1599         case PLUS:
1600         case MINUS:
1601         case LO_SUM:
1602           if (dest == stack_pointer_rtx)
1603             {
1604               /* Rule 2 */
1605               /* Adjusting SP.  */
1606               switch (GET_CODE (XEXP (src, 1)))
1607                 {
1608                 case CONST_INT:
1609                   offset = INTVAL (XEXP (src, 1));
1610                   break;
1611                 case REG:
1612                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1613                               == cfa_temp.reg);
1614                   offset = cfa_temp.offset;
1615                   break;
1616                 default:
1617                   gcc_unreachable ();
1618                 }
1619
1620               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1621                 {
1622                   /* Restoring SP from FP in the epilogue.  */
1623                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1624                   cfa.reg = STACK_POINTER_REGNUM;
1625                 }
1626               else if (GET_CODE (src) == LO_SUM)
1627                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1628                 ;
1629               else
1630                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1631
1632               if (GET_CODE (src) != MINUS)
1633                 offset = -offset;
1634               if (cfa.reg == STACK_POINTER_REGNUM)
1635                 cfa.offset += offset;
1636               if (cfa_store.reg == STACK_POINTER_REGNUM)
1637                 cfa_store.offset += offset;
1638             }
1639           else if (dest == hard_frame_pointer_rtx)
1640             {
1641               /* Rule 3 */
1642               /* Either setting the FP from an offset of the SP,
1643                  or adjusting the FP */
1644               gcc_assert (frame_pointer_needed);
1645
1646               gcc_assert (REG_P (XEXP (src, 0))
1647                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1648                           && GET_CODE (XEXP (src, 1)) == CONST_INT);
1649               offset = INTVAL (XEXP (src, 1));
1650               if (GET_CODE (src) != MINUS)
1651                 offset = -offset;
1652               cfa.offset += offset;
1653               cfa.reg = HARD_FRAME_POINTER_REGNUM;
1654             }
1655           else
1656             {
1657               gcc_assert (GET_CODE (src) != MINUS);
1658
1659               /* Rule 4 */
1660               if (REG_P (XEXP (src, 0))
1661                   && REGNO (XEXP (src, 0)) == cfa.reg
1662                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1663                 {
1664                   /* Setting a temporary CFA register that will be copied
1665                      into the FP later on.  */
1666                   offset = - INTVAL (XEXP (src, 1));
1667                   cfa.offset += offset;
1668                   cfa.reg = REGNO (dest);
1669                   /* Or used to save regs to the stack.  */
1670                   cfa_temp.reg = cfa.reg;
1671                   cfa_temp.offset = cfa.offset;
1672                 }
1673
1674               /* Rule 5 */
1675               else if (REG_P (XEXP (src, 0))
1676                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1677                        && XEXP (src, 1) == stack_pointer_rtx)
1678                 {
1679                   /* Setting a scratch register that we will use instead
1680                      of SP for saving registers to the stack.  */
1681                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1682                   cfa_store.reg = REGNO (dest);
1683                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1684                 }
1685
1686               /* Rule 9 */
1687               else if (GET_CODE (src) == LO_SUM
1688                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1689                 {
1690                   cfa_temp.reg = REGNO (dest);
1691                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1692                 }
1693               else
1694                 gcc_unreachable ();
1695             }
1696           break;
1697
1698           /* Rule 6 */
1699         case CONST_INT:
1700           cfa_temp.reg = REGNO (dest);
1701           cfa_temp.offset = INTVAL (src);
1702           break;
1703
1704           /* Rule 7 */
1705         case IOR:
1706           gcc_assert (REG_P (XEXP (src, 0))
1707                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1708                       && GET_CODE (XEXP (src, 1)) == CONST_INT);
1709
1710           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1711             cfa_temp.reg = REGNO (dest);
1712           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1713           break;
1714
1715           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1716              which will fill in all of the bits.  */
1717           /* Rule 8 */
1718         case HIGH:
1719           break;
1720
1721           /* Rule 15 */
1722         case UNSPEC:
1723         case UNSPEC_VOLATILE:
1724           gcc_assert (targetm.dwarf_handle_frame_unspec);
1725           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1726           return;
1727
1728         default:
1729           gcc_unreachable ();
1730         }
1731
1732       def_cfa_1 (label, &cfa);
1733       break;
1734
1735     case MEM:
1736       gcc_assert (REG_P (src));
1737
1738       /* Saving a register to the stack.  Make sure dest is relative to the
1739          CFA register.  */
1740       switch (GET_CODE (XEXP (dest, 0)))
1741         {
1742           /* Rule 10 */
1743           /* With a push.  */
1744         case PRE_MODIFY:
1745           /* We can't handle variable size modifications.  */
1746           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1747                       == CONST_INT);
1748           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1749
1750           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1751                       && cfa_store.reg == STACK_POINTER_REGNUM);
1752
1753           cfa_store.offset += offset;
1754           if (cfa.reg == STACK_POINTER_REGNUM)
1755             cfa.offset = cfa_store.offset;
1756
1757           offset = -cfa_store.offset;
1758           break;
1759
1760           /* Rule 11 */
1761         case PRE_INC:
1762         case PRE_DEC:
1763           offset = GET_MODE_SIZE (GET_MODE (dest));
1764           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1765             offset = -offset;
1766
1767           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1768                       && cfa_store.reg == STACK_POINTER_REGNUM);
1769
1770           cfa_store.offset += offset;
1771           if (cfa.reg == STACK_POINTER_REGNUM)
1772             cfa.offset = cfa_store.offset;
1773
1774           offset = -cfa_store.offset;
1775           break;
1776
1777           /* Rule 12 */
1778           /* With an offset.  */
1779         case PLUS:
1780         case MINUS:
1781         case LO_SUM:
1782           {
1783             int regno;
1784
1785             gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1786                         && REG_P (XEXP (XEXP (dest, 0), 0)));
1787             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1788             if (GET_CODE (XEXP (dest, 0)) == MINUS)
1789               offset = -offset;
1790
1791             regno = REGNO (XEXP (XEXP (dest, 0), 0));
1792
1793             if (cfa_store.reg == (unsigned) regno)
1794               offset -= cfa_store.offset;
1795             else
1796               {
1797                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1798                 offset -= cfa_temp.offset;
1799               }
1800           }
1801           break;
1802
1803           /* Rule 13 */
1804           /* Without an offset.  */
1805         case REG:
1806           {
1807             int regno = REGNO (XEXP (dest, 0));
1808
1809             if (cfa_store.reg == (unsigned) regno)
1810               offset = -cfa_store.offset;
1811             else
1812               {
1813                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1814                 offset = -cfa_temp.offset;
1815               }
1816           }
1817           break;
1818
1819           /* Rule 14 */
1820         case POST_INC:
1821           gcc_assert (cfa_temp.reg
1822                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1823           offset = -cfa_temp.offset;
1824           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1825           break;
1826
1827         default:
1828           gcc_unreachable ();
1829         }
1830
1831       if (REGNO (src) != STACK_POINTER_REGNUM
1832           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1833           && (unsigned) REGNO (src) == cfa.reg)
1834         {
1835           /* We're storing the current CFA reg into the stack.  */
1836
1837           if (cfa.offset == 0)
1838             {
1839               /* If the source register is exactly the CFA, assume
1840                  we're saving SP like any other register; this happens
1841                  on the ARM.  */
1842               def_cfa_1 (label, &cfa);
1843               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1844               break;
1845             }
1846           else
1847             {
1848               /* Otherwise, we'll need to look in the stack to
1849                  calculate the CFA.  */
1850               rtx x = XEXP (dest, 0);
1851
1852               if (!REG_P (x))
1853                 x = XEXP (x, 0);
1854               gcc_assert (REG_P (x));
1855
1856               cfa.reg = REGNO (x);
1857               cfa.base_offset = offset;
1858               cfa.indirect = 1;
1859               def_cfa_1 (label, &cfa);
1860               break;
1861             }
1862         }
1863
1864       def_cfa_1 (label, &cfa);
1865       queue_reg_save (label, src, NULL_RTX, offset);
1866       break;
1867
1868     default:
1869       gcc_unreachable ();
1870     }
1871 }
1872
1873 /* Record call frame debugging information for INSN, which either
1874    sets SP or FP (adjusting how we calculate the frame address) or saves a
1875    register to the stack.  If INSN is NULL_RTX, initialize our state.
1876
1877    If AFTER_P is false, we're being called before the insn is emitted,
1878    otherwise after.  Call instructions get invoked twice.  */
1879
1880 void
1881 dwarf2out_frame_debug (rtx insn, bool after_p)
1882 {
1883   const char *label;
1884   rtx src;
1885
1886   if (insn == NULL_RTX)
1887     {
1888       size_t i;
1889
1890       /* Flush any queued register saves.  */
1891       flush_queued_reg_saves ();
1892
1893       /* Set up state for generating call frame debug info.  */
1894       lookup_cfa (&cfa);
1895       gcc_assert (cfa.reg
1896                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1897
1898       cfa.reg = STACK_POINTER_REGNUM;
1899       cfa_store = cfa;
1900       cfa_temp.reg = -1;
1901       cfa_temp.offset = 0;
1902
1903       for (i = 0; i < num_regs_saved_in_regs; i++)
1904         {
1905           regs_saved_in_regs[i].orig_reg = NULL_RTX;
1906           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1907         }
1908       num_regs_saved_in_regs = 0;
1909       return;
1910     }
1911
1912   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1913     flush_queued_reg_saves ();
1914
1915   if (! RTX_FRAME_RELATED_P (insn))
1916     {
1917       if (!ACCUMULATE_OUTGOING_ARGS)
1918         dwarf2out_stack_adjust (insn, after_p);
1919       return;
1920     }
1921
1922   label = dwarf2out_cfi_label ();
1923   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1924   if (src)
1925     insn = XEXP (src, 0);
1926   else
1927     insn = PATTERN (insn);
1928
1929   dwarf2out_frame_debug_expr (insn, label);
1930 }
1931
1932 #endif
1933
1934 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1935 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1936  (enum dwarf_call_frame_info cfi);
1937
1938 static enum dw_cfi_oprnd_type
1939 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1940 {
1941   switch (cfi)
1942     {
1943     case DW_CFA_nop:
1944     case DW_CFA_GNU_window_save:
1945       return dw_cfi_oprnd_unused;
1946
1947     case DW_CFA_set_loc:
1948     case DW_CFA_advance_loc1:
1949     case DW_CFA_advance_loc2:
1950     case DW_CFA_advance_loc4:
1951     case DW_CFA_MIPS_advance_loc8:
1952       return dw_cfi_oprnd_addr;
1953
1954     case DW_CFA_offset:
1955     case DW_CFA_offset_extended:
1956     case DW_CFA_def_cfa:
1957     case DW_CFA_offset_extended_sf:
1958     case DW_CFA_def_cfa_sf:
1959     case DW_CFA_restore_extended:
1960     case DW_CFA_undefined:
1961     case DW_CFA_same_value:
1962     case DW_CFA_def_cfa_register:
1963     case DW_CFA_register:
1964       return dw_cfi_oprnd_reg_num;
1965
1966     case DW_CFA_def_cfa_offset:
1967     case DW_CFA_GNU_args_size:
1968     case DW_CFA_def_cfa_offset_sf:
1969       return dw_cfi_oprnd_offset;
1970
1971     case DW_CFA_def_cfa_expression:
1972     case DW_CFA_expression:
1973       return dw_cfi_oprnd_loc;
1974
1975     default:
1976       gcc_unreachable ();
1977     }
1978 }
1979
1980 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1981 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1982  (enum dwarf_call_frame_info cfi);
1983
1984 static enum dw_cfi_oprnd_type
1985 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1986 {
1987   switch (cfi)
1988     {
1989     case DW_CFA_def_cfa:
1990     case DW_CFA_def_cfa_sf:
1991     case DW_CFA_offset:
1992     case DW_CFA_offset_extended_sf:
1993     case DW_CFA_offset_extended:
1994       return dw_cfi_oprnd_offset;
1995
1996     case DW_CFA_register:
1997       return dw_cfi_oprnd_reg_num;
1998
1999     default:
2000       return dw_cfi_oprnd_unused;
2001     }
2002 }
2003
2004 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2005
2006 /* Switch to eh_frame_section.  If we don't have an eh_frame_section,
2007    switch to the data section instead, and write out a synthetic label
2008    for collect2.  */
2009
2010 static void
2011 switch_to_eh_frame_section (void)
2012 {
2013   tree label;
2014
2015 #ifdef EH_FRAME_SECTION_NAME
2016   if (eh_frame_section == 0)
2017     {
2018       int flags;
2019
2020       if (EH_TABLES_CAN_BE_READ_ONLY)
2021         {
2022           int fde_encoding;
2023           int per_encoding;
2024           int lsda_encoding;
2025
2026           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2027                                                        /*global=*/0);
2028           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2029                                                        /*global=*/1);
2030           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2031                                                         /*global=*/0);
2032           flags = ((! flag_pic
2033                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2034                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
2035                         && (per_encoding & 0x70) != DW_EH_PE_absptr
2036                         && (per_encoding & 0x70) != DW_EH_PE_aligned
2037                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2038                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2039                    ? 0 : SECTION_WRITE);
2040         }
2041       else
2042         flags = SECTION_WRITE;
2043       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2044     }
2045 #endif
2046
2047   if (eh_frame_section)
2048     switch_to_section (eh_frame_section);
2049   else
2050     {
2051       /* We have no special eh_frame section.  Put the information in
2052          the data section and emit special labels to guide collect2.  */
2053       switch_to_section (data_section);
2054       label = get_file_function_name ("F");
2055       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2056       targetm.asm_out.globalize_label (asm_out_file,
2057                                        IDENTIFIER_POINTER (label));
2058       ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2059     }
2060 }
2061
2062 /* Output a Call Frame Information opcode and its operand(s).  */
2063
2064 static void
2065 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2066 {
2067   unsigned long r;
2068   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2069     dw2_asm_output_data (1, (cfi->dw_cfi_opc
2070                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2071                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2072                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
2073   else if (cfi->dw_cfi_opc == DW_CFA_offset)
2074     {
2075       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2076       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2077                            "DW_CFA_offset, column 0x%lx", r);
2078       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2079     }
2080   else if (cfi->dw_cfi_opc == DW_CFA_restore)
2081     {
2082       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2083       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2084                            "DW_CFA_restore, column 0x%lx", r);
2085     }
2086   else
2087     {
2088       dw2_asm_output_data (1, cfi->dw_cfi_opc,
2089                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2090
2091       switch (cfi->dw_cfi_opc)
2092         {
2093         case DW_CFA_set_loc:
2094           if (for_eh)
2095             dw2_asm_output_encoded_addr_rtx (
2096                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2097                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2098                 false, NULL);
2099           else
2100             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2101                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2102           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2103           break;
2104
2105         case DW_CFA_advance_loc1:
2106           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2107                                 fde->dw_fde_current_label, NULL);
2108           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2109           break;
2110
2111         case DW_CFA_advance_loc2:
2112           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2113                                 fde->dw_fde_current_label, NULL);
2114           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2115           break;
2116
2117         case DW_CFA_advance_loc4:
2118           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2119                                 fde->dw_fde_current_label, NULL);
2120           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2121           break;
2122
2123         case DW_CFA_MIPS_advance_loc8:
2124           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2125                                 fde->dw_fde_current_label, NULL);
2126           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2127           break;
2128
2129         case DW_CFA_offset_extended:
2130         case DW_CFA_def_cfa:
2131           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2132           dw2_asm_output_data_uleb128 (r, NULL);
2133           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2134           break;
2135
2136         case DW_CFA_offset_extended_sf:
2137         case DW_CFA_def_cfa_sf:
2138           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2139           dw2_asm_output_data_uleb128 (r, NULL);
2140           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2141           break;
2142
2143         case DW_CFA_restore_extended:
2144         case DW_CFA_undefined:
2145         case DW_CFA_same_value:
2146         case DW_CFA_def_cfa_register:
2147           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2148           dw2_asm_output_data_uleb128 (r, NULL);
2149           break;
2150
2151         case DW_CFA_register:
2152           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2153           dw2_asm_output_data_uleb128 (r, NULL);
2154           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2155           dw2_asm_output_data_uleb128 (r, NULL);
2156           break;
2157
2158         case DW_CFA_def_cfa_offset:
2159         case DW_CFA_GNU_args_size:
2160           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2161           break;
2162
2163         case DW_CFA_def_cfa_offset_sf:
2164           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2165           break;
2166
2167         case DW_CFA_GNU_window_save:
2168           break;
2169
2170         case DW_CFA_def_cfa_expression:
2171         case DW_CFA_expression:
2172           output_cfa_loc (cfi);
2173           break;
2174
2175         case DW_CFA_GNU_negative_offset_extended:
2176           /* Obsoleted by DW_CFA_offset_extended_sf.  */
2177           gcc_unreachable ();
2178
2179         default:
2180           break;
2181         }
2182     }
2183 }
2184
2185 /* Output the call frame information used to record information
2186    that relates to calculating the frame pointer, and records the
2187    location of saved registers.  */
2188
2189 static void
2190 output_call_frame_info (int for_eh)
2191 {
2192   unsigned int i;
2193   dw_fde_ref fde;
2194   dw_cfi_ref cfi;
2195   char l1[20], l2[20], section_start_label[20];
2196   bool any_lsda_needed = false;
2197   char augmentation[6];
2198   int augmentation_size;
2199   int fde_encoding = DW_EH_PE_absptr;
2200   int per_encoding = DW_EH_PE_absptr;
2201   int lsda_encoding = DW_EH_PE_absptr;
2202   int return_reg;
2203
2204   /* Don't emit a CIE if there won't be any FDEs.  */
2205   if (fde_table_in_use == 0)
2206     return;
2207
2208   /* If we make FDEs linkonce, we may have to emit an empty label for
2209      an FDE that wouldn't otherwise be emitted.  We want to avoid
2210      having an FDE kept around when the function it refers to is
2211      discarded.  Example where this matters: a primary function
2212      template in C++ requires EH information, but an explicit
2213      specialization doesn't.  */
2214   if (TARGET_USES_WEAK_UNWIND_INFO
2215       && ! flag_asynchronous_unwind_tables
2216       && for_eh)
2217     for (i = 0; i < fde_table_in_use; i++)
2218       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2219           && !fde_table[i].uses_eh_lsda
2220           && ! DECL_WEAK (fde_table[i].decl))
2221         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2222                                       for_eh, /* empty */ 1);
2223
2224   /* If we don't have any functions we'll want to unwind out of, don't
2225      emit any EH unwind information.  Note that if exceptions aren't
2226      enabled, we won't have collected nothrow information, and if we
2227      asked for asynchronous tables, we always want this info.  */
2228   if (for_eh)
2229     {
2230       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2231
2232       for (i = 0; i < fde_table_in_use; i++)
2233         if (fde_table[i].uses_eh_lsda)
2234           any_eh_needed = any_lsda_needed = true;
2235         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2236           any_eh_needed = true;
2237         else if (! fde_table[i].nothrow
2238                  && ! fde_table[i].all_throwers_are_sibcalls)
2239           any_eh_needed = true;
2240
2241       if (! any_eh_needed)
2242         return;
2243     }
2244
2245   /* We're going to be generating comments, so turn on app.  */
2246   if (flag_debug_asm)
2247     app_enable ();
2248
2249   if (for_eh)
2250     switch_to_eh_frame_section ();
2251   else
2252     {
2253       if (!debug_frame_section)
2254         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2255                                            SECTION_DEBUG, NULL);
2256       switch_to_section (debug_frame_section);
2257     }
2258
2259   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2260   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2261
2262   /* Output the CIE.  */
2263   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2264   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2265   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2266     dw2_asm_output_data (4, 0xffffffff,
2267       "Initial length escape value indicating 64-bit DWARF extension");
2268   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2269                         "Length of Common Information Entry");
2270   ASM_OUTPUT_LABEL (asm_out_file, l1);
2271
2272   /* Now that the CIE pointer is PC-relative for EH,
2273      use 0 to identify the CIE.  */
2274   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2275                        (for_eh ? 0 : DWARF_CIE_ID),
2276                        "CIE Identifier Tag");
2277
2278   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2279
2280   augmentation[0] = 0;
2281   augmentation_size = 0;
2282   if (for_eh)
2283     {
2284       char *p;
2285
2286       /* Augmentation:
2287          z      Indicates that a uleb128 is present to size the
2288                 augmentation section.
2289          L      Indicates the encoding (and thus presence) of
2290                 an LSDA pointer in the FDE augmentation.
2291          R      Indicates a non-default pointer encoding for
2292                 FDE code pointers.
2293          P      Indicates the presence of an encoding + language
2294                 personality routine in the CIE augmentation.  */
2295
2296       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2297       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2298       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2299
2300       p = augmentation + 1;
2301       if (eh_personality_libfunc)
2302         {
2303           *p++ = 'P';
2304           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2305         }
2306       if (any_lsda_needed)
2307         {
2308           *p++ = 'L';
2309           augmentation_size += 1;
2310         }
2311       if (fde_encoding != DW_EH_PE_absptr)
2312         {
2313           *p++ = 'R';
2314           augmentation_size += 1;
2315         }
2316       if (p > augmentation + 1)
2317         {
2318           augmentation[0] = 'z';
2319           *p = '\0';
2320         }
2321
2322       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2323       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2324         {
2325           int offset = (  4             /* Length */
2326                         + 4             /* CIE Id */
2327                         + 1             /* CIE version */
2328                         + strlen (augmentation) + 1     /* Augmentation */
2329                         + size_of_uleb128 (1)           /* Code alignment */
2330                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2331                         + 1             /* RA column */
2332                         + 1             /* Augmentation size */
2333                         + 1             /* Personality encoding */ );
2334           int pad = -offset & (PTR_SIZE - 1);
2335
2336           augmentation_size += pad;
2337
2338           /* Augmentations should be small, so there's scarce need to
2339              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2340           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2341         }
2342     }
2343
2344   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2345   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2346   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2347                                "CIE Data Alignment Factor");
2348
2349   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2350   if (DW_CIE_VERSION == 1)
2351     dw2_asm_output_data (1, return_reg, "CIE RA Column");
2352   else
2353     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2354
2355   if (augmentation[0])
2356     {
2357       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2358       if (eh_personality_libfunc)
2359         {
2360           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2361                                eh_data_format_name (per_encoding));
2362           dw2_asm_output_encoded_addr_rtx (per_encoding,
2363                                            eh_personality_libfunc,
2364                                            true, NULL);
2365         }
2366
2367       if (any_lsda_needed)
2368         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2369                              eh_data_format_name (lsda_encoding));
2370
2371       if (fde_encoding != DW_EH_PE_absptr)
2372         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2373                              eh_data_format_name (fde_encoding));
2374     }
2375
2376   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2377     output_cfi (cfi, NULL, for_eh);
2378
2379   /* Pad the CIE out to an address sized boundary.  */
2380   ASM_OUTPUT_ALIGN (asm_out_file,
2381                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2382   ASM_OUTPUT_LABEL (asm_out_file, l2);
2383
2384   /* Loop through all of the FDE's.  */
2385   for (i = 0; i < fde_table_in_use; i++)
2386     {
2387       fde = &fde_table[i];
2388
2389       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2390       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2391           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2392           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2393           && !fde->uses_eh_lsda)
2394         continue;
2395
2396       targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2397       targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2398       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2399       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2400       if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2401         dw2_asm_output_data (4, 0xffffffff,
2402                              "Initial length escape value indicating 64-bit DWARF extension");
2403       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2404                             "FDE Length");
2405       ASM_OUTPUT_LABEL (asm_out_file, l1);
2406
2407       if (for_eh)
2408         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2409       else
2410         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2411                                debug_frame_section, "FDE CIE offset");
2412
2413       if (for_eh)
2414         {
2415           rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2416           SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2417           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2418                                            sym_ref,
2419                                            false,
2420                                            "FDE initial location");
2421           if (fde->dw_fde_switched_sections)
2422             {
2423               rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2424                                       fde->dw_fde_unlikely_section_label);
2425               rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2426                                       fde->dw_fde_hot_section_label);
2427               SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2428               SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2429               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2430                                                "FDE initial location");
2431               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2432                                     fde->dw_fde_hot_section_end_label,
2433                                     fde->dw_fde_hot_section_label,
2434                                     "FDE address range");
2435               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2436                                                "FDE initial location");
2437               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2438                                     fde->dw_fde_unlikely_section_end_label,
2439                                     fde->dw_fde_unlikely_section_label,
2440                                     "FDE address range");
2441             }
2442           else
2443             dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2444                                   fde->dw_fde_end, fde->dw_fde_begin,
2445                                   "FDE address range");
2446         }
2447       else
2448         {
2449           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2450                                "FDE initial location");
2451           if (fde->dw_fde_switched_sections)
2452             {
2453               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2454                                    fde->dw_fde_hot_section_label,
2455                                    "FDE initial location");
2456               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2457                                     fde->dw_fde_hot_section_end_label,
2458                                     fde->dw_fde_hot_section_label,
2459                                     "FDE address range");
2460               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2461                                    fde->dw_fde_unlikely_section_label,
2462                                    "FDE initial location");
2463               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2464                                     fde->dw_fde_unlikely_section_end_label,
2465                                     fde->dw_fde_unlikely_section_label,
2466                                     "FDE address range");
2467             }
2468           else
2469             dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2470                                   fde->dw_fde_end, fde->dw_fde_begin,
2471                                   "FDE address range");
2472         }
2473
2474       if (augmentation[0])
2475         {
2476           if (any_lsda_needed)
2477             {
2478               int size = size_of_encoded_value (lsda_encoding);
2479
2480               if (lsda_encoding == DW_EH_PE_aligned)
2481                 {
2482                   int offset = (  4             /* Length */
2483                                 + 4             /* CIE offset */
2484                                 + 2 * size_of_encoded_value (fde_encoding)
2485                                 + 1             /* Augmentation size */ );
2486                   int pad = -offset & (PTR_SIZE - 1);
2487
2488                   size += pad;
2489                   gcc_assert (size_of_uleb128 (size) == 1);
2490                 }
2491
2492               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2493
2494               if (fde->uses_eh_lsda)
2495                 {
2496                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2497                                                fde->funcdef_number);
2498                   dw2_asm_output_encoded_addr_rtx (
2499                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2500                         false, "Language Specific Data Area");
2501                 }
2502               else
2503                 {
2504                   if (lsda_encoding == DW_EH_PE_aligned)
2505                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2506                   dw2_asm_output_data
2507                     (size_of_encoded_value (lsda_encoding), 0,
2508                      "Language Specific Data Area (none)");
2509                 }
2510             }
2511           else
2512             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2513         }
2514
2515       /* Loop through the Call Frame Instructions associated with
2516          this FDE.  */
2517       fde->dw_fde_current_label = fde->dw_fde_begin;
2518       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2519         output_cfi (cfi, fde, for_eh);
2520
2521       /* Pad the FDE out to an address sized boundary.  */
2522       ASM_OUTPUT_ALIGN (asm_out_file,
2523                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2524       ASM_OUTPUT_LABEL (asm_out_file, l2);
2525     }
2526
2527   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2528     dw2_asm_output_data (4, 0, "End of Table");
2529 #ifdef MIPS_DEBUGGING_INFO
2530   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2531      get a value of 0.  Putting .align 0 after the label fixes it.  */
2532   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2533 #endif
2534
2535   /* Turn off app to make assembly quicker.  */
2536   if (flag_debug_asm)
2537     app_disable ();
2538 }
2539
2540 /* Output a marker (i.e. a label) for the beginning of a function, before
2541    the prologue.  */
2542
2543 void
2544 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2545                           const char *file ATTRIBUTE_UNUSED)
2546 {
2547   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2548   char * dup_label;
2549   dw_fde_ref fde;
2550
2551   current_function_func_begin_label = NULL;
2552
2553 #ifdef TARGET_UNWIND_INFO
2554   /* ??? current_function_func_begin_label is also used by except.c
2555      for call-site information.  We must emit this label if it might
2556      be used.  */
2557   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2558       && ! dwarf2out_do_frame ())
2559     return;
2560 #else
2561   if (! dwarf2out_do_frame ())
2562     return;
2563 #endif
2564
2565   switch_to_section (function_section (current_function_decl));
2566   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2567                                current_function_funcdef_no);
2568   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2569                           current_function_funcdef_no);
2570   dup_label = xstrdup (label);
2571   current_function_func_begin_label = dup_label;
2572
2573 #ifdef TARGET_UNWIND_INFO
2574   /* We can elide the fde allocation if we're not emitting debug info.  */
2575   if (! dwarf2out_do_frame ())
2576     return;
2577 #endif
2578
2579   /* Expand the fde table if necessary.  */
2580   if (fde_table_in_use == fde_table_allocated)
2581     {
2582       fde_table_allocated += FDE_TABLE_INCREMENT;
2583       fde_table = ggc_realloc (fde_table,
2584                                fde_table_allocated * sizeof (dw_fde_node));
2585       memset (fde_table + fde_table_in_use, 0,
2586               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2587     }
2588
2589   /* Record the FDE associated with this function.  */
2590   current_funcdef_fde = fde_table_in_use;
2591
2592   /* Add the new FDE at the end of the fde_table.  */
2593   fde = &fde_table[fde_table_in_use++];
2594   fde->decl = current_function_decl;
2595   fde->dw_fde_begin = dup_label;
2596   fde->dw_fde_current_label = dup_label;
2597   fde->dw_fde_hot_section_label = NULL;
2598   fde->dw_fde_hot_section_end_label = NULL;
2599   fde->dw_fde_unlikely_section_label = NULL;
2600   fde->dw_fde_unlikely_section_end_label = NULL;
2601   fde->dw_fde_switched_sections = false;
2602   fde->dw_fde_end = NULL;
2603   fde->dw_fde_cfi = NULL;
2604   fde->funcdef_number = current_function_funcdef_no;
2605   fde->nothrow = TREE_NOTHROW (current_function_decl);
2606   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2607   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2608
2609   args_size = old_args_size = 0;
2610
2611   /* We only want to output line number information for the genuine dwarf2
2612      prologue case, not the eh frame case.  */
2613 #ifdef DWARF2_DEBUGGING_INFO
2614   if (file)
2615     dwarf2out_source_line (line, file);
2616 #endif
2617 }
2618
2619 /* Output a marker (i.e. a label) for the absolute end of the generated code
2620    for a function definition.  This gets called *after* the epilogue code has
2621    been generated.  */
2622
2623 void
2624 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2625                         const char *file ATTRIBUTE_UNUSED)
2626 {
2627   dw_fde_ref fde;
2628   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2629
2630   /* Output a label to mark the endpoint of the code generated for this
2631      function.  */
2632   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2633                                current_function_funcdef_no);
2634   ASM_OUTPUT_LABEL (asm_out_file, label);
2635   fde = &fde_table[fde_table_in_use - 1];
2636   fde->dw_fde_end = xstrdup (label);
2637 }
2638
2639 void
2640 dwarf2out_frame_init (void)
2641 {
2642   /* Allocate the initial hunk of the fde_table.  */
2643   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2644   fde_table_allocated = FDE_TABLE_INCREMENT;
2645   fde_table_in_use = 0;
2646
2647   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2648      sake of lookup_cfa.  */
2649
2650   /* On entry, the Canonical Frame Address is at SP.  */
2651   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2652
2653 #ifdef DWARF2_UNWIND_INFO
2654   if (DWARF2_UNWIND_INFO)
2655     initial_return_save (INCOMING_RETURN_ADDR_RTX);
2656 #endif
2657 }
2658
2659 void
2660 dwarf2out_frame_finish (void)
2661 {
2662   /* Output call frame information.  */
2663   if (DWARF2_FRAME_INFO)
2664     output_call_frame_info (0);
2665
2666 #ifndef TARGET_UNWIND_INFO
2667   /* Output another copy for the unwinder.  */
2668   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2669     output_call_frame_info (1);
2670 #endif
2671 }
2672 #endif
2673 \f
2674 /* And now, the subset of the debugging information support code necessary
2675    for emitting location expressions.  */
2676
2677 /* Data about a single source file.  */
2678 struct dwarf_file_data GTY(())
2679 {
2680   const char * filename;
2681   int emitted_number;
2682 };
2683
2684 /* We need some way to distinguish DW_OP_addr with a direct symbol
2685    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2686 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2687
2688
2689 typedef struct dw_val_struct *dw_val_ref;
2690 typedef struct die_struct *dw_die_ref;
2691 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2692 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2693
2694 /* Each DIE may have a series of attribute/value pairs.  Values
2695    can take on several forms.  The forms that are used in this
2696    implementation are listed below.  */
2697
2698 enum dw_val_class
2699 {
2700   dw_val_class_addr,
2701   dw_val_class_offset,
2702   dw_val_class_loc,
2703   dw_val_class_loc_list,
2704   dw_val_class_range_list,
2705   dw_val_class_const,
2706   dw_val_class_unsigned_const,
2707   dw_val_class_long_long,
2708   dw_val_class_vec,
2709   dw_val_class_flag,
2710   dw_val_class_die_ref,
2711   dw_val_class_fde_ref,
2712   dw_val_class_lbl_id,
2713   dw_val_class_lineptr,
2714   dw_val_class_str,
2715   dw_val_class_macptr,
2716   dw_val_class_file
2717 };
2718
2719 /* Describe a double word constant value.  */
2720 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2721
2722 typedef struct dw_long_long_struct GTY(())
2723 {
2724   unsigned long hi;
2725   unsigned long low;
2726 }
2727 dw_long_long_const;
2728
2729 /* Describe a floating point constant value, or a vector constant value.  */
2730
2731 typedef struct dw_vec_struct GTY(())
2732 {
2733   unsigned char * GTY((length ("%h.length"))) array;
2734   unsigned length;
2735   unsigned elt_size;
2736 }
2737 dw_vec_const;
2738
2739 /* The dw_val_node describes an attribute's value, as it is
2740    represented internally.  */
2741
2742 typedef struct dw_val_struct GTY(())
2743 {
2744   enum dw_val_class val_class;
2745   union dw_val_struct_union
2746     {
2747       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2748       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2749       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2750       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2751       HOST_WIDE_INT GTY ((default)) val_int;
2752       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2753       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2754       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2755       struct dw_val_die_union
2756         {
2757           dw_die_ref die;
2758           int external;
2759         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2760       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2761       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2762       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2763       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2764       struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
2765     }
2766   GTY ((desc ("%1.val_class"))) v;
2767 }
2768 dw_val_node;
2769
2770 /* Locations in memory are described using a sequence of stack machine
2771    operations.  */
2772
2773 typedef struct dw_loc_descr_struct GTY(())
2774 {
2775   dw_loc_descr_ref dw_loc_next;
2776   enum dwarf_location_atom dw_loc_opc;
2777   dw_val_node dw_loc_oprnd1;
2778   dw_val_node dw_loc_oprnd2;
2779   int dw_loc_addr;
2780 }
2781 dw_loc_descr_node;
2782
2783 /* Location lists are ranges + location descriptions for that range,
2784    so you can track variables that are in different places over
2785    their entire life.  */
2786 typedef struct dw_loc_list_struct GTY(())
2787 {
2788   dw_loc_list_ref dw_loc_next;
2789   const char *begin; /* Label for begin address of range */
2790   const char *end;  /* Label for end address of range */
2791   char *ll_symbol; /* Label for beginning of location list.
2792                       Only on head of list */
2793   const char *section; /* Section this loclist is relative to */
2794   dw_loc_descr_ref expr;
2795 } dw_loc_list_node;
2796
2797 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2798
2799 static const char *dwarf_stack_op_name (unsigned);
2800 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2801                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2802 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2803 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2804 static unsigned long size_of_locs (dw_loc_descr_ref);
2805 static void output_loc_operands (dw_loc_descr_ref);
2806 static void output_loc_sequence (dw_loc_descr_ref);
2807
2808 /* Convert a DWARF stack opcode into its string name.  */
2809
2810 static const char *
2811 dwarf_stack_op_name (unsigned int op)
2812 {
2813   switch (op)
2814     {
2815     case DW_OP_addr:
2816     case INTERNAL_DW_OP_tls_addr:
2817       return "DW_OP_addr";
2818     case DW_OP_deref:
2819       return "DW_OP_deref";
2820     case DW_OP_const1u:
2821       return "DW_OP_const1u";
2822     case DW_OP_const1s:
2823       return "DW_OP_const1s";
2824     case DW_OP_const2u:
2825       return "DW_OP_const2u";
2826     case DW_OP_const2s:
2827       return "DW_OP_const2s";
2828     case DW_OP_const4u:
2829       return "DW_OP_const4u";
2830     case DW_OP_const4s:
2831       return "DW_OP_const4s";
2832     case DW_OP_const8u:
2833       return "DW_OP_const8u";
2834     case DW_OP_const8s:
2835       return "DW_OP_const8s";
2836     case DW_OP_constu:
2837       return "DW_OP_constu";
2838     case DW_OP_consts:
2839       return "DW_OP_consts";
2840     case DW_OP_dup:
2841       return "DW_OP_dup";
2842     case DW_OP_drop:
2843       return "DW_OP_drop";
2844     case DW_OP_over:
2845       return "DW_OP_over";
2846     case DW_OP_pick:
2847       return "DW_OP_pick";
2848     case DW_OP_swap:
2849       return "DW_OP_swap";
2850     case DW_OP_rot:
2851       return "DW_OP_rot";
2852     case DW_OP_xderef:
2853       return "DW_OP_xderef";
2854     case DW_OP_abs:
2855       return "DW_OP_abs";
2856     case DW_OP_and:
2857       return "DW_OP_and";
2858     case DW_OP_div:
2859       return "DW_OP_div";
2860     case DW_OP_minus:
2861       return "DW_OP_minus";
2862     case DW_OP_mod:
2863       return "DW_OP_mod";
2864     case DW_OP_mul:
2865       return "DW_OP_mul";
2866     case DW_OP_neg:
2867       return "DW_OP_neg";
2868     case DW_OP_not:
2869       return "DW_OP_not";
2870     case DW_OP_or:
2871       return "DW_OP_or";
2872     case DW_OP_plus:
2873       return "DW_OP_plus";
2874     case DW_OP_plus_uconst:
2875       return "DW_OP_plus_uconst";
2876     case DW_OP_shl:
2877       return "DW_OP_shl";
2878     case DW_OP_shr:
2879       return "DW_OP_shr";
2880     case DW_OP_shra:
2881       return "DW_OP_shra";
2882     case DW_OP_xor:
2883       return "DW_OP_xor";
2884     case DW_OP_bra:
2885       return "DW_OP_bra";
2886     case DW_OP_eq:
2887       return "DW_OP_eq";
2888     case DW_OP_ge:
2889       return "DW_OP_ge";
2890     case DW_OP_gt:
2891       return "DW_OP_gt";
2892     case DW_OP_le:
2893       return "DW_OP_le";
2894     case DW_OP_lt:
2895       return "DW_OP_lt";
2896     case DW_OP_ne:
2897       return "DW_OP_ne";
2898     case DW_OP_skip:
2899       return "DW_OP_skip";
2900     case DW_OP_lit0:
2901       return "DW_OP_lit0";
2902     case DW_OP_lit1:
2903       return "DW_OP_lit1";
2904     case DW_OP_lit2:
2905       return "DW_OP_lit2";
2906     case DW_OP_lit3:
2907       return "DW_OP_lit3";
2908     case DW_OP_lit4:
2909       return "DW_OP_lit4";
2910     case DW_OP_lit5:
2911       return "DW_OP_lit5";
2912     case DW_OP_lit6:
2913       return "DW_OP_lit6";
2914     case DW_OP_lit7:
2915       return "DW_OP_lit7";
2916     case DW_OP_lit8:
2917       return "DW_OP_lit8";
2918     case DW_OP_lit9:
2919       return "DW_OP_lit9";
2920     case DW_OP_lit10:
2921       return "DW_OP_lit10";
2922     case DW_OP_lit11:
2923       return "DW_OP_lit11";
2924     case DW_OP_lit12:
2925       return "DW_OP_lit12";
2926     case DW_OP_lit13:
2927       return "DW_OP_lit13";
2928     case DW_OP_lit14:
2929       return "DW_OP_lit14";
2930     case DW_OP_lit15:
2931       return "DW_OP_lit15";
2932     case DW_OP_lit16:
2933       return "DW_OP_lit16";
2934     case DW_OP_lit17:
2935       return "DW_OP_lit17";
2936     case DW_OP_lit18:
2937       return "DW_OP_lit18";
2938     case DW_OP_lit19:
2939       return "DW_OP_lit19";
2940     case DW_OP_lit20:
2941       return "DW_OP_lit20";
2942     case DW_OP_lit21:
2943       return "DW_OP_lit21";
2944     case DW_OP_lit22:
2945       return "DW_OP_lit22";
2946     case DW_OP_lit23:
2947       return "DW_OP_lit23";
2948     case DW_OP_lit24:
2949       return "DW_OP_lit24";
2950     case DW_OP_lit25:
2951       return "DW_OP_lit25";
2952     case DW_OP_lit26:
2953       return "DW_OP_lit26";
2954     case DW_OP_lit27:
2955       return "DW_OP_lit27";
2956     case DW_OP_lit28:
2957       return "DW_OP_lit28";
2958     case DW_OP_lit29:
2959       return "DW_OP_lit29";
2960     case DW_OP_lit30:
2961       return "DW_OP_lit30";
2962     case DW_OP_lit31:
2963       return "DW_OP_lit31";
2964     case DW_OP_reg0:
2965       return "DW_OP_reg0";
2966     case DW_OP_reg1:
2967       return "DW_OP_reg1";
2968     case DW_OP_reg2:
2969       return "DW_OP_reg2";
2970     case DW_OP_reg3:
2971       return "DW_OP_reg3";
2972     case DW_OP_reg4:
2973       return "DW_OP_reg4";
2974     case DW_OP_reg5:
2975       return "DW_OP_reg5";
2976     case DW_OP_reg6:
2977       return "DW_OP_reg6";
2978     case DW_OP_reg7:
2979       return "DW_OP_reg7";
2980     case DW_OP_reg8:
2981       return "DW_OP_reg8";
2982     case DW_OP_reg9:
2983       return "DW_OP_reg9";
2984     case DW_OP_reg10:
2985       return "DW_OP_reg10";
2986     case DW_OP_reg11:
2987       return "DW_OP_reg11";
2988     case DW_OP_reg12:
2989       return "DW_OP_reg12";
2990     case DW_OP_reg13:
2991       return "DW_OP_reg13";
2992     case DW_OP_reg14:
2993       return "DW_OP_reg14";
2994     case DW_OP_reg15:
2995       return "DW_OP_reg15";
2996     case DW_OP_reg16:
2997       return "DW_OP_reg16";
2998     case DW_OP_reg17:
2999       return "DW_OP_reg17";
3000     case DW_OP_reg18:
3001       return "DW_OP_reg18";
3002     case DW_OP_reg19:
3003       return "DW_OP_reg19";
3004     case DW_OP_reg20:
3005       return "DW_OP_reg20";
3006     case DW_OP_reg21:
3007       return "DW_OP_reg21";
3008     case DW_OP_reg22:
3009       return "DW_OP_reg22";
3010     case DW_OP_reg23:
3011       return "DW_OP_reg23";
3012     case DW_OP_reg24:
3013       return "DW_OP_reg24";
3014     case DW_OP_reg25:
3015       return "DW_OP_reg25";
3016     case DW_OP_reg26:
3017       return "DW_OP_reg26";
3018     case DW_OP_reg27:
3019       return "DW_OP_reg27";
3020     case DW_OP_reg28:
3021       return "DW_OP_reg28";
3022     case DW_OP_reg29:
3023       return "DW_OP_reg29";
3024     case DW_OP_reg30:
3025       return "DW_OP_reg30";
3026     case DW_OP_reg31:
3027       return "DW_OP_reg31";
3028     case DW_OP_breg0:
3029       return "DW_OP_breg0";
3030     case DW_OP_breg1:
3031       return "DW_OP_breg1";
3032     case DW_OP_breg2:
3033       return "DW_OP_breg2";
3034     case DW_OP_breg3:
3035       return "DW_OP_breg3";
3036     case DW_OP_breg4:
3037       return "DW_OP_breg4";
3038     case DW_OP_breg5:
3039       return "DW_OP_breg5";
3040     case DW_OP_breg6:
3041       return "DW_OP_breg6";
3042     case DW_OP_breg7:
3043       return "DW_OP_breg7";
3044     case DW_OP_breg8:
3045       return "DW_OP_breg8";
3046     case DW_OP_breg9:
3047       return "DW_OP_breg9";
3048     case DW_OP_breg10:
3049       return "DW_OP_breg10";
3050     case DW_OP_breg11:
3051       return "DW_OP_breg11";
3052     case DW_OP_breg12:
3053       return "DW_OP_breg12";
3054     case DW_OP_breg13:
3055       return "DW_OP_breg13";
3056     case DW_OP_breg14:
3057       return "DW_OP_breg14";
3058     case DW_OP_breg15:
3059       return "DW_OP_breg15";
3060     case DW_OP_breg16:
3061       return "DW_OP_breg16";
3062     case DW_OP_breg17:
3063       return "DW_OP_breg17";
3064     case DW_OP_breg18:
3065       return "DW_OP_breg18";
3066     case DW_OP_breg19:
3067       return "DW_OP_breg19";
3068     case DW_OP_breg20:
3069       return "DW_OP_breg20";
3070     case DW_OP_breg21:
3071       return "DW_OP_breg21";
3072     case DW_OP_breg22:
3073       return "DW_OP_breg22";
3074     case DW_OP_breg23:
3075       return "DW_OP_breg23";
3076     case DW_OP_breg24:
3077       return "DW_OP_breg24";
3078     case DW_OP_breg25:
3079       return "DW_OP_breg25";
3080     case DW_OP_breg26:
3081       return "DW_OP_breg26";
3082     case DW_OP_breg27:
3083       return "DW_OP_breg27";
3084     case DW_OP_breg28:
3085       return "DW_OP_breg28";
3086     case DW_OP_breg29:
3087       return "DW_OP_breg29";
3088     case DW_OP_breg30:
3089       return "DW_OP_breg30";
3090     case DW_OP_breg31:
3091       return "DW_OP_breg31";
3092     case DW_OP_regx:
3093       return "DW_OP_regx";
3094     case DW_OP_fbreg:
3095       return "DW_OP_fbreg";
3096     case DW_OP_bregx:
3097       return "DW_OP_bregx";
3098     case DW_OP_piece:
3099       return "DW_OP_piece";
3100     case DW_OP_deref_size:
3101       return "DW_OP_deref_size";
3102     case DW_OP_xderef_size:
3103       return "DW_OP_xderef_size";
3104     case DW_OP_nop:
3105       return "DW_OP_nop";
3106     case DW_OP_push_object_address:
3107       return "DW_OP_push_object_address";
3108     case DW_OP_call2:
3109       return "DW_OP_call2";
3110     case DW_OP_call4:
3111       return "DW_OP_call4";
3112     case DW_OP_call_ref:
3113       return "DW_OP_call_ref";
3114     case DW_OP_GNU_push_tls_address:
3115       return "DW_OP_GNU_push_tls_address";
3116     default:
3117       return "OP_<unknown>";
3118     }
3119 }
3120
3121 /* Return a pointer to a newly allocated location description.  Location
3122    descriptions are simple expression terms that can be strung
3123    together to form more complicated location (address) descriptions.  */
3124
3125 static inline dw_loc_descr_ref
3126 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3127                unsigned HOST_WIDE_INT oprnd2)
3128 {
3129   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3130
3131   descr->dw_loc_opc = op;
3132   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3133   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3134   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3135   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3136
3137   return descr;
3138 }
3139
3140 /* Add a location description term to a location description expression.  */
3141
3142 static inline void
3143 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3144 {
3145   dw_loc_descr_ref *d;
3146
3147   /* Find the end of the chain.  */
3148   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3149     ;
3150
3151   *d = descr;
3152 }
3153
3154 /* Return the size of a location descriptor.  */
3155
3156 static unsigned long
3157 size_of_loc_descr (dw_loc_descr_ref loc)
3158 {
3159   unsigned long size = 1;
3160
3161   switch (loc->dw_loc_opc)
3162     {
3163     case DW_OP_addr:
3164     case INTERNAL_DW_OP_tls_addr:
3165       size += DWARF2_ADDR_SIZE;
3166       break;
3167     case DW_OP_const1u:
3168     case DW_OP_const1s:
3169       size += 1;
3170       break;
3171     case DW_OP_const2u:
3172     case DW_OP_const2s:
3173       size += 2;
3174       break;
3175     case DW_OP_const4u:
3176     case DW_OP_const4s:
3177       size += 4;
3178       break;
3179     case DW_OP_const8u:
3180     case DW_OP_const8s:
3181       size += 8;
3182       break;
3183     case DW_OP_constu:
3184       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3185       break;
3186     case DW_OP_consts:
3187       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3188       break;
3189     case DW_OP_pick:
3190       size += 1;
3191       break;
3192     case DW_OP_plus_uconst:
3193       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3194       break;
3195     case DW_OP_skip:
3196     case DW_OP_bra:
3197       size += 2;
3198       break;
3199     case DW_OP_breg0:
3200     case DW_OP_breg1:
3201     case DW_OP_breg2:
3202     case DW_OP_breg3:
3203     case DW_OP_breg4:
3204     case DW_OP_breg5:
3205     case DW_OP_breg6:
3206     case DW_OP_breg7:
3207     case DW_OP_breg8:
3208     case DW_OP_breg9:
3209     case DW_OP_breg10:
3210     case DW_OP_breg11:
3211     case DW_OP_breg12:
3212     case DW_OP_breg13:
3213     case DW_OP_breg14:
3214     case DW_OP_breg15:
3215     case DW_OP_breg16:
3216     case DW_OP_breg17:
3217     case DW_OP_breg18:
3218     case DW_OP_breg19:
3219     case DW_OP_breg20:
3220     case DW_OP_breg21:
3221     case DW_OP_breg22:
3222     case DW_OP_breg23:
3223     case DW_OP_breg24:
3224     case DW_OP_breg25:
3225     case DW_OP_breg26:
3226     case DW_OP_breg27:
3227     case DW_OP_breg28:
3228     case DW_OP_breg29:
3229     case DW_OP_breg30:
3230     case DW_OP_breg31:
3231       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3232       break;
3233     case DW_OP_regx:
3234       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3235       break;
3236     case DW_OP_fbreg:
3237       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3238       break;
3239     case DW_OP_bregx:
3240       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3241       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3242       break;
3243     case DW_OP_piece:
3244       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3245       break;
3246     case DW_OP_deref_size:
3247     case DW_OP_xderef_size:
3248       size += 1;
3249       break;
3250     case DW_OP_call2:
3251       size += 2;
3252       break;
3253     case DW_OP_call4:
3254       size += 4;
3255       break;
3256     case DW_OP_call_ref:
3257       size += DWARF2_ADDR_SIZE;
3258       break;
3259     default:
3260       break;
3261     }
3262
3263   return size;
3264 }
3265
3266 /* Return the size of a series of location descriptors.  */
3267
3268 static unsigned long
3269 size_of_locs (dw_loc_descr_ref loc)
3270 {
3271   dw_loc_descr_ref l;
3272   unsigned long size;
3273
3274   /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
3275      field, to avoid writing to a PCH file.  */
3276   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3277     {
3278       if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
3279         break;
3280       size += size_of_loc_descr (l);
3281     }
3282   if (! l)
3283     return size;
3284
3285   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3286     {
3287       l->dw_loc_addr = size;
3288       size += size_of_loc_descr (l);
3289     }
3290
3291   return size;
3292 }
3293
3294 /* Output location description stack opcode's operands (if any).  */
3295
3296 static void
3297 output_loc_operands (dw_loc_descr_ref loc)
3298 {
3299   dw_val_ref val1 = &loc->dw_loc_oprnd1;
3300   dw_val_ref val2 = &loc->dw_loc_oprnd2;
3301
3302   switch (loc->dw_loc_opc)
3303     {
3304 #ifdef DWARF2_DEBUGGING_INFO
3305     case DW_OP_addr:
3306       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3307       break;
3308     case DW_OP_const2u:
3309     case DW_OP_const2s:
3310       dw2_asm_output_data (2, val1->v.val_int, NULL);
3311       break;
3312     case DW_OP_const4u:
3313     case DW_OP_const4s:
3314       dw2_asm_output_data (4, val1->v.val_int, NULL);
3315       break;
3316     case DW_OP_const8u:
3317     case DW_OP_const8s:
3318       gcc_assert (HOST_BITS_PER_LONG >= 64);
3319       dw2_asm_output_data (8, val1->v.val_int, NULL);
3320       break;
3321     case DW_OP_skip:
3322     case DW_OP_bra:
3323       {
3324         int offset;
3325
3326         gcc_assert (val1->val_class == dw_val_class_loc);
3327         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3328
3329         dw2_asm_output_data (2, offset, NULL);
3330       }
3331       break;
3332 #else
3333     case DW_OP_addr:
3334     case DW_OP_const2u:
3335     case DW_OP_const2s:
3336     case DW_OP_const4u:
3337     case DW_OP_const4s:
3338     case DW_OP_const8u:
3339     case DW_OP_const8s:
3340     case DW_OP_skip:
3341     case DW_OP_bra:
3342       /* We currently don't make any attempt to make sure these are
3343          aligned properly like we do for the main unwind info, so
3344          don't support emitting things larger than a byte if we're
3345          only doing unwinding.  */
3346       gcc_unreachable ();
3347 #endif
3348     case DW_OP_const1u:
3349     case DW_OP_const1s:
3350       dw2_asm_output_data (1, val1->v.val_int, NULL);
3351       break;
3352     case DW_OP_constu:
3353       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3354       break;
3355     case DW_OP_consts:
3356       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3357       break;
3358     case DW_OP_pick:
3359       dw2_asm_output_data (1, val1->v.val_int, NULL);
3360       break;
3361     case DW_OP_plus_uconst:
3362       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3363       break;
3364     case DW_OP_breg0:
3365     case DW_OP_breg1:
3366     case DW_OP_breg2:
3367     case DW_OP_breg3:
3368     case DW_OP_breg4:
3369     case DW_OP_breg5:
3370     case DW_OP_breg6:
3371     case DW_OP_breg7:
3372     case DW_OP_breg8:
3373     case DW_OP_breg9:
3374     case DW_OP_breg10:
3375     case DW_OP_breg11:
3376     case DW_OP_breg12:
3377     case DW_OP_breg13:
3378     case DW_OP_breg14:
3379     case DW_OP_breg15:
3380     case DW_OP_breg16:
3381     case DW_OP_breg17:
3382     case DW_OP_breg18:
3383     case DW_OP_breg19:
3384     case DW_OP_breg20:
3385     case DW_OP_breg21:
3386     case DW_OP_breg22:
3387     case DW_OP_breg23:
3388     case DW_OP_breg24:
3389     case DW_OP_breg25:
3390     case DW_OP_breg26:
3391     case DW_OP_breg27:
3392     case DW_OP_breg28:
3393     case DW_OP_breg29:
3394     case DW_OP_breg30:
3395     case DW_OP_breg31:
3396       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3397       break;
3398     case DW_OP_regx:
3399       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3400       break;
3401     case DW_OP_fbreg:
3402       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3403       break;
3404     case DW_OP_bregx:
3405       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3406       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3407       break;
3408     case DW_OP_piece:
3409       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3410       break;
3411     case DW_OP_deref_size:
3412     case DW_OP_xderef_size:
3413       dw2_asm_output_data (1, val1->v.val_int, NULL);
3414       break;
3415
3416     case INTERNAL_DW_OP_tls_addr:
3417       if (targetm.asm_out.output_dwarf_dtprel)
3418         {
3419           targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3420                                                DWARF2_ADDR_SIZE,
3421                                                val1->v.val_addr);
3422           fputc ('\n', asm_out_file);
3423         }
3424       else
3425         gcc_unreachable ();
3426       break;
3427
3428     default:
3429       /* Other codes have no operands.  */
3430       break;
3431     }
3432 }
3433
3434 /* Output a sequence of location operations.  */
3435
3436 static void
3437 output_loc_sequence (dw_loc_descr_ref loc)
3438 {
3439   for (; loc != NULL; loc = loc->dw_loc_next)
3440     {
3441       /* Output the opcode.  */
3442       dw2_asm_output_data (1, loc->dw_loc_opc,
3443                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3444
3445       /* Output the operand(s) (if any).  */
3446       output_loc_operands (loc);
3447     }
3448 }
3449
3450 /* This routine will generate the correct assembly data for a location
3451    description based on a cfi entry with a complex address.  */
3452
3453 static void
3454 output_cfa_loc (dw_cfi_ref cfi)
3455 {
3456   dw_loc_descr_ref loc;
3457   unsigned long size;
3458
3459   /* Output the size of the block.  */
3460   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3461   size = size_of_locs (loc);
3462   dw2_asm_output_data_uleb128 (size, NULL);
3463
3464   /* Now output the operations themselves.  */
3465   output_loc_sequence (loc);
3466 }
3467
3468 /* This function builds a dwarf location descriptor sequence from a
3469    dw_cfa_location, adding the given OFFSET to the result of the
3470    expression.  */
3471
3472 static struct dw_loc_descr_struct *
3473 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3474 {
3475   struct dw_loc_descr_struct *head, *tmp;
3476
3477   offset += cfa->offset;
3478
3479   if (cfa->indirect)
3480     {
3481       if (cfa->base_offset)
3482         {
3483           if (cfa->reg <= 31)
3484             head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3485           else
3486             head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3487         }
3488       else if (cfa->reg <= 31)
3489         head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3490       else
3491         head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3492
3493       head->dw_loc_oprnd1.val_class = dw_val_class_const;
3494       tmp = new_loc_descr (DW_OP_deref, 0, 0);
3495       add_loc_descr (&head, tmp);
3496       if (offset != 0)
3497         {
3498           tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3499           add_loc_descr (&head, tmp);
3500         }
3501     }
3502   else
3503     {
3504       if (offset == 0)
3505         if (cfa->reg <= 31)
3506           head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3507         else
3508           head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3509       else if (cfa->reg <= 31)
3510         head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3511       else
3512         head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3513     }
3514
3515   return head;
3516 }
3517
3518 /* This function fills in aa dw_cfa_location structure from a dwarf location
3519    descriptor sequence.  */
3520
3521 static void
3522 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3523 {
3524   struct dw_loc_descr_struct *ptr;
3525   cfa->offset = 0;
3526   cfa->base_offset = 0;
3527   cfa->indirect = 0;
3528   cfa->reg = -1;
3529
3530   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3531     {
3532       enum dwarf_location_atom op = ptr->dw_loc_opc;
3533
3534       switch (op)
3535         {
3536         case DW_OP_reg0:
3537         case DW_OP_reg1:
3538         case DW_OP_reg2:
3539         case DW_OP_reg3:
3540         case DW_OP_reg4:
3541         case DW_OP_reg5:
3542         case DW_OP_reg6:
3543         case DW_OP_reg7:
3544         case DW_OP_reg8:
3545         case DW_OP_reg9:
3546         case DW_OP_reg10:
3547         case DW_OP_reg11:
3548         case DW_OP_reg12:
3549         case DW_OP_reg13:
3550         case DW_OP_reg14:
3551         case DW_OP_reg15:
3552         case DW_OP_reg16:
3553         case DW_OP_reg17:
3554         case DW_OP_reg18:
3555         case DW_OP_reg19:
3556         case DW_OP_reg20:
3557         case DW_OP_reg21:
3558         case DW_OP_reg22:
3559         case DW_OP_reg23:
3560         case DW_OP_reg24:
3561         case DW_OP_reg25:
3562         case DW_OP_reg26:
3563         case DW_OP_reg27:
3564         case DW_OP_reg28:
3565         case DW_OP_reg29:
3566         case DW_OP_reg30:
3567         case DW_OP_reg31:
3568           cfa->reg = op - DW_OP_reg0;
3569           break;
3570         case DW_OP_regx:
3571           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3572           break;
3573         case DW_OP_breg0:
3574         case DW_OP_breg1:
3575         case DW_OP_breg2:
3576         case DW_OP_breg3:
3577         case DW_OP_breg4:
3578         case DW_OP_breg5:
3579         case DW_OP_breg6:
3580         case DW_OP_breg7:
3581         case DW_OP_breg8:
3582         case DW_OP_breg9:
3583         case DW_OP_breg10:
3584         case DW_OP_breg11:
3585         case DW_OP_breg12:
3586         case DW_OP_breg13:
3587         case DW_OP_breg14:
3588         case DW_OP_breg15:
3589         case DW_OP_breg16:
3590         case DW_OP_breg17:
3591         case DW_OP_breg18:
3592         case DW_OP_breg19:
3593         case DW_OP_breg20:
3594         case DW_OP_breg21:
3595         case DW_OP_breg22:
3596         case DW_OP_breg23:
3597         case DW_OP_breg24:
3598         case DW_OP_breg25:
3599         case DW_OP_breg26:
3600         case DW_OP_breg27:
3601         case DW_OP_breg28:
3602         case DW_OP_breg29:
3603         case DW_OP_breg30:
3604         case DW_OP_breg31:
3605           cfa->reg = op - DW_OP_breg0;
3606           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3607           break;
3608         case DW_OP_bregx:
3609           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3610           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3611           break;
3612         case DW_OP_deref:
3613           cfa->indirect = 1;
3614           break;
3615         case DW_OP_plus_uconst:
3616           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3617           break;
3618         default:
3619           internal_error ("DW_LOC_OP %s not implemented",
3620                           dwarf_stack_op_name (ptr->dw_loc_opc));
3621         }
3622     }
3623 }
3624 #endif /* .debug_frame support */
3625 \f
3626 /* And now, the support for symbolic debugging information.  */
3627 #ifdef DWARF2_DEBUGGING_INFO
3628
3629 /* .debug_str support.  */
3630 static int output_indirect_string (void **, void *);
3631
3632 static void dwarf2out_init (const char *);
3633 static void dwarf2out_finish (const char *);
3634 static void dwarf2out_define (unsigned int, const char *);
3635 static void dwarf2out_undef (unsigned int, const char *);
3636 static void dwarf2out_start_source_file (unsigned, const char *);
3637 static void dwarf2out_end_source_file (unsigned);
3638 static void dwarf2out_begin_block (unsigned, unsigned);
3639 static void dwarf2out_end_block (unsigned, unsigned);
3640 static bool dwarf2out_ignore_block (tree);
3641 static void dwarf2out_global_decl (tree);
3642 static void dwarf2out_type_decl (tree, int);
3643 static void dwarf2out_imported_module_or_decl (tree, tree);
3644 static void dwarf2out_abstract_function (tree);
3645 static void dwarf2out_var_location (rtx);
3646 static void dwarf2out_begin_function (tree);
3647 static void dwarf2out_switch_text_section (void);
3648
3649 /* The debug hooks structure.  */
3650
3651 const struct gcc_debug_hooks dwarf2_debug_hooks =
3652 {
3653   dwarf2out_init,
3654   dwarf2out_finish,
3655   dwarf2out_define,
3656   dwarf2out_undef,
3657   dwarf2out_start_source_file,
3658   dwarf2out_end_source_file,
3659   dwarf2out_begin_block,
3660   dwarf2out_end_block,
3661   dwarf2out_ignore_block,
3662   dwarf2out_source_line,
3663   dwarf2out_begin_prologue,
3664   debug_nothing_int_charstar,   /* end_prologue */
3665   dwarf2out_end_epilogue,
3666   dwarf2out_begin_function,
3667   debug_nothing_int,            /* end_function */
3668   dwarf2out_decl,               /* function_decl */
3669   dwarf2out_global_decl,
3670   dwarf2out_type_decl,          /* type_decl */
3671   dwarf2out_imported_module_or_decl,
3672   debug_nothing_tree,           /* deferred_inline_function */
3673   /* The DWARF 2 backend tries to reduce debugging bloat by not
3674      emitting the abstract description of inline functions until
3675      something tries to reference them.  */
3676   dwarf2out_abstract_function,  /* outlining_inline_function */
3677   debug_nothing_rtx,            /* label */
3678   debug_nothing_int,            /* handle_pch */
3679   dwarf2out_var_location,
3680   dwarf2out_switch_text_section,
3681   1                             /* start_end_main_source_file */
3682 };
3683 #endif
3684 \f
3685 /* NOTE: In the comments in this file, many references are made to
3686    "Debugging Information Entries".  This term is abbreviated as `DIE'
3687    throughout the remainder of this file.  */
3688
3689 /* An internal representation of the DWARF output is built, and then
3690    walked to generate the DWARF debugging info.  The walk of the internal
3691    representation is done after the entire program has been compiled.
3692    The types below are used to describe the internal representation.  */
3693
3694 /* Various DIE's use offsets relative to the beginning of the
3695    .debug_info section to refer to each other.  */
3696
3697 typedef long int dw_offset;
3698
3699 /* Define typedefs here to avoid circular dependencies.  */
3700
3701 typedef struct dw_attr_struct *dw_attr_ref;
3702 typedef struct dw_line_info_struct *dw_line_info_ref;
3703 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3704 typedef struct pubname_struct *pubname_ref;
3705 typedef struct dw_ranges_struct *dw_ranges_ref;
3706
3707 /* Each entry in the line_info_table maintains the file and
3708    line number associated with the label generated for that
3709    entry.  The label gives the PC value associated with
3710    the line number entry.  */
3711
3712 typedef struct dw_line_info_struct GTY(())
3713 {
3714   unsigned long dw_file_num;
3715   unsigned long dw_line_num;
3716 }
3717 dw_line_info_entry;
3718
3719 /* Line information for functions in separate sections; each one gets its
3720    own sequence.  */
3721 typedef struct dw_separate_line_info_struct GTY(())
3722 {
3723   unsigned long dw_file_num;
3724   unsigned long dw_line_num;
3725   unsigned long function;
3726 }
3727 dw_separate_line_info_entry;
3728
3729 /* Each DIE attribute has a field specifying the attribute kind,
3730    a link to the next attribute in the chain, and an attribute value.
3731    Attributes are typically linked below the DIE they modify.  */
3732
3733 typedef struct dw_attr_struct GTY(())
3734 {
3735   enum dwarf_attribute dw_attr;
3736   dw_val_node dw_attr_val;
3737 }
3738 dw_attr_node;
3739
3740 DEF_VEC_O(dw_attr_node);
3741 DEF_VEC_ALLOC_O(dw_attr_node,gc);
3742
3743 /* The Debugging Information Entry (DIE) structure.  DIEs form a tree.
3744    The children of each node form a circular list linked by
3745    die_sib.  die_child points to the node *before* the "first" child node.  */
3746
3747 typedef struct die_struct GTY(())
3748 {
3749   enum dwarf_tag die_tag;
3750   char *die_symbol;
3751   VEC(dw_attr_node,gc) * die_attr;
3752   dw_die_ref die_parent;
3753   dw_die_ref die_child;
3754   dw_die_ref die_sib;
3755   dw_die_ref die_definition; /* ref from a specification to its definition */
3756   dw_offset die_offset;
3757   unsigned long die_abbrev;
3758   int die_mark;
3759   /* Die is used and must not be pruned as unused.  */
3760   int die_perennial_p;
3761   unsigned int decl_id;
3762 }
3763 die_node;
3764
3765 /* Evaluate 'expr' while 'c' is set to each child of DIE in order.  */
3766 #define FOR_EACH_CHILD(die, c, expr) do {       \
3767   c = die->die_child;                           \
3768   if (c) do {                                   \
3769     c = c->die_sib;                             \
3770     expr;                                       \
3771   } while (c != die->die_child);                \
3772 } while (0)
3773
3774 /* The pubname structure */
3775
3776 typedef struct pubname_struct GTY(())
3777 {
3778   dw_die_ref die;
3779   const char *name;
3780 }
3781 pubname_entry;
3782
3783 DEF_VEC_O(pubname_entry);
3784 DEF_VEC_ALLOC_O(pubname_entry, gc);
3785
3786 struct dw_ranges_struct GTY(())
3787 {
3788   int block_num;
3789 };
3790
3791 /* The limbo die list structure.  */
3792 typedef struct limbo_die_struct GTY(())
3793 {
3794   dw_die_ref die;
3795   tree created_for;
3796   struct limbo_die_struct *next;
3797 }
3798 limbo_die_node;
3799
3800 /* How to start an assembler comment.  */
3801 #ifndef ASM_COMMENT_START
3802 #define ASM_COMMENT_START ";#"
3803 #endif
3804
3805 /* Define a macro which returns nonzero for a TYPE_DECL which was
3806    implicitly generated for a tagged type.
3807
3808    Note that unlike the gcc front end (which generates a NULL named
3809    TYPE_DECL node for each complete tagged type, each array type, and
3810    each function type node created) the g++ front end generates a
3811    _named_ TYPE_DECL node for each tagged type node created.
3812    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3813    generate a DW_TAG_typedef DIE for them.  */
3814
3815 #define TYPE_DECL_IS_STUB(decl)                         \
3816   (DECL_NAME (decl) == NULL_TREE                        \
3817    || (DECL_ARTIFICIAL (decl)                           \
3818        && is_tagged_type (TREE_TYPE (decl))             \
3819        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3820            /* This is necessary for stub decls that     \
3821               appear in nested inline functions.  */    \
3822            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3823                && (decl_ultimate_origin (decl)          \
3824                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3825
3826 /* Information concerning the compilation unit's programming
3827    language, and compiler version.  */
3828
3829 /* Fixed size portion of the DWARF compilation unit header.  */
3830 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3831   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3832
3833 /* Fixed size portion of public names info.  */
3834 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3835
3836 /* Fixed size portion of the address range info.  */
3837 #define DWARF_ARANGES_HEADER_SIZE                                       \
3838   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3839                 DWARF2_ADDR_SIZE * 2)                                   \
3840    - DWARF_INITIAL_LENGTH_SIZE)
3841
3842 /* Size of padding portion in the address range info.  It must be
3843    aligned to twice the pointer size.  */
3844 #define DWARF_ARANGES_PAD_SIZE \
3845   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3846                 DWARF2_ADDR_SIZE * 2) \
3847    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3848
3849 /* Use assembler line directives if available.  */
3850 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3851 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3852 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3853 #else
3854 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3855 #endif
3856 #endif
3857
3858 /* Minimum line offset in a special line info. opcode.
3859    This value was chosen to give a reasonable range of values.  */
3860 #define DWARF_LINE_BASE  -10
3861
3862 /* First special line opcode - leave room for the standard opcodes.  */
3863 #define DWARF_LINE_OPCODE_BASE  10
3864
3865 /* Range of line offsets in a special line info. opcode.  */
3866 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3867
3868 /* Flag that indicates the initial value of the is_stmt_start flag.
3869    In the present implementation, we do not mark any lines as
3870    the beginning of a source statement, because that information
3871    is not made available by the GCC front-end.  */
3872 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3873
3874 #ifdef DWARF2_DEBUGGING_INFO
3875 /* This location is used by calc_die_sizes() to keep track
3876    the offset of each DIE within the .debug_info section.  */
3877 static unsigned long next_die_offset;
3878 #endif
3879
3880 /* Record the root of the DIE's built for the current compilation unit.  */
3881 static GTY(()) dw_die_ref comp_unit_die;
3882
3883 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3884 static GTY(()) limbo_die_node *limbo_die_list;
3885
3886 /* Filenames referenced by this compilation unit.  */
3887 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
3888
3889 /* A hash table of references to DIE's that describe declarations.
3890    The key is a DECL_UID() which is a unique number identifying each decl.  */
3891 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3892
3893 /* Node of the variable location list.  */
3894 struct var_loc_node GTY ((chain_next ("%h.next")))
3895 {
3896   rtx GTY (()) var_loc_note;
3897   const char * GTY (()) label;
3898   const char * GTY (()) section_label;
3899   struct var_loc_node * GTY (()) next;
3900 };
3901
3902 /* Variable location list.  */
3903 struct var_loc_list_def GTY (())
3904 {
3905   struct var_loc_node * GTY (()) first;
3906
3907   /* Do not mark the last element of the chained list because
3908      it is marked through the chain.  */
3909   struct var_loc_node * GTY ((skip ("%h"))) last;
3910
3911   /* DECL_UID of the variable decl.  */
3912   unsigned int decl_id;
3913 };
3914 typedef struct var_loc_list_def var_loc_list;
3915
3916
3917 /* Table of decl location linked lists.  */
3918 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3919
3920 /* A pointer to the base of a list of references to DIE's that
3921    are uniquely identified by their tag, presence/absence of
3922    children DIE's, and list of attribute/value pairs.  */
3923 static GTY((length ("abbrev_die_table_allocated")))
3924   dw_die_ref *abbrev_die_table;
3925
3926 /* Number of elements currently allocated for abbrev_die_table.  */
3927 static GTY(()) unsigned abbrev_die_table_allocated;
3928
3929 /* Number of elements in type_die_table currently in use.  */
3930 static GTY(()) unsigned abbrev_die_table_in_use;
3931
3932 /* Size (in elements) of increments by which we may expand the
3933    abbrev_die_table.  */
3934 #define ABBREV_DIE_TABLE_INCREMENT 256
3935
3936 /* A pointer to the base of a table that contains line information
3937    for each source code line in .text in the compilation unit.  */
3938 static GTY((length ("line_info_table_allocated")))
3939      dw_line_info_ref line_info_table;
3940
3941 /* Number of elements currently allocated for line_info_table.  */
3942 static GTY(()) unsigned line_info_table_allocated;
3943
3944 /* Number of elements in line_info_table currently in use.  */
3945 static GTY(()) unsigned line_info_table_in_use;
3946
3947 /* True if the compilation unit places functions in more than one section.  */
3948 static GTY(()) bool have_multiple_function_sections = false;
3949
3950 /* A pointer to the base of a table that contains line information
3951    for each source code line outside of .text in the compilation unit.  */
3952 static GTY ((length ("separate_line_info_table_allocated")))
3953      dw_separate_line_info_ref separate_line_info_table;
3954
3955 /* Number of elements currently allocated for separate_line_info_table.  */
3956 static GTY(()) unsigned separate_line_info_table_allocated;
3957
3958 /* Number of elements in separate_line_info_table currently in use.  */
3959 static GTY(()) unsigned separate_line_info_table_in_use;
3960
3961 /* Size (in elements) of increments by which we may expand the
3962    line_info_table.  */
3963 #define LINE_INFO_TABLE_INCREMENT 1024
3964
3965 /* A pointer to the base of a table that contains a list of publicly
3966    accessible names.  */
3967 static GTY (()) VEC (pubname_entry, gc) *  pubname_table;
3968
3969 /* A pointer to the base of a table that contains a list of publicly
3970    accessible types.  */
3971 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3972
3973 /* Array of dies for which we should generate .debug_arange info.  */
3974 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3975
3976 /* Number of elements currently allocated for arange_table.  */
3977 static GTY(()) unsigned arange_table_allocated;
3978
3979 /* Number of elements in arange_table currently in use.  */
3980 static GTY(()) unsigned arange_table_in_use;
3981
3982 /* Size (in elements) of increments by which we may expand the
3983    arange_table.  */
3984 #define ARANGE_TABLE_INCREMENT 64
3985
3986 /* Array of dies for which we should generate .debug_ranges info.  */
3987 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3988
3989 /* Number of elements currently allocated for ranges_table.  */
3990 static GTY(()) unsigned ranges_table_allocated;
3991
3992 /* Number of elements in ranges_table currently in use.  */
3993 static GTY(()) unsigned ranges_table_in_use;
3994
3995 /* Size (in elements) of increments by which we may expand the
3996    ranges_table.  */
3997 #define RANGES_TABLE_INCREMENT 64
3998
3999 /* Whether we have location lists that need outputting */
4000 static GTY(()) bool have_location_lists;
4001
4002 /* Unique label counter.  */
4003 static GTY(()) unsigned int loclabel_num;
4004
4005 #ifdef DWARF2_DEBUGGING_INFO
4006 /* Record whether the function being analyzed contains inlined functions.  */
4007 static int current_function_has_inlines;
4008 #endif
4009 #if 0 && defined (MIPS_DEBUGGING_INFO)
4010 static int comp_unit_has_inlines;
4011 #endif
4012
4013 /* The last file entry emitted by maybe_emit_file().  */
4014 static GTY(()) struct dwarf_file_data * last_emitted_file;
4015
4016 /* Number of internal labels generated by gen_internal_sym().  */
4017 static GTY(()) int label_num;
4018
4019 /* Cached result of previous call to lookup_filename.  */
4020 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4021
4022 #ifdef DWARF2_DEBUGGING_INFO
4023
4024 /* Offset from the "steady-state frame pointer" to the frame base,
4025    within the current function.  */
4026 static HOST_WIDE_INT frame_pointer_fb_offset;
4027
4028 /* Forward declarations for functions defined in this file.  */
4029
4030 static int is_pseudo_reg (rtx);
4031 static tree type_main_variant (tree);
4032 static int is_tagged_type (tree);
4033 static const char *dwarf_tag_name (unsigned);
4034 static const char *dwarf_attr_name (unsigned);
4035 static const char *dwarf_form_name (unsigned);
4036 static tree decl_ultimate_origin (tree);
4037 static tree block_ultimate_origin (tree);
4038 static tree decl_class_context (tree);
4039 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4040 static inline enum dw_val_class AT_class (dw_attr_ref);
4041 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4042 static inline unsigned AT_flag (dw_attr_ref);
4043 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4044 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4045 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4046 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4047 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4048                               unsigned long);
4049 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4050                                unsigned int, unsigned char *);
4051 static hashval_t debug_str_do_hash (const void *);
4052 static int debug_str_eq (const void *, const void *);
4053 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4054 static inline const char *AT_string (dw_attr_ref);
4055 static int AT_string_form (dw_attr_ref);
4056 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4057 static void add_AT_specification (dw_die_ref, dw_die_ref);
4058 static inline dw_die_ref AT_ref (dw_attr_ref);
4059 static inline int AT_ref_external (dw_attr_ref);
4060 static inline void set_AT_ref_external (dw_attr_ref, int);
4061 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4062 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4063 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4064 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4065                              dw_loc_list_ref);
4066 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4067 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4068 static inline rtx AT_addr (dw_attr_ref);
4069 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4070 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4071 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4072 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4073                            unsigned HOST_WIDE_INT);
4074 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4075                                unsigned long);
4076 static inline const char *AT_lbl (dw_attr_ref);
4077 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
4078 static const char *get_AT_low_pc (dw_die_ref);
4079 static const char *get_AT_hi_pc (dw_die_ref);
4080 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
4081 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4082 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4083 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4084 static bool is_c_family (void);
4085 static bool is_cxx (void);
4086 static bool is_java (void);
4087 static bool is_fortran (void);
4088 static bool is_ada (void);
4089 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4090 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4091 static void add_child_die (dw_die_ref, dw_die_ref);
4092 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4093 static dw_die_ref lookup_type_die (tree);
4094 static void equate_type_number_to_die (tree, dw_die_ref);
4095 static hashval_t decl_die_table_hash (const void *);
4096 static int decl_die_table_eq (const void *, const void *);
4097 static dw_die_ref lookup_decl_die (tree);
4098 static hashval_t decl_loc_table_hash (const void *);
4099 static int decl_loc_table_eq (const void *, const void *);
4100 static var_loc_list *lookup_decl_loc (tree);
4101 static void equate_decl_number_to_die (tree, dw_die_ref);
4102 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4103 static void print_spaces (FILE *);
4104 static void print_die (dw_die_ref, FILE *);
4105 static void print_dwarf_line_table (FILE *);
4106 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4107 static dw_die_ref pop_compile_unit (dw_die_ref);
4108 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4109 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4110 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4111 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4112 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4113 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4114 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4115 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4116 static void compute_section_prefix (dw_die_ref);
4117 static int is_type_die (dw_die_ref);
4118 static int is_comdat_die (dw_die_ref);
4119 static int is_symbol_die (dw_die_ref);
4120 static void assign_symbol_names (dw_die_ref);
4121 static void break_out_includes (dw_die_ref);
4122 static hashval_t htab_cu_hash (const void *);
4123 static int htab_cu_eq (const void *, const void *);
4124 static void htab_cu_del (void *);
4125 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4126 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4127 static void add_sibling_attributes (dw_die_ref);
4128 static void build_abbrev_table (dw_die_ref);
4129 static void output_location_lists (dw_die_ref);
4130 static int constant_size (long unsigned);
4131 static unsigned long size_of_die (dw_die_ref);
4132 static void calc_die_sizes (dw_die_ref);
4133 static void mark_dies (dw_die_ref);
4134 static void unmark_dies (dw_die_ref);
4135 static void unmark_all_dies (dw_die_ref);
4136 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
4137 static unsigned long size_of_aranges (void);
4138 static enum dwarf_form value_format (dw_attr_ref);
4139 static void output_value_format (dw_attr_ref);
4140 static void output_abbrev_section (void);
4141 static void output_die_symbol (dw_die_ref);
4142 static void output_die (dw_die_ref);
4143 static void output_compilation_unit_header (void);
4144 static void output_comp_unit (dw_die_ref, int);
4145 static const char *dwarf2_name (tree, int);
4146 static void add_pubname (tree, dw_die_ref);
4147 static void add_pubtype (tree, dw_die_ref);
4148 static void output_pubnames (VEC (pubname_entry,gc) *);
4149 static void add_arange (tree, dw_die_ref);
4150 static void output_aranges (void);
4151 static unsigned int add_ranges (tree);
4152 static void output_ranges (void);
4153 static void output_line_info (void);
4154 static void output_file_names (void);
4155 static dw_die_ref base_type_die (tree);
4156 static tree root_type (tree);
4157 static int is_base_type (tree);
4158 static bool is_subrange_type (tree);
4159 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4160 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4161 static int type_is_enum (tree);
4162 static unsigned int dbx_reg_number (rtx);
4163 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4164 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4165 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4166 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4167 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4168 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4169 static int is_based_loc (rtx);
4170 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4171 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4172 static dw_loc_descr_ref loc_descriptor (rtx);
4173 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4174 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4175 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4176 static tree field_type (tree);
4177 static unsigned int simple_type_align_in_bits (tree);
4178 static unsigned int simple_decl_align_in_bits (tree);
4179 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4180 static HOST_WIDE_INT field_byte_offset (tree);
4181 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4182                                          dw_loc_descr_ref);
4183 static void add_data_member_location_attribute (dw_die_ref, tree);
4184 static void add_const_value_attribute (dw_die_ref, rtx);
4185 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4186 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4187 static void insert_float (rtx, unsigned char *);
4188 static rtx rtl_for_decl_location (tree);
4189 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4190                                                    enum dwarf_attribute);
4191 static void tree_add_const_value_attribute (dw_die_ref, tree);
4192 static void add_name_attribute (dw_die_ref, const char *);
4193 static void add_comp_dir_attribute (dw_die_ref);
4194 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4195 static void add_subscript_info (dw_die_ref, tree);
4196 static void add_byte_size_attribute (dw_die_ref, tree);
4197 static void add_bit_offset_attribute (dw_die_ref, tree);
4198 static void add_bit_size_attribute (dw_die_ref, tree);
4199 static void add_prototyped_attribute (dw_die_ref, tree);
4200 static void add_abstract_origin_attribute (dw_die_ref, tree);
4201 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4202 static void add_src_coords_attributes (dw_die_ref, tree);
4203 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4204 static void push_decl_scope (tree);
4205 static void pop_decl_scope (void);
4206 static dw_die_ref scope_die_for (tree, dw_die_ref);
4207 static inline int local_scope_p (dw_die_ref);
4208 static inline int class_or_namespace_scope_p (dw_die_ref);
4209 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4210 static void add_calling_convention_attribute (dw_die_ref, tree);
4211 static const char *type_tag (tree);
4212 static tree member_declared_type (tree);
4213 #if 0
4214 static const char *decl_start_label (tree);
4215 #endif
4216 static void gen_array_type_die (tree, dw_die_ref);
4217 #if 0
4218 static void gen_entry_point_die (tree, dw_die_ref);
4219 #endif
4220 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4221 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4222 static void gen_inlined_union_type_die (tree, dw_die_ref);
4223 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4224 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4225 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4226 static void gen_formal_types_die (tree, dw_die_ref);
4227 static void gen_subprogram_die (tree, dw_die_ref);
4228 static void gen_variable_die (tree, dw_die_ref);
4229 static void gen_label_die (tree, dw_die_ref);
4230 static void gen_lexical_block_die (tree, dw_die_ref, int);
4231 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4232 static void gen_field_die (tree, dw_die_ref);
4233 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4234 static dw_die_ref gen_compile_unit_die (const char *);
4235 static void gen_inheritance_die (tree, tree, dw_die_ref);
4236 static void gen_member_die (tree, dw_die_ref);
4237 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4238 static void gen_subroutine_type_die (tree, dw_die_ref);
4239 static void gen_typedef_die (tree, dw_die_ref);
4240 static void gen_type_die (tree, dw_die_ref);
4241 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4242 static void gen_block_die (tree, dw_die_ref, int);
4243 static void decls_for_scope (tree, dw_die_ref, int);
4244 static int is_redundant_typedef (tree);
4245 static void gen_namespace_die (tree);
4246 static void gen_decl_die (tree, dw_die_ref);
4247 static dw_die_ref force_decl_die (tree);
4248 static dw_die_ref force_type_die (tree);
4249 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4250 static void declare_in_namespace (tree, dw_die_ref);
4251 static struct dwarf_file_data * lookup_filename (const char *);
4252 static void retry_incomplete_types (void);
4253 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4254 static void splice_child_die (dw_die_ref, dw_die_ref);
4255 static int file_info_cmp (const void *, const void *);
4256 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4257                                      const char *, const char *, unsigned);
4258 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4259                                        const char *, const char *,
4260                                        const char *);
4261 static void output_loc_list (dw_loc_list_ref);
4262 static char *gen_internal_sym (const char *);
4263
4264 static void prune_unmark_dies (dw_die_ref);
4265 static void prune_unused_types_mark (dw_die_ref, int);
4266 static void prune_unused_types_walk (dw_die_ref);
4267 static void prune_unused_types_walk_attribs (dw_die_ref);
4268 static void prune_unused_types_prune (dw_die_ref);
4269 static void prune_unused_types (void);
4270 static int maybe_emit_file (struct dwarf_file_data *fd);
4271
4272 /* Section names used to hold DWARF debugging information.  */
4273 #ifndef DEBUG_INFO_SECTION
4274 #define DEBUG_INFO_SECTION      ".debug_info"
4275 #endif
4276 #ifndef DEBUG_ABBREV_SECTION
4277 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4278 #endif
4279 #ifndef DEBUG_ARANGES_SECTION
4280 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4281 #endif
4282 #ifndef DEBUG_MACINFO_SECTION
4283 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4284 #endif
4285 #ifndef DEBUG_LINE_SECTION
4286 #define DEBUG_LINE_SECTION      ".debug_line"
4287 #endif
4288 #ifndef DEBUG_LOC_SECTION
4289 #define DEBUG_LOC_SECTION       ".debug_loc"
4290 #endif
4291 #ifndef DEBUG_PUBNAMES_SECTION
4292 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4293 #endif
4294 #ifndef DEBUG_STR_SECTION
4295 #define DEBUG_STR_SECTION       ".debug_str"
4296 #endif
4297 #ifndef DEBUG_RANGES_SECTION
4298 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4299 #endif
4300
4301 /* Standard ELF section names for compiled code and data.  */
4302 #ifndef TEXT_SECTION_NAME
4303 #define TEXT_SECTION_NAME       ".text"
4304 #endif
4305
4306 /* Section flags for .debug_str section.  */
4307 #define DEBUG_STR_SECTION_FLAGS \
4308   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4309    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4310    : SECTION_DEBUG)
4311
4312 /* Labels we insert at beginning sections we can reference instead of
4313    the section names themselves.  */
4314
4315 #ifndef TEXT_SECTION_LABEL
4316 #define TEXT_SECTION_LABEL              "Ltext"
4317 #endif
4318 #ifndef COLD_TEXT_SECTION_LABEL
4319 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4320 #endif
4321 #ifndef DEBUG_LINE_SECTION_LABEL
4322 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4323 #endif
4324 #ifndef DEBUG_INFO_SECTION_LABEL
4325 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4326 #endif
4327 #ifndef DEBUG_ABBREV_SECTION_LABEL
4328 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4329 #endif
4330 #ifndef DEBUG_LOC_SECTION_LABEL
4331 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4332 #endif
4333 #ifndef DEBUG_RANGES_SECTION_LABEL
4334 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4335 #endif
4336 #ifndef DEBUG_MACINFO_SECTION_LABEL
4337 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4338 #endif
4339
4340 /* Definitions of defaults for formats and names of various special
4341    (artificial) labels which may be generated within this file (when the -g
4342    options is used and DWARF2_DEBUGGING_INFO is in effect.
4343    If necessary, these may be overridden from within the tm.h file, but
4344    typically, overriding these defaults is unnecessary.  */
4345
4346 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4347 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4348 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4349 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4350 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4351 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4352 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4353 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4354 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4355 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4356
4357 #ifndef TEXT_END_LABEL
4358 #define TEXT_END_LABEL          "Letext"
4359 #endif
4360 #ifndef COLD_END_LABEL
4361 #define COLD_END_LABEL          "Letext_cold"
4362 #endif
4363 #ifndef BLOCK_BEGIN_LABEL
4364 #define BLOCK_BEGIN_LABEL       "LBB"
4365 #endif
4366 #ifndef BLOCK_END_LABEL
4367 #define BLOCK_END_LABEL         "LBE"
4368 #endif
4369 #ifndef LINE_CODE_LABEL
4370 #define LINE_CODE_LABEL         "LM"
4371 #endif
4372 #ifndef SEPARATE_LINE_CODE_LABEL
4373 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4374 #endif
4375 \f
4376 /* We allow a language front-end to designate a function that is to be
4377    called to "demangle" any name before it is put into a DIE.  */
4378
4379 static const char *(*demangle_name_func) (const char *);
4380
4381 void
4382 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4383 {
4384   demangle_name_func = func;
4385 }
4386
4387 /* Test if rtl node points to a pseudo register.  */
4388
4389 static inline int
4390 is_pseudo_reg (rtx rtl)
4391 {
4392   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4393           || (GET_CODE (rtl) == SUBREG
4394               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4395 }
4396
4397 /* Return a reference to a type, with its const and volatile qualifiers
4398    removed.  */
4399
4400 static inline tree
4401 type_main_variant (tree type)
4402 {
4403   type = TYPE_MAIN_VARIANT (type);
4404
4405   /* ??? There really should be only one main variant among any group of
4406      variants of a given type (and all of the MAIN_VARIANT values for all
4407      members of the group should point to that one type) but sometimes the C
4408      front-end messes this up for array types, so we work around that bug
4409      here.  */
4410   if (TREE_CODE (type) == ARRAY_TYPE)
4411     while (type != TYPE_MAIN_VARIANT (type))
4412       type = TYPE_MAIN_VARIANT (type);
4413
4414   return type;
4415 }
4416
4417 /* Return nonzero if the given type node represents a tagged type.  */
4418
4419 static inline int
4420 is_tagged_type (tree type)
4421 {
4422   enum tree_code code = TREE_CODE (type);
4423
4424   return (code == RECORD_TYPE || code == UNION_TYPE
4425           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4426 }
4427
4428 /* Convert a DIE tag into its string name.  */
4429
4430 static const char *
4431 dwarf_tag_name (unsigned int tag)
4432 {
4433   switch (tag)
4434     {
4435     case DW_TAG_padding:
4436       return "DW_TAG_padding";
4437     case DW_TAG_array_type:
4438       return "DW_TAG_array_type";
4439     case DW_TAG_class_type:
4440       return "DW_TAG_class_type";
4441     case DW_TAG_entry_point:
4442       return "DW_TAG_entry_point";
4443     case DW_TAG_enumeration_type:
4444       return "DW_TAG_enumeration_type";
4445     case DW_TAG_formal_parameter:
4446       return "DW_TAG_formal_parameter";
4447     case DW_TAG_imported_declaration:
4448       return "DW_TAG_imported_declaration";
4449     case DW_TAG_label:
4450       return "DW_TAG_label";
4451     case DW_TAG_lexical_block:
4452       return "DW_TAG_lexical_block";
4453     case DW_TAG_member:
4454       return "DW_TAG_member";
4455     case DW_TAG_pointer_type:
4456       return "DW_TAG_pointer_type";
4457     case DW_TAG_reference_type:
4458       return "DW_TAG_reference_type";
4459     case DW_TAG_compile_unit:
4460       return "DW_TAG_compile_unit";
4461     case DW_TAG_string_type:
4462       return "DW_TAG_string_type";
4463     case DW_TAG_structure_type:
4464       return "DW_TAG_structure_type";
4465     case DW_TAG_subroutine_type:
4466       return "DW_TAG_subroutine_type";
4467     case DW_TAG_typedef:
4468       return "DW_TAG_typedef";
4469     case DW_TAG_union_type:
4470       return "DW_TAG_union_type";
4471     case DW_TAG_unspecified_parameters:
4472       return "DW_TAG_unspecified_parameters";
4473     case DW_TAG_variant:
4474       return "DW_TAG_variant";
4475     case DW_TAG_common_block:
4476       return "DW_TAG_common_block";
4477     case DW_TAG_common_inclusion:
4478       return "DW_TAG_common_inclusion";
4479     case DW_TAG_inheritance:
4480       return "DW_TAG_inheritance";
4481     case DW_TAG_inlined_subroutine:
4482       return "DW_TAG_inlined_subroutine";
4483     case DW_TAG_module:
4484       return "DW_TAG_module";
4485     case DW_TAG_ptr_to_member_type:
4486       return "DW_TAG_ptr_to_member_type";
4487     case DW_TAG_set_type:
4488       return "DW_TAG_set_type";
4489     case DW_TAG_subrange_type:
4490       return "DW_TAG_subrange_type";
4491     case DW_TAG_with_stmt:
4492       return "DW_TAG_with_stmt";
4493     case DW_TAG_access_declaration:
4494       return "DW_TAG_access_declaration";
4495     case DW_TAG_base_type:
4496       return "DW_TAG_base_type";
4497     case DW_TAG_catch_block:
4498       return "DW_TAG_catch_block";
4499     case DW_TAG_const_type:
4500       return "DW_TAG_const_type";
4501     case DW_TAG_constant:
4502       return "DW_TAG_constant";
4503     case DW_TAG_enumerator:
4504       return "DW_TAG_enumerator";
4505     case DW_TAG_file_type:
4506       return "DW_TAG_file_type";
4507     case DW_TAG_friend:
4508       return "DW_TAG_friend";
4509     case DW_TAG_namelist:
4510       return "DW_TAG_namelist";
4511     case DW_TAG_namelist_item:
4512       return "DW_TAG_namelist_item";
4513     case DW_TAG_namespace:
4514       return "DW_TAG_namespace";
4515     case DW_TAG_packed_type:
4516       return "DW_TAG_packed_type";
4517     case DW_TAG_subprogram:
4518       return "DW_TAG_subprogram";
4519     case DW_TAG_template_type_param:
4520       return "DW_TAG_template_type_param";
4521     case DW_TAG_template_value_param:
4522       return "DW_TAG_template_value_param";
4523     case DW_TAG_thrown_type:
4524       return "DW_TAG_thrown_type";
4525     case DW_TAG_try_block:
4526       return "DW_TAG_try_block";
4527     case DW_TAG_variant_part:
4528       return "DW_TAG_variant_part";
4529     case DW_TAG_variable:
4530       return "DW_TAG_variable";
4531     case DW_TAG_volatile_type:
4532       return "DW_TAG_volatile_type";
4533     case DW_TAG_imported_module:
4534       return "DW_TAG_imported_module";
4535     case DW_TAG_MIPS_loop:
4536       return "DW_TAG_MIPS_loop";
4537     case DW_TAG_format_label:
4538       return "DW_TAG_format_label";
4539     case DW_TAG_function_template:
4540       return "DW_TAG_function_template";
4541     case DW_TAG_class_template:
4542       return "DW_TAG_class_template";
4543     case DW_TAG_GNU_BINCL:
4544       return "DW_TAG_GNU_BINCL";
4545     case DW_TAG_GNU_EINCL:
4546       return "DW_TAG_GNU_EINCL";
4547     default:
4548       return "DW_TAG_<unknown>";
4549     }
4550 }
4551
4552 /* Convert a DWARF attribute code into its string name.  */
4553
4554 static const char *
4555 dwarf_attr_name (unsigned int attr)
4556 {
4557   switch (attr)
4558     {
4559     case DW_AT_sibling:
4560       return "DW_AT_sibling";
4561     case DW_AT_location:
4562       return "DW_AT_location";
4563     case DW_AT_name:
4564       return "DW_AT_name";
4565     case DW_AT_ordering:
4566       return "DW_AT_ordering";
4567     case DW_AT_subscr_data:
4568       return "DW_AT_subscr_data";
4569     case DW_AT_byte_size:
4570       return "DW_AT_byte_size";
4571     case DW_AT_bit_offset:
4572       return "DW_AT_bit_offset";
4573     case DW_AT_bit_size:
4574       return "DW_AT_bit_size";
4575     case DW_AT_element_list:
4576       return "DW_AT_element_list";
4577     case DW_AT_stmt_list:
4578       return "DW_AT_stmt_list";
4579     case DW_AT_low_pc:
4580       return "DW_AT_low_pc";
4581     case DW_AT_high_pc:
4582       return "DW_AT_high_pc";
4583     case DW_AT_language:
4584       return "DW_AT_language";
4585     case DW_AT_member:
4586       return "DW_AT_member";
4587     case DW_AT_discr:
4588       return "DW_AT_discr";
4589     case DW_AT_discr_value:
4590       return "DW_AT_discr_value";
4591     case DW_AT_visibility:
4592       return "DW_AT_visibility";
4593     case DW_AT_import:
4594       return "DW_AT_import";
4595     case DW_AT_string_length:
4596       return "DW_AT_string_length";
4597     case DW_AT_common_reference:
4598       return "DW_AT_common_reference";
4599     case DW_AT_comp_dir:
4600       return "DW_AT_comp_dir";
4601     case DW_AT_const_value:
4602       return "DW_AT_const_value";
4603     case DW_AT_containing_type:
4604       return "DW_AT_containing_type";
4605     case DW_AT_default_value:
4606       return "DW_AT_default_value";
4607     case DW_AT_inline:
4608       return "DW_AT_inline";
4609     case DW_AT_is_optional:
4610       return "DW_AT_is_optional";
4611     case DW_AT_lower_bound:
4612       return "DW_AT_lower_bound";
4613     case DW_AT_producer:
4614       return "DW_AT_producer";
4615     case DW_AT_prototyped:
4616       return "DW_AT_prototyped";
4617     case DW_AT_return_addr:
4618       return "DW_AT_return_addr";
4619     case DW_AT_start_scope:
4620       return "DW_AT_start_scope";
4621     case DW_AT_stride_size:
4622       return "DW_AT_stride_size";
4623     case DW_AT_upper_bound:
4624       return "DW_AT_upper_bound";
4625     case DW_AT_abstract_origin:
4626       return "DW_AT_abstract_origin";
4627     case DW_AT_accessibility:
4628       return "DW_AT_accessibility";
4629     case DW_AT_address_class:
4630       return "DW_AT_address_class";
4631     case DW_AT_artificial:
4632       return "DW_AT_artificial";
4633     case DW_AT_base_types:
4634       return "DW_AT_base_types";
4635     case DW_AT_calling_convention:
4636       return "DW_AT_calling_convention";
4637     case DW_AT_count:
4638       return "DW_AT_count";
4639     case DW_AT_data_member_location:
4640       return "DW_AT_data_member_location";
4641     case DW_AT_decl_column:
4642       return "DW_AT_decl_column";
4643     case DW_AT_decl_file:
4644       return "DW_AT_decl_file";
4645     case DW_AT_decl_line:
4646       return "DW_AT_decl_line";
4647     case DW_AT_declaration:
4648       return "DW_AT_declaration";
4649     case DW_AT_discr_list:
4650       return "DW_AT_discr_list";
4651     case DW_AT_encoding:
4652       return "DW_AT_encoding";
4653     case DW_AT_external:
4654       return "DW_AT_external";
4655     case DW_AT_frame_base:
4656       return "DW_AT_frame_base";
4657     case DW_AT_friend:
4658       return "DW_AT_friend";
4659     case DW_AT_identifier_case:
4660       return "DW_AT_identifier_case";
4661     case DW_AT_macro_info:
4662       return "DW_AT_macro_info";
4663     case DW_AT_namelist_items:
4664       return "DW_AT_namelist_items";
4665     case DW_AT_priority:
4666       return "DW_AT_priority";
4667     case DW_AT_segment:
4668       return "DW_AT_segment";
4669     case DW_AT_specification:
4670       return "DW_AT_specification";
4671     case DW_AT_static_link:
4672       return "DW_AT_static_link";
4673     case DW_AT_type:
4674       return "DW_AT_type";
4675     case DW_AT_use_location:
4676       return "DW_AT_use_location";
4677     case DW_AT_variable_parameter:
4678       return "DW_AT_variable_parameter";
4679     case DW_AT_virtuality:
4680       return "DW_AT_virtuality";
4681     case DW_AT_vtable_elem_location:
4682       return "DW_AT_vtable_elem_location";
4683
4684     case DW_AT_allocated:
4685       return "DW_AT_allocated";
4686     case DW_AT_associated:
4687       return "DW_AT_associated";
4688     case DW_AT_data_location:
4689       return "DW_AT_data_location";
4690     case DW_AT_stride:
4691       return "DW_AT_stride";
4692     case DW_AT_entry_pc:
4693       return "DW_AT_entry_pc";
4694     case DW_AT_use_UTF8:
4695       return "DW_AT_use_UTF8";
4696     case DW_AT_extension:
4697       return "DW_AT_extension";
4698     case DW_AT_ranges:
4699       return "DW_AT_ranges";
4700     case DW_AT_trampoline:
4701       return "DW_AT_trampoline";
4702     case DW_AT_call_column:
4703       return "DW_AT_call_column";
4704     case DW_AT_call_file:
4705       return "DW_AT_call_file";
4706     case DW_AT_call_line:
4707       return "DW_AT_call_line";
4708
4709     case DW_AT_MIPS_fde:
4710       return "DW_AT_MIPS_fde";
4711     case DW_AT_MIPS_loop_begin:
4712       return "DW_AT_MIPS_loop_begin";
4713     case DW_AT_MIPS_tail_loop_begin:
4714       return "DW_AT_MIPS_tail_loop_begin";
4715     case DW_AT_MIPS_epilog_begin:
4716       return "DW_AT_MIPS_epilog_begin";
4717     case DW_AT_MIPS_loop_unroll_factor:
4718       return "DW_AT_MIPS_loop_unroll_factor";
4719     case DW_AT_MIPS_software_pipeline_depth:
4720       return "DW_AT_MIPS_software_pipeline_depth";
4721     case DW_AT_MIPS_linkage_name:
4722       return "DW_AT_MIPS_linkage_name";
4723     case DW_AT_MIPS_stride:
4724       return "DW_AT_MIPS_stride";
4725     case DW_AT_MIPS_abstract_name:
4726       return "DW_AT_MIPS_abstract_name";
4727     case DW_AT_MIPS_clone_origin:
4728       return "DW_AT_MIPS_clone_origin";
4729     case DW_AT_MIPS_has_inlines:
4730       return "DW_AT_MIPS_has_inlines";
4731
4732     case DW_AT_sf_names:
4733       return "DW_AT_sf_names";
4734     case DW_AT_src_info:
4735       return "DW_AT_src_info";
4736     case DW_AT_mac_info:
4737       return "DW_AT_mac_info";
4738     case DW_AT_src_coords:
4739       return "DW_AT_src_coords";
4740     case DW_AT_body_begin:
4741       return "DW_AT_body_begin";
4742     case DW_AT_body_end:
4743       return "DW_AT_body_end";
4744     case DW_AT_GNU_vector:
4745       return "DW_AT_GNU_vector";
4746
4747     case DW_AT_VMS_rtnbeg_pd_address:
4748       return "DW_AT_VMS_rtnbeg_pd_address";
4749
4750     default:
4751       return "DW_AT_<unknown>";
4752     }
4753 }
4754
4755 /* Convert a DWARF value form code into its string name.  */
4756
4757 static const char *
4758 dwarf_form_name (unsigned int form)
4759 {
4760   switch (form)
4761     {
4762     case DW_FORM_addr:
4763       return "DW_FORM_addr";
4764     case DW_FORM_block2:
4765       return "DW_FORM_block2";
4766     case DW_FORM_block4:
4767       return "DW_FORM_block4";
4768     case DW_FORM_data2:
4769       return "DW_FORM_data2";
4770     case DW_FORM_data4:
4771       return "DW_FORM_data4";
4772     case DW_FORM_data8:
4773       return "DW_FORM_data8";
4774     case DW_FORM_string:
4775       return "DW_FORM_string";
4776     case DW_FORM_block:
4777       return "DW_FORM_block";
4778     case DW_FORM_block1:
4779       return "DW_FORM_block1";
4780     case DW_FORM_data1:
4781       return "DW_FORM_data1";
4782     case DW_FORM_flag:
4783       return "DW_FORM_flag";
4784     case DW_FORM_sdata:
4785       return "DW_FORM_sdata";
4786     case DW_FORM_strp:
4787       return "DW_FORM_strp";
4788     case DW_FORM_udata:
4789       return "DW_FORM_udata";
4790     case DW_FORM_ref_addr:
4791       return "DW_FORM_ref_addr";
4792     case DW_FORM_ref1:
4793       return "DW_FORM_ref1";
4794     case DW_FORM_ref2:
4795       return "DW_FORM_ref2";
4796     case DW_FORM_ref4:
4797       return "DW_FORM_ref4";
4798     case DW_FORM_ref8:
4799       return "DW_FORM_ref8";
4800     case DW_FORM_ref_udata:
4801       return "DW_FORM_ref_udata";
4802     case DW_FORM_indirect:
4803       return "DW_FORM_indirect";
4804     default:
4805       return "DW_FORM_<unknown>";
4806     }
4807 }
4808 \f
4809 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4810    instance of an inlined instance of a decl which is local to an inline
4811    function, so we have to trace all of the way back through the origin chain
4812    to find out what sort of node actually served as the original seed for the
4813    given block.  */
4814
4815 static tree
4816 decl_ultimate_origin (tree decl)
4817 {
4818   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4819     return NULL_TREE;
4820
4821   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4822      nodes in the function to point to themselves; ignore that if
4823      we're trying to output the abstract instance of this function.  */
4824   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4825     return NULL_TREE;
4826
4827   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4828      most distant ancestor, this should never happen.  */
4829   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4830
4831   return DECL_ABSTRACT_ORIGIN (decl);
4832 }
4833
4834 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4835    instance of an inlined instance of a block which is local to an inline
4836    function, so we have to trace all of the way back through the origin chain
4837    to find out what sort of node actually served as the original seed for the
4838    given block.  */
4839
4840 static tree
4841 block_ultimate_origin (tree block)
4842 {
4843   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4844
4845   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4846      nodes in the function to point to themselves; ignore that if
4847      we're trying to output the abstract instance of this function.  */
4848   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4849     return NULL_TREE;
4850
4851   if (immediate_origin == NULL_TREE)
4852     return NULL_TREE;
4853   else
4854     {
4855       tree ret_val;
4856       tree lookahead = immediate_origin;
4857
4858       do
4859         {
4860           ret_val = lookahead;
4861           lookahead = (TREE_CODE (ret_val) == BLOCK
4862                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4863         }
4864       while (lookahead != NULL && lookahead != ret_val);
4865
4866       /* The block's abstract origin chain may not be the *ultimate* origin of
4867          the block. It could lead to a DECL that has an abstract origin set.
4868          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4869          will give us if it has one).  Note that DECL's abstract origins are
4870          supposed to be the most distant ancestor (or so decl_ultimate_origin
4871          claims), so we don't need to loop following the DECL origins.  */
4872       if (DECL_P (ret_val))
4873         return DECL_ORIGIN (ret_val);
4874
4875       return ret_val;
4876     }
4877 }
4878
4879 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4880    of a virtual function may refer to a base class, so we check the 'this'
4881    parameter.  */
4882
4883 static tree
4884 decl_class_context (tree decl)
4885 {
4886   tree context = NULL_TREE;
4887
4888   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4889     context = DECL_CONTEXT (decl);
4890   else
4891     context = TYPE_MAIN_VARIANT
4892       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4893
4894   if (context && !TYPE_P (context))
4895     context = NULL_TREE;
4896
4897   return context;
4898 }
4899 \f
4900 /* Add an attribute/value pair to a DIE.  */
4901
4902 static inline void
4903 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4904 {
4905   /* Maybe this should be an assert?  */
4906   if (die == NULL)
4907     return;
4908
4909   if (die->die_attr == NULL)
4910     die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4911   VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4912 }
4913
4914 static inline enum dw_val_class
4915 AT_class (dw_attr_ref a)
4916 {
4917   return a->dw_attr_val.val_class;
4918 }
4919
4920 /* Add a flag value attribute to a DIE.  */
4921
4922 static inline void
4923 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4924 {
4925   dw_attr_node attr;
4926
4927   attr.dw_attr = attr_kind;
4928   attr.dw_attr_val.val_class = dw_val_class_flag;
4929   attr.dw_attr_val.v.val_flag = flag;
4930   add_dwarf_attr (die, &attr);
4931 }
4932
4933 static inline unsigned
4934 AT_flag (dw_attr_ref a)
4935 {
4936   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4937   return a->dw_attr_val.v.val_flag;
4938 }
4939
4940 /* Add a signed integer attribute value to a DIE.  */
4941
4942 static inline void
4943 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4944 {
4945   dw_attr_node attr;
4946
4947   attr.dw_attr = attr_kind;
4948   attr.dw_attr_val.val_class = dw_val_class_const;
4949   attr.dw_attr_val.v.val_int = int_val;
4950   add_dwarf_attr (die, &attr);
4951 }
4952
4953 static inline HOST_WIDE_INT
4954 AT_int (dw_attr_ref a)
4955 {
4956   gcc_assert (a && AT_class (a) == dw_val_class_const);
4957   return a->dw_attr_val.v.val_int;
4958 }
4959
4960 /* Add an unsigned integer attribute value to a DIE.  */
4961
4962 static inline void
4963 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4964                  unsigned HOST_WIDE_INT unsigned_val)
4965 {
4966   dw_attr_node attr;
4967
4968   attr.dw_attr = attr_kind;
4969   attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4970   attr.dw_attr_val.v.val_unsigned = unsigned_val;
4971   add_dwarf_attr (die, &attr);
4972 }
4973
4974 static inline unsigned HOST_WIDE_INT
4975 AT_unsigned (dw_attr_ref a)
4976 {
4977   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4978   return a->dw_attr_val.v.val_unsigned;
4979 }
4980
4981 /* Add an unsigned double integer attribute value to a DIE.  */
4982
4983 static inline void
4984 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4985                   long unsigned int val_hi, long unsigned int val_low)
4986 {
4987   dw_attr_node attr;
4988
4989   attr.dw_attr = attr_kind;
4990   attr.dw_attr_val.val_class = dw_val_class_long_long;
4991   attr.dw_attr_val.v.val_long_long.hi = val_hi;
4992   attr.dw_attr_val.v.val_long_long.low = val_low;
4993   add_dwarf_attr (die, &attr);
4994 }
4995
4996 /* Add a floating point attribute value to a DIE and return it.  */
4997
4998 static inline void
4999 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5000             unsigned int length, unsigned int elt_size, unsigned char *array)
5001 {
5002   dw_attr_node attr;
5003
5004   attr.dw_attr = attr_kind;
5005   attr.dw_attr_val.val_class = dw_val_class_vec;
5006   attr.dw_attr_val.v.val_vec.length = length;
5007   attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5008   attr.dw_attr_val.v.val_vec.array = array;
5009   add_dwarf_attr (die, &attr);
5010 }
5011
5012 /* Hash and equality functions for debug_str_hash.  */
5013
5014 static hashval_t
5015 debug_str_do_hash (const void *x)
5016 {
5017   return htab_hash_string (((const struct indirect_string_node *)x)->str);
5018 }
5019
5020 static int
5021 debug_str_eq (const void *x1, const void *x2)
5022 {
5023   return strcmp ((((const struct indirect_string_node *)x1)->str),
5024                  (const char *)x2) == 0;
5025 }
5026
5027 /* Add a string attribute value to a DIE.  */
5028
5029 static inline void
5030 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5031 {
5032   dw_attr_node attr;
5033   struct indirect_string_node *node;
5034   void **slot;
5035
5036   if (! debug_str_hash)
5037     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5038                                       debug_str_eq, NULL);
5039
5040   slot = htab_find_slot_with_hash (debug_str_hash, str,
5041                                    htab_hash_string (str), INSERT);
5042   if (*slot == NULL)
5043     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
5044   node = (struct indirect_string_node *) *slot;
5045   node->str = ggc_strdup (str);
5046   node->refcount++;
5047
5048   attr.dw_attr = attr_kind;
5049   attr.dw_attr_val.val_class = dw_val_class_str;
5050   attr.dw_attr_val.v.val_str = node;
5051   add_dwarf_attr (die, &attr);
5052 }
5053
5054 static inline const char *
5055 AT_string (dw_attr_ref a)
5056 {
5057   gcc_assert (a && AT_class (a) == dw_val_class_str);
5058   return a->dw_attr_val.v.val_str->str;
5059 }
5060
5061 /* Find out whether a string should be output inline in DIE
5062    or out-of-line in .debug_str section.  */
5063
5064 static int
5065 AT_string_form (dw_attr_ref a)
5066 {
5067   struct indirect_string_node *node;
5068   unsigned int len;
5069   char label[32];
5070
5071   gcc_assert (a && AT_class (a) == dw_val_class_str);
5072
5073   node = a->dw_attr_val.v.val_str;
5074   if (node->form)
5075     return node->form;
5076
5077   len = strlen (node->str) + 1;
5078
5079   /* If the string is shorter or equal to the size of the reference, it is
5080      always better to put it inline.  */
5081   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5082     return node->form = DW_FORM_string;
5083
5084   /* If we cannot expect the linker to merge strings in .debug_str
5085      section, only put it into .debug_str if it is worth even in this
5086      single module.  */
5087   if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5088       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5089     return node->form = DW_FORM_string;
5090
5091   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5092   ++dw2_string_counter;
5093   node->label = xstrdup (label);
5094
5095   return node->form = DW_FORM_strp;
5096 }
5097
5098 /* Add a DIE reference attribute value to a DIE.  */
5099
5100 static inline void
5101 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5102 {
5103   dw_attr_node attr;
5104
5105   attr.dw_attr = attr_kind;
5106   attr.dw_attr_val.val_class = dw_val_class_die_ref;
5107   attr.dw_attr_val.v.val_die_ref.die = targ_die;
5108   attr.dw_attr_val.v.val_die_ref.external = 0;
5109   add_dwarf_attr (die, &attr);
5110 }
5111
5112 /* Add an AT_specification attribute to a DIE, and also make the back
5113    pointer from the specification to the definition.  */
5114
5115 static inline void
5116 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5117 {
5118   add_AT_die_ref (die, DW_AT_specification, targ_die);
5119   gcc_assert (!targ_die->die_definition);
5120   targ_die->die_definition = die;
5121 }
5122
5123 static inline dw_die_ref
5124 AT_ref (dw_attr_ref a)
5125 {
5126   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5127   return a->dw_attr_val.v.val_die_ref.die;
5128 }
5129
5130 static inline int
5131 AT_ref_external (dw_attr_ref a)
5132 {
5133   if (a && AT_class (a) == dw_val_class_die_ref)
5134     return a->dw_attr_val.v.val_die_ref.external;
5135
5136   return 0;
5137 }
5138
5139 static inline void
5140 set_AT_ref_external (dw_attr_ref a, int i)
5141 {
5142   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5143   a->dw_attr_val.v.val_die_ref.external = i;
5144 }
5145
5146 /* Add an FDE reference attribute value to a DIE.  */
5147
5148 static inline void
5149 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5150 {
5151   dw_attr_node attr;
5152
5153   attr.dw_attr = attr_kind;
5154   attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5155   attr.dw_attr_val.v.val_fde_index = targ_fde;
5156   add_dwarf_attr (die, &attr);
5157 }
5158
5159 /* Add a location description attribute value to a DIE.  */
5160
5161 static inline void
5162 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5163 {
5164   dw_attr_node attr;
5165
5166   attr.dw_attr = attr_kind;
5167   attr.dw_attr_val.val_class = dw_val_class_loc;
5168   attr.dw_attr_val.v.val_loc = loc;
5169   add_dwarf_attr (die, &attr);
5170 }
5171
5172 static inline dw_loc_descr_ref
5173 AT_loc (dw_attr_ref a)
5174 {
5175   gcc_assert (a && AT_class (a) == dw_val_class_loc);
5176   return a->dw_attr_val.v.val_loc;
5177 }
5178
5179 static inline void
5180 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5181 {
5182   dw_attr_node attr;
5183
5184   attr.dw_attr = attr_kind;
5185   attr.dw_attr_val.val_class = dw_val_class_loc_list;
5186   attr.dw_attr_val.v.val_loc_list = loc_list;
5187   add_dwarf_attr (die, &attr);
5188   have_location_lists = true;
5189 }
5190
5191 static inline dw_loc_list_ref
5192 AT_loc_list (dw_attr_ref a)
5193 {
5194   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5195   return a->dw_attr_val.v.val_loc_list;
5196 }
5197
5198 /* Add an address constant attribute value to a DIE.  */
5199
5200 static inline void
5201 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5202 {
5203   dw_attr_node attr;
5204
5205   attr.dw_attr = attr_kind;
5206   attr.dw_attr_val.val_class = dw_val_class_addr;
5207   attr.dw_attr_val.v.val_addr = addr;
5208   add_dwarf_attr (die, &attr);
5209 }
5210
5211 /* Get the RTX from to an address DIE attribute.  */
5212
5213 static inline rtx
5214 AT_addr (dw_attr_ref a)
5215 {
5216   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5217   return a->dw_attr_val.v.val_addr;
5218 }
5219
5220 /* Add a file attribute value to a DIE.  */
5221
5222 static inline void
5223 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5224              struct dwarf_file_data *fd)
5225 {
5226   dw_attr_node attr;
5227
5228   attr.dw_attr = attr_kind;
5229   attr.dw_attr_val.val_class = dw_val_class_file;
5230   attr.dw_attr_val.v.val_file = fd;
5231   add_dwarf_attr (die, &attr);
5232 }
5233
5234 /* Get the dwarf_file_data from a file DIE attribute.  */
5235
5236 static inline struct dwarf_file_data *
5237 AT_file (dw_attr_ref a)
5238 {
5239   gcc_assert (a && AT_class (a) == dw_val_class_file);
5240   return a->dw_attr_val.v.val_file;
5241 }
5242
5243 /* Add a label identifier attribute value to a DIE.  */
5244
5245 static inline void
5246 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5247 {
5248   dw_attr_node attr;
5249
5250   attr.dw_attr = attr_kind;
5251   attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5252   attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5253   add_dwarf_attr (die, &attr);
5254 }
5255
5256 /* Add a section offset attribute value to a DIE, an offset into the
5257    debug_line section.  */
5258
5259 static inline void
5260 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5261                 const char *label)
5262 {
5263   dw_attr_node attr;
5264
5265   attr.dw_attr = attr_kind;
5266   attr.dw_attr_val.val_class = dw_val_class_lineptr;
5267   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5268   add_dwarf_attr (die, &attr);
5269 }
5270
5271 /* Add a section offset attribute value to a DIE, an offset into the
5272    debug_macinfo section.  */
5273
5274 static inline void
5275 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5276                const char *label)
5277 {
5278   dw_attr_node attr;
5279
5280   attr.dw_attr = attr_kind;
5281   attr.dw_attr_val.val_class = dw_val_class_macptr;
5282   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5283   add_dwarf_attr (die, &attr);
5284 }
5285
5286 /* Add an offset attribute value to a DIE.  */
5287
5288 static inline void
5289 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5290                unsigned HOST_WIDE_INT offset)
5291 {
5292   dw_attr_node attr;
5293
5294   attr.dw_attr = attr_kind;
5295   attr.dw_attr_val.val_class = dw_val_class_offset;
5296   attr.dw_attr_val.v.val_offset = offset;
5297   add_dwarf_attr (die, &attr);
5298 }
5299
5300 /* Add an range_list attribute value to a DIE.  */
5301
5302 static void
5303 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5304                    long unsigned int offset)
5305 {
5306   dw_attr_node attr;
5307
5308   attr.dw_attr = attr_kind;
5309   attr.dw_attr_val.val_class = dw_val_class_range_list;
5310   attr.dw_attr_val.v.val_offset = offset;
5311   add_dwarf_attr (die, &attr);
5312 }
5313
5314 static inline const char *
5315 AT_lbl (dw_attr_ref a)
5316 {
5317   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5318                     || AT_class (a) == dw_val_class_lineptr
5319                     || AT_class (a) == dw_val_class_macptr));
5320   return a->dw_attr_val.v.val_lbl_id;
5321 }
5322
5323 /* Get the attribute of type attr_kind.  */
5324
5325 static dw_attr_ref
5326 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5327 {
5328   dw_attr_ref a;
5329   unsigned ix;
5330   dw_die_ref spec = NULL;
5331
5332   if (! die)
5333     return NULL;
5334
5335   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5336     if (a->dw_attr == attr_kind)
5337       return a;
5338     else if (a->dw_attr == DW_AT_specification
5339              || a->dw_attr == DW_AT_abstract_origin)
5340       spec = AT_ref (a);
5341
5342   if (spec)
5343     return get_AT (spec, attr_kind);
5344
5345   return NULL;
5346 }
5347
5348 /* Return the "low pc" attribute value, typically associated with a subprogram
5349    DIE.  Return null if the "low pc" attribute is either not present, or if it
5350    cannot be represented as an assembler label identifier.  */
5351
5352 static inline const char *
5353 get_AT_low_pc (dw_die_ref die)
5354 {
5355   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5356
5357   return a ? AT_lbl (a) : NULL;
5358 }
5359
5360 /* Return the "high pc" attribute value, typically associated with a subprogram
5361    DIE.  Return null if the "high pc" attribute is either not present, or if it
5362    cannot be represented as an assembler label identifier.  */
5363
5364 static inline const char *
5365 get_AT_hi_pc (dw_die_ref die)
5366 {
5367   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5368
5369   return a ? AT_lbl (a) : NULL;
5370 }
5371
5372 /* Return the value of the string attribute designated by ATTR_KIND, or
5373    NULL if it is not present.  */
5374
5375 static inline const char *
5376 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5377 {
5378   dw_attr_ref a = get_AT (die, attr_kind);
5379
5380   return a ? AT_string (a) : NULL;
5381 }
5382
5383 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5384    if it is not present.  */
5385
5386 static inline int
5387 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5388 {
5389   dw_attr_ref a = get_AT (die, attr_kind);
5390
5391   return a ? AT_flag (a) : 0;
5392 }
5393
5394 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5395    if it is not present.  */
5396
5397 static inline unsigned
5398 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5399 {
5400   dw_attr_ref a = get_AT (die, attr_kind);
5401
5402   return a ? AT_unsigned (a) : 0;
5403 }
5404
5405 static inline dw_die_ref
5406 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5407 {
5408   dw_attr_ref a = get_AT (die, attr_kind);
5409
5410   return a ? AT_ref (a) : NULL;
5411 }
5412
5413 static inline struct dwarf_file_data *
5414 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5415 {
5416   dw_attr_ref a = get_AT (die, attr_kind);
5417
5418   return a ? AT_file (a) : NULL;
5419 }
5420
5421 /* Return TRUE if the language is C or C++.  */
5422
5423 static inline bool
5424 is_c_family (void)
5425 {
5426   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5427
5428   return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5429           || lang == DW_LANG_C99
5430           || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5431 }
5432
5433 /* Return TRUE if the language is C++.  */
5434
5435 static inline bool
5436 is_cxx (void)
5437 {
5438   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5439
5440   return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5441 }
5442
5443 /* Return TRUE if the language is Fortran.  */
5444
5445 static inline bool
5446 is_fortran (void)
5447 {
5448   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5449
5450   return (lang == DW_LANG_Fortran77
5451           || lang == DW_LANG_Fortran90
5452           || lang == DW_LANG_Fortran95);
5453 }
5454
5455 /* Return TRUE if the language is Java.  */
5456
5457 static inline bool
5458 is_java (void)
5459 {
5460   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5461
5462   return lang == DW_LANG_Java;
5463 }
5464
5465 /* Return TRUE if the language is Ada.  */
5466
5467 static inline bool
5468 is_ada (void)
5469 {
5470   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5471
5472   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5473 }
5474
5475 /* Remove the specified attribute if present.  */
5476
5477 static void
5478 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5479 {
5480   dw_attr_ref a;
5481   unsigned ix;
5482
5483   if (! die)
5484     return;
5485
5486   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5487     if (a->dw_attr == attr_kind)
5488       {
5489         if (AT_class (a) == dw_val_class_str)
5490           if (a->dw_attr_val.v.val_str->refcount)
5491             a->dw_attr_val.v.val_str->refcount--;
5492
5493         /* VEC_ordered_remove should help reduce the number of abbrevs
5494            that are needed.  */
5495         VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5496         return;
5497       }
5498 }
5499
5500 /* Remove CHILD from its parent.  PREV must have the property that
5501    PREV->DIE_SIB == CHILD.  Does not alter CHILD.  */
5502
5503 static void
5504 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5505 {
5506   gcc_assert (child->die_parent == prev->die_parent);
5507   gcc_assert (prev->die_sib == child);
5508   if (prev == child)
5509     {
5510       gcc_assert (child->die_parent->die_child == child);
5511       prev = NULL;
5512     }
5513   else
5514     prev->die_sib = child->die_sib;
5515   if (child->die_parent->die_child == child)
5516     child->die_parent->die_child = prev;
5517 }
5518
5519 /* Remove child DIE whose die_tag is TAG.  Do nothing if no child
5520    matches TAG.  */
5521
5522 static void
5523 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5524 {
5525   dw_die_ref c;
5526
5527   c = die->die_child;
5528   if (c) do {
5529     dw_die_ref prev = c;
5530     c = c->die_sib;
5531     while (c->die_tag == tag)
5532       {
5533         remove_child_with_prev (c, prev);
5534         /* Might have removed every child.  */
5535         if (c == c->die_sib)
5536           return;
5537         c = c->die_sib;
5538       }
5539   } while (c != die->die_child);
5540 }
5541
5542 /* Add a CHILD_DIE as the last child of DIE.  */
5543
5544 static void
5545 add_child_die (dw_die_ref die, dw_die_ref child_die)
5546 {
5547   /* FIXME this should probably be an assert.  */
5548   if (! die || ! child_die)
5549     return;
5550   gcc_assert (die != child_die);
5551
5552   child_die->die_parent = die;
5553   if (die->die_child)
5554     {
5555       child_die->die_sib = die->die_child->die_sib;
5556       die->die_child->die_sib = child_die;
5557     }
5558   else
5559     child_die->die_sib = child_die;
5560   die->die_child = child_die;
5561 }
5562
5563 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5564    is the specification, to the end of PARENT's list of children.
5565    This is done by removing and re-adding it.  */
5566
5567 static void
5568 splice_child_die (dw_die_ref parent, dw_die_ref child)
5569 {
5570   dw_die_ref p;
5571
5572   /* We want the declaration DIE from inside the class, not the
5573      specification DIE at toplevel.  */
5574   if (child->die_parent != parent)
5575     {
5576       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5577
5578       if (tmp)
5579         child = tmp;
5580     }
5581
5582   gcc_assert (child->die_parent == parent
5583               || (child->die_parent
5584                   == get_AT_ref (parent, DW_AT_specification)));
5585
5586   for (p = child->die_parent->die_child; ; p = p->die_sib)
5587     if (p->die_sib == child)
5588       {
5589         remove_child_with_prev (child, p);
5590         break;
5591       }
5592
5593   add_child_die (parent, child);
5594 }
5595
5596 /* Return a pointer to a newly created DIE node.  */
5597
5598 static inline dw_die_ref
5599 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5600 {
5601   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5602
5603   die->die_tag = tag_value;
5604
5605   if (parent_die != NULL)
5606     add_child_die (parent_die, die);
5607   else
5608     {
5609       limbo_die_node *limbo_node;
5610
5611       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5612       limbo_node->die = die;
5613       limbo_node->created_for = t;
5614       limbo_node->next = limbo_die_list;
5615       limbo_die_list = limbo_node;
5616     }
5617
5618   return die;
5619 }
5620
5621 /* Return the DIE associated with the given type specifier.  */
5622
5623 static inline dw_die_ref
5624 lookup_type_die (tree type)
5625 {
5626   return TYPE_SYMTAB_DIE (type);
5627 }
5628
5629 /* Equate a DIE to a given type specifier.  */
5630
5631 static inline void
5632 equate_type_number_to_die (tree type, dw_die_ref type_die)
5633 {
5634   TYPE_SYMTAB_DIE (type) = type_die;
5635 }
5636
5637 /* Returns a hash value for X (which really is a die_struct).  */
5638
5639 static hashval_t
5640 decl_die_table_hash (const void *x)
5641 {
5642   return (hashval_t) ((const dw_die_ref) x)->decl_id;
5643 }
5644
5645 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5646
5647 static int
5648 decl_die_table_eq (const void *x, const void *y)
5649 {
5650   return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5651 }
5652
5653 /* Return the DIE associated with a given declaration.  */
5654
5655 static inline dw_die_ref
5656 lookup_decl_die (tree decl)
5657 {
5658   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5659 }
5660
5661 /* Returns a hash value for X (which really is a var_loc_list).  */
5662
5663 static hashval_t
5664 decl_loc_table_hash (const void *x)
5665 {
5666   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5667 }
5668
5669 /* Return nonzero if decl_id of var_loc_list X is the same as
5670    UID of decl *Y.  */
5671
5672 static int
5673 decl_loc_table_eq (const void *x, const void *y)
5674 {
5675   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5676 }
5677
5678 /* Return the var_loc list associated with a given declaration.  */
5679
5680 static inline var_loc_list *
5681 lookup_decl_loc (tree decl)
5682 {
5683   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5684 }
5685
5686 /* Equate a DIE to a particular declaration.  */
5687
5688 static void
5689 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5690 {
5691   unsigned int decl_id = DECL_UID (decl);
5692   void **slot;
5693
5694   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5695   *slot = decl_die;
5696   decl_die->decl_id = decl_id;
5697 }
5698
5699 /* Add a variable location node to the linked list for DECL.  */
5700
5701 static void
5702 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5703 {
5704   unsigned int decl_id = DECL_UID (decl);
5705   var_loc_list *temp;
5706   void **slot;
5707
5708   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5709   if (*slot == NULL)
5710     {
5711       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5712       temp->decl_id = decl_id;
5713       *slot = temp;
5714     }
5715   else
5716     temp = *slot;
5717
5718   if (temp->last)
5719     {
5720       /* If the current location is the same as the end of the list,
5721          we have nothing to do.  */
5722       if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5723                         NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5724         {
5725           /* Add LOC to the end of list and update LAST.  */
5726           temp->last->next = loc;
5727           temp->last = loc;
5728         }
5729     }
5730   /* Do not add empty location to the beginning of the list.  */
5731   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5732     {
5733       temp->first = loc;
5734       temp->last = loc;
5735     }
5736 }
5737 \f
5738 /* Keep track of the number of spaces used to indent the
5739    output of the debugging routines that print the structure of
5740    the DIE internal representation.  */
5741 static int print_indent;
5742
5743 /* Indent the line the number of spaces given by print_indent.  */
5744
5745 static inline void
5746 print_spaces (FILE *outfile)
5747 {
5748   fprintf (outfile, "%*s", print_indent, "");
5749 }
5750
5751 /* Print the information associated with a given DIE, and its children.
5752    This routine is a debugging aid only.  */
5753
5754 static void
5755 print_die (dw_die_ref die, FILE *outfile)
5756 {
5757   dw_attr_ref a;
5758   dw_die_ref c;
5759   unsigned ix;
5760
5761   print_spaces (outfile);
5762   fprintf (outfile, "DIE %4lu: %s\n",
5763            die->die_offset, dwarf_tag_name (die->die_tag));
5764   print_spaces (outfile);
5765   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5766   fprintf (outfile, " offset: %lu\n", die->die_offset);
5767
5768   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5769     {
5770       print_spaces (outfile);
5771       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5772
5773       switch (AT_class (a))
5774         {
5775         case dw_val_class_addr:
5776           fprintf (outfile, "address");
5777           break;
5778         case dw_val_class_offset:
5779           fprintf (outfile, "offset");
5780           break;
5781         case dw_val_class_loc:
5782           fprintf (outfile, "location descriptor");
5783           break;
5784         case dw_val_class_loc_list:
5785           fprintf (outfile, "location list -> label:%s",
5786                    AT_loc_list (a)->ll_symbol);
5787           break;
5788         case dw_val_class_range_list:
5789           fprintf (outfile, "range list");
5790           break;
5791         case dw_val_class_const:
5792           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5793           break;
5794         case dw_val_class_unsigned_const:
5795           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5796           break;
5797         case dw_val_class_long_long:
5798           fprintf (outfile, "constant (%lu,%lu)",
5799                    a->dw_attr_val.v.val_long_long.hi,
5800                    a->dw_attr_val.v.val_long_long.low);
5801           break;
5802         case dw_val_class_vec:
5803           fprintf (outfile, "floating-point or vector constant");
5804           break;
5805         case dw_val_class_flag:
5806           fprintf (outfile, "%u", AT_flag (a));
5807           break;
5808         case dw_val_class_die_ref:
5809           if (AT_ref (a) != NULL)
5810             {
5811               if (AT_ref (a)->die_symbol)
5812                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5813               else
5814                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5815             }
5816           else
5817             fprintf (outfile, "die -> <null>");
5818           break;
5819         case dw_val_class_lbl_id:
5820         case dw_val_class_lineptr:
5821         case dw_val_class_macptr:
5822           fprintf (outfile, "label: %s", AT_lbl (a));
5823           break;
5824         case dw_val_class_str:
5825           if (AT_string (a) != NULL)
5826             fprintf (outfile, "\"%s\"", AT_string (a));
5827           else
5828             fprintf (outfile, "<null>");
5829           break;
5830         case dw_val_class_file:
5831           fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5832                    AT_file (a)->emitted_number);
5833           break;
5834         default:
5835           break;
5836         }
5837
5838       fprintf (outfile, "\n");
5839     }
5840
5841   if (die->die_child != NULL)
5842     {
5843       print_indent += 4;
5844       FOR_EACH_CHILD (die, c, print_die (c, outfile));
5845       print_indent -= 4;
5846     }
5847   if (print_indent == 0)
5848     fprintf (outfile, "\n");
5849 }
5850
5851 /* Print the contents of the source code line number correspondence table.
5852    This routine is a debugging aid only.  */
5853
5854 static void
5855 print_dwarf_line_table (FILE *outfile)
5856 {
5857   unsigned i;
5858   dw_line_info_ref line_info;
5859
5860   fprintf (outfile, "\n\nDWARF source line information\n");
5861   for (i = 1; i < line_info_table_in_use; i++)
5862     {
5863       line_info = &line_info_table[i];
5864       fprintf (outfile, "%5d: %4ld %6ld\n", i,
5865                line_info->dw_file_num,
5866                line_info->dw_line_num);
5867     }
5868
5869   fprintf (outfile, "\n\n");
5870 }
5871
5872 /* Print the information collected for a given DIE.  */
5873
5874 void
5875 debug_dwarf_die (dw_die_ref die)
5876 {
5877   print_die (die, stderr);
5878 }
5879
5880 /* Print all DWARF information collected for the compilation unit.
5881    This routine is a debugging aid only.  */
5882
5883 void
5884 debug_dwarf (void)
5885 {
5886   print_indent = 0;
5887   print_die (comp_unit_die, stderr);
5888   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5889     print_dwarf_line_table (stderr);
5890 }
5891 \f
5892 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5893    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5894    DIE that marks the start of the DIEs for this include file.  */
5895
5896 static dw_die_ref
5897 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5898 {
5899   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5900   dw_die_ref new_unit = gen_compile_unit_die (filename);
5901
5902   new_unit->die_sib = old_unit;
5903   return new_unit;
5904 }
5905
5906 /* Close an include-file CU and reopen the enclosing one.  */
5907
5908 static dw_die_ref
5909 pop_compile_unit (dw_die_ref old_unit)
5910 {
5911   dw_die_ref new_unit = old_unit->die_sib;
5912
5913   old_unit->die_sib = NULL;
5914   return new_unit;
5915 }
5916
5917 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5918 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5919
5920 /* Calculate the checksum of a location expression.  */
5921
5922 static inline void
5923 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5924 {
5925   CHECKSUM (loc->dw_loc_opc);
5926   CHECKSUM (loc->dw_loc_oprnd1);
5927   CHECKSUM (loc->dw_loc_oprnd2);
5928 }
5929
5930 /* Calculate the checksum of an attribute.  */
5931
5932 static void
5933 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5934 {
5935   dw_loc_descr_ref loc;
5936   rtx r;
5937
5938   CHECKSUM (at->dw_attr);
5939
5940   /* We don't care that this was compiled with a different compiler
5941      snapshot; if the output is the same, that's what matters.  */
5942   if (at->dw_attr == DW_AT_producer)
5943     return;
5944
5945   switch (AT_class (at))
5946     {
5947     case dw_val_class_const:
5948       CHECKSUM (at->dw_attr_val.v.val_int);
5949       break;
5950     case dw_val_class_unsigned_const:
5951       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5952       break;
5953     case dw_val_class_long_long:
5954       CHECKSUM (at->dw_attr_val.v.val_long_long);
5955       break;
5956     case dw_val_class_vec:
5957       CHECKSUM (at->dw_attr_val.v.val_vec);
5958       break;
5959     case dw_val_class_flag:
5960       CHECKSUM (at->dw_attr_val.v.val_flag);
5961       break;
5962     case dw_val_class_str:
5963       CHECKSUM_STRING (AT_string (at));
5964       break;
5965
5966     case dw_val_class_addr:
5967       r = AT_addr (at);
5968       gcc_assert (GET_CODE (r) == SYMBOL_REF);
5969       CHECKSUM_STRING (XSTR (r, 0));
5970       break;
5971
5972     case dw_val_class_offset:
5973       CHECKSUM (at->dw_attr_val.v.val_offset);
5974       break;
5975
5976     case dw_val_class_loc:
5977       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5978         loc_checksum (loc, ctx);
5979       break;
5980
5981     case dw_val_class_die_ref:
5982       die_checksum (AT_ref (at), ctx, mark);
5983       break;
5984
5985     case dw_val_class_fde_ref:
5986     case dw_val_class_lbl_id:
5987     case dw_val_class_lineptr:
5988     case dw_val_class_macptr:
5989       break;
5990
5991     case dw_val_class_file:
5992       CHECKSUM_STRING (AT_file (at)->filename);
5993       break;
5994
5995     default:
5996       break;
5997     }
5998 }
5999
6000 /* Calculate the checksum of a DIE.  */
6001
6002 static void
6003 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6004 {
6005   dw_die_ref c;
6006   dw_attr_ref a;
6007   unsigned ix;
6008
6009   /* To avoid infinite recursion.  */
6010   if (die->die_mark)
6011     {
6012       CHECKSUM (die->die_mark);
6013       return;
6014     }
6015   die->die_mark = ++(*mark);
6016
6017   CHECKSUM (die->die_tag);
6018
6019   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6020     attr_checksum (a, ctx, mark);
6021
6022   FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6023 }
6024
6025 #undef CHECKSUM
6026 #undef CHECKSUM_STRING
6027
6028 /* Do the location expressions look same?  */
6029 static inline int
6030 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6031 {
6032   return loc1->dw_loc_opc == loc2->dw_loc_opc
6033          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6034          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6035 }
6036
6037 /* Do the values look the same?  */
6038 static int
6039 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6040 {
6041   dw_loc_descr_ref loc1, loc2;
6042   rtx r1, r2;
6043
6044   if (v1->val_class != v2->val_class)
6045     return 0;
6046
6047   switch (v1->val_class)
6048     {
6049     case dw_val_class_const:
6050       return v1->v.val_int == v2->v.val_int;
6051     case dw_val_class_unsigned_const:
6052       return v1->v.val_unsigned == v2->v.val_unsigned;
6053     case dw_val_class_long_long:
6054       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6055              && v1->v.val_long_long.low == v2->v.val_long_long.low;
6056     case dw_val_class_vec:
6057       if (v1->v.val_vec.length != v2->v.val_vec.length
6058           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6059         return 0;
6060       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6061                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
6062         return 0;
6063       return 1;
6064     case dw_val_class_flag:
6065       return v1->v.val_flag == v2->v.val_flag;
6066     case dw_val_class_str:
6067       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6068
6069     case dw_val_class_addr:
6070       r1 = v1->v.val_addr;
6071       r2 = v2->v.val_addr;
6072       if (GET_CODE (r1) != GET_CODE (r2))
6073         return 0;
6074       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6075       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6076
6077     case dw_val_class_offset:
6078       return v1->v.val_offset == v2->v.val_offset;
6079
6080     case dw_val_class_loc:
6081       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6082            loc1 && loc2;
6083            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6084         if (!same_loc_p (loc1, loc2, mark))
6085           return 0;
6086       return !loc1 && !loc2;
6087
6088     case dw_val_class_die_ref:
6089       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6090
6091     case dw_val_class_fde_ref:
6092     case dw_val_class_lbl_id:
6093     case dw_val_class_lineptr:
6094     case dw_val_class_macptr:
6095       return 1;
6096
6097     case dw_val_class_file:
6098       return v1->v.val_file == v2->v.val_file;
6099
6100     default:
6101       return 1;
6102     }
6103 }
6104
6105 /* Do the attributes look the same?  */
6106
6107 static int
6108 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6109 {
6110   if (at1->dw_attr != at2->dw_attr)
6111     return 0;
6112
6113   /* We don't care that this was compiled with a different compiler
6114      snapshot; if the output is the same, that's what matters. */
6115   if (at1->dw_attr == DW_AT_producer)
6116     return 1;
6117
6118   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6119 }
6120
6121 /* Do the dies look the same?  */
6122
6123 static int
6124 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6125 {
6126   dw_die_ref c1, c2;
6127   dw_attr_ref a1;
6128   unsigned ix;
6129
6130   /* To avoid infinite recursion.  */
6131   if (die1->die_mark)
6132     return die1->die_mark == die2->die_mark;
6133   die1->die_mark = die2->die_mark = ++(*mark);
6134
6135   if (die1->die_tag != die2->die_tag)
6136     return 0;
6137
6138   if (VEC_length (dw_attr_node, die1->die_attr)
6139       != VEC_length (dw_attr_node, die2->die_attr))
6140     return 0;
6141
6142   for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6143     if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6144       return 0;
6145
6146   c1 = die1->die_child;
6147   c2 = die2->die_child;
6148   if (! c1)
6149     {
6150       if (c2)
6151         return 0;
6152     }
6153   else
6154     for (;;)
6155       {
6156         if (!same_die_p (c1, c2, mark))
6157           return 0;
6158         c1 = c1->die_sib;
6159         c2 = c2->die_sib;
6160         if (c1 == die1->die_child)
6161           {
6162             if (c2 == die2->die_child)
6163               break;
6164             else
6165               return 0;
6166           }
6167     }
6168
6169   return 1;
6170 }
6171
6172 /* Do the dies look the same?  Wrapper around same_die_p.  */
6173
6174 static int
6175 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6176 {
6177   int mark = 0;
6178   int ret = same_die_p (die1, die2, &mark);
6179
6180   unmark_all_dies (die1);
6181   unmark_all_dies (die2);
6182
6183   return ret;
6184 }
6185
6186 /* The prefix to attach to symbols on DIEs in the current comdat debug
6187    info section.  */
6188 static char *comdat_symbol_id;
6189
6190 /* The index of the current symbol within the current comdat CU.  */
6191 static unsigned int comdat_symbol_number;
6192
6193 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6194    children, and set comdat_symbol_id accordingly.  */
6195
6196 static void
6197 compute_section_prefix (dw_die_ref unit_die)
6198 {
6199   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6200   const char *base = die_name ? lbasename (die_name) : "anonymous";
6201   char *name = alloca (strlen (base) + 64);
6202   char *p;
6203   int i, mark;
6204   unsigned char checksum[16];
6205   struct md5_ctx ctx;
6206
6207   /* Compute the checksum of the DIE, then append part of it as hex digits to
6208      the name filename of the unit.  */
6209
6210   md5_init_ctx (&ctx);
6211   mark = 0;
6212   die_checksum (unit_die, &ctx, &mark);
6213   unmark_all_dies (unit_die);
6214   md5_finish_ctx (&ctx, checksum);
6215
6216   sprintf (name, "%s.", base);
6217   clean_symbol_name (name);
6218
6219   p = name + strlen (name);
6220   for (i = 0; i < 4; i++)
6221     {
6222       sprintf (p, "%.2x", checksum[i]);
6223       p += 2;
6224     }
6225
6226   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6227   comdat_symbol_number = 0;
6228 }
6229
6230 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6231
6232 static int
6233 is_type_die (dw_die_ref die)
6234 {
6235   switch (die->die_tag)
6236     {
6237     case DW_TAG_array_type:
6238     case DW_TAG_class_type:
6239     case DW_TAG_enumeration_type:
6240     case DW_TAG_pointer_type:
6241     case DW_TAG_reference_type:
6242     case DW_TAG_string_type:
6243     case DW_TAG_structure_type:
6244     case DW_TAG_subroutine_type:
6245     case DW_TAG_union_type:
6246     case DW_TAG_ptr_to_member_type:
6247     case DW_TAG_set_type:
6248     case DW_TAG_subrange_type:
6249     case DW_TAG_base_type:
6250     case DW_TAG_const_type:
6251     case DW_TAG_file_type:
6252     case DW_TAG_packed_type:
6253     case DW_TAG_volatile_type:
6254     case DW_TAG_typedef:
6255       return 1;
6256     default:
6257       return 0;
6258     }
6259 }
6260
6261 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6262    Basically, we want to choose the bits that are likely to be shared between
6263    compilations (types) and leave out the bits that are specific to individual
6264    compilations (functions).  */
6265
6266 static int
6267 is_comdat_die (dw_die_ref c)
6268 {
6269   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6270      we do for stabs.  The advantage is a greater likelihood of sharing between
6271      objects that don't include headers in the same order (and therefore would
6272      put the base types in a different comdat).  jason 8/28/00 */
6273
6274   if (c->die_tag == DW_TAG_base_type)
6275     return 0;
6276
6277   if (c->die_tag == DW_TAG_pointer_type
6278       || c->die_tag == DW_TAG_reference_type
6279       || c->die_tag == DW_TAG_const_type
6280       || c->die_tag == DW_TAG_volatile_type)
6281     {
6282       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6283
6284       return t ? is_comdat_die (t) : 0;
6285     }
6286
6287   return is_type_die (c);
6288 }
6289
6290 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6291    compilation unit.  */
6292
6293 static int
6294 is_symbol_die (dw_die_ref c)
6295 {
6296   return (is_type_die (c)
6297           || (get_AT (c, DW_AT_declaration)
6298               && !get_AT (c, DW_AT_specification))
6299           || c->die_tag == DW_TAG_namespace);
6300 }
6301
6302 static char *
6303 gen_internal_sym (const char *prefix)
6304 {
6305   char buf[256];
6306
6307   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6308   return xstrdup (buf);
6309 }
6310
6311 /* Assign symbols to all worthy DIEs under DIE.  */
6312
6313 static void
6314 assign_symbol_names (dw_die_ref die)
6315 {
6316   dw_die_ref c;
6317
6318   if (is_symbol_die (die))
6319     {
6320       if (comdat_symbol_id)
6321         {
6322           char *p = alloca (strlen (comdat_symbol_id) + 64);
6323
6324           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6325                    comdat_symbol_id, comdat_symbol_number++);
6326           die->die_symbol = xstrdup (p);
6327         }
6328       else
6329         die->die_symbol = gen_internal_sym ("LDIE");
6330     }
6331
6332   FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6333 }
6334
6335 struct cu_hash_table_entry
6336 {
6337   dw_die_ref cu;
6338   unsigned min_comdat_num, max_comdat_num;
6339   struct cu_hash_table_entry *next;
6340 };
6341
6342 /* Routines to manipulate hash table of CUs.  */
6343 static hashval_t
6344 htab_cu_hash (const void *of)
6345 {
6346   const struct cu_hash_table_entry *entry = of;
6347
6348   return htab_hash_string (entry->cu->die_symbol);
6349 }
6350
6351 static int
6352 htab_cu_eq (const void *of1, const void *of2)
6353 {
6354   const struct cu_hash_table_entry *entry1 = of1;
6355   const struct die_struct *entry2 = of2;
6356
6357   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6358 }
6359
6360 static void
6361 htab_cu_del (void *what)
6362 {
6363   struct cu_hash_table_entry *next, *entry = what;
6364
6365   while (entry)
6366     {
6367       next = entry->next;
6368       free (entry);
6369       entry = next;
6370     }
6371 }
6372
6373 /* Check whether we have already seen this CU and set up SYM_NUM
6374    accordingly.  */
6375 static int
6376 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6377 {
6378   struct cu_hash_table_entry dummy;
6379   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6380
6381   dummy.max_comdat_num = 0;
6382
6383   slot = (struct cu_hash_table_entry **)
6384     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6385         INSERT);
6386   entry = *slot;
6387
6388   for (; entry; last = entry, entry = entry->next)
6389     {
6390       if (same_die_p_wrap (cu, entry->cu))
6391         break;
6392     }
6393
6394   if (entry)
6395     {
6396       *sym_num = entry->min_comdat_num;
6397       return 1;
6398     }
6399
6400   entry = XCNEW (struct cu_hash_table_entry);
6401   entry->cu = cu;
6402   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6403   entry->next = *slot;
6404   *slot = entry;
6405
6406   return 0;
6407 }
6408
6409 /* Record SYM_NUM to record of CU in HTABLE.  */
6410 static void
6411 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6412 {
6413   struct cu_hash_table_entry **slot, *entry;
6414
6415   slot = (struct cu_hash_table_entry **)
6416     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6417         NO_INSERT);
6418   entry = *slot;
6419
6420   entry->max_comdat_num = sym_num;
6421 }
6422
6423 /* Traverse the DIE (which is always comp_unit_die), and set up
6424    additional compilation units for each of the include files we see
6425    bracketed by BINCL/EINCL.  */
6426
6427 static void
6428 break_out_includes (dw_die_ref die)
6429 {
6430   dw_die_ref c;
6431   dw_die_ref unit = NULL;
6432   limbo_die_node *node, **pnode;
6433   htab_t cu_hash_table;
6434
6435   c = die->die_child;
6436   if (c) do {
6437     dw_die_ref prev = c;
6438     c = c->die_sib;
6439     while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6440            || (unit && is_comdat_die (c)))
6441       {
6442         dw_die_ref next = c->die_sib;
6443
6444         /* This DIE is for a secondary CU; remove it from the main one.  */
6445         remove_child_with_prev (c, prev);
6446
6447         if (c->die_tag == DW_TAG_GNU_BINCL)
6448           unit = push_new_compile_unit (unit, c);
6449         else if (c->die_tag == DW_TAG_GNU_EINCL)
6450           unit = pop_compile_unit (unit);
6451         else
6452           add_child_die (unit, c);
6453         c = next;
6454         if (c == die->die_child)
6455           break;
6456       }
6457   } while (c != die->die_child);
6458
6459 #if 0
6460   /* We can only use this in debugging, since the frontend doesn't check
6461      to make sure that we leave every include file we enter.  */
6462   gcc_assert (!unit);
6463 #endif
6464
6465   assign_symbol_names (die);
6466   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6467   for (node = limbo_die_list, pnode = &limbo_die_list;
6468        node;
6469        node = node->next)
6470     {
6471       int is_dupl;
6472
6473       compute_section_prefix (node->die);
6474       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6475                         &comdat_symbol_number);
6476       assign_symbol_names (node->die);
6477       if (is_dupl)
6478         *pnode = node->next;
6479       else
6480         {
6481           pnode = &node->next;
6482           record_comdat_symbol_number (node->die, cu_hash_table,
6483                 comdat_symbol_number);
6484         }
6485     }
6486   htab_delete (cu_hash_table);
6487 }
6488
6489 /* Traverse the DIE and add a sibling attribute if it may have the
6490    effect of speeding up access to siblings.  To save some space,
6491    avoid generating sibling attributes for DIE's without children.  */
6492
6493 static void
6494 add_sibling_attributes (dw_die_ref die)
6495 {
6496   dw_die_ref c;
6497
6498   if (! die->die_child)
6499     return;
6500
6501   if (die->die_parent && die != die->die_parent->die_child)
6502     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6503
6504   FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6505 }
6506
6507 /* Output all location lists for the DIE and its children.  */
6508
6509 static void
6510 output_location_lists (dw_die_ref die)
6511 {
6512   dw_die_ref c;
6513   dw_attr_ref a;
6514   unsigned ix;
6515
6516   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6517     if (AT_class (a) == dw_val_class_loc_list)
6518       output_loc_list (AT_loc_list (a));
6519
6520   FOR_EACH_CHILD (die, c, output_location_lists (c));
6521 }
6522
6523 /* The format of each DIE (and its attribute value pairs) is encoded in an
6524    abbreviation table.  This routine builds the abbreviation table and assigns
6525    a unique abbreviation id for each abbreviation entry.  The children of each
6526    die are visited recursively.  */
6527
6528 static void
6529 build_abbrev_table (dw_die_ref die)
6530 {
6531   unsigned long abbrev_id;
6532   unsigned int n_alloc;
6533   dw_die_ref c;
6534   dw_attr_ref a;
6535   unsigned ix;
6536
6537   /* Scan the DIE references, and mark as external any that refer to
6538      DIEs from other CUs (i.e. those which are not marked).  */
6539   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6540     if (AT_class (a) == dw_val_class_die_ref
6541         && AT_ref (a)->die_mark == 0)
6542       {
6543         gcc_assert (AT_ref (a)->die_symbol);
6544
6545         set_AT_ref_external (a, 1);
6546       }
6547
6548   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6549     {
6550       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6551       dw_attr_ref die_a, abbrev_a;
6552       unsigned ix;
6553       bool ok = true;
6554
6555       if (abbrev->die_tag != die->die_tag)
6556         continue;
6557       if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6558         continue;
6559
6560       if (VEC_length (dw_attr_node, abbrev->die_attr)
6561           != VEC_length (dw_attr_node, die->die_attr))
6562         continue;
6563
6564       for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6565         {
6566           abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6567           if ((abbrev_a->dw_attr != die_a->dw_attr)
6568               || (value_format (abbrev_a) != value_format (die_a)))
6569             {
6570               ok = false;
6571               break;
6572             }
6573         }
6574       if (ok)
6575         break;
6576     }
6577
6578   if (abbrev_id >= abbrev_die_table_in_use)
6579     {
6580       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6581         {
6582           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6583           abbrev_die_table = ggc_realloc (abbrev_die_table,
6584                                           sizeof (dw_die_ref) * n_alloc);
6585
6586           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6587                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6588           abbrev_die_table_allocated = n_alloc;
6589         }
6590
6591       ++abbrev_die_table_in_use;
6592       abbrev_die_table[abbrev_id] = die;
6593     }
6594
6595   die->die_abbrev = abbrev_id;
6596   FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6597 }
6598 \f
6599 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6600
6601 static int
6602 constant_size (long unsigned int value)
6603 {
6604   int log;
6605
6606   if (value == 0)
6607     log = 0;
6608   else
6609     log = floor_log2 (value);
6610
6611   log = log / 8;
6612   log = 1 << (floor_log2 (log) + 1);
6613
6614   return log;
6615 }
6616
6617 /* Return the size of a DIE as it is represented in the
6618    .debug_info section.  */
6619
6620 static unsigned long
6621 size_of_die (dw_die_ref die)
6622 {
6623   unsigned long size = 0;
6624   dw_attr_ref a;
6625   unsigned ix;
6626
6627   size += size_of_uleb128 (die->die_abbrev);
6628   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6629     {
6630       switch (AT_class (a))
6631         {
6632         case dw_val_class_addr:
6633           size += DWARF2_ADDR_SIZE;
6634           break;
6635         case dw_val_class_offset:
6636           size += DWARF_OFFSET_SIZE;
6637           break;
6638         case dw_val_class_loc:
6639           {
6640             unsigned long lsize = size_of_locs (AT_loc (a));
6641
6642             /* Block length.  */
6643             size += constant_size (lsize);
6644             size += lsize;
6645           }
6646           break;
6647         case dw_val_class_loc_list:
6648           size += DWARF_OFFSET_SIZE;
6649           break;
6650         case dw_val_class_range_list:
6651           size += DWARF_OFFSET_SIZE;
6652           break;
6653         case dw_val_class_const:
6654           size += size_of_sleb128 (AT_int (a));
6655           break;
6656         case dw_val_class_unsigned_const:
6657           size += constant_size (AT_unsigned (a));
6658           break;
6659         case dw_val_class_long_long:
6660           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6661           break;
6662         case dw_val_class_vec:
6663           size += 1 + (a->dw_attr_val.v.val_vec.length
6664                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6665           break;
6666         case dw_val_class_flag:
6667           size += 1;
6668           break;
6669         case dw_val_class_die_ref:
6670           if (AT_ref_external (a))
6671             size += DWARF2_ADDR_SIZE;
6672           else
6673             size += DWARF_OFFSET_SIZE;
6674           break;
6675         case dw_val_class_fde_ref:
6676           size += DWARF_OFFSET_SIZE;
6677           break;
6678         case dw_val_class_lbl_id:
6679           size += DWARF2_ADDR_SIZE;
6680           break;
6681         case dw_val_class_lineptr:
6682         case dw_val_class_macptr:
6683           size += DWARF_OFFSET_SIZE;
6684           break;
6685         case dw_val_class_str:
6686           if (AT_string_form (a) == DW_FORM_strp)
6687             size += DWARF_OFFSET_SIZE;
6688           else
6689             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6690           break;
6691         case dw_val_class_file:
6692           size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6693           break;
6694         default:
6695           gcc_unreachable ();
6696         }
6697     }
6698
6699   return size;
6700 }
6701
6702 /* Size the debugging information associated with a given DIE.  Visits the
6703    DIE's children recursively.  Updates the global variable next_die_offset, on
6704    each time through.  Uses the current value of next_die_offset to update the
6705    die_offset field in each DIE.  */
6706
6707 static void
6708 calc_die_sizes (dw_die_ref die)
6709 {
6710   dw_die_ref c;
6711
6712   die->die_offset = next_die_offset;
6713   next_die_offset += size_of_die (die);
6714
6715   FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6716
6717   if (die->die_child != NULL)
6718     /* Count the null byte used to terminate sibling lists.  */
6719     next_die_offset += 1;
6720 }
6721
6722 /* Set the marks for a die and its children.  We do this so
6723    that we know whether or not a reference needs to use FORM_ref_addr; only
6724    DIEs in the same CU will be marked.  We used to clear out the offset
6725    and use that as the flag, but ran into ordering problems.  */
6726
6727 static void
6728 mark_dies (dw_die_ref die)
6729 {
6730   dw_die_ref c;
6731
6732   gcc_assert (!die->die_mark);
6733
6734   die->die_mark = 1;
6735   FOR_EACH_CHILD (die, c, mark_dies (c));
6736 }
6737
6738 /* Clear the marks for a die and its children.  */
6739
6740 static void
6741 unmark_dies (dw_die_ref die)
6742 {
6743   dw_die_ref c;
6744
6745   gcc_assert (die->die_mark);
6746
6747   die->die_mark = 0;
6748   FOR_EACH_CHILD (die, c, unmark_dies (c));
6749 }
6750
6751 /* Clear the marks for a die, its children and referred dies.  */
6752
6753 static void
6754 unmark_all_dies (dw_die_ref die)
6755 {
6756   dw_die_ref c;
6757   dw_attr_ref a;
6758   unsigned ix;
6759
6760   if (!die->die_mark)
6761     return;
6762   die->die_mark = 0;
6763
6764   FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6765
6766   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6767     if (AT_class (a) == dw_val_class_die_ref)
6768       unmark_all_dies (AT_ref (a));
6769 }
6770
6771 /* Return the size of the .debug_pubnames or .debug_pubtypes table
6772    generated for the compilation unit.  */
6773
6774 static unsigned long
6775 size_of_pubnames (VEC (pubname_entry, gc) * names)
6776 {
6777   unsigned long size;
6778   unsigned i;
6779   pubname_ref p;
6780
6781   size = DWARF_PUBNAMES_HEADER_SIZE;
6782   for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
6783     if (names != pubtype_table
6784         || p->die->die_offset != 0
6785         || !flag_eliminate_unused_debug_types)
6786       size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
6787
6788   size += DWARF_OFFSET_SIZE;
6789   return size;
6790 }
6791
6792 /* Return the size of the information in the .debug_aranges section.  */
6793
6794 static unsigned long
6795 size_of_aranges (void)
6796 {
6797   unsigned long size;
6798
6799   size = DWARF_ARANGES_HEADER_SIZE;
6800
6801   /* Count the address/length pair for this compilation unit.  */
6802   size += 2 * DWARF2_ADDR_SIZE;
6803   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6804
6805   /* Count the two zero words used to terminated the address range table.  */
6806   size += 2 * DWARF2_ADDR_SIZE;
6807   return size;
6808 }
6809 \f
6810 /* Select the encoding of an attribute value.  */
6811
6812 static enum dwarf_form
6813 value_format (dw_attr_ref a)
6814 {
6815   switch (a->dw_attr_val.val_class)
6816     {
6817     case dw_val_class_addr:
6818       return DW_FORM_addr;
6819     case dw_val_class_range_list:
6820     case dw_val_class_offset:
6821     case dw_val_class_loc_list:
6822       switch (DWARF_OFFSET_SIZE)
6823         {
6824         case 4:
6825           return DW_FORM_data4;
6826         case 8:
6827           return DW_FORM_data8;
6828         default:
6829           gcc_unreachable ();
6830         }
6831     case dw_val_class_loc:
6832       switch (constant_size (size_of_locs (AT_loc (a))))
6833         {
6834         case 1:
6835           return DW_FORM_block1;
6836         case 2:
6837           return DW_FORM_block2;
6838         default:
6839           gcc_unreachable ();
6840         }
6841     case dw_val_class_const:
6842       return DW_FORM_sdata;
6843     case dw_val_class_unsigned_const:
6844       switch (constant_size (AT_unsigned (a)))
6845         {
6846         case 1:
6847           return DW_FORM_data1;
6848         case 2:
6849           return DW_FORM_data2;
6850         case 4:
6851           return DW_FORM_data4;
6852         case 8:
6853           return DW_FORM_data8;
6854         default:
6855           gcc_unreachable ();
6856         }
6857     case dw_val_class_long_long:
6858       return DW_FORM_block1;
6859     case dw_val_class_vec:
6860       return DW_FORM_block1;
6861     case dw_val_class_flag:
6862       return DW_FORM_flag;
6863     case dw_val_class_die_ref:
6864       if (AT_ref_external (a))
6865         return DW_FORM_ref_addr;
6866       else
6867         return DW_FORM_ref;
6868     case dw_val_class_fde_ref:
6869       return DW_FORM_data;
6870     case dw_val_class_lbl_id:
6871       return DW_FORM_addr;
6872     case dw_val_class_lineptr:
6873     case dw_val_class_macptr:
6874       return DW_FORM_data;
6875     case dw_val_class_str:
6876       return AT_string_form (a);
6877     case dw_val_class_file:
6878       switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6879         {
6880         case 1:
6881           return DW_FORM_data1;
6882         case 2:
6883           return DW_FORM_data2;
6884         case 4:
6885           return DW_FORM_data4;
6886         default:
6887           gcc_unreachable ();
6888         }
6889
6890     default:
6891       gcc_unreachable ();
6892     }
6893 }
6894
6895 /* Output the encoding of an attribute value.  */
6896
6897 static void
6898 output_value_format (dw_attr_ref a)
6899 {
6900   enum dwarf_form form = value_format (a);
6901
6902   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6903 }
6904
6905 /* Output the .debug_abbrev section which defines the DIE abbreviation
6906    table.  */
6907
6908 static void
6909 output_abbrev_section (void)
6910 {
6911   unsigned long abbrev_id;
6912
6913   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6914     {
6915       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6916       unsigned ix;
6917       dw_attr_ref a_attr;
6918
6919       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6920       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6921                                    dwarf_tag_name (abbrev->die_tag));
6922
6923       if (abbrev->die_child != NULL)
6924         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6925       else
6926         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6927
6928       for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6929            ix++)
6930         {
6931           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6932                                        dwarf_attr_name (a_attr->dw_attr));
6933           output_value_format (a_attr);
6934         }
6935
6936       dw2_asm_output_data (1, 0, NULL);
6937       dw2_asm_output_data (1, 0, NULL);
6938     }
6939
6940   /* Terminate the table.  */
6941   dw2_asm_output_data (1, 0, NULL);
6942 }
6943
6944 /* Output a symbol we can use to refer to this DIE from another CU.  */
6945
6946 static inline void
6947 output_die_symbol (dw_die_ref die)
6948 {
6949   char *sym = die->die_symbol;
6950
6951   if (sym == 0)
6952     return;
6953
6954   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6955     /* We make these global, not weak; if the target doesn't support
6956        .linkonce, it doesn't support combining the sections, so debugging
6957        will break.  */
6958     targetm.asm_out.globalize_label (asm_out_file, sym);
6959
6960   ASM_OUTPUT_LABEL (asm_out_file, sym);
6961 }
6962
6963 /* Return a new location list, given the begin and end range, and the
6964    expression. gensym tells us whether to generate a new internal symbol for
6965    this location list node, which is done for the head of the list only.  */
6966
6967 static inline dw_loc_list_ref
6968 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6969               const char *section, unsigned int gensym)
6970 {
6971   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6972
6973   retlist->begin = begin;
6974   retlist->end = end;
6975   retlist->expr = expr;
6976   retlist->section = section;
6977   if (gensym)
6978     retlist->ll_symbol = gen_internal_sym ("LLST");
6979
6980   return retlist;
6981 }
6982
6983 /* Add a location description expression to a location list.  */
6984
6985 static inline void
6986 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6987                            const char *begin, const char *end,
6988                            const char *section)
6989 {
6990   dw_loc_list_ref *d;
6991
6992   /* Find the end of the chain.  */
6993   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6994     ;
6995
6996   /* Add a new location list node to the list.  */
6997   *d = new_loc_list (descr, begin, end, section, 0);
6998 }
6999
7000 static void
7001 dwarf2out_switch_text_section (void)
7002 {
7003   dw_fde_ref fde;
7004
7005   gcc_assert (cfun);
7006
7007   fde = &fde_table[fde_table_in_use - 1];
7008   fde->dw_fde_switched_sections = true;
7009   fde->dw_fde_hot_section_label = cfun->hot_section_label;
7010   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
7011   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
7012   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
7013   have_multiple_function_sections = true;
7014
7015   /* Reset the current label on switching text sections, so that we
7016      don't attempt to advance_loc4 between labels in different sections.  */
7017   fde->dw_fde_current_label = NULL;
7018 }
7019
7020 /* Output the location list given to us.  */
7021
7022 static void
7023 output_loc_list (dw_loc_list_ref list_head)
7024 {
7025   dw_loc_list_ref curr = list_head;
7026
7027   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7028
7029   /* Walk the location list, and output each range + expression.  */
7030   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7031     {
7032       unsigned long size;
7033       if (!have_multiple_function_sections)
7034         {
7035           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7036                                 "Location list begin address (%s)",
7037                                 list_head->ll_symbol);
7038           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7039                                 "Location list end address (%s)",
7040                                 list_head->ll_symbol);
7041         }
7042       else
7043         {
7044           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7045                                "Location list begin address (%s)",
7046                                list_head->ll_symbol);
7047           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7048                                "Location list end address (%s)",
7049                                list_head->ll_symbol);
7050         }
7051       size = size_of_locs (curr->expr);
7052
7053       /* Output the block length for this list of location operations.  */
7054       gcc_assert (size <= 0xffff);
7055       dw2_asm_output_data (2, size, "%s", "Location expression size");
7056
7057       output_loc_sequence (curr->expr);
7058     }
7059
7060   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7061                        "Location list terminator begin (%s)",
7062                        list_head->ll_symbol);
7063   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7064                        "Location list terminator end (%s)",
7065                        list_head->ll_symbol);
7066 }
7067
7068 /* Output the DIE and its attributes.  Called recursively to generate
7069    the definitions of each child DIE.  */
7070
7071 static void
7072 output_die (dw_die_ref die)
7073 {
7074   dw_attr_ref a;
7075   dw_die_ref c;
7076   unsigned long size;
7077   unsigned ix;
7078
7079   /* If someone in another CU might refer to us, set up a symbol for
7080      them to point to.  */
7081   if (die->die_symbol)
7082     output_die_symbol (die);
7083
7084   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7085                                die->die_offset, dwarf_tag_name (die->die_tag));
7086
7087   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7088     {
7089       const char *name = dwarf_attr_name (a->dw_attr);
7090
7091       switch (AT_class (a))
7092         {
7093         case dw_val_class_addr:
7094           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7095           break;
7096
7097         case dw_val_class_offset:
7098           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7099                                "%s", name);
7100           break;
7101
7102         case dw_val_class_range_list:
7103           {
7104             char *p = strchr (ranges_section_label, '\0');
7105
7106             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7107                      a->dw_attr_val.v.val_offset);
7108             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7109                                    debug_ranges_section, "%s", name);
7110             *p = '\0';
7111           }
7112           break;
7113
7114         case dw_val_class_loc:
7115           size = size_of_locs (AT_loc (a));
7116
7117           /* Output the block length for this list of location operations.  */
7118           dw2_asm_output_data (constant_size (size), size, "%s", name);
7119
7120           output_loc_sequence (AT_loc (a));
7121           break;
7122
7123         case dw_val_class_const:
7124           /* ??? It would be slightly more efficient to use a scheme like is
7125              used for unsigned constants below, but gdb 4.x does not sign
7126              extend.  Gdb 5.x does sign extend.  */
7127           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7128           break;
7129
7130         case dw_val_class_unsigned_const:
7131           dw2_asm_output_data (constant_size (AT_unsigned (a)),
7132                                AT_unsigned (a), "%s", name);
7133           break;
7134
7135         case dw_val_class_long_long:
7136           {
7137             unsigned HOST_WIDE_INT first, second;
7138
7139             dw2_asm_output_data (1,
7140                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7141                                  "%s", name);
7142
7143             if (WORDS_BIG_ENDIAN)
7144               {
7145                 first = a->dw_attr_val.v.val_long_long.hi;
7146                 second = a->dw_attr_val.v.val_long_long.low;
7147               }
7148             else
7149               {
7150                 first = a->dw_attr_val.v.val_long_long.low;
7151                 second = a->dw_attr_val.v.val_long_long.hi;
7152               }
7153
7154             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7155                                  first, "long long constant");
7156             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7157                                  second, NULL);
7158           }
7159           break;
7160
7161         case dw_val_class_vec:
7162           {
7163             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7164             unsigned int len = a->dw_attr_val.v.val_vec.length;
7165             unsigned int i;
7166             unsigned char *p;
7167
7168             dw2_asm_output_data (1, len * elt_size, "%s", name);
7169             if (elt_size > sizeof (HOST_WIDE_INT))
7170               {
7171                 elt_size /= 2;
7172                 len *= 2;
7173               }
7174             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7175                  i < len;
7176                  i++, p += elt_size)
7177               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7178                                    "fp or vector constant word %u", i);
7179             break;
7180           }
7181
7182         case dw_val_class_flag:
7183           dw2_asm_output_data (1, AT_flag (a), "%s", name);
7184           break;
7185
7186         case dw_val_class_loc_list:
7187           {
7188             char *sym = AT_loc_list (a)->ll_symbol;
7189
7190             gcc_assert (sym);
7191             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7192                                    "%s", name);
7193           }
7194           break;
7195
7196         case dw_val_class_die_ref:
7197           if (AT_ref_external (a))
7198             {
7199               char *sym = AT_ref (a)->die_symbol;
7200
7201               gcc_assert (sym);
7202               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7203                                      "%s", name);
7204             }
7205           else
7206             {
7207               gcc_assert (AT_ref (a)->die_offset);
7208               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7209                                    "%s", name);
7210             }
7211           break;
7212
7213         case dw_val_class_fde_ref:
7214           {
7215             char l1[20];
7216
7217             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7218                                          a->dw_attr_val.v.val_fde_index * 2);
7219             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7220                                    "%s", name);
7221           }
7222           break;
7223
7224         case dw_val_class_lbl_id:
7225           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7226           break;
7227
7228         case dw_val_class_lineptr:
7229           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7230                                  debug_line_section, "%s", name);
7231           break;
7232
7233         case dw_val_class_macptr:
7234           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7235                                  debug_macinfo_section, "%s", name);
7236           break;
7237
7238         case dw_val_class_str:
7239           if (AT_string_form (a) == DW_FORM_strp)
7240             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7241                                    a->dw_attr_val.v.val_str->label,
7242                                    debug_str_section,
7243                                    "%s: \"%s\"", name, AT_string (a));
7244           else
7245             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7246           break;
7247
7248         case dw_val_class_file:
7249           {
7250             int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7251
7252             dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7253                                  a->dw_attr_val.v.val_file->filename);
7254             break;
7255           }
7256
7257         default:
7258           gcc_unreachable ();
7259         }
7260     }
7261
7262   FOR_EACH_CHILD (die, c, output_die (c));
7263
7264   /* Add null byte to terminate sibling list.  */
7265   if (die->die_child != NULL)
7266     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7267                          die->die_offset);
7268 }
7269
7270 /* Output the compilation unit that appears at the beginning of the
7271    .debug_info section, and precedes the DIE descriptions.  */
7272
7273 static void
7274 output_compilation_unit_header (void)
7275 {
7276   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7277     dw2_asm_output_data (4, 0xffffffff,
7278       "Initial length escape value indicating 64-bit DWARF extension");
7279   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7280                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7281                        "Length of Compilation Unit Info");
7282   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7283   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7284                          debug_abbrev_section,
7285                          "Offset Into Abbrev. Section");
7286   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7287 }
7288
7289 /* Output the compilation unit DIE and its children.  */
7290
7291 static void
7292 output_comp_unit (dw_die_ref die, int output_if_empty)
7293 {
7294   const char *secname;
7295   char *oldsym, *tmp;
7296
7297   /* Unless we are outputting main CU, we may throw away empty ones.  */
7298   if (!output_if_empty && die->die_child == NULL)
7299     return;
7300
7301   /* Even if there are no children of this DIE, we must output the information
7302      about the compilation unit.  Otherwise, on an empty translation unit, we
7303      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7304      will then complain when examining the file.  First mark all the DIEs in
7305      this CU so we know which get local refs.  */
7306   mark_dies (die);
7307
7308   build_abbrev_table (die);
7309
7310   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7311   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7312   calc_die_sizes (die);
7313
7314   oldsym = die->die_symbol;
7315   if (oldsym)
7316     {
7317       tmp = alloca (strlen (oldsym) + 24);
7318
7319       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7320       secname = tmp;
7321       die->die_symbol = NULL;
7322       switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7323     }
7324   else
7325     switch_to_section (debug_info_section);
7326
7327   /* Output debugging information.  */
7328   output_compilation_unit_header ();
7329   output_die (die);
7330
7331   /* Leave the marks on the main CU, so we can check them in
7332      output_pubnames.  */
7333   if (oldsym)
7334     {
7335       unmark_dies (die);
7336       die->die_symbol = oldsym;
7337     }
7338 }
7339
7340 /* Return the DWARF2/3 pubname associated with a decl.  */
7341
7342 static const char *
7343 dwarf2_name (tree decl, int scope)
7344 {
7345   return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7346 }
7347
7348 /* Add a new entry to .debug_pubnames if appropriate.  */
7349
7350 static void
7351 add_pubname (tree decl, dw_die_ref die)
7352 {
7353   pubname_entry e;
7354
7355   if (! TREE_PUBLIC (decl))
7356     return;
7357
7358   e.die = die;
7359   e.name = xstrdup (dwarf2_name (decl, 1));
7360   VEC_safe_push (pubname_entry, gc, pubname_table, &e);
7361 }
7362
7363 /* Add a new entry to .debug_pubtypes if appropriate.  */
7364
7365 static void
7366 add_pubtype (tree decl, dw_die_ref die)
7367 {
7368   pubname_entry e;
7369
7370   e.name = NULL;
7371   if ((TREE_PUBLIC (decl)
7372        || die->die_parent == comp_unit_die)
7373       && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
7374     {
7375       e.die = die;
7376       if (TYPE_P (decl))
7377         {
7378           if (TYPE_NAME (decl))
7379             {
7380               if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
7381                 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
7382               else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
7383                        && DECL_NAME (TYPE_NAME (decl)))
7384                 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
7385              else
7386                e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
7387             }
7388         }
7389       else
7390         e.name = xstrdup (dwarf2_name (decl, 1));
7391
7392       /* If we don't have a name for the type, there's no point in adding
7393          it to the table.  */
7394       if (e.name && e.name[0] != '\0')
7395         VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
7396     }
7397 }
7398
7399 /* Output the public names table used to speed up access to externally
7400    visible names; or the public types table used to find type definitions.  */
7401
7402 static void
7403 output_pubnames (VEC (pubname_entry, gc) * names)
7404 {
7405   unsigned i;
7406   unsigned long pubnames_length = size_of_pubnames (names);
7407   pubname_ref pub;
7408
7409   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7410     dw2_asm_output_data (4, 0xffffffff,
7411       "Initial length escape value indicating 64-bit DWARF extension");
7412   if (names == pubname_table)
7413     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7414                          "Length of Public Names Info");
7415   else
7416     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7417                          "Length of Public Type Names Info");
7418   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7419   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7420                          debug_info_section,
7421                          "Offset of Compilation Unit Info");
7422   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7423                        "Compilation Unit Length");
7424
7425   for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
7426     {
7427       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7428       if (names == pubname_table)
7429         gcc_assert (pub->die->die_mark);
7430
7431       if (names != pubtype_table
7432           || pub->die->die_offset != 0
7433           || !flag_eliminate_unused_debug_types)
7434         {
7435           dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7436                                "DIE offset");
7437
7438           dw2_asm_output_nstring (pub->name, -1, "external name");
7439         }
7440     }
7441
7442   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7443 }
7444
7445 /* Add a new entry to .debug_aranges if appropriate.  */
7446
7447 static void
7448 add_arange (tree decl, dw_die_ref die)
7449 {
7450   if (! DECL_SECTION_NAME (decl))
7451     return;
7452
7453   if (arange_table_in_use == arange_table_allocated)
7454     {
7455       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7456       arange_table = ggc_realloc (arange_table,
7457                                   (arange_table_allocated
7458                                    * sizeof (dw_die_ref)));
7459       memset (arange_table + arange_table_in_use, 0,
7460               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7461     }
7462
7463   arange_table[arange_table_in_use++] = die;
7464 }
7465
7466 /* Output the information that goes into the .debug_aranges table.
7467    Namely, define the beginning and ending address range of the
7468    text section generated for this compilation unit.  */
7469
7470 static void
7471 output_aranges (void)
7472 {
7473   unsigned i;
7474   unsigned long aranges_length = size_of_aranges ();
7475
7476   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7477     dw2_asm_output_data (4, 0xffffffff,
7478       "Initial length escape value indicating 64-bit DWARF extension");
7479   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7480                        "Length of Address Ranges Info");
7481   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7482   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7483                          debug_info_section,
7484                          "Offset of Compilation Unit Info");
7485   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7486   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7487
7488   /* We need to align to twice the pointer size here.  */
7489   if (DWARF_ARANGES_PAD_SIZE)
7490     {
7491       /* Pad using a 2 byte words so that padding is correct for any
7492          pointer size.  */
7493       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7494                            2 * DWARF2_ADDR_SIZE);
7495       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7496         dw2_asm_output_data (2, 0, NULL);
7497     }
7498
7499   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7500   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7501                         text_section_label, "Length");
7502   if (flag_reorder_blocks_and_partition)
7503     {
7504       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7505                            "Address");
7506       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7507                             cold_text_section_label, "Length");
7508     }
7509
7510   for (i = 0; i < arange_table_in_use; i++)
7511     {
7512       dw_die_ref die = arange_table[i];
7513
7514       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7515       gcc_assert (die->die_mark);
7516
7517       if (die->die_tag == DW_TAG_subprogram)
7518         {
7519           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7520                                "Address");
7521           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7522                                 get_AT_low_pc (die), "Length");
7523         }
7524       else
7525         {
7526           /* A static variable; extract the symbol from DW_AT_location.
7527              Note that this code isn't currently hit, as we only emit
7528              aranges for functions (jason 9/23/99).  */
7529           dw_attr_ref a = get_AT (die, DW_AT_location);
7530           dw_loc_descr_ref loc;
7531
7532           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7533
7534           loc = AT_loc (a);
7535           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7536
7537           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7538                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7539           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7540                                get_AT_unsigned (die, DW_AT_byte_size),
7541                                "Length");
7542         }
7543     }
7544
7545   /* Output the terminator words.  */
7546   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7547   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7548 }
7549
7550 /* Add a new entry to .debug_ranges.  Return the offset at which it
7551    was placed.  */
7552
7553 static unsigned int
7554 add_ranges (tree block)
7555 {
7556   unsigned int in_use = ranges_table_in_use;
7557
7558   if (in_use == ranges_table_allocated)
7559     {
7560       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7561       ranges_table
7562         = ggc_realloc (ranges_table, (ranges_table_allocated
7563                                       * sizeof (struct dw_ranges_struct)));
7564       memset (ranges_table + ranges_table_in_use, 0,
7565               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7566     }
7567
7568   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7569   ranges_table_in_use = in_use + 1;
7570
7571   return in_use * 2 * DWARF2_ADDR_SIZE;
7572 }
7573
7574 static void
7575 output_ranges (void)
7576 {
7577   unsigned i;
7578   static const char *const start_fmt = "Offset 0x%x";
7579   const char *fmt = start_fmt;
7580
7581   for (i = 0; i < ranges_table_in_use; i++)
7582     {
7583       int block_num = ranges_table[i].block_num;
7584
7585       if (block_num)
7586         {
7587           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7588           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7589
7590           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7591           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7592
7593           /* If all code is in the text section, then the compilation
7594              unit base address defaults to DW_AT_low_pc, which is the
7595              base of the text section.  */
7596           if (!have_multiple_function_sections)
7597             {
7598               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7599                                     text_section_label,
7600                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7601               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7602                                     text_section_label, NULL);
7603             }
7604
7605           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7606              compilation unit base address to zero, which allows us to
7607              use absolute addresses, and not worry about whether the
7608              target supports cross-section arithmetic.  */
7609           else
7610             {
7611               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7612                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7613               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7614             }
7615
7616           fmt = NULL;
7617         }
7618       else
7619         {
7620           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7621           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7622           fmt = start_fmt;
7623         }
7624     }
7625 }
7626
7627 /* Data structure containing information about input files.  */
7628 struct file_info
7629 {
7630   const char *path;     /* Complete file name.  */
7631   const char *fname;    /* File name part.  */
7632   int length;           /* Length of entire string.  */
7633   struct dwarf_file_data * file_idx;    /* Index in input file table.  */
7634   int dir_idx;          /* Index in directory table.  */
7635 };
7636
7637 /* Data structure containing information about directories with source
7638    files.  */
7639 struct dir_info
7640 {
7641   const char *path;     /* Path including directory name.  */
7642   int length;           /* Path length.  */
7643   int prefix;           /* Index of directory entry which is a prefix.  */
7644   int count;            /* Number of files in this directory.  */
7645   int dir_idx;          /* Index of directory used as base.  */
7646 };
7647
7648 /* Callback function for file_info comparison.  We sort by looking at
7649    the directories in the path.  */
7650
7651 static int
7652 file_info_cmp (const void *p1, const void *p2)
7653 {
7654   const struct file_info *s1 = p1;
7655   const struct file_info *s2 = p2;
7656   unsigned char *cp1;
7657   unsigned char *cp2;
7658
7659   /* Take care of file names without directories.  We need to make sure that
7660      we return consistent values to qsort since some will get confused if
7661      we return the same value when identical operands are passed in opposite
7662      orders.  So if neither has a directory, return 0 and otherwise return
7663      1 or -1 depending on which one has the directory.  */
7664   if ((s1->path == s1->fname || s2->path == s2->fname))
7665     return (s2->path == s2->fname) - (s1->path == s1->fname);
7666
7667   cp1 = (unsigned char *) s1->path;
7668   cp2 = (unsigned char *) s2->path;
7669
7670   while (1)
7671     {
7672       ++cp1;
7673       ++cp2;
7674       /* Reached the end of the first path?  If so, handle like above.  */
7675       if ((cp1 == (unsigned char *) s1->fname)
7676           || (cp2 == (unsigned char *) s2->fname))
7677         return ((cp2 == (unsigned char *) s2->fname)
7678                 - (cp1 == (unsigned char *) s1->fname));
7679
7680       /* Character of current path component the same?  */
7681       else if (*cp1 != *cp2)
7682         return *cp1 - *cp2;
7683     }
7684 }
7685
7686 struct file_name_acquire_data
7687 {
7688   struct file_info *files;
7689   int used_files;
7690   int max_files;
7691 };
7692
7693 /* Traversal function for the hash table.  */
7694
7695 static int
7696 file_name_acquire (void ** slot, void *data)
7697 {
7698   struct file_name_acquire_data *fnad = data;
7699   struct dwarf_file_data *d = *slot;
7700   struct file_info *fi;
7701   const char *f;
7702
7703   gcc_assert (fnad->max_files >= d->emitted_number);
7704
7705   if (! d->emitted_number)
7706     return 1;
7707
7708   gcc_assert (fnad->max_files != fnad->used_files);
7709
7710   fi = fnad->files + fnad->used_files++;
7711
7712   /* Skip all leading "./".  */
7713   f = d->filename;
7714   while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
7715     f += 2;
7716
7717   /* Create a new array entry.  */
7718   fi->path = f;
7719   fi->length = strlen (f);
7720   fi->file_idx = d;
7721
7722   /* Search for the file name part.  */
7723   f = strrchr (f, DIR_SEPARATOR);
7724 #if defined (DIR_SEPARATOR_2)
7725   {
7726     char *g = strrchr (fi->path, DIR_SEPARATOR_2);
7727
7728     if (g != NULL)
7729       {
7730         if (f == NULL || f < g)
7731           f = g;
7732       }
7733   }
7734 #endif
7735
7736   fi->fname = f == NULL ? fi->path : f + 1;
7737   return 1;
7738 }
7739
7740 /* Output the directory table and the file name table.  We try to minimize
7741    the total amount of memory needed.  A heuristic is used to avoid large
7742    slowdowns with many input files.  */
7743
7744 static void
7745 output_file_names (void)
7746 {
7747   struct file_name_acquire_data fnad;
7748   int numfiles;
7749   struct file_info *files;
7750   struct dir_info *dirs;
7751   int *saved;
7752   int *savehere;
7753   int *backmap;
7754   int ndirs;
7755   int idx_offset;
7756   int i;
7757   int idx;
7758
7759   if (!last_emitted_file)
7760     {
7761       dw2_asm_output_data (1, 0, "End directory table");
7762       dw2_asm_output_data (1, 0, "End file name table");
7763       return;
7764     }
7765
7766   numfiles = last_emitted_file->emitted_number;
7767
7768   /* Allocate the various arrays we need.  */
7769   files = alloca (numfiles * sizeof (struct file_info));
7770   dirs = alloca (numfiles * sizeof (struct dir_info));
7771
7772   fnad.files = files;
7773   fnad.used_files = 0;
7774   fnad.max_files = numfiles;
7775   htab_traverse (file_table, file_name_acquire, &fnad);
7776   gcc_assert (fnad.used_files == fnad.max_files);
7777
7778   qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7779
7780   /* Find all the different directories used.  */
7781   dirs[0].path = files[0].path;
7782   dirs[0].length = files[0].fname - files[0].path;
7783   dirs[0].prefix = -1;
7784   dirs[0].count = 1;
7785   dirs[0].dir_idx = 0;
7786   files[0].dir_idx = 0;
7787   ndirs = 1;
7788
7789   for (i = 1; i < numfiles; i++)
7790     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7791         && memcmp (dirs[ndirs - 1].path, files[i].path,
7792                    dirs[ndirs - 1].length) == 0)
7793       {
7794         /* Same directory as last entry.  */
7795         files[i].dir_idx = ndirs - 1;
7796         ++dirs[ndirs - 1].count;
7797       }
7798     else
7799       {
7800         int j;
7801
7802         /* This is a new directory.  */
7803         dirs[ndirs].path = files[i].path;
7804         dirs[ndirs].length = files[i].fname - files[i].path;
7805         dirs[ndirs].count = 1;
7806         dirs[ndirs].dir_idx = ndirs;
7807         files[i].dir_idx = ndirs;
7808
7809         /* Search for a prefix.  */
7810         dirs[ndirs].prefix = -1;
7811         for (j = 0; j < ndirs; j++)
7812           if (dirs[j].length < dirs[ndirs].length
7813               && dirs[j].length > 1
7814               && (dirs[ndirs].prefix == -1
7815                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7816               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7817             dirs[ndirs].prefix = j;
7818
7819         ++ndirs;
7820       }
7821
7822   /* Now to the actual work.  We have to find a subset of the directories which
7823      allow expressing the file name using references to the directory table
7824      with the least amount of characters.  We do not do an exhaustive search
7825      where we would have to check out every combination of every single
7826      possible prefix.  Instead we use a heuristic which provides nearly optimal
7827      results in most cases and never is much off.  */
7828   saved = alloca (ndirs * sizeof (int));
7829   savehere = alloca (ndirs * sizeof (int));
7830
7831   memset (saved, '\0', ndirs * sizeof (saved[0]));
7832   for (i = 0; i < ndirs; i++)
7833     {
7834       int j;
7835       int total;
7836
7837       /* We can always save some space for the current directory.  But this
7838          does not mean it will be enough to justify adding the directory.  */
7839       savehere[i] = dirs[i].length;
7840       total = (savehere[i] - saved[i]) * dirs[i].count;
7841
7842       for (j = i + 1; j < ndirs; j++)
7843         {
7844           savehere[j] = 0;
7845           if (saved[j] < dirs[i].length)
7846             {
7847               /* Determine whether the dirs[i] path is a prefix of the
7848                  dirs[j] path.  */
7849               int k;
7850
7851               k = dirs[j].prefix;
7852               while (k != -1 && k != (int) i)
7853                 k = dirs[k].prefix;
7854
7855               if (k == (int) i)
7856                 {
7857                   /* Yes it is.  We can possibly save some memory by
7858                      writing the filenames in dirs[j] relative to
7859                      dirs[i].  */
7860                   savehere[j] = dirs[i].length;
7861                   total += (savehere[j] - saved[j]) * dirs[j].count;
7862                 }
7863             }
7864         }
7865
7866       /* Check whether we can save enough to justify adding the dirs[i]
7867          directory.  */
7868       if (total > dirs[i].length + 1)
7869         {
7870           /* It's worthwhile adding.  */
7871           for (j = i; j < ndirs; j++)
7872             if (savehere[j] > 0)
7873               {
7874                 /* Remember how much we saved for this directory so far.  */
7875                 saved[j] = savehere[j];
7876
7877                 /* Remember the prefix directory.  */
7878                 dirs[j].dir_idx = i;
7879               }
7880         }
7881     }
7882
7883   /* Emit the directory name table.  */
7884   idx = 1;
7885   idx_offset = dirs[0].length > 0 ? 1 : 0;
7886   for (i = 1 - idx_offset; i < ndirs; i++)
7887     dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7888                             "Directory Entry: 0x%x", i + idx_offset);
7889
7890   dw2_asm_output_data (1, 0, "End directory table");
7891
7892   /* We have to emit them in the order of emitted_number since that's
7893      used in the debug info generation.  To do this efficiently we
7894      generate a back-mapping of the indices first.  */
7895   backmap = alloca (numfiles * sizeof (int));
7896   for (i = 0; i < numfiles; i++)
7897     backmap[files[i].file_idx->emitted_number - 1] = i;
7898
7899   /* Now write all the file names.  */
7900   for (i = 0; i < numfiles; i++)
7901     {
7902       int file_idx = backmap[i];
7903       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7904
7905       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7906                               "File Entry: 0x%x", (unsigned) i + 1);
7907
7908       /* Include directory index.  */
7909       dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
7910
7911       /* Modification time.  */
7912       dw2_asm_output_data_uleb128 (0, NULL);
7913
7914       /* File length in bytes.  */
7915       dw2_asm_output_data_uleb128 (0, NULL);
7916     }
7917
7918   dw2_asm_output_data (1, 0, "End file name table");
7919 }
7920
7921
7922 /* Output the source line number correspondence information.  This
7923    information goes into the .debug_line section.  */
7924
7925 static void
7926 output_line_info (void)
7927 {
7928   char l1[20], l2[20], p1[20], p2[20];
7929   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7930   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7931   unsigned opc;
7932   unsigned n_op_args;
7933   unsigned long lt_index;
7934   unsigned long current_line;
7935   long line_offset;
7936   long line_delta;
7937   unsigned long current_file;
7938   unsigned long function;
7939
7940   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7941   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7942   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7943   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7944
7945   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7946     dw2_asm_output_data (4, 0xffffffff,
7947       "Initial length escape value indicating 64-bit DWARF extension");
7948   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7949                         "Length of Source Line Info");
7950   ASM_OUTPUT_LABEL (asm_out_file, l1);
7951
7952   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7953   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7954   ASM_OUTPUT_LABEL (asm_out_file, p1);
7955
7956   /* Define the architecture-dependent minimum instruction length (in
7957    bytes).  In this implementation of DWARF, this field is used for
7958    information purposes only.  Since GCC generates assembly language,
7959    we have no a priori knowledge of how many instruction bytes are
7960    generated for each source line, and therefore can use only the
7961    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7962    commands.  Accordingly, we fix this as `1', which is "correct
7963    enough" for all architectures, and don't let the target override.  */
7964   dw2_asm_output_data (1, 1,
7965                        "Minimum Instruction Length");
7966
7967   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7968                        "Default is_stmt_start flag");
7969   dw2_asm_output_data (1, DWARF_LINE_BASE,
7970                        "Line Base Value (Special Opcodes)");
7971   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7972                        "Line Range Value (Special Opcodes)");
7973   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7974                        "Special Opcode Base");
7975
7976   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7977     {
7978       switch (opc)
7979         {
7980         case DW_LNS_advance_pc:
7981         case DW_LNS_advance_line:
7982         case DW_LNS_set_file:
7983         case DW_LNS_set_column:
7984         case DW_LNS_fixed_advance_pc:
7985           n_op_args = 1;
7986           break;
7987         default:
7988           n_op_args = 0;
7989           break;
7990         }
7991
7992       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7993                            opc, n_op_args);
7994     }
7995
7996   /* Write out the information about the files we use.  */
7997   output_file_names ();
7998   ASM_OUTPUT_LABEL (asm_out_file, p2);
7999
8000   /* We used to set the address register to the first location in the text
8001      section here, but that didn't accomplish anything since we already
8002      have a line note for the opening brace of the first function.  */
8003
8004   /* Generate the line number to PC correspondence table, encoded as
8005      a series of state machine operations.  */
8006   current_file = 1;
8007   current_line = 1;
8008
8009   if (cfun && in_cold_section_p)
8010     strcpy (prev_line_label, cfun->cold_section_label);
8011   else
8012     strcpy (prev_line_label, text_section_label);
8013   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
8014     {
8015       dw_line_info_ref line_info = &line_info_table[lt_index];
8016
8017 #if 0
8018       /* Disable this optimization for now; GDB wants to see two line notes
8019          at the beginning of a function so it can find the end of the
8020          prologue.  */
8021
8022       /* Don't emit anything for redundant notes.  Just updating the
8023          address doesn't accomplish anything, because we already assume
8024          that anything after the last address is this line.  */
8025       if (line_info->dw_line_num == current_line
8026           && line_info->dw_file_num == current_file)
8027         continue;
8028 #endif
8029
8030       /* Emit debug info for the address of the current line.
8031
8032          Unfortunately, we have little choice here currently, and must always
8033          use the most general form.  GCC does not know the address delta
8034          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
8035          attributes which will give an upper bound on the address range.  We
8036          could perhaps use length attributes to determine when it is safe to
8037          use DW_LNS_fixed_advance_pc.  */
8038
8039       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
8040       if (0)
8041         {
8042           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
8043           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8044                                "DW_LNS_fixed_advance_pc");
8045           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8046         }
8047       else
8048         {
8049           /* This can handle any delta.  This takes
8050              4+DWARF2_ADDR_SIZE bytes.  */
8051           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8052           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8053           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8054           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8055         }
8056
8057       strcpy (prev_line_label, line_label);
8058
8059       /* Emit debug info for the source file of the current line, if
8060          different from the previous line.  */
8061       if (line_info->dw_file_num != current_file)
8062         {
8063           current_file = line_info->dw_file_num;
8064           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8065           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8066         }
8067
8068       /* Emit debug info for the current line number, choosing the encoding
8069          that uses the least amount of space.  */
8070       if (line_info->dw_line_num != current_line)
8071         {
8072           line_offset = line_info->dw_line_num - current_line;
8073           line_delta = line_offset - DWARF_LINE_BASE;
8074           current_line = line_info->dw_line_num;
8075           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8076             /* This can handle deltas from -10 to 234, using the current
8077                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
8078                takes 1 byte.  */
8079             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8080                                  "line %lu", current_line);
8081           else
8082             {
8083               /* This can handle any delta.  This takes at least 4 bytes,
8084                  depending on the value being encoded.  */
8085               dw2_asm_output_data (1, DW_LNS_advance_line,
8086                                    "advance to line %lu", current_line);
8087               dw2_asm_output_data_sleb128 (line_offset, NULL);
8088               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8089             }
8090         }
8091       else
8092         /* We still need to start a new row, so output a copy insn.  */
8093         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8094     }
8095
8096   /* Emit debug info for the address of the end of the function.  */
8097   if (0)
8098     {
8099       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8100                            "DW_LNS_fixed_advance_pc");
8101       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8102     }
8103   else
8104     {
8105       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8106       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8107       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8108       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8109     }
8110
8111   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8112   dw2_asm_output_data_uleb128 (1, NULL);
8113   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8114
8115   function = 0;
8116   current_file = 1;
8117   current_line = 1;
8118   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8119     {
8120       dw_separate_line_info_ref line_info
8121         = &separate_line_info_table[lt_index];
8122
8123 #if 0
8124       /* Don't emit anything for redundant notes.  */
8125       if (line_info->dw_line_num == current_line
8126           && line_info->dw_file_num == current_file
8127           && line_info->function == function)
8128         goto cont;
8129 #endif
8130
8131       /* Emit debug info for the address of the current line.  If this is
8132          a new function, or the first line of a function, then we need
8133          to handle it differently.  */
8134       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8135                                    lt_index);
8136       if (function != line_info->function)
8137         {
8138           function = line_info->function;
8139
8140           /* Set the address register to the first line in the function.  */
8141           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8142           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8143           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8144           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8145         }
8146       else
8147         {
8148           /* ??? See the DW_LNS_advance_pc comment above.  */
8149           if (0)
8150             {
8151               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8152                                    "DW_LNS_fixed_advance_pc");
8153               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8154             }
8155           else
8156             {
8157               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8158               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8159               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8160               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8161             }
8162         }
8163
8164       strcpy (prev_line_label, line_label);
8165
8166       /* Emit debug info for the source file of the current line, if
8167          different from the previous line.  */
8168       if (line_info->dw_file_num != current_file)
8169         {
8170           current_file = line_info->dw_file_num;
8171           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8172           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8173         }
8174
8175       /* Emit debug info for the current line number, choosing the encoding
8176          that uses the least amount of space.  */
8177       if (line_info->dw_line_num != current_line)
8178         {
8179           line_offset = line_info->dw_line_num - current_line;
8180           line_delta = line_offset - DWARF_LINE_BASE;
8181           current_line = line_info->dw_line_num;
8182           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8183             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8184                                  "line %lu", current_line);
8185           else
8186             {
8187               dw2_asm_output_data (1, DW_LNS_advance_line,
8188                                    "advance to line %lu", current_line);
8189               dw2_asm_output_data_sleb128 (line_offset, NULL);
8190               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8191             }
8192         }
8193       else
8194         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8195
8196 #if 0
8197     cont:
8198 #endif
8199
8200       lt_index++;
8201
8202       /* If we're done with a function, end its sequence.  */
8203       if (lt_index == separate_line_info_table_in_use
8204           || separate_line_info_table[lt_index].function != function)
8205         {
8206           current_file = 1;
8207           current_line = 1;
8208
8209           /* Emit debug info for the address of the end of the function.  */
8210           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8211           if (0)
8212             {
8213               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8214                                    "DW_LNS_fixed_advance_pc");
8215               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8216             }
8217           else
8218             {
8219               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8220               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8221               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8222               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8223             }
8224
8225           /* Output the marker for the end of this sequence.  */
8226           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8227           dw2_asm_output_data_uleb128 (1, NULL);
8228           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8229         }
8230     }
8231
8232   /* Output the marker for the end of the line number info.  */
8233   ASM_OUTPUT_LABEL (asm_out_file, l2);
8234 }
8235 \f
8236 /* Given a pointer to a tree node for some base type, return a pointer to
8237    a DIE that describes the given type.
8238
8239    This routine must only be called for GCC type nodes that correspond to
8240    Dwarf base (fundamental) types.  */
8241
8242 static dw_die_ref
8243 base_type_die (tree type)
8244 {
8245   dw_die_ref base_type_result;
8246   enum dwarf_type encoding;
8247
8248   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8249     return 0;
8250
8251   switch (TREE_CODE (type))
8252     {
8253     case INTEGER_TYPE:
8254       if (TYPE_STRING_FLAG (type))
8255         {
8256           if (TYPE_UNSIGNED (type))
8257             encoding = DW_ATE_unsigned_char;
8258           else
8259             encoding = DW_ATE_signed_char;
8260         }
8261       else if (TYPE_UNSIGNED (type))
8262         encoding = DW_ATE_unsigned;
8263       else
8264         encoding = DW_ATE_signed;
8265       break;
8266
8267     case REAL_TYPE:
8268       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8269         encoding = DW_ATE_decimal_float;
8270       else
8271         encoding = DW_ATE_float;
8272       break;
8273
8274       /* Dwarf2 doesn't know anything about complex ints, so use
8275          a user defined type for it.  */
8276     case COMPLEX_TYPE:
8277       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8278         encoding = DW_ATE_complex_float;
8279       else
8280         encoding = DW_ATE_lo_user;
8281       break;
8282
8283     case BOOLEAN_TYPE:
8284       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8285       encoding = DW_ATE_boolean;
8286       break;
8287
8288     default:
8289       /* No other TREE_CODEs are Dwarf fundamental types.  */
8290       gcc_unreachable ();
8291     }
8292
8293   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8294
8295   /* This probably indicates a bug.  */
8296   if (! TYPE_NAME (type))
8297     add_name_attribute (base_type_result, "__unknown__");
8298
8299   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8300                    int_size_in_bytes (type));
8301   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8302
8303   return base_type_result;
8304 }
8305
8306 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8307    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
8308    a given type is generally the same as the given type, except that if the
8309    given type is a pointer or reference type, then the root type of the given
8310    type is the root type of the "basis" type for the pointer or reference
8311    type.  (This definition of the "root" type is recursive.) Also, the root
8312    type of a `const' qualified type or a `volatile' qualified type is the
8313    root type of the given type without the qualifiers.  */
8314
8315 static tree
8316 root_type (tree type)
8317 {
8318   if (TREE_CODE (type) == ERROR_MARK)
8319     return error_mark_node;
8320
8321   switch (TREE_CODE (type))
8322     {
8323     case ERROR_MARK:
8324       return error_mark_node;
8325
8326     case POINTER_TYPE:
8327     case REFERENCE_TYPE:
8328       return type_main_variant (root_type (TREE_TYPE (type)));
8329
8330     default:
8331       return type_main_variant (type);
8332     }
8333 }
8334
8335 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8336    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8337
8338 static inline int
8339 is_base_type (tree type)
8340 {
8341   switch (TREE_CODE (type))
8342     {
8343     case ERROR_MARK:
8344     case VOID_TYPE:
8345     case INTEGER_TYPE:
8346     case REAL_TYPE:
8347     case COMPLEX_TYPE:
8348     case BOOLEAN_TYPE:
8349       return 1;
8350
8351     case ARRAY_TYPE:
8352     case RECORD_TYPE:
8353     case UNION_TYPE:
8354     case QUAL_UNION_TYPE:
8355     case ENUMERAL_TYPE:
8356     case FUNCTION_TYPE:
8357     case METHOD_TYPE:
8358     case POINTER_TYPE:
8359     case REFERENCE_TYPE:
8360     case OFFSET_TYPE:
8361     case LANG_TYPE:
8362     case VECTOR_TYPE:
8363       return 0;
8364
8365     default:
8366       gcc_unreachable ();
8367     }
8368
8369   return 0;
8370 }
8371
8372 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8373    node, return the size in bits for the type if it is a constant, or else
8374    return the alignment for the type if the type's size is not constant, or
8375    else return BITS_PER_WORD if the type actually turns out to be an
8376    ERROR_MARK node.  */
8377
8378 static inline unsigned HOST_WIDE_INT
8379 simple_type_size_in_bits (tree type)
8380 {
8381   if (TREE_CODE (type) == ERROR_MARK)
8382     return BITS_PER_WORD;
8383   else if (TYPE_SIZE (type) == NULL_TREE)
8384     return 0;
8385   else if (host_integerp (TYPE_SIZE (type), 1))
8386     return tree_low_cst (TYPE_SIZE (type), 1);
8387   else
8388     return TYPE_ALIGN (type);
8389 }
8390
8391 /* Return true if the debug information for the given type should be
8392    emitted as a subrange type.  */
8393
8394 static inline bool
8395 is_subrange_type (tree type)
8396 {
8397   tree subtype = TREE_TYPE (type);
8398
8399   /* Subrange types are identified by the fact that they are integer
8400      types, and that they have a subtype which is either an integer type
8401      or an enumeral type.  */
8402
8403   if (TREE_CODE (type) != INTEGER_TYPE
8404       || subtype == NULL_TREE)
8405     return false;
8406
8407   if (TREE_CODE (subtype) != INTEGER_TYPE
8408       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8409     return false;
8410
8411   if (TREE_CODE (type) == TREE_CODE (subtype)
8412       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8413       && TYPE_MIN_VALUE (type) != NULL
8414       && TYPE_MIN_VALUE (subtype) != NULL
8415       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8416       && TYPE_MAX_VALUE (type) != NULL
8417       && TYPE_MAX_VALUE (subtype) != NULL
8418       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8419     {
8420       /* The type and its subtype have the same representation.  If in
8421          addition the two types also have the same name, then the given
8422          type is not a subrange type, but rather a plain base type.  */
8423       /* FIXME: brobecker/2004-03-22:
8424          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8425          therefore be sufficient to check the TYPE_SIZE node pointers
8426          rather than checking the actual size.  Unfortunately, we have
8427          found some cases, such as in the Ada "integer" type, where
8428          this is not the case.  Until this problem is solved, we need to
8429          keep checking the actual size.  */
8430       tree type_name = TYPE_NAME (type);
8431       tree subtype_name = TYPE_NAME (subtype);
8432
8433       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8434         type_name = DECL_NAME (type_name);
8435
8436       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8437         subtype_name = DECL_NAME (subtype_name);
8438
8439       if (type_name == subtype_name)
8440         return false;
8441     }
8442
8443   return true;
8444 }
8445
8446 /*  Given a pointer to a tree node for a subrange type, return a pointer
8447     to a DIE that describes the given type.  */
8448
8449 static dw_die_ref
8450 subrange_type_die (tree type, dw_die_ref context_die)
8451 {
8452   dw_die_ref subrange_die;
8453   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8454
8455   if (context_die == NULL)
8456     context_die = comp_unit_die;
8457
8458   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8459
8460   if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8461     {
8462       /* The size of the subrange type and its base type do not match,
8463          so we need to generate a size attribute for the subrange type.  */
8464       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8465     }
8466
8467   if (TYPE_MIN_VALUE (type) != NULL)
8468     add_bound_info (subrange_die, DW_AT_lower_bound,
8469                     TYPE_MIN_VALUE (type));
8470   if (TYPE_MAX_VALUE (type) != NULL)
8471     add_bound_info (subrange_die, DW_AT_upper_bound,
8472                     TYPE_MAX_VALUE (type));
8473
8474   return subrange_die;
8475 }
8476
8477 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8478    entry that chains various modifiers in front of the given type.  */
8479
8480 static dw_die_ref
8481 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8482                    dw_die_ref context_die)
8483 {
8484   enum tree_code code = TREE_CODE (type);
8485   dw_die_ref mod_type_die;
8486   dw_die_ref sub_die = NULL;
8487   tree item_type = NULL;
8488   tree qualified_type;
8489   tree name;
8490
8491   if (code == ERROR_MARK)
8492     return NULL;
8493
8494   /* See if we already have the appropriately qualified variant of
8495      this type.  */
8496   qualified_type
8497     = get_qualified_type (type,
8498                           ((is_const_type ? TYPE_QUAL_CONST : 0)
8499                            | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8500
8501   /* If we do, then we can just use its DIE, if it exists.  */
8502   if (qualified_type)
8503     {
8504       mod_type_die = lookup_type_die (qualified_type);
8505       if (mod_type_die)
8506         return mod_type_die;
8507     }
8508
8509   name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8510
8511   /* Handle C typedef types.  */
8512   if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8513     {
8514       tree dtype = TREE_TYPE (name);
8515
8516       if (qualified_type == dtype)
8517         {
8518           /* For a named type, use the typedef.  */
8519           gen_type_die (qualified_type, context_die);
8520           return lookup_type_die (qualified_type);
8521         }
8522       else if (DECL_ORIGINAL_TYPE (name)
8523                && (is_const_type < TYPE_READONLY (dtype)
8524                    || is_volatile_type < TYPE_VOLATILE (dtype)))
8525         /* cv-unqualified version of named type.  Just use the unnamed
8526            type to which it refers.  */
8527         return modified_type_die (DECL_ORIGINAL_TYPE (name),
8528                                   is_const_type, is_volatile_type,
8529                                   context_die);
8530       /* Else cv-qualified version of named type; fall through.  */
8531     }
8532
8533   if (is_const_type)
8534     {
8535       mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8536       sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8537     }
8538   else if (is_volatile_type)
8539     {
8540       mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8541       sub_die = modified_type_die (type, 0, 0, context_die);
8542     }
8543   else if (code == POINTER_TYPE)
8544     {
8545       mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8546       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8547                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8548       item_type = TREE_TYPE (type);
8549     }
8550   else if (code == REFERENCE_TYPE)
8551     {
8552       mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8553       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8554                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8555       item_type = TREE_TYPE (type);
8556     }
8557   else if (is_subrange_type (type))
8558     {
8559       mod_type_die = subrange_type_die (type, context_die);
8560       item_type = TREE_TYPE (type);
8561     }
8562   else if (is_base_type (type))
8563     mod_type_die = base_type_die (type);
8564   else
8565     {
8566       gen_type_die (type, context_die);
8567
8568       /* We have to get the type_main_variant here (and pass that to the
8569          `lookup_type_die' routine) because the ..._TYPE node we have
8570          might simply be a *copy* of some original type node (where the
8571          copy was created to help us keep track of typedef names) and
8572          that copy might have a different TYPE_UID from the original
8573          ..._TYPE node.  */
8574       if (TREE_CODE (type) != VECTOR_TYPE)
8575         return lookup_type_die (type_main_variant (type));
8576       else
8577         /* Vectors have the debugging information in the type,
8578            not the main variant.  */
8579         return lookup_type_die (type);
8580     }
8581
8582   /* Builtin types don't have a DECL_ORIGINAL_TYPE.  For those,
8583      don't output a DW_TAG_typedef, since there isn't one in the
8584      user's program; just attach a DW_AT_name to the type.  */
8585   if (name
8586       && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8587     {
8588       if (TREE_CODE (name) == TYPE_DECL)
8589         /* Could just call add_name_and_src_coords_attributes here,
8590            but since this is a builtin type it doesn't have any
8591            useful source coordinates anyway.  */
8592         name = DECL_NAME (name);
8593       add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8594     }
8595
8596   if (qualified_type)
8597     equate_type_number_to_die (qualified_type, mod_type_die);
8598
8599   if (item_type)
8600     /* We must do this after the equate_type_number_to_die call, in case
8601        this is a recursive type.  This ensures that the modified_type_die
8602        recursion will terminate even if the type is recursive.  Recursive
8603        types are possible in Ada.  */
8604     sub_die = modified_type_die (item_type,
8605                                  TYPE_READONLY (item_type),
8606                                  TYPE_VOLATILE (item_type),
8607                                  context_die);
8608
8609   if (sub_die != NULL)
8610     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8611
8612   return mod_type_die;
8613 }
8614
8615 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8616    an enumerated type.  */
8617
8618 static inline int
8619 type_is_enum (tree type)
8620 {
8621   return TREE_CODE (type) == ENUMERAL_TYPE;
8622 }
8623
8624 /* Return the DBX register number described by a given RTL node.  */
8625
8626 static unsigned int
8627 dbx_reg_number (rtx rtl)
8628 {
8629   unsigned regno = REGNO (rtl);
8630
8631   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8632
8633 #ifdef LEAF_REG_REMAP
8634   if (current_function_uses_only_leaf_regs)
8635     {
8636       int leaf_reg = LEAF_REG_REMAP (regno);
8637       if (leaf_reg != -1)
8638         regno = (unsigned) leaf_reg;
8639     }
8640 #endif
8641
8642   return DBX_REGISTER_NUMBER (regno);
8643 }
8644
8645 /* Optionally add a DW_OP_piece term to a location description expression.
8646    DW_OP_piece is only added if the location description expression already
8647    doesn't end with DW_OP_piece.  */
8648
8649 static void
8650 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8651 {
8652   dw_loc_descr_ref loc;
8653
8654   if (*list_head != NULL)
8655     {
8656       /* Find the end of the chain.  */
8657       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8658         ;
8659
8660       if (loc->dw_loc_opc != DW_OP_piece)
8661         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8662     }
8663 }
8664
8665 /* Return a location descriptor that designates a machine register or
8666    zero if there is none.  */
8667
8668 static dw_loc_descr_ref
8669 reg_loc_descriptor (rtx rtl)
8670 {
8671   rtx regs;
8672
8673   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8674     return 0;
8675
8676   regs = targetm.dwarf_register_span (rtl);
8677
8678   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8679     return multiple_reg_loc_descriptor (rtl, regs);
8680   else
8681     return one_reg_loc_descriptor (dbx_reg_number (rtl));
8682 }
8683
8684 /* Return a location descriptor that designates a machine register for
8685    a given hard register number.  */
8686
8687 static dw_loc_descr_ref
8688 one_reg_loc_descriptor (unsigned int regno)
8689 {
8690   if (regno <= 31)
8691     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8692   else
8693     return new_loc_descr (DW_OP_regx, regno, 0);
8694 }
8695
8696 /* Given an RTL of a register, return a location descriptor that
8697    designates a value that spans more than one register.  */
8698
8699 static dw_loc_descr_ref
8700 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8701 {
8702   int nregs, size, i;
8703   unsigned reg;
8704   dw_loc_descr_ref loc_result = NULL;
8705
8706   reg = REGNO (rtl);
8707 #ifdef LEAF_REG_REMAP
8708   if (current_function_uses_only_leaf_regs)
8709     {
8710       int leaf_reg = LEAF_REG_REMAP (reg);
8711       if (leaf_reg != -1)
8712         reg = (unsigned) leaf_reg;
8713     }
8714 #endif
8715   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8716   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8717
8718   /* Simple, contiguous registers.  */
8719   if (regs == NULL_RTX)
8720     {
8721       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8722
8723       loc_result = NULL;
8724       while (nregs--)
8725         {
8726           dw_loc_descr_ref t;
8727
8728           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8729           add_loc_descr (&loc_result, t);
8730           add_loc_descr_op_piece (&loc_result, size);
8731           ++reg;
8732         }
8733       return loc_result;
8734     }
8735
8736   /* Now onto stupid register sets in non contiguous locations.  */
8737
8738   gcc_assert (GET_CODE (regs) == PARALLEL);
8739
8740   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8741   loc_result = NULL;
8742
8743   for (i = 0; i < XVECLEN (regs, 0); ++i)
8744     {
8745       dw_loc_descr_ref t;
8746
8747       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8748       add_loc_descr (&loc_result, t);
8749       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8750       add_loc_descr_op_piece (&loc_result, size);
8751     }
8752   return loc_result;
8753 }
8754
8755 /* Return a location descriptor that designates a constant.  */
8756
8757 static dw_loc_descr_ref
8758 int_loc_descriptor (HOST_WIDE_INT i)
8759 {
8760   enum dwarf_location_atom op;
8761
8762   /* Pick the smallest representation of a constant, rather than just
8763      defaulting to the LEB encoding.  */
8764   if (i >= 0)
8765     {
8766       if (i <= 31)
8767         op = DW_OP_lit0 + i;
8768       else if (i <= 0xff)
8769         op = DW_OP_const1u;
8770       else if (i <= 0xffff)
8771         op = DW_OP_const2u;
8772       else if (HOST_BITS_PER_WIDE_INT == 32
8773                || i <= 0xffffffff)
8774         op = DW_OP_const4u;
8775       else
8776         op = DW_OP_constu;
8777     }
8778   else
8779     {
8780       if (i >= -0x80)
8781         op = DW_OP_const1s;
8782       else if (i >= -0x8000)
8783         op = DW_OP_const2s;
8784       else if (HOST_BITS_PER_WIDE_INT == 32
8785                || i >= -0x80000000)
8786         op = DW_OP_const4s;
8787       else
8788         op = DW_OP_consts;
8789     }
8790
8791   return new_loc_descr (op, i, 0);
8792 }
8793
8794 /* Return a location descriptor that designates a base+offset location.  */
8795
8796 static dw_loc_descr_ref
8797 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8798 {
8799   unsigned int regno;
8800
8801   /* We only use "frame base" when we're sure we're talking about the
8802      post-prologue local stack frame.  We do this by *not* running
8803      register elimination until this point, and recognizing the special
8804      argument pointer and soft frame pointer rtx's.  */
8805   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8806     {
8807       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8808
8809       if (elim != reg)
8810         {
8811           if (GET_CODE (elim) == PLUS)
8812             {
8813               offset += INTVAL (XEXP (elim, 1));
8814               elim = XEXP (elim, 0);
8815             }
8816           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8817                       : stack_pointer_rtx));
8818           offset += frame_pointer_fb_offset;
8819
8820           return new_loc_descr (DW_OP_fbreg, offset, 0);
8821         }
8822     }
8823
8824   regno = dbx_reg_number (reg);
8825   if (regno <= 31)
8826     return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8827   else
8828     return new_loc_descr (DW_OP_bregx, regno, offset);
8829 }
8830
8831 /* Return true if this RTL expression describes a base+offset calculation.  */
8832
8833 static inline int
8834 is_based_loc (rtx rtl)
8835 {
8836   return (GET_CODE (rtl) == PLUS
8837           && ((REG_P (XEXP (rtl, 0))
8838                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8839                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8840 }
8841
8842 /* The following routine converts the RTL for a variable or parameter
8843    (resident in memory) into an equivalent Dwarf representation of a
8844    mechanism for getting the address of that same variable onto the top of a
8845    hypothetical "address evaluation" stack.
8846
8847    When creating memory location descriptors, we are effectively transforming
8848    the RTL for a memory-resident object into its Dwarf postfix expression
8849    equivalent.  This routine recursively descends an RTL tree, turning
8850    it into Dwarf postfix code as it goes.
8851
8852    MODE is the mode of the memory reference, needed to handle some
8853    autoincrement addressing modes.
8854
8855    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8856    location list for RTL.
8857
8858    Return 0 if we can't represent the location.  */
8859
8860 static dw_loc_descr_ref
8861 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8862 {
8863   dw_loc_descr_ref mem_loc_result = NULL;
8864   enum dwarf_location_atom op;
8865
8866   /* Note that for a dynamically sized array, the location we will generate a
8867      description of here will be the lowest numbered location which is
8868      actually within the array.  That's *not* necessarily the same as the
8869      zeroth element of the array.  */
8870
8871   rtl = targetm.delegitimize_address (rtl);
8872
8873   switch (GET_CODE (rtl))
8874     {
8875     case POST_INC:
8876     case POST_DEC:
8877     case POST_MODIFY:
8878       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8879          just fall into the SUBREG code.  */
8880
8881       /* ... fall through ...  */
8882
8883     case SUBREG:
8884       /* The case of a subreg may arise when we have a local (register)
8885          variable or a formal (register) parameter which doesn't quite fill
8886          up an entire register.  For now, just assume that it is
8887          legitimate to make the Dwarf info refer to the whole register which
8888          contains the given subreg.  */
8889       rtl = XEXP (rtl, 0);
8890
8891       /* ... fall through ...  */
8892
8893     case REG:
8894       /* Whenever a register number forms a part of the description of the
8895          method for calculating the (dynamic) address of a memory resident
8896          object, DWARF rules require the register number be referred to as
8897          a "base register".  This distinction is not based in any way upon
8898          what category of register the hardware believes the given register
8899          belongs to.  This is strictly DWARF terminology we're dealing with
8900          here. Note that in cases where the location of a memory-resident
8901          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8902          OP_CONST (0)) the actual DWARF location descriptor that we generate
8903          may just be OP_BASEREG (basereg).  This may look deceptively like
8904          the object in question was allocated to a register (rather than in
8905          memory) so DWARF consumers need to be aware of the subtle
8906          distinction between OP_REG and OP_BASEREG.  */
8907       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8908         mem_loc_result = based_loc_descr (rtl, 0);
8909       break;
8910
8911     case MEM:
8912       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8913       if (mem_loc_result != 0)
8914         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8915       break;
8916
8917     case LO_SUM:
8918          rtl = XEXP (rtl, 1);
8919
8920       /* ... fall through ...  */
8921
8922     case LABEL_REF:
8923       /* Some ports can transform a symbol ref into a label ref, because
8924          the symbol ref is too far away and has to be dumped into a constant
8925          pool.  */
8926     case CONST:
8927     case SYMBOL_REF:
8928       /* Alternatively, the symbol in the constant pool might be referenced
8929          by a different symbol.  */
8930       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8931         {
8932           bool marked;
8933           rtx tmp = get_pool_constant_mark (rtl, &marked);
8934
8935           if (GET_CODE (tmp) == SYMBOL_REF)
8936             {
8937               rtl = tmp;
8938               if (CONSTANT_POOL_ADDRESS_P (tmp))
8939                 get_pool_constant_mark (tmp, &marked);
8940               else
8941                 marked = true;
8942             }
8943
8944           /* If all references to this pool constant were optimized away,
8945              it was not output and thus we can't represent it.
8946              FIXME: might try to use DW_OP_const_value here, though
8947              DW_OP_piece complicates it.  */
8948           if (!marked)
8949             return 0;
8950         }
8951
8952       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8953       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8954       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8955       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8956       break;
8957
8958     case PRE_MODIFY:
8959       /* Extract the PLUS expression nested inside and fall into
8960          PLUS code below.  */
8961       rtl = XEXP (rtl, 1);
8962       goto plus;
8963
8964     case PRE_INC:
8965     case PRE_DEC:
8966       /* Turn these into a PLUS expression and fall into the PLUS code
8967          below.  */
8968       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8969                           GEN_INT (GET_CODE (rtl) == PRE_INC
8970                                    ? GET_MODE_UNIT_SIZE (mode)
8971                                    : -GET_MODE_UNIT_SIZE (mode)));
8972
8973       /* ... fall through ...  */
8974
8975     case PLUS:
8976     plus:
8977       if (is_based_loc (rtl))
8978         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8979                                           INTVAL (XEXP (rtl, 1)));
8980       else
8981         {
8982           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8983           if (mem_loc_result == 0)
8984             break;
8985
8986           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8987               && INTVAL (XEXP (rtl, 1)) >= 0)
8988             add_loc_descr (&mem_loc_result,
8989                            new_loc_descr (DW_OP_plus_uconst,
8990                                           INTVAL (XEXP (rtl, 1)), 0));
8991           else
8992             {
8993               add_loc_descr (&mem_loc_result,
8994                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8995               add_loc_descr (&mem_loc_result,
8996                              new_loc_descr (DW_OP_plus, 0, 0));
8997             }
8998         }
8999       break;
9000
9001     /* If a pseudo-reg is optimized away, it is possible for it to
9002        be replaced with a MEM containing a multiply or shift.  */
9003     case MULT:
9004       op = DW_OP_mul;
9005       goto do_binop;
9006
9007     case ASHIFT:
9008       op = DW_OP_shl;
9009       goto do_binop;
9010
9011     case ASHIFTRT:
9012       op = DW_OP_shra;
9013       goto do_binop;
9014
9015     case LSHIFTRT:
9016       op = DW_OP_shr;
9017       goto do_binop;
9018
9019     do_binop:
9020       {
9021         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
9022         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
9023
9024         if (op0 == 0 || op1 == 0)
9025           break;
9026
9027         mem_loc_result = op0;
9028         add_loc_descr (&mem_loc_result, op1);
9029         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
9030         break;
9031       }
9032
9033     case CONST_INT:
9034       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
9035       break;
9036
9037     default:
9038       gcc_unreachable ();
9039     }
9040
9041   return mem_loc_result;
9042 }
9043
9044 /* Return a descriptor that describes the concatenation of two locations.
9045    This is typically a complex variable.  */
9046
9047 static dw_loc_descr_ref
9048 concat_loc_descriptor (rtx x0, rtx x1)
9049 {
9050   dw_loc_descr_ref cc_loc_result = NULL;
9051   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
9052   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
9053
9054   if (x0_ref == 0 || x1_ref == 0)
9055     return 0;
9056
9057   cc_loc_result = x0_ref;
9058   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
9059
9060   add_loc_descr (&cc_loc_result, x1_ref);
9061   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
9062
9063   return cc_loc_result;
9064 }
9065
9066 /* Return a descriptor that describes the concatenation of N
9067    locations.  */
9068
9069 static dw_loc_descr_ref
9070 concatn_loc_descriptor (rtx concatn)
9071 {
9072   unsigned int i;
9073   dw_loc_descr_ref cc_loc_result = NULL;
9074   unsigned int n = XVECLEN (concatn, 0);
9075
9076   for (i = 0; i < n; ++i)
9077     {
9078       dw_loc_descr_ref ref;
9079       rtx x = XVECEXP (concatn, 0, i);
9080
9081       ref = loc_descriptor (x);
9082       if (ref == NULL)
9083         return NULL;
9084
9085       add_loc_descr (&cc_loc_result, ref);
9086       add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9087     }
9088
9089   return cc_loc_result;
9090 }
9091
9092 /* Output a proper Dwarf location descriptor for a variable or parameter
9093    which is either allocated in a register or in a memory location.  For a
9094    register, we just generate an OP_REG and the register number.  For a
9095    memory location we provide a Dwarf postfix expression describing how to
9096    generate the (dynamic) address of the object onto the address stack.
9097
9098    If we don't know how to describe it, return 0.  */
9099
9100 static dw_loc_descr_ref
9101 loc_descriptor (rtx rtl)
9102 {
9103   dw_loc_descr_ref loc_result = NULL;
9104
9105   switch (GET_CODE (rtl))
9106     {
9107     case SUBREG:
9108       /* The case of a subreg may arise when we have a local (register)
9109          variable or a formal (register) parameter which doesn't quite fill
9110          up an entire register.  For now, just assume that it is
9111          legitimate to make the Dwarf info refer to the whole register which
9112          contains the given subreg.  */
9113       rtl = SUBREG_REG (rtl);
9114
9115       /* ... fall through ...  */
9116
9117     case REG:
9118       loc_result = reg_loc_descriptor (rtl);
9119       break;
9120
9121     case MEM:
9122       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
9123       break;
9124
9125     case CONCAT:
9126       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
9127       break;
9128
9129     case CONCATN:
9130       loc_result = concatn_loc_descriptor (rtl);
9131       break;
9132
9133     case VAR_LOCATION:
9134       /* Single part.  */
9135       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9136         {
9137           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
9138           break;
9139         }
9140
9141       rtl = XEXP (rtl, 1);
9142       /* FALLTHRU */
9143
9144     case PARALLEL:
9145       {
9146         rtvec par_elems = XVEC (rtl, 0);
9147         int num_elem = GET_NUM_ELEM (par_elems);
9148         enum machine_mode mode;
9149         int i;
9150
9151         /* Create the first one, so we have something to add to.  */
9152         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
9153         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9154         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9155         for (i = 1; i < num_elem; i++)
9156           {
9157             dw_loc_descr_ref temp;
9158
9159             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9160             add_loc_descr (&loc_result, temp);
9161             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9162             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9163           }
9164       }
9165       break;
9166
9167     default:
9168       gcc_unreachable ();
9169     }
9170
9171   return loc_result;
9172 }
9173
9174 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
9175    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
9176    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9177    top-level invocation, and we require the address of LOC; is 0 if we require
9178    the value of LOC.  */
9179
9180 static dw_loc_descr_ref
9181 loc_descriptor_from_tree_1 (tree loc, int want_address)
9182 {
9183   dw_loc_descr_ref ret, ret1;
9184   int have_address = 0;
9185   enum dwarf_location_atom op;
9186
9187   /* ??? Most of the time we do not take proper care for sign/zero
9188      extending the values properly.  Hopefully this won't be a real
9189      problem...  */
9190
9191   switch (TREE_CODE (loc))
9192     {
9193     case ERROR_MARK:
9194       return 0;
9195
9196     case PLACEHOLDER_EXPR:
9197       /* This case involves extracting fields from an object to determine the
9198          position of other fields.  We don't try to encode this here.  The
9199          only user of this is Ada, which encodes the needed information using
9200          the names of types.  */
9201       return 0;
9202
9203     case CALL_EXPR:
9204       return 0;
9205
9206     case PREINCREMENT_EXPR:
9207     case PREDECREMENT_EXPR:
9208     case POSTINCREMENT_EXPR:
9209     case POSTDECREMENT_EXPR:
9210       /* There are no opcodes for these operations.  */
9211       return 0;
9212
9213     case ADDR_EXPR:
9214       /* If we already want an address, there's nothing we can do.  */
9215       if (want_address)
9216         return 0;
9217
9218       /* Otherwise, process the argument and look for the address.  */
9219       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9220
9221     case VAR_DECL:
9222       if (DECL_THREAD_LOCAL_P (loc))
9223         {
9224           rtx rtl;
9225
9226           /* If this is not defined, we have no way to emit the data.  */
9227           if (!targetm.asm_out.output_dwarf_dtprel)
9228             return 0;
9229
9230           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9231              look up addresses of objects in the current module.  */
9232           if (DECL_EXTERNAL (loc))
9233             return 0;
9234
9235           rtl = rtl_for_decl_location (loc);
9236           if (rtl == NULL_RTX)
9237             return 0;
9238
9239           if (!MEM_P (rtl))
9240             return 0;
9241           rtl = XEXP (rtl, 0);
9242           if (! CONSTANT_P (rtl))
9243             return 0;
9244
9245           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9246           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9247           ret->dw_loc_oprnd1.v.val_addr = rtl;
9248
9249           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9250           add_loc_descr (&ret, ret1);
9251
9252           have_address = 1;
9253           break;
9254         }
9255       /* FALLTHRU */
9256
9257     case PARM_DECL:
9258       if (DECL_HAS_VALUE_EXPR_P (loc))
9259         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9260                                            want_address);
9261       /* FALLTHRU */
9262
9263     case RESULT_DECL:
9264     case FUNCTION_DECL:
9265       {
9266         rtx rtl = rtl_for_decl_location (loc);
9267
9268         if (rtl == NULL_RTX)
9269           return 0;
9270         else if (GET_CODE (rtl) == CONST_INT)
9271           {
9272             HOST_WIDE_INT val = INTVAL (rtl);
9273             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9274               val &= GET_MODE_MASK (DECL_MODE (loc));
9275             ret = int_loc_descriptor (val);
9276           }
9277         else if (GET_CODE (rtl) == CONST_STRING)
9278           return 0;
9279         else if (CONSTANT_P (rtl))
9280           {
9281             ret = new_loc_descr (DW_OP_addr, 0, 0);
9282             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9283             ret->dw_loc_oprnd1.v.val_addr = rtl;
9284           }
9285         else
9286           {
9287             enum machine_mode mode;
9288
9289             /* Certain constructs can only be represented at top-level.  */
9290             if (want_address == 2)
9291               return loc_descriptor (rtl);
9292
9293             mode = GET_MODE (rtl);
9294             if (MEM_P (rtl))
9295               {
9296                 rtl = XEXP (rtl, 0);
9297                 have_address = 1;
9298               }
9299             ret = mem_loc_descriptor (rtl, mode);
9300           }
9301       }
9302       break;
9303
9304     case INDIRECT_REF:
9305       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9306       have_address = 1;
9307       break;
9308
9309     case COMPOUND_EXPR:
9310       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9311
9312     case NOP_EXPR:
9313     case CONVERT_EXPR:
9314     case NON_LVALUE_EXPR:
9315     case VIEW_CONVERT_EXPR:
9316     case SAVE_EXPR:
9317     case GIMPLE_MODIFY_STMT:
9318       return loc_descriptor_from_tree_1 (GENERIC_TREE_OPERAND (loc, 0),
9319                                          want_address);
9320
9321     case COMPONENT_REF:
9322     case BIT_FIELD_REF:
9323     case ARRAY_REF:
9324     case ARRAY_RANGE_REF:
9325       {
9326         tree obj, offset;
9327         HOST_WIDE_INT bitsize, bitpos, bytepos;
9328         enum machine_mode mode;
9329         int volatilep;
9330         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9331
9332         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9333                                    &unsignedp, &volatilep, false);
9334
9335         if (obj == loc)
9336           return 0;
9337
9338         ret = loc_descriptor_from_tree_1 (obj, 1);
9339         if (ret == 0
9340             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9341           return 0;
9342
9343         if (offset != NULL_TREE)
9344           {
9345             /* Variable offset.  */
9346             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9347             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9348           }
9349
9350         bytepos = bitpos / BITS_PER_UNIT;
9351         if (bytepos > 0)
9352           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9353         else if (bytepos < 0)
9354           {
9355             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9356             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9357           }
9358
9359         have_address = 1;
9360         break;
9361       }
9362
9363     case INTEGER_CST:
9364       if (host_integerp (loc, 0))
9365         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9366       else
9367         return 0;
9368       break;
9369
9370     case CONSTRUCTOR:
9371       {
9372         /* Get an RTL for this, if something has been emitted.  */
9373         rtx rtl = lookup_constant_def (loc);
9374         enum machine_mode mode;
9375
9376         if (!rtl || !MEM_P (rtl))
9377           return 0;
9378         mode = GET_MODE (rtl);
9379         rtl = XEXP (rtl, 0);
9380         ret = mem_loc_descriptor (rtl, mode);
9381         have_address = 1;
9382         break;
9383       }
9384
9385     case TRUTH_AND_EXPR:
9386     case TRUTH_ANDIF_EXPR:
9387     case BIT_AND_EXPR:
9388       op = DW_OP_and;
9389       goto do_binop;
9390
9391     case TRUTH_XOR_EXPR:
9392     case BIT_XOR_EXPR:
9393       op = DW_OP_xor;
9394       goto do_binop;
9395
9396     case TRUTH_OR_EXPR:
9397     case TRUTH_ORIF_EXPR:
9398     case BIT_IOR_EXPR:
9399       op = DW_OP_or;
9400       goto do_binop;
9401
9402     case FLOOR_DIV_EXPR:
9403     case CEIL_DIV_EXPR:
9404     case ROUND_DIV_EXPR:
9405     case TRUNC_DIV_EXPR:
9406       op = DW_OP_div;
9407       goto do_binop;
9408
9409     case MINUS_EXPR:
9410       op = DW_OP_minus;
9411       goto do_binop;
9412
9413     case FLOOR_MOD_EXPR:
9414     case CEIL_MOD_EXPR:
9415     case ROUND_MOD_EXPR:
9416     case TRUNC_MOD_EXPR:
9417       op = DW_OP_mod;
9418       goto do_binop;
9419
9420     case MULT_EXPR:
9421       op = DW_OP_mul;
9422       goto do_binop;
9423
9424     case LSHIFT_EXPR:
9425       op = DW_OP_shl;
9426       goto do_binop;
9427
9428     case RSHIFT_EXPR:
9429       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9430       goto do_binop;
9431
9432     case PLUS_EXPR:
9433       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9434           && host_integerp (TREE_OPERAND (loc, 1), 0))
9435         {
9436           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9437           if (ret == 0)
9438             return 0;
9439
9440           add_loc_descr (&ret,
9441                          new_loc_descr (DW_OP_plus_uconst,
9442                                         tree_low_cst (TREE_OPERAND (loc, 1),
9443                                                       0),
9444                                         0));
9445           break;
9446         }
9447
9448       op = DW_OP_plus;
9449       goto do_binop;
9450
9451     case LE_EXPR:
9452       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9453         return 0;
9454
9455       op = DW_OP_le;
9456       goto do_binop;
9457
9458     case GE_EXPR:
9459       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9460         return 0;
9461
9462       op = DW_OP_ge;
9463       goto do_binop;
9464
9465     case LT_EXPR:
9466       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9467         return 0;
9468
9469       op = DW_OP_lt;
9470       goto do_binop;
9471
9472     case GT_EXPR:
9473       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9474         return 0;
9475
9476       op = DW_OP_gt;
9477       goto do_binop;
9478
9479     case EQ_EXPR:
9480       op = DW_OP_eq;
9481       goto do_binop;
9482
9483     case NE_EXPR:
9484       op = DW_OP_ne;
9485       goto do_binop;
9486
9487     do_binop:
9488       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9489       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9490       if (ret == 0 || ret1 == 0)
9491         return 0;
9492
9493       add_loc_descr (&ret, ret1);
9494       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9495       break;
9496
9497     case TRUTH_NOT_EXPR:
9498     case BIT_NOT_EXPR:
9499       op = DW_OP_not;
9500       goto do_unop;
9501
9502     case ABS_EXPR:
9503       op = DW_OP_abs;
9504       goto do_unop;
9505
9506     case NEGATE_EXPR:
9507       op = DW_OP_neg;
9508       goto do_unop;
9509
9510     do_unop:
9511       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9512       if (ret == 0)
9513         return 0;
9514
9515       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9516       break;
9517
9518     case MIN_EXPR:
9519     case MAX_EXPR:
9520       {
9521         const enum tree_code code =
9522           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9523
9524         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9525                       build2 (code, integer_type_node,
9526                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9527                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9528       }
9529
9530       /* ... fall through ...  */
9531
9532     case COND_EXPR:
9533       {
9534         dw_loc_descr_ref lhs
9535           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9536         dw_loc_descr_ref rhs
9537           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9538         dw_loc_descr_ref bra_node, jump_node, tmp;
9539
9540         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9541         if (ret == 0 || lhs == 0 || rhs == 0)
9542           return 0;
9543
9544         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9545         add_loc_descr (&ret, bra_node);
9546
9547         add_loc_descr (&ret, rhs);
9548         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9549         add_loc_descr (&ret, jump_node);
9550
9551         add_loc_descr (&ret, lhs);
9552         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9553         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9554
9555         /* ??? Need a node to point the skip at.  Use a nop.  */
9556         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9557         add_loc_descr (&ret, tmp);
9558         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9559         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9560       }
9561       break;
9562
9563     case FIX_TRUNC_EXPR:
9564       return 0;
9565
9566     default:
9567       /* Leave front-end specific codes as simply unknown.  This comes
9568          up, for instance, with the C STMT_EXPR.  */
9569       if ((unsigned int) TREE_CODE (loc)
9570           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9571         return 0;
9572
9573 #ifdef ENABLE_CHECKING
9574       /* Otherwise this is a generic code; we should just lists all of
9575          these explicitly.  We forgot one.  */
9576       gcc_unreachable ();
9577 #else
9578       /* In a release build, we want to degrade gracefully: better to
9579          generate incomplete debugging information than to crash.  */
9580       return NULL;
9581 #endif
9582     }
9583
9584   /* Show if we can't fill the request for an address.  */
9585   if (want_address && !have_address)
9586     return 0;
9587
9588   /* If we've got an address and don't want one, dereference.  */
9589   if (!want_address && have_address && ret)
9590     {
9591       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9592
9593       if (size > DWARF2_ADDR_SIZE || size == -1)
9594         return 0;
9595       else if (size == DWARF2_ADDR_SIZE)
9596         op = DW_OP_deref;
9597       else
9598         op = DW_OP_deref_size;
9599
9600       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9601     }
9602
9603   return ret;
9604 }
9605
9606 static inline dw_loc_descr_ref
9607 loc_descriptor_from_tree (tree loc)
9608 {
9609   return loc_descriptor_from_tree_1 (loc, 2);
9610 }
9611
9612 /* Given a value, round it up to the lowest multiple of `boundary'
9613    which is not less than the value itself.  */
9614
9615 static inline HOST_WIDE_INT
9616 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9617 {
9618   return (((value + boundary - 1) / boundary) * boundary);
9619 }
9620
9621 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9622    pointer to the declared type for the relevant field variable, or return
9623    `integer_type_node' if the given node turns out to be an
9624    ERROR_MARK node.  */
9625
9626 static inline tree
9627 field_type (tree decl)
9628 {
9629   tree type;
9630
9631   if (TREE_CODE (decl) == ERROR_MARK)
9632     return integer_type_node;
9633
9634   type = DECL_BIT_FIELD_TYPE (decl);
9635   if (type == NULL_TREE)
9636     type = TREE_TYPE (decl);
9637
9638   return type;
9639 }
9640
9641 /* Given a pointer to a tree node, return the alignment in bits for
9642    it, or else return BITS_PER_WORD if the node actually turns out to
9643    be an ERROR_MARK node.  */
9644
9645 static inline unsigned
9646 simple_type_align_in_bits (tree type)
9647 {
9648   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9649 }
9650
9651 static inline unsigned
9652 simple_decl_align_in_bits (tree decl)
9653 {
9654   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9655 }
9656
9657 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9658    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9659    or return 0 if we are unable to determine what that offset is, either
9660    because the argument turns out to be a pointer to an ERROR_MARK node, or
9661    because the offset is actually variable.  (We can't handle the latter case
9662    just yet).  */
9663
9664 static HOST_WIDE_INT
9665 field_byte_offset (tree decl)
9666 {
9667   unsigned int type_align_in_bits;
9668   unsigned int decl_align_in_bits;
9669   unsigned HOST_WIDE_INT type_size_in_bits;
9670   HOST_WIDE_INT object_offset_in_bits;
9671   tree type;
9672   tree field_size_tree;
9673   HOST_WIDE_INT bitpos_int;
9674   HOST_WIDE_INT deepest_bitpos;
9675   unsigned HOST_WIDE_INT field_size_in_bits;
9676
9677   if (TREE_CODE (decl) == ERROR_MARK)
9678     return 0;
9679
9680   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9681
9682   type = field_type (decl);
9683   field_size_tree = DECL_SIZE (decl);
9684
9685   /* The size could be unspecified if there was an error, or for
9686      a flexible array member.  */
9687   if (! field_size_tree)
9688     field_size_tree = bitsize_zero_node;
9689
9690   /* We cannot yet cope with fields whose positions are variable, so
9691      for now, when we see such things, we simply return 0.  Someday, we may
9692      be able to handle such cases, but it will be damn difficult.  */
9693   if (! host_integerp (bit_position (decl), 0))
9694     return 0;
9695
9696   bitpos_int = int_bit_position (decl);
9697
9698   /* If we don't know the size of the field, pretend it's a full word.  */
9699   if (host_integerp (field_size_tree, 1))
9700     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9701   else
9702     field_size_in_bits = BITS_PER_WORD;
9703
9704   type_size_in_bits = simple_type_size_in_bits (type);
9705   type_align_in_bits = simple_type_align_in_bits (type);
9706   decl_align_in_bits = simple_decl_align_in_bits (decl);
9707
9708   /* The GCC front-end doesn't make any attempt to keep track of the starting
9709      bit offset (relative to the start of the containing structure type) of the
9710      hypothetical "containing object" for a bit-field.  Thus, when computing
9711      the byte offset value for the start of the "containing object" of a
9712      bit-field, we must deduce this information on our own. This can be rather
9713      tricky to do in some cases.  For example, handling the following structure
9714      type definition when compiling for an i386/i486 target (which only aligns
9715      long long's to 32-bit boundaries) can be very tricky:
9716
9717          struct S { int field1; long long field2:31; };
9718
9719      Fortunately, there is a simple rule-of-thumb which can be used in such
9720      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9721      structure shown above.  It decides to do this based upon one simple rule
9722      for bit-field allocation.  GCC allocates each "containing object" for each
9723      bit-field at the first (i.e. lowest addressed) legitimate alignment
9724      boundary (based upon the required minimum alignment for the declared type
9725      of the field) which it can possibly use, subject to the condition that
9726      there is still enough available space remaining in the containing object
9727      (when allocated at the selected point) to fully accommodate all of the
9728      bits of the bit-field itself.
9729
9730      This simple rule makes it obvious why GCC allocates 8 bytes for each
9731      object of the structure type shown above.  When looking for a place to
9732      allocate the "containing object" for `field2', the compiler simply tries
9733      to allocate a 64-bit "containing object" at each successive 32-bit
9734      boundary (starting at zero) until it finds a place to allocate that 64-
9735      bit field such that at least 31 contiguous (and previously unallocated)
9736      bits remain within that selected 64 bit field.  (As it turns out, for the
9737      example above, the compiler finds it is OK to allocate the "containing
9738      object" 64-bit field at bit-offset zero within the structure type.)
9739
9740      Here we attempt to work backwards from the limited set of facts we're
9741      given, and we try to deduce from those facts, where GCC must have believed
9742      that the containing object started (within the structure type). The value
9743      we deduce is then used (by the callers of this routine) to generate
9744      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9745      and, in the case of DW_AT_location, regular fields as well).  */
9746
9747   /* Figure out the bit-distance from the start of the structure to the
9748      "deepest" bit of the bit-field.  */
9749   deepest_bitpos = bitpos_int + field_size_in_bits;
9750
9751   /* This is the tricky part.  Use some fancy footwork to deduce where the
9752      lowest addressed bit of the containing object must be.  */
9753   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9754
9755   /* Round up to type_align by default.  This works best for bitfields.  */
9756   object_offset_in_bits += type_align_in_bits - 1;
9757   object_offset_in_bits /= type_align_in_bits;
9758   object_offset_in_bits *= type_align_in_bits;
9759
9760   if (object_offset_in_bits > bitpos_int)
9761     {
9762       /* Sigh, the decl must be packed.  */
9763       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9764
9765       /* Round up to decl_align instead.  */
9766       object_offset_in_bits += decl_align_in_bits - 1;
9767       object_offset_in_bits /= decl_align_in_bits;
9768       object_offset_in_bits *= decl_align_in_bits;
9769     }
9770
9771   return object_offset_in_bits / BITS_PER_UNIT;
9772 }
9773 \f
9774 /* The following routines define various Dwarf attributes and any data
9775    associated with them.  */
9776
9777 /* Add a location description attribute value to a DIE.
9778
9779    This emits location attributes suitable for whole variables and
9780    whole parameters.  Note that the location attributes for struct fields are
9781    generated by the routine `data_member_location_attribute' below.  */
9782
9783 static inline void
9784 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9785                              dw_loc_descr_ref descr)
9786 {
9787   if (descr != 0)
9788     add_AT_loc (die, attr_kind, descr);
9789 }
9790
9791 /* Attach the specialized form of location attribute used for data members of
9792    struct and union types.  In the special case of a FIELD_DECL node which
9793    represents a bit-field, the "offset" part of this special location
9794    descriptor must indicate the distance in bytes from the lowest-addressed
9795    byte of the containing struct or union type to the lowest-addressed byte of
9796    the "containing object" for the bit-field.  (See the `field_byte_offset'
9797    function above).
9798
9799    For any given bit-field, the "containing object" is a hypothetical object
9800    (of some integral or enum type) within which the given bit-field lives.  The
9801    type of this hypothetical "containing object" is always the same as the
9802    declared type of the individual bit-field itself (for GCC anyway... the
9803    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9804    bytes) of the hypothetical "containing object" which will be given in the
9805    DW_AT_byte_size attribute for this bit-field.  (See the
9806    `byte_size_attribute' function below.)  It is also used when calculating the
9807    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9808    function below.)  */
9809
9810 static void
9811 add_data_member_location_attribute (dw_die_ref die, tree decl)
9812 {
9813   HOST_WIDE_INT offset;
9814   dw_loc_descr_ref loc_descr = 0;
9815
9816   if (TREE_CODE (decl) == TREE_BINFO)
9817     {
9818       /* We're working on the TAG_inheritance for a base class.  */
9819       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9820         {
9821           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9822              aren't at a fixed offset from all (sub)objects of the same
9823              type.  We need to extract the appropriate offset from our
9824              vtable.  The following dwarf expression means
9825
9826                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9827
9828              This is specific to the V3 ABI, of course.  */
9829
9830           dw_loc_descr_ref tmp;
9831
9832           /* Make a copy of the object address.  */
9833           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9834           add_loc_descr (&loc_descr, tmp);
9835
9836           /* Extract the vtable address.  */
9837           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9838           add_loc_descr (&loc_descr, tmp);
9839
9840           /* Calculate the address of the offset.  */
9841           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9842           gcc_assert (offset < 0);
9843
9844           tmp = int_loc_descriptor (-offset);
9845           add_loc_descr (&loc_descr, tmp);
9846           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9847           add_loc_descr (&loc_descr, tmp);
9848
9849           /* Extract the offset.  */
9850           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9851           add_loc_descr (&loc_descr, tmp);
9852
9853           /* Add it to the object address.  */
9854           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9855           add_loc_descr (&loc_descr, tmp);
9856         }
9857       else
9858         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9859     }
9860   else
9861     offset = field_byte_offset (decl);
9862
9863   if (! loc_descr)
9864     {
9865       enum dwarf_location_atom op;
9866
9867       /* The DWARF2 standard says that we should assume that the structure
9868          address is already on the stack, so we can specify a structure field
9869          address by using DW_OP_plus_uconst.  */
9870
9871 #ifdef MIPS_DEBUGGING_INFO
9872       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9873          operator correctly.  It works only if we leave the offset on the
9874          stack.  */
9875       op = DW_OP_constu;
9876 #else
9877       op = DW_OP_plus_uconst;
9878 #endif
9879
9880       loc_descr = new_loc_descr (op, offset, 0);
9881     }
9882
9883   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9884 }
9885
9886 /* Writes integer values to dw_vec_const array.  */
9887
9888 static void
9889 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9890 {
9891   while (size != 0)
9892     {
9893       *dest++ = val & 0xff;
9894       val >>= 8;
9895       --size;
9896     }
9897 }
9898
9899 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9900
9901 static HOST_WIDE_INT
9902 extract_int (const unsigned char *src, unsigned int size)
9903 {
9904   HOST_WIDE_INT val = 0;
9905
9906   src += size;
9907   while (size != 0)
9908     {
9909       val <<= 8;
9910       val |= *--src & 0xff;
9911       --size;
9912     }
9913   return val;
9914 }
9915
9916 /* Writes floating point values to dw_vec_const array.  */
9917
9918 static void
9919 insert_float (rtx rtl, unsigned char *array)
9920 {
9921   REAL_VALUE_TYPE rv;
9922   long val[4];
9923   int i;
9924
9925   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9926   real_to_target (val, &rv, GET_MODE (rtl));
9927
9928   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9929   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9930     {
9931       insert_int (val[i], 4, array);
9932       array += 4;
9933     }
9934 }
9935
9936 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9937    does not have a "location" either in memory or in a register.  These
9938    things can arise in GNU C when a constant is passed as an actual parameter
9939    to an inlined function.  They can also arise in C++ where declared
9940    constants do not necessarily get memory "homes".  */
9941
9942 static void
9943 add_const_value_attribute (dw_die_ref die, rtx rtl)
9944 {
9945   switch (GET_CODE (rtl))
9946     {
9947     case CONST_INT:
9948       {
9949         HOST_WIDE_INT val = INTVAL (rtl);
9950
9951         if (val < 0)
9952           add_AT_int (die, DW_AT_const_value, val);
9953         else
9954           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9955       }
9956       break;
9957
9958     case CONST_DOUBLE:
9959       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9960          floating-point constant.  A CONST_DOUBLE is used whenever the
9961          constant requires more than one word in order to be adequately
9962          represented.  We output CONST_DOUBLEs as blocks.  */
9963       {
9964         enum machine_mode mode = GET_MODE (rtl);
9965
9966         if (SCALAR_FLOAT_MODE_P (mode))
9967           {
9968             unsigned int length = GET_MODE_SIZE (mode);
9969             unsigned char *array = ggc_alloc (length);
9970
9971             insert_float (rtl, array);
9972             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9973           }
9974         else
9975           {
9976             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9977             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9978
9979             add_AT_long_long (die, DW_AT_const_value,
9980                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9981           }
9982       }
9983       break;
9984
9985     case CONST_VECTOR:
9986       {
9987         enum machine_mode mode = GET_MODE (rtl);
9988         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9989         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9990         unsigned char *array = ggc_alloc (length * elt_size);
9991         unsigned int i;
9992         unsigned char *p;
9993
9994         switch (GET_MODE_CLASS (mode))
9995           {
9996           case MODE_VECTOR_INT:
9997             for (i = 0, p = array; i < length; i++, p += elt_size)
9998               {
9999                 rtx elt = CONST_VECTOR_ELT (rtl, i);
10000                 HOST_WIDE_INT lo, hi;
10001
10002                 switch (GET_CODE (elt))
10003                   {
10004                   case CONST_INT:
10005                     lo = INTVAL (elt);
10006                     hi = -(lo < 0);
10007                     break;
10008
10009                   case CONST_DOUBLE:
10010                     lo = CONST_DOUBLE_LOW (elt);
10011                     hi = CONST_DOUBLE_HIGH (elt);
10012                     break;
10013
10014                   default:
10015                     gcc_unreachable ();
10016                   }
10017
10018                 if (elt_size <= sizeof (HOST_WIDE_INT))
10019                   insert_int (lo, elt_size, p);
10020                 else
10021                   {
10022                     unsigned char *p0 = p;
10023                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
10024
10025                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
10026                     if (WORDS_BIG_ENDIAN)
10027                       {
10028                         p0 = p1;
10029                         p1 = p;
10030                       }
10031                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
10032                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
10033                   }
10034               }
10035             break;
10036
10037           case MODE_VECTOR_FLOAT:
10038             for (i = 0, p = array; i < length; i++, p += elt_size)
10039               {
10040                 rtx elt = CONST_VECTOR_ELT (rtl, i);
10041                 insert_float (elt, p);
10042               }
10043             break;
10044
10045           default:
10046             gcc_unreachable ();
10047           }
10048
10049         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
10050       }
10051       break;
10052
10053     case CONST_STRING:
10054       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
10055       break;
10056
10057     case SYMBOL_REF:
10058     case LABEL_REF:
10059     case CONST:
10060       add_AT_addr (die, DW_AT_const_value, rtl);
10061       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10062       break;
10063
10064     case PLUS:
10065       /* In cases where an inlined instance of an inline function is passed
10066          the address of an `auto' variable (which is local to the caller) we
10067          can get a situation where the DECL_RTL of the artificial local
10068          variable (for the inlining) which acts as a stand-in for the
10069          corresponding formal parameter (of the inline function) will look
10070          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
10071          exactly a compile-time constant expression, but it isn't the address
10072          of the (artificial) local variable either.  Rather, it represents the
10073          *value* which the artificial local variable always has during its
10074          lifetime.  We currently have no way to represent such quasi-constant
10075          values in Dwarf, so for now we just punt and generate nothing.  */
10076       break;
10077
10078     default:
10079       /* No other kinds of rtx should be possible here.  */
10080       gcc_unreachable ();
10081     }
10082
10083 }
10084
10085 /* Determine whether the evaluation of EXPR references any variables
10086    or functions which aren't otherwise used (and therefore may not be
10087    output).  */
10088 static tree
10089 reference_to_unused (tree * tp, int * walk_subtrees,
10090                      void * data ATTRIBUTE_UNUSED)
10091 {
10092   if (! EXPR_P (*tp) && ! GIMPLE_STMT_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10093     *walk_subtrees = 0;
10094
10095   if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10096       && ! TREE_ASM_WRITTEN (*tp))
10097     return *tp;
10098   else if (DECL_P (*tp) && TREE_CODE (*tp) != FUNCTION_DECL)
10099     {
10100       struct varpool_node *node = varpool_node (*tp);
10101       if (!node->needed)
10102         return *tp;
10103     }
10104
10105   return NULL_TREE;
10106 }
10107
10108 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10109    for use in a later add_const_value_attribute call.  */
10110
10111 static rtx
10112 rtl_for_decl_init (tree init, tree type)
10113 {
10114   rtx rtl = NULL_RTX;
10115
10116   /* If a variable is initialized with a string constant without embedded
10117      zeros, build CONST_STRING.  */
10118   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10119     {
10120       tree enttype = TREE_TYPE (type);
10121       tree domain = TYPE_DOMAIN (type);
10122       enum machine_mode mode = TYPE_MODE (enttype);
10123
10124       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10125           && domain
10126           && integer_zerop (TYPE_MIN_VALUE (domain))
10127           && compare_tree_int (TYPE_MAX_VALUE (domain),
10128                                TREE_STRING_LENGTH (init) - 1) == 0
10129           && ((size_t) TREE_STRING_LENGTH (init)
10130               == strlen (TREE_STRING_POINTER (init)) + 1))
10131         rtl = gen_rtx_CONST_STRING (VOIDmode,
10132                                     ggc_strdup (TREE_STRING_POINTER (init)));
10133     }
10134   /* Other aggregates, and complex values, could be represented using
10135      CONCAT: FIXME!  */
10136   else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10137     ;
10138   /* Vectors only work if their mode is supported by the target.
10139      FIXME: generic vectors ought to work too.  */
10140   else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10141     ;
10142   /* If the initializer is something that we know will expand into an
10143      immediate RTL constant, expand it now.  We must be careful not to
10144      reference variables which won't be output.  */
10145   else if (initializer_constant_valid_p (init, type)
10146            && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10147     {
10148       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10149
10150       /* If expand_expr returns a MEM, it wasn't immediate.  */
10151       gcc_assert (!rtl || !MEM_P (rtl));
10152     }
10153
10154   return rtl;
10155 }
10156
10157 /* Generate RTL for the variable DECL to represent its location.  */
10158
10159 static rtx
10160 rtl_for_decl_location (tree decl)
10161 {
10162   rtx rtl;
10163
10164   /* Here we have to decide where we are going to say the parameter "lives"
10165      (as far as the debugger is concerned).  We only have a couple of
10166      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10167
10168      DECL_RTL normally indicates where the parameter lives during most of the
10169      activation of the function.  If optimization is enabled however, this
10170      could be either NULL or else a pseudo-reg.  Both of those cases indicate
10171      that the parameter doesn't really live anywhere (as far as the code
10172      generation parts of GCC are concerned) during most of the function's
10173      activation.  That will happen (for example) if the parameter is never
10174      referenced within the function.
10175
10176      We could just generate a location descriptor here for all non-NULL
10177      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10178      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10179      where DECL_RTL is NULL or is a pseudo-reg.
10180
10181      Note however that we can only get away with using DECL_INCOMING_RTL as
10182      a backup substitute for DECL_RTL in certain limited cases.  In cases
10183      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10184      we can be sure that the parameter was passed using the same type as it is
10185      declared to have within the function, and that its DECL_INCOMING_RTL
10186      points us to a place where a value of that type is passed.
10187
10188      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10189      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10190      because in these cases DECL_INCOMING_RTL points us to a value of some
10191      type which is *different* from the type of the parameter itself.  Thus,
10192      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10193      such cases, the debugger would end up (for example) trying to fetch a
10194      `float' from a place which actually contains the first part of a
10195      `double'.  That would lead to really incorrect and confusing
10196      output at debug-time.
10197
10198      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10199      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
10200      are a couple of exceptions however.  On little-endian machines we can
10201      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10202      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10203      an integral type that is smaller than TREE_TYPE (decl). These cases arise
10204      when (on a little-endian machine) a non-prototyped function has a
10205      parameter declared to be of type `short' or `char'.  In such cases,
10206      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10207      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10208      passed `int' value.  If the debugger then uses that address to fetch
10209      a `short' or a `char' (on a little-endian machine) the result will be
10210      the correct data, so we allow for such exceptional cases below.
10211
10212      Note that our goal here is to describe the place where the given formal
10213      parameter lives during most of the function's activation (i.e. between the
10214      end of the prologue and the start of the epilogue).  We'll do that as best
10215      as we can. Note however that if the given formal parameter is modified
10216      sometime during the execution of the function, then a stack backtrace (at
10217      debug-time) will show the function as having been called with the *new*
10218      value rather than the value which was originally passed in.  This happens
10219      rarely enough that it is not a major problem, but it *is* a problem, and
10220      I'd like to fix it.
10221
10222      A future version of dwarf2out.c may generate two additional attributes for
10223      any given DW_TAG_formal_parameter DIE which will describe the "passed
10224      type" and the "passed location" for the given formal parameter in addition
10225      to the attributes we now generate to indicate the "declared type" and the
10226      "active location" for each parameter.  This additional set of attributes
10227      could be used by debuggers for stack backtraces. Separately, note that
10228      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10229      This happens (for example) for inlined-instances of inline function formal
10230      parameters which are never referenced.  This really shouldn't be
10231      happening.  All PARM_DECL nodes should get valid non-NULL
10232      DECL_INCOMING_RTL values.  FIXME.  */
10233
10234   /* Use DECL_RTL as the "location" unless we find something better.  */
10235   rtl = DECL_RTL_IF_SET (decl);
10236
10237   /* When generating abstract instances, ignore everything except
10238      constants, symbols living in memory, and symbols living in
10239      fixed registers.  */
10240   if (! reload_completed)
10241     {
10242       if (rtl
10243           && (CONSTANT_P (rtl)
10244               || (MEM_P (rtl)
10245                   && CONSTANT_P (XEXP (rtl, 0)))
10246               || (REG_P (rtl)
10247                   && TREE_CODE (decl) == VAR_DECL
10248                   && TREE_STATIC (decl))))
10249         {
10250           rtl = targetm.delegitimize_address (rtl);
10251           return rtl;
10252         }
10253       rtl = NULL_RTX;
10254     }
10255   else if (TREE_CODE (decl) == PARM_DECL)
10256     {
10257       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10258         {
10259           tree declared_type = TREE_TYPE (decl);
10260           tree passed_type = DECL_ARG_TYPE (decl);
10261           enum machine_mode dmode = TYPE_MODE (declared_type);
10262           enum machine_mode pmode = TYPE_MODE (passed_type);
10263
10264           /* This decl represents a formal parameter which was optimized out.
10265              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10266              all cases where (rtl == NULL_RTX) just below.  */
10267           if (dmode == pmode)
10268             rtl = DECL_INCOMING_RTL (decl);
10269           else if (SCALAR_INT_MODE_P (dmode)
10270                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10271                    && DECL_INCOMING_RTL (decl))
10272             {
10273               rtx inc = DECL_INCOMING_RTL (decl);
10274               if (REG_P (inc))
10275                 rtl = inc;
10276               else if (MEM_P (inc))
10277                 {
10278                   if (BYTES_BIG_ENDIAN)
10279                     rtl = adjust_address_nv (inc, dmode,
10280                                              GET_MODE_SIZE (pmode)
10281                                              - GET_MODE_SIZE (dmode));
10282                   else
10283                     rtl = inc;
10284                 }
10285             }
10286         }
10287
10288       /* If the parm was passed in registers, but lives on the stack, then
10289          make a big endian correction if the mode of the type of the
10290          parameter is not the same as the mode of the rtl.  */
10291       /* ??? This is the same series of checks that are made in dbxout.c before
10292          we reach the big endian correction code there.  It isn't clear if all
10293          of these checks are necessary here, but keeping them all is the safe
10294          thing to do.  */
10295       else if (MEM_P (rtl)
10296                && XEXP (rtl, 0) != const0_rtx
10297                && ! CONSTANT_P (XEXP (rtl, 0))
10298                /* Not passed in memory.  */
10299                && !MEM_P (DECL_INCOMING_RTL (decl))
10300                /* Not passed by invisible reference.  */
10301                && (!REG_P (XEXP (rtl, 0))
10302                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10303                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10304 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10305                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10306 #endif
10307                      )
10308                /* Big endian correction check.  */
10309                && BYTES_BIG_ENDIAN
10310                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10311                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10312                    < UNITS_PER_WORD))
10313         {
10314           int offset = (UNITS_PER_WORD
10315                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10316
10317           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10318                              plus_constant (XEXP (rtl, 0), offset));
10319         }
10320     }
10321   else if (TREE_CODE (decl) == VAR_DECL
10322            && rtl
10323            && MEM_P (rtl)
10324            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10325            && BYTES_BIG_ENDIAN)
10326     {
10327       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10328       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10329
10330       /* If a variable is declared "register" yet is smaller than
10331          a register, then if we store the variable to memory, it
10332          looks like we're storing a register-sized value, when in
10333          fact we are not.  We need to adjust the offset of the
10334          storage location to reflect the actual value's bytes,
10335          else gdb will not be able to display it.  */
10336       if (rsize > dsize)
10337         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10338                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10339     }
10340
10341   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10342      and will have been substituted directly into all expressions that use it.
10343      C does not have such a concept, but C++ and other languages do.  */
10344   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10345     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10346
10347   if (rtl)
10348     rtl = targetm.delegitimize_address (rtl);
10349
10350   /* If we don't look past the constant pool, we risk emitting a
10351      reference to a constant pool entry that isn't referenced from
10352      code, and thus is not emitted.  */
10353   if (rtl)
10354     rtl = avoid_constant_pool_reference (rtl);
10355
10356   return rtl;
10357 }
10358
10359 /* We need to figure out what section we should use as the base for the
10360    address ranges where a given location is valid.
10361    1. If this particular DECL has a section associated with it, use that.
10362    2. If this function has a section associated with it, use that.
10363    3. Otherwise, use the text section.
10364    XXX: If you split a variable across multiple sections, we won't notice.  */
10365
10366 static const char *
10367 secname_for_decl (tree decl)
10368 {
10369   const char *secname;
10370
10371   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10372     {
10373       tree sectree = DECL_SECTION_NAME (decl);
10374       secname = TREE_STRING_POINTER (sectree);
10375     }
10376   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10377     {
10378       tree sectree = DECL_SECTION_NAME (current_function_decl);
10379       secname = TREE_STRING_POINTER (sectree);
10380     }
10381   else if (cfun && in_cold_section_p)
10382     secname = cfun->cold_section_label;
10383   else
10384     secname = text_section_label;
10385
10386   return secname;
10387 }
10388
10389 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10390    data attribute for a variable or a parameter.  We generate the
10391    DW_AT_const_value attribute only in those cases where the given variable
10392    or parameter does not have a true "location" either in memory or in a
10393    register.  This can happen (for example) when a constant is passed as an
10394    actual argument in a call to an inline function.  (It's possible that
10395    these things can crop up in other ways also.)  Note that one type of
10396    constant value which can be passed into an inlined function is a constant
10397    pointer.  This can happen for example if an actual argument in an inlined
10398    function call evaluates to a compile-time constant address.  */
10399
10400 static void
10401 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10402                                        enum dwarf_attribute attr)
10403 {
10404   rtx rtl;
10405   dw_loc_descr_ref descr;
10406   var_loc_list *loc_list;
10407   struct var_loc_node *node;
10408   if (TREE_CODE (decl) == ERROR_MARK)
10409     return;
10410
10411   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10412               || TREE_CODE (decl) == RESULT_DECL);
10413
10414   /* See if we possibly have multiple locations for this variable.  */
10415   loc_list = lookup_decl_loc (decl);
10416
10417   /* If it truly has multiple locations, the first and last node will
10418      differ.  */
10419   if (loc_list && loc_list->first != loc_list->last)
10420     {
10421       const char *endname, *secname;
10422       dw_loc_list_ref list;
10423       rtx varloc;
10424
10425       /* Now that we know what section we are using for a base,
10426          actually construct the list of locations.
10427          The first location information is what is passed to the
10428          function that creates the location list, and the remaining
10429          locations just get added on to that list.
10430          Note that we only know the start address for a location
10431          (IE location changes), so to build the range, we use
10432          the range [current location start, next location start].
10433          This means we have to special case the last node, and generate
10434          a range of [last location start, end of function label].  */
10435
10436       node = loc_list->first;
10437       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10438       secname = secname_for_decl (decl);
10439
10440       list = new_loc_list (loc_descriptor (varloc),
10441                            node->label, node->next->label, secname, 1);
10442       node = node->next;
10443
10444       for (; node->next; node = node->next)
10445         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10446           {
10447             /* The variable has a location between NODE->LABEL and
10448                NODE->NEXT->LABEL.  */
10449             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10450             add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10451                                        node->label, node->next->label, secname);
10452           }
10453
10454       /* If the variable has a location at the last label
10455          it keeps its location until the end of function.  */
10456       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10457         {
10458           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10459
10460           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10461           if (!current_function_decl)
10462             endname = text_end_label;
10463           else
10464             {
10465               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10466                                            current_function_funcdef_no);
10467               endname = ggc_strdup (label_id);
10468             }
10469           add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10470                                      node->label, endname, secname);
10471         }
10472
10473       /* Finally, add the location list to the DIE, and we are done.  */
10474       add_AT_loc_list (die, attr, list);
10475       return;
10476     }
10477
10478   /* Try to get some constant RTL for this decl, and use that as the value of
10479      the location.  */
10480
10481   rtl = rtl_for_decl_location (decl);
10482   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10483     {
10484       add_const_value_attribute (die, rtl);
10485       return;
10486     }
10487
10488   /* If we have tried to generate the location otherwise, and it
10489      didn't work out (we wouldn't be here if we did), and we have a one entry
10490      location list, try generating a location from that.  */
10491   if (loc_list && loc_list->first)
10492     {
10493       node = loc_list->first;
10494       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10495       if (descr)
10496         {
10497           add_AT_location_description (die, attr, descr);
10498           return;
10499         }
10500     }
10501
10502   /* We couldn't get any rtl, so try directly generating the location
10503      description from the tree.  */
10504   descr = loc_descriptor_from_tree (decl);
10505   if (descr)
10506     {
10507       add_AT_location_description (die, attr, descr);
10508       return;
10509     }
10510   /* None of that worked, so it must not really have a location;
10511      try adding a constant value attribute from the DECL_INITIAL.  */
10512   tree_add_const_value_attribute (die, decl);
10513 }
10514
10515 /* If we don't have a copy of this variable in memory for some reason (such
10516    as a C++ member constant that doesn't have an out-of-line definition),
10517    we should tell the debugger about the constant value.  */
10518
10519 static void
10520 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10521 {
10522   tree init = DECL_INITIAL (decl);
10523   tree type = TREE_TYPE (decl);
10524   rtx rtl;
10525
10526   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10527     /* OK */;
10528   else
10529     return;
10530
10531   rtl = rtl_for_decl_init (init, type);
10532   if (rtl)
10533     add_const_value_attribute (var_die, rtl);
10534 }
10535
10536 /* Convert the CFI instructions for the current function into a
10537    location list.  This is used for DW_AT_frame_base when we targeting
10538    a dwarf2 consumer that does not support the dwarf3
10539    DW_OP_call_frame_cfa.  OFFSET is a constant to be added to all CFA
10540    expressions.  */
10541
10542 static dw_loc_list_ref
10543 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10544 {
10545   dw_fde_ref fde;
10546   dw_loc_list_ref list, *list_tail;
10547   dw_cfi_ref cfi;
10548   dw_cfa_location last_cfa, next_cfa;
10549   const char *start_label, *last_label, *section;
10550
10551   fde = &fde_table[fde_table_in_use - 1];
10552
10553   section = secname_for_decl (current_function_decl);
10554   list_tail = &list;
10555   list = NULL;
10556
10557   next_cfa.reg = INVALID_REGNUM;
10558   next_cfa.offset = 0;
10559   next_cfa.indirect = 0;
10560   next_cfa.base_offset = 0;
10561
10562   start_label = fde->dw_fde_begin;
10563
10564   /* ??? Bald assumption that the CIE opcode list does not contain
10565      advance opcodes.  */
10566   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10567     lookup_cfa_1 (cfi, &next_cfa);
10568
10569   last_cfa = next_cfa;
10570   last_label = start_label;
10571
10572   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10573     switch (cfi->dw_cfi_opc)
10574       {
10575       case DW_CFA_set_loc:
10576       case DW_CFA_advance_loc1:
10577       case DW_CFA_advance_loc2:
10578       case DW_CFA_advance_loc4:
10579         if (!cfa_equal_p (&last_cfa, &next_cfa))
10580           {
10581             *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10582                                        start_label, last_label, section,
10583                                        list == NULL);
10584
10585             list_tail = &(*list_tail)->dw_loc_next;
10586             last_cfa = next_cfa;
10587             start_label = last_label;
10588           }
10589         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10590         break;
10591
10592       case DW_CFA_advance_loc:
10593         /* The encoding is complex enough that we should never emit this.  */
10594       case DW_CFA_remember_state:
10595       case DW_CFA_restore_state:
10596         /* We don't handle these two in this function.  It would be possible
10597            if it were to be required.  */
10598         gcc_unreachable ();
10599
10600       default:
10601         lookup_cfa_1 (cfi, &next_cfa);
10602         break;
10603       }
10604
10605   if (!cfa_equal_p (&last_cfa, &next_cfa))
10606     {
10607       *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10608                                  start_label, last_label, section,
10609                                  list == NULL);
10610       list_tail = &(*list_tail)->dw_loc_next;
10611       start_label = last_label;
10612     }
10613   *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10614                              start_label, fde->dw_fde_end, section,
10615                              list == NULL);
10616
10617   return list;
10618 }
10619
10620 /* Compute a displacement from the "steady-state frame pointer" to the
10621    frame base (often the same as the CFA), and store it in
10622    frame_pointer_fb_offset.  OFFSET is added to the displacement
10623    before the latter is negated.  */
10624
10625 static void
10626 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10627 {
10628   rtx reg, elim;
10629
10630 #ifdef FRAME_POINTER_CFA_OFFSET
10631   reg = frame_pointer_rtx;
10632   offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10633 #else
10634   reg = arg_pointer_rtx;
10635   offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10636 #endif
10637
10638   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10639   if (GET_CODE (elim) == PLUS)
10640     {
10641       offset += INTVAL (XEXP (elim, 1));
10642       elim = XEXP (elim, 0);
10643     }
10644   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10645                        : stack_pointer_rtx));
10646
10647   frame_pointer_fb_offset = -offset;
10648 }
10649
10650 /* Generate a DW_AT_name attribute given some string value to be included as
10651    the value of the attribute.  */
10652
10653 static void
10654 add_name_attribute (dw_die_ref die, const char *name_string)
10655 {
10656   if (name_string != NULL && *name_string != 0)
10657     {
10658       if (demangle_name_func)
10659         name_string = (*demangle_name_func) (name_string);
10660
10661       add_AT_string (die, DW_AT_name, name_string);
10662     }
10663 }
10664
10665 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10666
10667 static void
10668 add_comp_dir_attribute (dw_die_ref die)
10669 {
10670   const char *wd = get_src_pwd ();
10671   if (wd != NULL)
10672     add_AT_string (die, DW_AT_comp_dir, wd);
10673 }
10674
10675 /* Given a tree node describing an array bound (either lower or upper) output
10676    a representation for that bound.  */
10677
10678 static void
10679 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10680 {
10681   switch (TREE_CODE (bound))
10682     {
10683     case ERROR_MARK:
10684       return;
10685
10686     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10687     case INTEGER_CST:
10688       if (! host_integerp (bound, 0)
10689           || (bound_attr == DW_AT_lower_bound
10690               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10691                   || (is_fortran () && integer_onep (bound)))))
10692         /* Use the default.  */
10693         ;
10694       else
10695         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10696       break;
10697
10698     case CONVERT_EXPR:
10699     case NOP_EXPR:
10700     case NON_LVALUE_EXPR:
10701     case VIEW_CONVERT_EXPR:
10702       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10703       break;
10704
10705     case SAVE_EXPR:
10706       break;
10707
10708     case VAR_DECL:
10709     case PARM_DECL:
10710     case RESULT_DECL:
10711       {
10712         dw_die_ref decl_die = lookup_decl_die (bound);
10713
10714         /* ??? Can this happen, or should the variable have been bound
10715            first?  Probably it can, since I imagine that we try to create
10716            the types of parameters in the order in which they exist in
10717            the list, and won't have created a forward reference to a
10718            later parameter.  */
10719         if (decl_die != NULL)
10720           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10721         break;
10722       }
10723
10724     default:
10725       {
10726         /* Otherwise try to create a stack operation procedure to
10727            evaluate the value of the array bound.  */
10728
10729         dw_die_ref ctx, decl_die;
10730         dw_loc_descr_ref loc;
10731
10732         loc = loc_descriptor_from_tree (bound);
10733         if (loc == NULL)
10734           break;
10735
10736         if (current_function_decl == 0)
10737           ctx = comp_unit_die;
10738         else
10739           ctx = lookup_decl_die (current_function_decl);
10740
10741         decl_die = new_die (DW_TAG_variable, ctx, bound);
10742         add_AT_flag (decl_die, DW_AT_artificial, 1);
10743         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10744         add_AT_loc (decl_die, DW_AT_location, loc);
10745
10746         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10747         break;
10748       }
10749     }
10750 }
10751
10752 /* Note that the block of subscript information for an array type also
10753    includes information about the element type of type given array type.  */
10754
10755 static void
10756 add_subscript_info (dw_die_ref type_die, tree type)
10757 {
10758 #ifndef MIPS_DEBUGGING_INFO
10759   unsigned dimension_number;
10760 #endif
10761   tree lower, upper;
10762   dw_die_ref subrange_die;
10763
10764   /* The GNU compilers represent multidimensional array types as sequences of
10765      one dimensional array types whose element types are themselves array
10766      types.  Here we squish that down, so that each multidimensional array
10767      type gets only one array_type DIE in the Dwarf debugging info. The draft
10768      Dwarf specification say that we are allowed to do this kind of
10769      compression in C (because there is no difference between an array or
10770      arrays and a multidimensional array in C) but for other source languages
10771      (e.g. Ada) we probably shouldn't do this.  */
10772
10773   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10774      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10775      We work around this by disabling this feature.  See also
10776      gen_array_type_die.  */
10777 #ifndef MIPS_DEBUGGING_INFO
10778   for (dimension_number = 0;
10779        TREE_CODE (type) == ARRAY_TYPE;
10780        type = TREE_TYPE (type), dimension_number++)
10781 #endif
10782     {
10783       tree domain = TYPE_DOMAIN (type);
10784
10785       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10786          and (in GNU C only) variable bounds.  Handle all three forms
10787          here.  */
10788       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10789       if (domain)
10790         {
10791           /* We have an array type with specified bounds.  */
10792           lower = TYPE_MIN_VALUE (domain);
10793           upper = TYPE_MAX_VALUE (domain);
10794
10795           /* Define the index type.  */
10796           if (TREE_TYPE (domain))
10797             {
10798               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10799                  TREE_TYPE field.  We can't emit debug info for this
10800                  because it is an unnamed integral type.  */
10801               if (TREE_CODE (domain) == INTEGER_TYPE
10802                   && TYPE_NAME (domain) == NULL_TREE
10803                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10804                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10805                 ;
10806               else
10807                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10808                                     type_die);
10809             }
10810
10811           /* ??? If upper is NULL, the array has unspecified length,
10812              but it does have a lower bound.  This happens with Fortran
10813                dimension arr(N:*)
10814              Since the debugger is definitely going to need to know N
10815              to produce useful results, go ahead and output the lower
10816              bound solo, and hope the debugger can cope.  */
10817
10818           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10819           if (upper)
10820             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10821         }
10822
10823       /* Otherwise we have an array type with an unspecified length.  The
10824          DWARF-2 spec does not say how to handle this; let's just leave out the
10825          bounds.  */
10826     }
10827 }
10828
10829 static void
10830 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10831 {
10832   unsigned size;
10833
10834   switch (TREE_CODE (tree_node))
10835     {
10836     case ERROR_MARK:
10837       size = 0;
10838       break;
10839     case ENUMERAL_TYPE:
10840     case RECORD_TYPE:
10841     case UNION_TYPE:
10842     case QUAL_UNION_TYPE:
10843       size = int_size_in_bytes (tree_node);
10844       break;
10845     case FIELD_DECL:
10846       /* For a data member of a struct or union, the DW_AT_byte_size is
10847          generally given as the number of bytes normally allocated for an
10848          object of the *declared* type of the member itself.  This is true
10849          even for bit-fields.  */
10850       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10851       break;
10852     default:
10853       gcc_unreachable ();
10854     }
10855
10856   /* Note that `size' might be -1 when we get to this point.  If it is, that
10857      indicates that the byte size of the entity in question is variable.  We
10858      have no good way of expressing this fact in Dwarf at the present time,
10859      so just let the -1 pass on through.  */
10860   add_AT_unsigned (die, DW_AT_byte_size, size);
10861 }
10862
10863 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10864    which specifies the distance in bits from the highest order bit of the
10865    "containing object" for the bit-field to the highest order bit of the
10866    bit-field itself.
10867
10868    For any given bit-field, the "containing object" is a hypothetical object
10869    (of some integral or enum type) within which the given bit-field lives.  The
10870    type of this hypothetical "containing object" is always the same as the
10871    declared type of the individual bit-field itself.  The determination of the
10872    exact location of the "containing object" for a bit-field is rather
10873    complicated.  It's handled by the `field_byte_offset' function (above).
10874
10875    Note that it is the size (in bytes) of the hypothetical "containing object"
10876    which will be given in the DW_AT_byte_size attribute for this bit-field.
10877    (See `byte_size_attribute' above).  */
10878
10879 static inline void
10880 add_bit_offset_attribute (dw_die_ref die, tree decl)
10881 {
10882   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10883   tree type = DECL_BIT_FIELD_TYPE (decl);
10884   HOST_WIDE_INT bitpos_int;
10885   HOST_WIDE_INT highest_order_object_bit_offset;
10886   HOST_WIDE_INT highest_order_field_bit_offset;
10887   HOST_WIDE_INT unsigned bit_offset;
10888
10889   /* Must be a field and a bit field.  */
10890   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10891
10892   /* We can't yet handle bit-fields whose offsets are variable, so if we
10893      encounter such things, just return without generating any attribute
10894      whatsoever.  Likewise for variable or too large size.  */
10895   if (! host_integerp (bit_position (decl), 0)
10896       || ! host_integerp (DECL_SIZE (decl), 1))
10897     return;
10898
10899   bitpos_int = int_bit_position (decl);
10900
10901   /* Note that the bit offset is always the distance (in bits) from the
10902      highest-order bit of the "containing object" to the highest-order bit of
10903      the bit-field itself.  Since the "high-order end" of any object or field
10904      is different on big-endian and little-endian machines, the computation
10905      below must take account of these differences.  */
10906   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10907   highest_order_field_bit_offset = bitpos_int;
10908
10909   if (! BYTES_BIG_ENDIAN)
10910     {
10911       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10912       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10913     }
10914
10915   bit_offset
10916     = (! BYTES_BIG_ENDIAN
10917        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10918        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10919
10920   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10921 }
10922
10923 /* For a FIELD_DECL node which represents a bit field, output an attribute
10924    which specifies the length in bits of the given field.  */
10925
10926 static inline void
10927 add_bit_size_attribute (dw_die_ref die, tree decl)
10928 {
10929   /* Must be a field and a bit field.  */
10930   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10931               && DECL_BIT_FIELD_TYPE (decl));
10932
10933   if (host_integerp (DECL_SIZE (decl), 1))
10934     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10935 }
10936
10937 /* If the compiled language is ANSI C, then add a 'prototyped'
10938    attribute, if arg types are given for the parameters of a function.  */
10939
10940 static inline void
10941 add_prototyped_attribute (dw_die_ref die, tree func_type)
10942 {
10943   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10944       && TYPE_ARG_TYPES (func_type) != NULL)
10945     add_AT_flag (die, DW_AT_prototyped, 1);
10946 }
10947
10948 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10949    by looking in either the type declaration or object declaration
10950    equate table.  */
10951
10952 static inline void
10953 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10954 {
10955   dw_die_ref origin_die = NULL;
10956
10957   if (TREE_CODE (origin) != FUNCTION_DECL)
10958     {
10959       /* We may have gotten separated from the block for the inlined
10960          function, if we're in an exception handler or some such; make
10961          sure that the abstract function has been written out.
10962
10963          Doing this for nested functions is wrong, however; functions are
10964          distinct units, and our context might not even be inline.  */
10965       tree fn = origin;
10966
10967       if (TYPE_P (fn))
10968         fn = TYPE_STUB_DECL (fn);
10969
10970       fn = decl_function_context (fn);
10971       if (fn)
10972         dwarf2out_abstract_function (fn);
10973     }
10974
10975   if (DECL_P (origin))
10976     origin_die = lookup_decl_die (origin);
10977   else if (TYPE_P (origin))
10978     origin_die = lookup_type_die (origin);
10979
10980   /* XXX: Functions that are never lowered don't always have correct block
10981      trees (in the case of java, they simply have no block tree, in some other
10982      languages).  For these functions, there is nothing we can really do to
10983      output correct debug info for inlined functions in all cases.  Rather
10984      than die, we'll just produce deficient debug info now, in that we will
10985      have variables without a proper abstract origin.  In the future, when all
10986      functions are lowered, we should re-add a gcc_assert (origin_die)
10987      here.  */
10988
10989   if (origin_die)
10990       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10991 }
10992
10993 /* We do not currently support the pure_virtual attribute.  */
10994
10995 static inline void
10996 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10997 {
10998   if (DECL_VINDEX (func_decl))
10999     {
11000       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11001
11002       if (host_integerp (DECL_VINDEX (func_decl), 0))
11003         add_AT_loc (die, DW_AT_vtable_elem_location,
11004                     new_loc_descr (DW_OP_constu,
11005                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
11006                                    0));
11007
11008       /* GNU extension: Record what type this method came from originally.  */
11009       if (debug_info_level > DINFO_LEVEL_TERSE)
11010         add_AT_die_ref (die, DW_AT_containing_type,
11011                         lookup_type_die (DECL_CONTEXT (func_decl)));
11012     }
11013 }
11014 \f
11015 /* Add source coordinate attributes for the given decl.  */
11016
11017 static void
11018 add_src_coords_attributes (dw_die_ref die, tree decl)
11019 {
11020   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11021
11022   add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
11023   add_AT_unsigned (die, DW_AT_decl_line, s.line);
11024 }
11025
11026 /* Add a DW_AT_name attribute and source coordinate attribute for the
11027    given decl, but only if it actually has a name.  */
11028
11029 static void
11030 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
11031 {
11032   tree decl_name;
11033
11034   decl_name = DECL_NAME (decl);
11035   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
11036     {
11037       add_name_attribute (die, dwarf2_name (decl, 0));
11038       if (! DECL_ARTIFICIAL (decl))
11039         add_src_coords_attributes (die, decl);
11040
11041       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
11042           && TREE_PUBLIC (decl)
11043           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
11044           && !DECL_ABSTRACT (decl)
11045           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
11046         add_AT_string (die, DW_AT_MIPS_linkage_name,
11047                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
11048     }
11049
11050 #ifdef VMS_DEBUGGING_INFO
11051   /* Get the function's name, as described by its RTL.  This may be different
11052      from the DECL_NAME name used in the source file.  */
11053   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
11054     {
11055       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
11056                    XEXP (DECL_RTL (decl), 0));
11057       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
11058     }
11059 #endif
11060 }
11061
11062 /* Push a new declaration scope.  */
11063
11064 static void
11065 push_decl_scope (tree scope)
11066 {
11067   VEC_safe_push (tree, gc, decl_scope_table, scope);
11068 }
11069
11070 /* Pop a declaration scope.  */
11071
11072 static inline void
11073 pop_decl_scope (void)
11074 {
11075   VEC_pop (tree, decl_scope_table);
11076 }
11077
11078 /* Return the DIE for the scope that immediately contains this type.
11079    Non-named types get global scope.  Named types nested in other
11080    types get their containing scope if it's open, or global scope
11081    otherwise.  All other types (i.e. function-local named types) get
11082    the current active scope.  */
11083
11084 static dw_die_ref
11085 scope_die_for (tree t, dw_die_ref context_die)
11086 {
11087   dw_die_ref scope_die = NULL;
11088   tree containing_scope;
11089   int i;
11090
11091   /* Non-types always go in the current scope.  */
11092   gcc_assert (TYPE_P (t));
11093
11094   containing_scope = TYPE_CONTEXT (t);
11095
11096   /* Use the containing namespace if it was passed in (for a declaration).  */
11097   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11098     {
11099       if (context_die == lookup_decl_die (containing_scope))
11100         /* OK */;
11101       else
11102         containing_scope = NULL_TREE;
11103     }
11104
11105   /* Ignore function type "scopes" from the C frontend.  They mean that
11106      a tagged type is local to a parmlist of a function declarator, but
11107      that isn't useful to DWARF.  */
11108   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11109     containing_scope = NULL_TREE;
11110
11111   if (containing_scope == NULL_TREE)
11112     scope_die = comp_unit_die;
11113   else if (TYPE_P (containing_scope))
11114     {
11115       /* For types, we can just look up the appropriate DIE.  But
11116          first we check to see if we're in the middle of emitting it
11117          so we know where the new DIE should go.  */
11118       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11119         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11120           break;
11121
11122       if (i < 0)
11123         {
11124           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11125                       || TREE_ASM_WRITTEN (containing_scope));
11126
11127           /* If none of the current dies are suitable, we get file scope.  */
11128           scope_die = comp_unit_die;
11129         }
11130       else
11131         scope_die = lookup_type_die (containing_scope);
11132     }
11133   else
11134     scope_die = context_die;
11135
11136   return scope_die;
11137 }
11138
11139 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
11140
11141 static inline int
11142 local_scope_p (dw_die_ref context_die)
11143 {
11144   for (; context_die; context_die = context_die->die_parent)
11145     if (context_die->die_tag == DW_TAG_inlined_subroutine
11146         || context_die->die_tag == DW_TAG_subprogram)
11147       return 1;
11148
11149   return 0;
11150 }
11151
11152 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11153    whether or not to treat a DIE in this context as a declaration.  */
11154
11155 static inline int
11156 class_or_namespace_scope_p (dw_die_ref context_die)
11157 {
11158   return (context_die
11159           && (context_die->die_tag == DW_TAG_structure_type
11160               || context_die->die_tag == DW_TAG_union_type
11161               || context_die->die_tag == DW_TAG_namespace));
11162 }
11163
11164 /* Many forms of DIEs require a "type description" attribute.  This
11165    routine locates the proper "type descriptor" die for the type given
11166    by 'type', and adds a DW_AT_type attribute below the given die.  */
11167
11168 static void
11169 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11170                     int decl_volatile, dw_die_ref context_die)
11171 {
11172   enum tree_code code  = TREE_CODE (type);
11173   dw_die_ref type_die  = NULL;
11174
11175   /* ??? If this type is an unnamed subrange type of an integral or
11176      floating-point type, use the inner type.  This is because we have no
11177      support for unnamed types in base_type_die.  This can happen if this is
11178      an Ada subrange type.  Correct solution is emit a subrange type die.  */
11179   if ((code == INTEGER_TYPE || code == REAL_TYPE)
11180       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11181     type = TREE_TYPE (type), code = TREE_CODE (type);
11182
11183   if (code == ERROR_MARK
11184       /* Handle a special case.  For functions whose return type is void, we
11185          generate *no* type attribute.  (Note that no object may have type
11186          `void', so this only applies to function return types).  */
11187       || code == VOID_TYPE)
11188     return;
11189
11190   type_die = modified_type_die (type,
11191                                 decl_const || TYPE_READONLY (type),
11192                                 decl_volatile || TYPE_VOLATILE (type),
11193                                 context_die);
11194
11195   if (type_die != NULL)
11196     add_AT_die_ref (object_die, DW_AT_type, type_die);
11197 }
11198
11199 /* Given an object die, add the calling convention attribute for the
11200    function call type.  */
11201 static void
11202 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11203 {
11204   enum dwarf_calling_convention value = DW_CC_normal;
11205
11206   value = targetm.dwarf_calling_convention (type);
11207
11208   /* Only add the attribute if the backend requests it, and
11209      is not DW_CC_normal.  */
11210   if (value && (value != DW_CC_normal))
11211     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11212 }
11213
11214 /* Given a tree pointer to a struct, class, union, or enum type node, return
11215    a pointer to the (string) tag name for the given type, or zero if the type
11216    was declared without a tag.  */
11217
11218 static const char *
11219 type_tag (tree type)
11220 {
11221   const char *name = 0;
11222
11223   if (TYPE_NAME (type) != 0)
11224     {
11225       tree t = 0;
11226
11227       /* Find the IDENTIFIER_NODE for the type name.  */
11228       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11229         t = TYPE_NAME (type);
11230
11231       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11232          a TYPE_DECL node, regardless of whether or not a `typedef' was
11233          involved.  */
11234       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11235                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11236         t = DECL_NAME (TYPE_NAME (type));
11237
11238       /* Now get the name as a string, or invent one.  */
11239       if (t != 0)
11240         name = IDENTIFIER_POINTER (t);
11241     }
11242
11243   return (name == 0 || *name == '\0') ? 0 : name;
11244 }
11245
11246 /* Return the type associated with a data member, make a special check
11247    for bit field types.  */
11248
11249 static inline tree
11250 member_declared_type (tree member)
11251 {
11252   return (DECL_BIT_FIELD_TYPE (member)
11253           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11254 }
11255
11256 /* Get the decl's label, as described by its RTL. This may be different
11257    from the DECL_NAME name used in the source file.  */
11258
11259 #if 0
11260 static const char *
11261 decl_start_label (tree decl)
11262 {
11263   rtx x;
11264   const char *fnname;
11265
11266   x = DECL_RTL (decl);
11267   gcc_assert (MEM_P (x));
11268
11269   x = XEXP (x, 0);
11270   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11271
11272   fnname = XSTR (x, 0);
11273   return fnname;
11274 }
11275 #endif
11276 \f
11277 /* These routines generate the internal representation of the DIE's for
11278    the compilation unit.  Debugging information is collected by walking
11279    the declaration trees passed in from dwarf2out_decl().  */
11280
11281 static void
11282 gen_array_type_die (tree type, dw_die_ref context_die)
11283 {
11284   dw_die_ref scope_die = scope_die_for (type, context_die);
11285   dw_die_ref array_die;
11286   tree element_type;
11287
11288   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11289      the inner array type comes before the outer array type.  Thus we must
11290      call gen_type_die before we call new_die.  See below also.  */
11291 #ifdef MIPS_DEBUGGING_INFO
11292   gen_type_die (TREE_TYPE (type), context_die);
11293 #endif
11294
11295   array_die = new_die (DW_TAG_array_type, scope_die, type);
11296   add_name_attribute (array_die, type_tag (type));
11297   equate_type_number_to_die (type, array_die);
11298
11299   if (TREE_CODE (type) == VECTOR_TYPE)
11300     {
11301       /* The frontend feeds us a representation for the vector as a struct
11302          containing an array.  Pull out the array type.  */
11303       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11304       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11305     }
11306
11307 #if 0
11308   /* We default the array ordering.  SDB will probably do
11309      the right things even if DW_AT_ordering is not present.  It's not even
11310      an issue until we start to get into multidimensional arrays anyway.  If
11311      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11312      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11313      and when we find out that we need to put these in, we will only do so
11314      for multidimensional arrays.  */
11315   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11316 #endif
11317
11318 #ifdef MIPS_DEBUGGING_INFO
11319   /* The SGI compilers handle arrays of unknown bound by setting
11320      AT_declaration and not emitting any subrange DIEs.  */
11321   if (! TYPE_DOMAIN (type))
11322     add_AT_flag (array_die, DW_AT_declaration, 1);
11323   else
11324 #endif
11325     add_subscript_info (array_die, type);
11326
11327   /* Add representation of the type of the elements of this array type.  */
11328   element_type = TREE_TYPE (type);
11329
11330   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11331      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11332      We work around this by disabling this feature.  See also
11333      add_subscript_info.  */
11334 #ifndef MIPS_DEBUGGING_INFO
11335   while (TREE_CODE (element_type) == ARRAY_TYPE)
11336     element_type = TREE_TYPE (element_type);
11337
11338   gen_type_die (element_type, context_die);
11339 #endif
11340
11341   add_type_attribute (array_die, element_type, 0, 0, context_die);
11342
11343   if (get_AT (array_die, DW_AT_name))
11344     add_pubtype (type, array_die);
11345 }
11346
11347 #if 0
11348 static void
11349 gen_entry_point_die (tree decl, dw_die_ref context_die)
11350 {
11351   tree origin = decl_ultimate_origin (decl);
11352   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11353
11354   if (origin != NULL)
11355     add_abstract_origin_attribute (decl_die, origin);
11356   else
11357     {
11358       add_name_and_src_coords_attributes (decl_die, decl);
11359       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11360                           0, 0, context_die);
11361     }
11362
11363   if (DECL_ABSTRACT (decl))
11364     equate_decl_number_to_die (decl, decl_die);
11365   else
11366     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11367 }
11368 #endif
11369
11370 /* Walk through the list of incomplete types again, trying once more to
11371    emit full debugging info for them.  */
11372
11373 static void
11374 retry_incomplete_types (void)
11375 {
11376   int i;
11377
11378   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11379     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11380 }
11381
11382 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11383
11384 static void
11385 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11386 {
11387   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11388
11389   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11390      be incomplete and such types are not marked.  */
11391   add_abstract_origin_attribute (type_die, type);
11392 }
11393
11394 /* Generate a DIE to represent an inlined instance of a structure type.  */
11395
11396 static void
11397 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11398 {
11399   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11400
11401   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11402      be incomplete and such types are not marked.  */
11403   add_abstract_origin_attribute (type_die, type);
11404 }
11405
11406 /* Generate a DIE to represent an inlined instance of a union type.  */
11407
11408 static void
11409 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11410 {
11411   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11412
11413   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11414      be incomplete and such types are not marked.  */
11415   add_abstract_origin_attribute (type_die, type);
11416 }
11417
11418 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11419    include all of the information about the enumeration values also. Each
11420    enumerated type name/value is listed as a child of the enumerated type
11421    DIE.  */
11422
11423 static dw_die_ref
11424 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11425 {
11426   dw_die_ref type_die = lookup_type_die (type);
11427
11428   if (type_die == NULL)
11429     {
11430       type_die = new_die (DW_TAG_enumeration_type,
11431                           scope_die_for (type, context_die), type);
11432       equate_type_number_to_die (type, type_die);
11433       add_name_attribute (type_die, type_tag (type));
11434     }
11435   else if (! TYPE_SIZE (type))
11436     return type_die;
11437   else
11438     remove_AT (type_die, DW_AT_declaration);
11439
11440   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11441      given enum type is incomplete, do not generate the DW_AT_byte_size
11442      attribute or the DW_AT_element_list attribute.  */
11443   if (TYPE_SIZE (type))
11444     {
11445       tree link;
11446
11447       TREE_ASM_WRITTEN (type) = 1;
11448       add_byte_size_attribute (type_die, type);
11449       if (TYPE_STUB_DECL (type) != NULL_TREE)
11450         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11451
11452       /* If the first reference to this type was as the return type of an
11453          inline function, then it may not have a parent.  Fix this now.  */
11454       if (type_die->die_parent == NULL)
11455         add_child_die (scope_die_for (type, context_die), type_die);
11456
11457       for (link = TYPE_VALUES (type);
11458            link != NULL; link = TREE_CHAIN (link))
11459         {
11460           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11461           tree value = TREE_VALUE (link);
11462
11463           add_name_attribute (enum_die,
11464                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11465
11466           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11467             /* DWARF2 does not provide a way of indicating whether or
11468                not enumeration constants are signed or unsigned.  GDB
11469                always assumes the values are signed, so we output all
11470                values as if they were signed.  That means that
11471                enumeration constants with very large unsigned values
11472                will appear to have negative values in the debugger.  */
11473             add_AT_int (enum_die, DW_AT_const_value,
11474                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11475         }
11476     }
11477   else
11478     add_AT_flag (type_die, DW_AT_declaration, 1);
11479
11480   if (get_AT (type_die, DW_AT_name))
11481     add_pubtype (type, type_die);
11482
11483   return type_die;
11484 }
11485
11486 /* Generate a DIE to represent either a real live formal parameter decl or to
11487    represent just the type of some formal parameter position in some function
11488    type.
11489
11490    Note that this routine is a bit unusual because its argument may be a
11491    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11492    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11493    node.  If it's the former then this function is being called to output a
11494    DIE to represent a formal parameter object (or some inlining thereof).  If
11495    it's the latter, then this function is only being called to output a
11496    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11497    argument type of some subprogram type.  */
11498
11499 static dw_die_ref
11500 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11501 {
11502   dw_die_ref parm_die
11503     = new_die (DW_TAG_formal_parameter, context_die, node);
11504   tree origin;
11505
11506   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11507     {
11508     case tcc_declaration:
11509       origin = decl_ultimate_origin (node);
11510       if (origin != NULL)
11511         add_abstract_origin_attribute (parm_die, origin);
11512       else
11513         {
11514           add_name_and_src_coords_attributes (parm_die, node);
11515           add_type_attribute (parm_die, TREE_TYPE (node),
11516                               TREE_READONLY (node),
11517                               TREE_THIS_VOLATILE (node),
11518                               context_die);
11519           if (DECL_ARTIFICIAL (node))
11520             add_AT_flag (parm_die, DW_AT_artificial, 1);
11521         }
11522
11523       equate_decl_number_to_die (node, parm_die);
11524       if (! DECL_ABSTRACT (node))
11525         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11526
11527       break;
11528
11529     case tcc_type:
11530       /* We were called with some kind of a ..._TYPE node.  */
11531       add_type_attribute (parm_die, node, 0, 0, context_die);
11532       break;
11533
11534     default:
11535       gcc_unreachable ();
11536     }
11537
11538   return parm_die;
11539 }
11540
11541 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11542    at the end of an (ANSI prototyped) formal parameters list.  */
11543
11544 static void
11545 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11546 {
11547   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11548 }
11549
11550 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11551    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11552    parameters as specified in some function type specification (except for
11553    those which appear as part of a function *definition*).  */
11554
11555 static void
11556 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11557 {
11558   tree link;
11559   tree formal_type = NULL;
11560   tree first_parm_type;
11561   tree arg;
11562
11563   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11564     {
11565       arg = DECL_ARGUMENTS (function_or_method_type);
11566       function_or_method_type = TREE_TYPE (function_or_method_type);
11567     }
11568   else
11569     arg = NULL_TREE;
11570
11571   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11572
11573   /* Make our first pass over the list of formal parameter types and output a
11574      DW_TAG_formal_parameter DIE for each one.  */
11575   for (link = first_parm_type; link; )
11576     {
11577       dw_die_ref parm_die;
11578
11579       formal_type = TREE_VALUE (link);
11580       if (formal_type == void_type_node)
11581         break;
11582
11583       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11584       parm_die = gen_formal_parameter_die (formal_type, context_die);
11585       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11586            && link == first_parm_type)
11587           || (arg && DECL_ARTIFICIAL (arg)))
11588         add_AT_flag (parm_die, DW_AT_artificial, 1);
11589
11590       link = TREE_CHAIN (link);
11591       if (arg)
11592         arg = TREE_CHAIN (arg);
11593     }
11594
11595   /* If this function type has an ellipsis, add a
11596      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11597   if (formal_type != void_type_node)
11598     gen_unspecified_parameters_die (function_or_method_type, context_die);
11599
11600   /* Make our second (and final) pass over the list of formal parameter types
11601      and output DIEs to represent those types (as necessary).  */
11602   for (link = TYPE_ARG_TYPES (function_or_method_type);
11603        link && TREE_VALUE (link);
11604        link = TREE_CHAIN (link))
11605     gen_type_die (TREE_VALUE (link), context_die);
11606 }
11607
11608 /* We want to generate the DIE for TYPE so that we can generate the
11609    die for MEMBER, which has been defined; we will need to refer back
11610    to the member declaration nested within TYPE.  If we're trying to
11611    generate minimal debug info for TYPE, processing TYPE won't do the
11612    trick; we need to attach the member declaration by hand.  */
11613
11614 static void
11615 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11616 {
11617   gen_type_die (type, context_die);
11618
11619   /* If we're trying to avoid duplicate debug info, we may not have
11620      emitted the member decl for this function.  Emit it now.  */
11621   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11622       && ! lookup_decl_die (member))
11623     {
11624       dw_die_ref type_die;
11625       gcc_assert (!decl_ultimate_origin (member));
11626
11627       push_decl_scope (type);
11628       type_die = lookup_type_die (type);
11629       if (TREE_CODE (member) == FUNCTION_DECL)
11630         gen_subprogram_die (member, type_die);
11631       else if (TREE_CODE (member) == FIELD_DECL)
11632         {
11633           /* Ignore the nameless fields that are used to skip bits but handle
11634              C++ anonymous unions and structs.  */
11635           if (DECL_NAME (member) != NULL_TREE
11636               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11637               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11638             {
11639               gen_type_die (member_declared_type (member), type_die);
11640               gen_field_die (member, type_die);
11641             }
11642         }
11643       else
11644         gen_variable_die (member, type_die);
11645
11646       pop_decl_scope ();
11647     }
11648 }
11649
11650 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11651    may later generate inlined and/or out-of-line instances of.  */
11652
11653 static void
11654 dwarf2out_abstract_function (tree decl)
11655 {
11656   dw_die_ref old_die;
11657   tree save_fn;
11658   struct function *save_cfun;
11659   tree context;
11660   int was_abstract = DECL_ABSTRACT (decl);
11661
11662   /* Make sure we have the actual abstract inline, not a clone.  */
11663   decl = DECL_ORIGIN (decl);
11664
11665   old_die = lookup_decl_die (decl);
11666   if (old_die && get_AT (old_die, DW_AT_inline))
11667     /* We've already generated the abstract instance.  */
11668     return;
11669
11670   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11671      we don't get confused by DECL_ABSTRACT.  */
11672   if (debug_info_level > DINFO_LEVEL_TERSE)
11673     {
11674       context = decl_class_context (decl);
11675       if (context)
11676         gen_type_die_for_member
11677           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11678     }
11679
11680   /* Pretend we've just finished compiling this function.  */
11681   save_fn = current_function_decl;
11682   save_cfun = cfun;
11683   current_function_decl = decl;
11684   cfun = DECL_STRUCT_FUNCTION (decl);
11685
11686   set_decl_abstract_flags (decl, 1);
11687   dwarf2out_decl (decl);
11688   if (! was_abstract)
11689     set_decl_abstract_flags (decl, 0);
11690
11691   current_function_decl = save_fn;
11692   cfun = save_cfun;
11693 }
11694
11695 /* Helper function of premark_used_types() which gets called through
11696    htab_traverse_resize().
11697
11698    Marks the DIE of a given type in *SLOT as perennial, so it never gets
11699    marked as unused by prune_unused_types.  */
11700 static int
11701 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
11702 {
11703   tree type;
11704   dw_die_ref die;
11705
11706   type = *slot;
11707   die = lookup_type_die (type);
11708   if (die != NULL)
11709     die->die_perennial_p = 1;
11710   return 1;
11711 }
11712
11713 /* Mark all members of used_types_hash as perennial.  */
11714 static void
11715 premark_used_types (void)
11716 {
11717   if (cfun && cfun->used_types_hash)
11718     htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
11719 }
11720
11721 /* Generate a DIE to represent a declared function (either file-scope or
11722    block-local).  */
11723
11724 static void
11725 gen_subprogram_die (tree decl, dw_die_ref context_die)
11726 {
11727   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11728   tree origin = decl_ultimate_origin (decl);
11729   dw_die_ref subr_die;
11730   tree fn_arg_types;
11731   tree outer_scope;
11732   dw_die_ref old_die = lookup_decl_die (decl);
11733   int declaration = (current_function_decl != decl
11734                      || class_or_namespace_scope_p (context_die));
11735
11736   premark_used_types ();
11737
11738   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11739      started to generate the abstract instance of an inline, decided to output
11740      its containing class, and proceeded to emit the declaration of the inline
11741      from the member list for the class.  If so, DECLARATION takes priority;
11742      we'll get back to the abstract instance when done with the class.  */
11743
11744   /* The class-scope declaration DIE must be the primary DIE.  */
11745   if (origin && declaration && class_or_namespace_scope_p (context_die))
11746     {
11747       origin = NULL;
11748       gcc_assert (!old_die);
11749     }
11750
11751   /* Now that the C++ front end lazily declares artificial member fns, we
11752      might need to retrofit the declaration into its class.  */
11753   if (!declaration && !origin && !old_die
11754       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11755       && !class_or_namespace_scope_p (context_die)
11756       && debug_info_level > DINFO_LEVEL_TERSE)
11757     old_die = force_decl_die (decl);
11758
11759   if (origin != NULL)
11760     {
11761       gcc_assert (!declaration || local_scope_p (context_die));
11762
11763       /* Fixup die_parent for the abstract instance of a nested
11764          inline function.  */
11765       if (old_die && old_die->die_parent == NULL)
11766         add_child_die (context_die, old_die);
11767
11768       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11769       add_abstract_origin_attribute (subr_die, origin);
11770     }
11771   else if (old_die)
11772     {
11773       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11774       struct dwarf_file_data * file_index = lookup_filename (s.file);
11775
11776       if (!get_AT_flag (old_die, DW_AT_declaration)
11777           /* We can have a normal definition following an inline one in the
11778              case of redefinition of GNU C extern inlines.
11779              It seems reasonable to use AT_specification in this case.  */
11780           && !get_AT (old_die, DW_AT_inline))
11781         {
11782           /* Detect and ignore this case, where we are trying to output
11783              something we have already output.  */
11784           return;
11785         }
11786
11787       /* If the definition comes from the same place as the declaration,
11788          maybe use the old DIE.  We always want the DIE for this function
11789          that has the *_pc attributes to be under comp_unit_die so the
11790          debugger can find it.  We also need to do this for abstract
11791          instances of inlines, since the spec requires the out-of-line copy
11792          to have the same parent.  For local class methods, this doesn't
11793          apply; we just use the old DIE.  */
11794       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11795           && (DECL_ARTIFICIAL (decl)
11796               || (get_AT_file (old_die, DW_AT_decl_file) == file_index
11797                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11798                       == (unsigned) s.line))))
11799         {
11800           subr_die = old_die;
11801
11802           /* Clear out the declaration attribute and the formal parameters.
11803              Do not remove all children, because it is possible that this
11804              declaration die was forced using force_decl_die(). In such
11805              cases die that forced declaration die (e.g. TAG_imported_module)
11806              is one of the children that we do not want to remove.  */
11807           remove_AT (subr_die, DW_AT_declaration);
11808           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11809         }
11810       else
11811         {
11812           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11813           add_AT_specification (subr_die, old_die);
11814           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
11815             add_AT_file (subr_die, DW_AT_decl_file, file_index);
11816           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
11817             add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
11818         }
11819     }
11820   else
11821     {
11822       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11823
11824       if (TREE_PUBLIC (decl))
11825         add_AT_flag (subr_die, DW_AT_external, 1);
11826
11827       add_name_and_src_coords_attributes (subr_die, decl);
11828       if (debug_info_level > DINFO_LEVEL_TERSE)
11829         {
11830           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11831           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11832                               0, 0, context_die);
11833         }
11834
11835       add_pure_or_virtual_attribute (subr_die, decl);
11836       if (DECL_ARTIFICIAL (decl))
11837         add_AT_flag (subr_die, DW_AT_artificial, 1);
11838
11839       if (TREE_PROTECTED (decl))
11840         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11841       else if (TREE_PRIVATE (decl))
11842         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11843     }
11844
11845   if (declaration)
11846     {
11847       if (!old_die || !get_AT (old_die, DW_AT_inline))
11848         {
11849           add_AT_flag (subr_die, DW_AT_declaration, 1);
11850
11851           /* The first time we see a member function, it is in the context of
11852              the class to which it belongs.  We make sure of this by emitting
11853              the class first.  The next time is the definition, which is
11854              handled above.  The two may come from the same source text.
11855
11856              Note that force_decl_die() forces function declaration die. It is
11857              later reused to represent definition.  */
11858           equate_decl_number_to_die (decl, subr_die);
11859         }
11860     }
11861   else if (DECL_ABSTRACT (decl))
11862     {
11863       if (DECL_DECLARED_INLINE_P (decl))
11864         {
11865           if (cgraph_function_possibly_inlined_p (decl))
11866             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11867           else
11868             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11869         }
11870       else
11871         {
11872           if (cgraph_function_possibly_inlined_p (decl))
11873             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11874           else
11875             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11876         }
11877
11878       equate_decl_number_to_die (decl, subr_die);
11879     }
11880   else if (!DECL_EXTERNAL (decl))
11881     {
11882       HOST_WIDE_INT cfa_fb_offset;
11883
11884       if (!old_die || !get_AT (old_die, DW_AT_inline))
11885         equate_decl_number_to_die (decl, subr_die);
11886
11887       if (!flag_reorder_blocks_and_partition)
11888         {
11889           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11890                                        current_function_funcdef_no);
11891           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11892           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11893                                        current_function_funcdef_no);
11894           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11895
11896           add_pubname (decl, subr_die);
11897           add_arange (decl, subr_die);
11898         }
11899       else
11900         {  /* Do nothing for now; maybe need to duplicate die, one for
11901               hot section and ond for cold section, then use the hot/cold
11902               section begin/end labels to generate the aranges...  */
11903           /*
11904             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11905             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11906             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11907             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11908
11909             add_pubname (decl, subr_die);
11910             add_arange (decl, subr_die);
11911             add_arange (decl, subr_die);
11912            */
11913         }
11914
11915 #ifdef MIPS_DEBUGGING_INFO
11916       /* Add a reference to the FDE for this routine.  */
11917       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11918 #endif
11919
11920       cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11921
11922       /* We define the "frame base" as the function's CFA.  This is more
11923          convenient for several reasons: (1) It's stable across the prologue
11924          and epilogue, which makes it better than just a frame pointer,
11925          (2) With dwarf3, there exists a one-byte encoding that allows us
11926          to reference the .debug_frame data by proxy, but failing that,
11927          (3) We can at least reuse the code inspection and interpretation
11928          code that determines the CFA position at various points in the
11929          function.  */
11930       /* ??? Use some command-line or configury switch to enable the use
11931          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
11932          consumers that understand it; fall back to "pure" dwarf2 and
11933          convert the CFA data into a location list.  */
11934       {
11935         dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11936         if (list->dw_loc_next)
11937           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11938         else
11939           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11940       }
11941
11942       /* Compute a displacement from the "steady-state frame pointer" to
11943          the CFA.  The former is what all stack slots and argument slots
11944          will reference in the rtl; the later is what we've told the
11945          debugger about.  We'll need to adjust all frame_base references
11946          by this displacement.  */
11947       compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11948
11949       if (cfun->static_chain_decl)
11950         add_AT_location_description (subr_die, DW_AT_static_link,
11951                  loc_descriptor_from_tree (cfun->static_chain_decl));
11952     }
11953
11954   /* Now output descriptions of the arguments for this function. This gets
11955      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11956      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11957      `...' at the end of the formal parameter list.  In order to find out if
11958      there was a trailing ellipsis or not, we must instead look at the type
11959      associated with the FUNCTION_DECL.  This will be a node of type
11960      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11961      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11962      an ellipsis at the end.  */
11963
11964   /* In the case where we are describing a mere function declaration, all we
11965      need to do here (and all we *can* do here) is to describe the *types* of
11966      its formal parameters.  */
11967   if (debug_info_level <= DINFO_LEVEL_TERSE)
11968     ;
11969   else if (declaration)
11970     gen_formal_types_die (decl, subr_die);
11971   else
11972     {
11973       /* Generate DIEs to represent all known formal parameters.  */
11974       tree arg_decls = DECL_ARGUMENTS (decl);
11975       tree parm;
11976
11977       /* When generating DIEs, generate the unspecified_parameters DIE
11978          instead if we come across the arg "__builtin_va_alist" */
11979       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11980         if (TREE_CODE (parm) == PARM_DECL)
11981           {
11982             if (DECL_NAME (parm)
11983                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11984                             "__builtin_va_alist"))
11985               gen_unspecified_parameters_die (parm, subr_die);
11986             else
11987               gen_decl_die (parm, subr_die);
11988           }
11989
11990       /* Decide whether we need an unspecified_parameters DIE at the end.
11991          There are 2 more cases to do this for: 1) the ansi ... declaration -
11992          this is detectable when the end of the arg list is not a
11993          void_type_node 2) an unprototyped function declaration (not a
11994          definition).  This just means that we have no info about the
11995          parameters at all.  */
11996       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11997       if (fn_arg_types != NULL)
11998         {
11999           /* This is the prototyped case, check for....  */
12000           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
12001             gen_unspecified_parameters_die (decl, subr_die);
12002         }
12003       else if (DECL_INITIAL (decl) == NULL_TREE)
12004         gen_unspecified_parameters_die (decl, subr_die);
12005     }
12006
12007   /* Output Dwarf info for all of the stuff within the body of the function
12008      (if it has one - it may be just a declaration).  */
12009   outer_scope = DECL_INITIAL (decl);
12010
12011   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
12012      a function.  This BLOCK actually represents the outermost binding contour
12013      for the function, i.e. the contour in which the function's formal
12014      parameters and labels get declared. Curiously, it appears that the front
12015      end doesn't actually put the PARM_DECL nodes for the current function onto
12016      the BLOCK_VARS list for this outer scope, but are strung off of the
12017      DECL_ARGUMENTS list for the function instead.
12018
12019      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
12020      the LABEL_DECL nodes for the function however, and we output DWARF info
12021      for those in decls_for_scope.  Just within the `outer_scope' there will be
12022      a BLOCK node representing the function's outermost pair of curly braces,
12023      and any blocks used for the base and member initializers of a C++
12024      constructor function.  */
12025   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
12026     {
12027       /* Emit a DW_TAG_variable DIE for a named return value.  */
12028       if (DECL_NAME (DECL_RESULT (decl)))
12029         gen_decl_die (DECL_RESULT (decl), subr_die);
12030
12031       current_function_has_inlines = 0;
12032       decls_for_scope (outer_scope, subr_die, 0);
12033
12034 #if 0 && defined (MIPS_DEBUGGING_INFO)
12035       if (current_function_has_inlines)
12036         {
12037           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
12038           if (! comp_unit_has_inlines)
12039             {
12040               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
12041               comp_unit_has_inlines = 1;
12042             }
12043         }
12044 #endif
12045     }
12046   /* Add the calling convention attribute if requested.  */
12047   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
12048
12049 }
12050
12051 /* Generate a DIE to represent a declared data object.  */
12052
12053 static void
12054 gen_variable_die (tree decl, dw_die_ref context_die)
12055 {
12056   tree origin = decl_ultimate_origin (decl);
12057   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
12058
12059   dw_die_ref old_die = lookup_decl_die (decl);
12060   int declaration = (DECL_EXTERNAL (decl)
12061                      /* If DECL is COMDAT and has not actually been
12062                         emitted, we cannot take its address; there
12063                         might end up being no definition anywhere in
12064                         the program.  For example, consider the C++
12065                         test case:
12066
12067                           template <class T>
12068                           struct S { static const int i = 7; };
12069
12070                           template <class T>
12071                           const int S<T>::i;
12072
12073                           int f() { return S<int>::i; }
12074
12075                         Here, S<int>::i is not DECL_EXTERNAL, but no
12076                         definition is required, so the compiler will
12077                         not emit a definition.  */
12078                      || (TREE_CODE (decl) == VAR_DECL
12079                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
12080                      || class_or_namespace_scope_p (context_die));
12081
12082   if (origin != NULL)
12083     add_abstract_origin_attribute (var_die, origin);
12084
12085   /* Loop unrolling can create multiple blocks that refer to the same
12086      static variable, so we must test for the DW_AT_declaration flag.
12087
12088      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12089      copy decls and set the DECL_ABSTRACT flag on them instead of
12090      sharing them.
12091
12092      ??? Duplicated blocks have been rewritten to use .debug_ranges.
12093
12094      ??? The declare_in_namespace support causes us to get two DIEs for one
12095      variable, both of which are declarations.  We want to avoid considering
12096      one to be a specification, so we must test that this DIE is not a
12097      declaration.  */
12098   else if (old_die && TREE_STATIC (decl) && ! declaration
12099            && get_AT_flag (old_die, DW_AT_declaration) == 1)
12100     {
12101       /* This is a definition of a C++ class level static.  */
12102       add_AT_specification (var_die, old_die);
12103       if (DECL_NAME (decl))
12104         {
12105           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12106           struct dwarf_file_data * file_index = lookup_filename (s.file);
12107
12108           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12109             add_AT_file (var_die, DW_AT_decl_file, file_index);
12110
12111           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12112             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12113         }
12114     }
12115   else
12116     {
12117       add_name_and_src_coords_attributes (var_die, decl);
12118       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12119                           TREE_THIS_VOLATILE (decl), context_die);
12120
12121       if (TREE_PUBLIC (decl))
12122         add_AT_flag (var_die, DW_AT_external, 1);
12123
12124       if (DECL_ARTIFICIAL (decl))
12125         add_AT_flag (var_die, DW_AT_artificial, 1);
12126
12127       if (TREE_PROTECTED (decl))
12128         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12129       else if (TREE_PRIVATE (decl))
12130         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12131     }
12132
12133   if (declaration)
12134     add_AT_flag (var_die, DW_AT_declaration, 1);
12135
12136   if (DECL_ABSTRACT (decl) || declaration)
12137     equate_decl_number_to_die (decl, var_die);
12138
12139   if (! declaration && ! DECL_ABSTRACT (decl))
12140     {
12141       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12142       add_pubname (decl, var_die);
12143     }
12144   else
12145     tree_add_const_value_attribute (var_die, decl);
12146 }
12147
12148 /* Generate a DIE to represent a label identifier.  */
12149
12150 static void
12151 gen_label_die (tree decl, dw_die_ref context_die)
12152 {
12153   tree origin = decl_ultimate_origin (decl);
12154   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12155   rtx insn;
12156   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12157
12158   if (origin != NULL)
12159     add_abstract_origin_attribute (lbl_die, origin);
12160   else
12161     add_name_and_src_coords_attributes (lbl_die, decl);
12162
12163   if (DECL_ABSTRACT (decl))
12164     equate_decl_number_to_die (decl, lbl_die);
12165   else
12166     {
12167       insn = DECL_RTL_IF_SET (decl);
12168
12169       /* Deleted labels are programmer specified labels which have been
12170          eliminated because of various optimizations.  We still emit them
12171          here so that it is possible to put breakpoints on them.  */
12172       if (insn
12173           && (LABEL_P (insn)
12174               || ((NOTE_P (insn)
12175                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
12176         {
12177           /* When optimization is enabled (via -O) some parts of the compiler
12178              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12179              represent source-level labels which were explicitly declared by
12180              the user.  This really shouldn't be happening though, so catch
12181              it if it ever does happen.  */
12182           gcc_assert (!INSN_DELETED_P (insn));
12183
12184           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12185           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12186         }
12187     }
12188 }
12189
12190 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
12191    attributes to the DIE for a block STMT, to describe where the inlined
12192    function was called from.  This is similar to add_src_coords_attributes.  */
12193
12194 static inline void
12195 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12196 {
12197   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12198
12199   add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12200   add_AT_unsigned (die, DW_AT_call_line, s.line);
12201 }
12202
12203 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12204    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
12205
12206 static inline void
12207 add_high_low_attributes (tree stmt, dw_die_ref die)
12208 {
12209   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12210
12211   if (BLOCK_FRAGMENT_CHAIN (stmt))
12212     {
12213       tree chain;
12214
12215       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12216
12217       chain = BLOCK_FRAGMENT_CHAIN (stmt);
12218       do
12219         {
12220           add_ranges (chain);
12221           chain = BLOCK_FRAGMENT_CHAIN (chain);
12222         }
12223       while (chain);
12224       add_ranges (NULL);
12225     }
12226   else
12227     {
12228       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12229                                    BLOCK_NUMBER (stmt));
12230       add_AT_lbl_id (die, DW_AT_low_pc, label);
12231       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12232                                    BLOCK_NUMBER (stmt));
12233       add_AT_lbl_id (die, DW_AT_high_pc, label);
12234     }
12235 }
12236
12237 /* Generate a DIE for a lexical block.  */
12238
12239 static void
12240 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12241 {
12242   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12243
12244   if (! BLOCK_ABSTRACT (stmt))
12245     add_high_low_attributes (stmt, stmt_die);
12246
12247   decls_for_scope (stmt, stmt_die, depth);
12248 }
12249
12250 /* Generate a DIE for an inlined subprogram.  */
12251
12252 static void
12253 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12254 {
12255   tree decl = block_ultimate_origin (stmt);
12256
12257   /* Emit info for the abstract instance first, if we haven't yet.  We
12258      must emit this even if the block is abstract, otherwise when we
12259      emit the block below (or elsewhere), we may end up trying to emit
12260      a die whose origin die hasn't been emitted, and crashing.  */
12261   dwarf2out_abstract_function (decl);
12262
12263   if (! BLOCK_ABSTRACT (stmt))
12264     {
12265       dw_die_ref subr_die
12266         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12267
12268       add_abstract_origin_attribute (subr_die, decl);
12269       add_high_low_attributes (stmt, subr_die);
12270       add_call_src_coords_attributes (stmt, subr_die);
12271
12272       decls_for_scope (stmt, subr_die, depth);
12273       current_function_has_inlines = 1;
12274     }
12275   else
12276     /* We may get here if we're the outer block of function A that was
12277        inlined into function B that was inlined into function C.  When
12278        generating debugging info for C, dwarf2out_abstract_function(B)
12279        would mark all inlined blocks as abstract, including this one.
12280        So, we wouldn't (and shouldn't) expect labels to be generated
12281        for this one.  Instead, just emit debugging info for
12282        declarations within the block.  This is particularly important
12283        in the case of initializers of arguments passed from B to us:
12284        if they're statement expressions containing declarations, we
12285        wouldn't generate dies for their abstract variables, and then,
12286        when generating dies for the real variables, we'd die (pun
12287        intended :-)  */
12288     gen_lexical_block_die (stmt, context_die, depth);
12289 }
12290
12291 /* Generate a DIE for a field in a record, or structure.  */
12292
12293 static void
12294 gen_field_die (tree decl, dw_die_ref context_die)
12295 {
12296   dw_die_ref decl_die;
12297
12298   if (TREE_TYPE (decl) == error_mark_node)
12299     return;
12300
12301   decl_die = new_die (DW_TAG_member, context_die, decl);
12302   add_name_and_src_coords_attributes (decl_die, decl);
12303   add_type_attribute (decl_die, member_declared_type (decl),
12304                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12305                       context_die);
12306
12307   if (DECL_BIT_FIELD_TYPE (decl))
12308     {
12309       add_byte_size_attribute (decl_die, decl);
12310       add_bit_size_attribute (decl_die, decl);
12311       add_bit_offset_attribute (decl_die, decl);
12312     }
12313
12314   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12315     add_data_member_location_attribute (decl_die, decl);
12316
12317   if (DECL_ARTIFICIAL (decl))
12318     add_AT_flag (decl_die, DW_AT_artificial, 1);
12319
12320   if (TREE_PROTECTED (decl))
12321     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12322   else if (TREE_PRIVATE (decl))
12323     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12324
12325   /* Equate decl number to die, so that we can look up this decl later on.  */
12326   equate_decl_number_to_die (decl, decl_die);
12327 }
12328
12329 #if 0
12330 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12331    Use modified_type_die instead.
12332    We keep this code here just in case these types of DIEs may be needed to
12333    represent certain things in other languages (e.g. Pascal) someday.  */
12334
12335 static void
12336 gen_pointer_type_die (tree type, dw_die_ref context_die)
12337 {
12338   dw_die_ref ptr_die
12339     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12340
12341   equate_type_number_to_die (type, ptr_die);
12342   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12343   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12344 }
12345
12346 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12347    Use modified_type_die instead.
12348    We keep this code here just in case these types of DIEs may be needed to
12349    represent certain things in other languages (e.g. Pascal) someday.  */
12350
12351 static void
12352 gen_reference_type_die (tree type, dw_die_ref context_die)
12353 {
12354   dw_die_ref ref_die
12355     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12356
12357   equate_type_number_to_die (type, ref_die);
12358   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12359   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12360 }
12361 #endif
12362
12363 /* Generate a DIE for a pointer to a member type.  */
12364
12365 static void
12366 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12367 {
12368   dw_die_ref ptr_die
12369     = new_die (DW_TAG_ptr_to_member_type,
12370                scope_die_for (type, context_die), type);
12371
12372   equate_type_number_to_die (type, ptr_die);
12373   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12374                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12375   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12376 }
12377
12378 /* Generate the DIE for the compilation unit.  */
12379
12380 static dw_die_ref
12381 gen_compile_unit_die (const char *filename)
12382 {
12383   dw_die_ref die;
12384   char producer[250];
12385   const char *language_string = lang_hooks.name;
12386   int language;
12387
12388   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12389
12390   if (filename)
12391     {
12392       add_name_attribute (die, filename);
12393       /* Don't add cwd for <built-in>.  */
12394       if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
12395         add_comp_dir_attribute (die);
12396     }
12397
12398   sprintf (producer, "%s %s", language_string, version_string);
12399
12400 #ifdef MIPS_DEBUGGING_INFO
12401   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12402      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12403      not appear in the producer string, the debugger reaches the conclusion
12404      that the object file is stripped and has no debugging information.
12405      To get the MIPS/SGI debugger to believe that there is debugging
12406      information in the object file, we add a -g to the producer string.  */
12407   if (debug_info_level > DINFO_LEVEL_TERSE)
12408     strcat (producer, " -g");
12409 #endif
12410
12411   add_AT_string (die, DW_AT_producer, producer);
12412
12413   if (strcmp (language_string, "GNU C++") == 0)
12414     language = DW_LANG_C_plus_plus;
12415   else if (strcmp (language_string, "GNU Ada") == 0)
12416     language = DW_LANG_Ada95;
12417   else if (strcmp (language_string, "GNU F77") == 0)
12418     language = DW_LANG_Fortran77;
12419   else if (strcmp (language_string, "GNU F95") == 0)
12420     language = DW_LANG_Fortran95;
12421   else if (strcmp (language_string, "GNU Pascal") == 0)
12422     language = DW_LANG_Pascal83;
12423   else if (strcmp (language_string, "GNU Java") == 0)
12424     language = DW_LANG_Java;
12425   else if (strcmp (language_string, "GNU Objective-C") == 0)
12426     language = DW_LANG_ObjC;
12427   else if (strcmp (language_string, "GNU Objective-C++") == 0)
12428     language = DW_LANG_ObjC_plus_plus;
12429   else
12430     language = DW_LANG_C89;
12431
12432   add_AT_unsigned (die, DW_AT_language, language);
12433   return die;
12434 }
12435
12436 /* Generate the DIE for a base class.  */
12437
12438 static void
12439 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12440 {
12441   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12442
12443   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12444   add_data_member_location_attribute (die, binfo);
12445
12446   if (BINFO_VIRTUAL_P (binfo))
12447     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12448
12449   if (access == access_public_node)
12450     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12451   else if (access == access_protected_node)
12452     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12453 }
12454
12455 /* Generate a DIE for a class member.  */
12456
12457 static void
12458 gen_member_die (tree type, dw_die_ref context_die)
12459 {
12460   tree member;
12461   tree binfo = TYPE_BINFO (type);
12462   dw_die_ref child;
12463
12464   /* If this is not an incomplete type, output descriptions of each of its
12465      members. Note that as we output the DIEs necessary to represent the
12466      members of this record or union type, we will also be trying to output
12467      DIEs to represent the *types* of those members. However the `type'
12468      function (above) will specifically avoid generating type DIEs for member
12469      types *within* the list of member DIEs for this (containing) type except
12470      for those types (of members) which are explicitly marked as also being
12471      members of this (containing) type themselves.  The g++ front- end can
12472      force any given type to be treated as a member of some other (containing)
12473      type by setting the TYPE_CONTEXT of the given (member) type to point to
12474      the TREE node representing the appropriate (containing) type.  */
12475
12476   /* First output info about the base classes.  */
12477   if (binfo)
12478     {
12479       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12480       int i;
12481       tree base;
12482
12483       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12484         gen_inheritance_die (base,
12485                              (accesses ? VEC_index (tree, accesses, i)
12486                               : access_public_node), context_die);
12487     }
12488
12489   /* Now output info about the data members and type members.  */
12490   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12491     {
12492       /* If we thought we were generating minimal debug info for TYPE
12493          and then changed our minds, some of the member declarations
12494          may have already been defined.  Don't define them again, but
12495          do put them in the right order.  */
12496
12497       child = lookup_decl_die (member);
12498       if (child)
12499         splice_child_die (context_die, child);
12500       else
12501         gen_decl_die (member, context_die);
12502     }
12503
12504   /* Now output info about the function members (if any).  */
12505   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12506     {
12507       /* Don't include clones in the member list.  */
12508       if (DECL_ABSTRACT_ORIGIN (member))
12509         continue;
12510
12511       child = lookup_decl_die (member);
12512       if (child)
12513         splice_child_die (context_die, child);
12514       else
12515         gen_decl_die (member, context_die);
12516     }
12517 }
12518
12519 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12520    is set, we pretend that the type was never defined, so we only get the
12521    member DIEs needed by later specification DIEs.  */
12522
12523 static void
12524 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12525 {
12526   dw_die_ref type_die = lookup_type_die (type);
12527   dw_die_ref scope_die = 0;
12528   int nested = 0;
12529   int complete = (TYPE_SIZE (type)
12530                   && (! TYPE_STUB_DECL (type)
12531                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12532   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12533
12534   if (type_die && ! complete)
12535     return;
12536
12537   if (TYPE_CONTEXT (type) != NULL_TREE
12538       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12539           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12540     nested = 1;
12541
12542   scope_die = scope_die_for (type, context_die);
12543
12544   if (! type_die || (nested && scope_die == comp_unit_die))
12545     /* First occurrence of type or toplevel definition of nested class.  */
12546     {
12547       dw_die_ref old_die = type_die;
12548
12549       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12550                           ? DW_TAG_structure_type : DW_TAG_union_type,
12551                           scope_die, type);
12552       equate_type_number_to_die (type, type_die);
12553       if (old_die)
12554         add_AT_specification (type_die, old_die);
12555       else
12556         add_name_attribute (type_die, type_tag (type));
12557     }
12558   else
12559     remove_AT (type_die, DW_AT_declaration);
12560
12561   /* If this type has been completed, then give it a byte_size attribute and
12562      then give a list of members.  */
12563   if (complete && !ns_decl)
12564     {
12565       /* Prevent infinite recursion in cases where the type of some member of
12566          this type is expressed in terms of this type itself.  */
12567       TREE_ASM_WRITTEN (type) = 1;
12568       add_byte_size_attribute (type_die, type);
12569       if (TYPE_STUB_DECL (type) != NULL_TREE)
12570         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12571
12572       /* If the first reference to this type was as the return type of an
12573          inline function, then it may not have a parent.  Fix this now.  */
12574       if (type_die->die_parent == NULL)
12575         add_child_die (scope_die, type_die);
12576
12577       push_decl_scope (type);
12578       gen_member_die (type, type_die);
12579       pop_decl_scope ();
12580
12581       /* GNU extension: Record what type our vtable lives in.  */
12582       if (TYPE_VFIELD (type))
12583         {
12584           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12585
12586           gen_type_die (vtype, context_die);
12587           add_AT_die_ref (type_die, DW_AT_containing_type,
12588                           lookup_type_die (vtype));
12589         }
12590     }
12591   else
12592     {
12593       add_AT_flag (type_die, DW_AT_declaration, 1);
12594
12595       /* We don't need to do this for function-local types.  */
12596       if (TYPE_STUB_DECL (type)
12597           && ! decl_function_context (TYPE_STUB_DECL (type)))
12598         VEC_safe_push (tree, gc, incomplete_types, type);
12599     }
12600
12601   if (get_AT (type_die, DW_AT_name))
12602     add_pubtype (type, type_die);
12603 }
12604
12605 /* Generate a DIE for a subroutine _type_.  */
12606
12607 static void
12608 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12609 {
12610   tree return_type = TREE_TYPE (type);
12611   dw_die_ref subr_die
12612     = new_die (DW_TAG_subroutine_type,
12613                scope_die_for (type, context_die), type);
12614
12615   equate_type_number_to_die (type, subr_die);
12616   add_prototyped_attribute (subr_die, type);
12617   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12618   gen_formal_types_die (type, subr_die);
12619
12620   if (get_AT (subr_die, DW_AT_name))
12621     add_pubtype (type, subr_die);
12622 }
12623
12624 /* Generate a DIE for a type definition.  */
12625
12626 static void
12627 gen_typedef_die (tree decl, dw_die_ref context_die)
12628 {
12629   dw_die_ref type_die;
12630   tree origin;
12631
12632   if (TREE_ASM_WRITTEN (decl))
12633     return;
12634
12635   TREE_ASM_WRITTEN (decl) = 1;
12636   type_die = new_die (DW_TAG_typedef, context_die, decl);
12637   origin = decl_ultimate_origin (decl);
12638   if (origin != NULL)
12639     add_abstract_origin_attribute (type_die, origin);
12640   else
12641     {
12642       tree type;
12643
12644       add_name_and_src_coords_attributes (type_die, decl);
12645       if (DECL_ORIGINAL_TYPE (decl))
12646         {
12647           type = DECL_ORIGINAL_TYPE (decl);
12648
12649           gcc_assert (type != TREE_TYPE (decl));
12650           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12651         }
12652       else
12653         type = TREE_TYPE (decl);
12654
12655       add_type_attribute (type_die, type, TREE_READONLY (decl),
12656                           TREE_THIS_VOLATILE (decl), context_die);
12657     }
12658
12659   if (DECL_ABSTRACT (decl))
12660     equate_decl_number_to_die (decl, type_die);
12661
12662   if (get_AT (type_die, DW_AT_name))
12663     add_pubtype (decl, type_die);
12664 }
12665
12666 /* Generate a type description DIE.  */
12667
12668 static void
12669 gen_type_die (tree type, dw_die_ref context_die)
12670 {
12671   int need_pop;
12672
12673   if (type == NULL_TREE || type == error_mark_node)
12674     return;
12675
12676   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12677       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12678     {
12679       if (TREE_ASM_WRITTEN (type))
12680         return;
12681
12682       /* Prevent broken recursion; we can't hand off to the same type.  */
12683       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12684
12685       TREE_ASM_WRITTEN (type) = 1;
12686       gen_decl_die (TYPE_NAME (type), context_die);
12687       return;
12688     }
12689
12690   /* We are going to output a DIE to represent the unqualified version
12691      of this type (i.e. without any const or volatile qualifiers) so
12692      get the main variant (i.e. the unqualified version) of this type
12693      now.  (Vectors are special because the debugging info is in the
12694      cloned type itself).  */
12695   if (TREE_CODE (type) != VECTOR_TYPE)
12696     type = type_main_variant (type);
12697
12698   if (TREE_ASM_WRITTEN (type))
12699     return;
12700
12701   switch (TREE_CODE (type))
12702     {
12703     case ERROR_MARK:
12704       break;
12705
12706     case POINTER_TYPE:
12707     case REFERENCE_TYPE:
12708       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12709          ensures that the gen_type_die recursion will terminate even if the
12710          type is recursive.  Recursive types are possible in Ada.  */
12711       /* ??? We could perhaps do this for all types before the switch
12712          statement.  */
12713       TREE_ASM_WRITTEN (type) = 1;
12714
12715       /* For these types, all that is required is that we output a DIE (or a
12716          set of DIEs) to represent the "basis" type.  */
12717       gen_type_die (TREE_TYPE (type), context_die);
12718       break;
12719
12720     case OFFSET_TYPE:
12721       /* This code is used for C++ pointer-to-data-member types.
12722          Output a description of the relevant class type.  */
12723       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12724
12725       /* Output a description of the type of the object pointed to.  */
12726       gen_type_die (TREE_TYPE (type), context_die);
12727
12728       /* Now output a DIE to represent this pointer-to-data-member type
12729          itself.  */
12730       gen_ptr_to_mbr_type_die (type, context_die);
12731       break;
12732
12733     case FUNCTION_TYPE:
12734       /* Force out return type (in case it wasn't forced out already).  */
12735       gen_type_die (TREE_TYPE (type), context_die);
12736       gen_subroutine_type_die (type, context_die);
12737       break;
12738
12739     case METHOD_TYPE:
12740       /* Force out return type (in case it wasn't forced out already).  */
12741       gen_type_die (TREE_TYPE (type), context_die);
12742       gen_subroutine_type_die (type, context_die);
12743       break;
12744
12745     case ARRAY_TYPE:
12746       gen_array_type_die (type, context_die);
12747       break;
12748
12749     case VECTOR_TYPE:
12750       gen_array_type_die (type, context_die);
12751       break;
12752
12753     case ENUMERAL_TYPE:
12754     case RECORD_TYPE:
12755     case UNION_TYPE:
12756     case QUAL_UNION_TYPE:
12757       /* If this is a nested type whose containing class hasn't been written
12758          out yet, writing it out will cover this one, too.  This does not apply
12759          to instantiations of member class templates; they need to be added to
12760          the containing class as they are generated.  FIXME: This hurts the
12761          idea of combining type decls from multiple TUs, since we can't predict
12762          what set of template instantiations we'll get.  */
12763       if (TYPE_CONTEXT (type)
12764           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12765           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12766         {
12767           gen_type_die (TYPE_CONTEXT (type), context_die);
12768
12769           if (TREE_ASM_WRITTEN (type))
12770             return;
12771
12772           /* If that failed, attach ourselves to the stub.  */
12773           push_decl_scope (TYPE_CONTEXT (type));
12774           context_die = lookup_type_die (TYPE_CONTEXT (type));
12775           need_pop = 1;
12776         }
12777       else
12778         {
12779           declare_in_namespace (type, context_die);
12780           need_pop = 0;
12781         }
12782
12783       if (TREE_CODE (type) == ENUMERAL_TYPE)
12784         {
12785           /* This might have been written out by the call to
12786              declare_in_namespace.  */
12787           if (!TREE_ASM_WRITTEN (type))
12788             gen_enumeration_type_die (type, context_die);
12789         }
12790       else
12791         gen_struct_or_union_type_die (type, context_die);
12792
12793       if (need_pop)
12794         pop_decl_scope ();
12795
12796       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12797          it up if it is ever completed.  gen_*_type_die will set it for us
12798          when appropriate.  */
12799       return;
12800
12801     case VOID_TYPE:
12802     case INTEGER_TYPE:
12803     case REAL_TYPE:
12804     case COMPLEX_TYPE:
12805     case BOOLEAN_TYPE:
12806       /* No DIEs needed for fundamental types.  */
12807       break;
12808
12809     case LANG_TYPE:
12810       /* No Dwarf representation currently defined.  */
12811       break;
12812
12813     default:
12814       gcc_unreachable ();
12815     }
12816
12817   TREE_ASM_WRITTEN (type) = 1;
12818 }
12819
12820 /* Generate a DIE for a tagged type instantiation.  */
12821
12822 static void
12823 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12824 {
12825   if (type == NULL_TREE || type == error_mark_node)
12826     return;
12827
12828   /* We are going to output a DIE to represent the unqualified version of
12829      this type (i.e. without any const or volatile qualifiers) so make sure
12830      that we have the main variant (i.e. the unqualified version) of this
12831      type now.  */
12832   gcc_assert (type == type_main_variant (type));
12833
12834   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12835      an instance of an unresolved type.  */
12836
12837   switch (TREE_CODE (type))
12838     {
12839     case ERROR_MARK:
12840       break;
12841
12842     case ENUMERAL_TYPE:
12843       gen_inlined_enumeration_type_die (type, context_die);
12844       break;
12845
12846     case RECORD_TYPE:
12847       gen_inlined_structure_type_die (type, context_die);
12848       break;
12849
12850     case UNION_TYPE:
12851     case QUAL_UNION_TYPE:
12852       gen_inlined_union_type_die (type, context_die);
12853       break;
12854
12855     default:
12856       gcc_unreachable ();
12857     }
12858 }
12859
12860 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12861    things which are local to the given block.  */
12862
12863 static void
12864 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12865 {
12866   int must_output_die = 0;
12867   tree origin;
12868   tree decl;
12869   enum tree_code origin_code;
12870
12871   /* Ignore blocks that are NULL.  */
12872   if (stmt == NULL_TREE)
12873     return;
12874
12875   /* If the block is one fragment of a non-contiguous block, do not
12876      process the variables, since they will have been done by the
12877      origin block.  Do process subblocks.  */
12878   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12879     {
12880       tree sub;
12881
12882       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12883         gen_block_die (sub, context_die, depth + 1);
12884
12885       return;
12886     }
12887
12888   /* Determine the "ultimate origin" of this block.  This block may be an
12889      inlined instance of an inlined instance of inline function, so we have
12890      to trace all of the way back through the origin chain to find out what
12891      sort of node actually served as the original seed for the creation of
12892      the current block.  */
12893   origin = block_ultimate_origin (stmt);
12894   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12895
12896   /* Determine if we need to output any Dwarf DIEs at all to represent this
12897      block.  */
12898   if (origin_code == FUNCTION_DECL)
12899     /* The outer scopes for inlinings *must* always be represented.  We
12900        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12901     must_output_die = 1;
12902   else
12903     {
12904       /* In the case where the current block represents an inlining of the
12905          "body block" of an inline function, we must *NOT* output any DIE for
12906          this block because we have already output a DIE to represent the whole
12907          inlined function scope and the "body block" of any function doesn't
12908          really represent a different scope according to ANSI C rules.  So we
12909          check here to make sure that this block does not represent a "body
12910          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12911       if (! is_body_block (origin ? origin : stmt))
12912         {
12913           /* Determine if this block directly contains any "significant"
12914              local declarations which we will need to output DIEs for.  */
12915           if (debug_info_level > DINFO_LEVEL_TERSE)
12916             /* We are not in terse mode so *any* local declaration counts
12917                as being a "significant" one.  */
12918             must_output_die = (BLOCK_VARS (stmt) != NULL
12919                                && (TREE_USED (stmt)
12920                                    || TREE_ASM_WRITTEN (stmt)
12921                                    || BLOCK_ABSTRACT (stmt)));
12922           else
12923             /* We are in terse mode, so only local (nested) function
12924                definitions count as "significant" local declarations.  */
12925             for (decl = BLOCK_VARS (stmt);
12926                  decl != NULL; decl = TREE_CHAIN (decl))
12927               if (TREE_CODE (decl) == FUNCTION_DECL
12928                   && DECL_INITIAL (decl))
12929                 {
12930                   must_output_die = 1;
12931                   break;
12932                 }
12933         }
12934     }
12935
12936   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12937      DIE for any block which contains no significant local declarations at
12938      all.  Rather, in such cases we just call `decls_for_scope' so that any
12939      needed Dwarf info for any sub-blocks will get properly generated. Note
12940      that in terse mode, our definition of what constitutes a "significant"
12941      local declaration gets restricted to include only inlined function
12942      instances and local (nested) function definitions.  */
12943   if (must_output_die)
12944     {
12945       if (origin_code == FUNCTION_DECL)
12946         gen_inlined_subroutine_die (stmt, context_die, depth);
12947       else
12948         gen_lexical_block_die (stmt, context_die, depth);
12949     }
12950   else
12951     decls_for_scope (stmt, context_die, depth);
12952 }
12953
12954 /* Generate all of the decls declared within a given scope and (recursively)
12955    all of its sub-blocks.  */
12956
12957 static void
12958 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12959 {
12960   tree decl;
12961   tree subblocks;
12962
12963   /* Ignore NULL blocks.  */
12964   if (stmt == NULL_TREE)
12965     return;
12966
12967   if (TREE_USED (stmt))
12968     {
12969       /* Output the DIEs to represent all of the data objects and typedefs
12970          declared directly within this block but not within any nested
12971          sub-blocks.  Also, nested function and tag DIEs have been
12972          generated with a parent of NULL; fix that up now.  */
12973       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12974         {
12975           dw_die_ref die;
12976
12977           if (TREE_CODE (decl) == FUNCTION_DECL)
12978             die = lookup_decl_die (decl);
12979           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12980             die = lookup_type_die (TREE_TYPE (decl));
12981           else
12982             die = NULL;
12983
12984           if (die != NULL && die->die_parent == NULL)
12985             add_child_die (context_die, die);
12986           /* Do not produce debug information for static variables since
12987              these might be optimized out.  We are called for these later
12988              in varpool_analyze_pending_decls. */
12989           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12990             ;
12991           else
12992             gen_decl_die (decl, context_die);
12993         }
12994     }
12995
12996   /* If we're at -g1, we're not interested in subblocks.  */
12997   if (debug_info_level <= DINFO_LEVEL_TERSE)
12998     return;
12999
13000   /* Output the DIEs to represent all sub-blocks (and the items declared
13001      therein) of this block.  */
13002   for (subblocks = BLOCK_SUBBLOCKS (stmt);
13003        subblocks != NULL;
13004        subblocks = BLOCK_CHAIN (subblocks))
13005     gen_block_die (subblocks, context_die, depth + 1);
13006 }
13007
13008 /* Is this a typedef we can avoid emitting?  */
13009
13010 static inline int
13011 is_redundant_typedef (tree decl)
13012 {
13013   if (TYPE_DECL_IS_STUB (decl))
13014     return 1;
13015
13016   if (DECL_ARTIFICIAL (decl)
13017       && DECL_CONTEXT (decl)
13018       && is_tagged_type (DECL_CONTEXT (decl))
13019       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
13020       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
13021     /* Also ignore the artificial member typedef for the class name.  */
13022     return 1;
13023
13024   return 0;
13025 }
13026
13027 /* Returns the DIE for decl.  A DIE will always be returned.  */
13028
13029 static dw_die_ref
13030 force_decl_die (tree decl)
13031 {
13032   dw_die_ref decl_die;
13033   unsigned saved_external_flag;
13034   tree save_fn = NULL_TREE;
13035   decl_die = lookup_decl_die (decl);
13036   if (!decl_die)
13037     {
13038       dw_die_ref context_die;
13039       tree decl_context = DECL_CONTEXT (decl);
13040       if (decl_context)
13041         {
13042           /* Find die that represents this context.  */
13043           if (TYPE_P (decl_context))
13044             context_die = force_type_die (decl_context);
13045           else
13046             context_die = force_decl_die (decl_context);
13047         }
13048       else
13049         context_die = comp_unit_die;
13050
13051       decl_die = lookup_decl_die (decl);
13052       if (decl_die)
13053         return decl_die;
13054
13055       switch (TREE_CODE (decl))
13056         {
13057         case FUNCTION_DECL:
13058           /* Clear current_function_decl, so that gen_subprogram_die thinks
13059              that this is a declaration. At this point, we just want to force
13060              declaration die.  */
13061           save_fn = current_function_decl;
13062           current_function_decl = NULL_TREE;
13063           gen_subprogram_die (decl, context_die);
13064           current_function_decl = save_fn;
13065           break;
13066
13067         case VAR_DECL:
13068           /* Set external flag to force declaration die. Restore it after
13069            gen_decl_die() call.  */
13070           saved_external_flag = DECL_EXTERNAL (decl);
13071           DECL_EXTERNAL (decl) = 1;
13072           gen_decl_die (decl, context_die);
13073           DECL_EXTERNAL (decl) = saved_external_flag;
13074           break;
13075
13076         case NAMESPACE_DECL:
13077           dwarf2out_decl (decl);
13078           break;
13079
13080         default:
13081           gcc_unreachable ();
13082         }
13083
13084       /* We should be able to find the DIE now.  */
13085       if (!decl_die)
13086         decl_die = lookup_decl_die (decl);
13087       gcc_assert (decl_die);
13088     }
13089
13090   return decl_die;
13091 }
13092
13093 /* Returns the DIE for TYPE.  A DIE is always returned.  */
13094
13095 static dw_die_ref
13096 force_type_die (tree type)
13097 {
13098   dw_die_ref type_die;
13099
13100   type_die = lookup_type_die (type);
13101   if (!type_die)
13102     {
13103       dw_die_ref context_die;
13104       if (TYPE_CONTEXT (type))
13105         {
13106           if (TYPE_P (TYPE_CONTEXT (type)))
13107             context_die = force_type_die (TYPE_CONTEXT (type));
13108           else
13109             context_die = force_decl_die (TYPE_CONTEXT (type));
13110         }
13111       else
13112         context_die = comp_unit_die;
13113
13114       type_die = lookup_type_die (type);
13115       if (type_die)
13116         return type_die;
13117       gen_type_die (type, context_die);
13118       type_die = lookup_type_die (type);
13119       gcc_assert (type_die);
13120     }
13121   return type_die;
13122 }
13123
13124 /* Force out any required namespaces to be able to output DECL,
13125    and return the new context_die for it, if it's changed.  */
13126
13127 static dw_die_ref
13128 setup_namespace_context (tree thing, dw_die_ref context_die)
13129 {
13130   tree context = (DECL_P (thing)
13131                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13132   if (context && TREE_CODE (context) == NAMESPACE_DECL)
13133     /* Force out the namespace.  */
13134     context_die = force_decl_die (context);
13135
13136   return context_die;
13137 }
13138
13139 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
13140    type) within its namespace, if appropriate.
13141
13142    For compatibility with older debuggers, namespace DIEs only contain
13143    declarations; all definitions are emitted at CU scope.  */
13144
13145 static void
13146 declare_in_namespace (tree thing, dw_die_ref context_die)
13147 {
13148   dw_die_ref ns_context;
13149
13150   if (debug_info_level <= DINFO_LEVEL_TERSE)
13151     return;
13152
13153   /* If this decl is from an inlined function, then don't try to emit it in its
13154      namespace, as we will get confused.  It would have already been emitted
13155      when the abstract instance of the inline function was emitted anyways.  */
13156   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13157     return;
13158
13159   ns_context = setup_namespace_context (thing, context_die);
13160
13161   if (ns_context != context_die)
13162     {
13163       if (DECL_P (thing))
13164         gen_decl_die (thing, ns_context);
13165       else
13166         gen_type_die (thing, ns_context);
13167     }
13168 }
13169
13170 /* Generate a DIE for a namespace or namespace alias.  */
13171
13172 static void
13173 gen_namespace_die (tree decl)
13174 {
13175   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13176
13177   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13178      they are an alias of.  */
13179   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13180     {
13181       /* Output a real namespace.  */
13182       dw_die_ref namespace_die
13183         = new_die (DW_TAG_namespace, context_die, decl);
13184       add_name_and_src_coords_attributes (namespace_die, decl);
13185       equate_decl_number_to_die (decl, namespace_die);
13186     }
13187   else
13188     {
13189       /* Output a namespace alias.  */
13190
13191       /* Force out the namespace we are an alias of, if necessary.  */
13192       dw_die_ref origin_die
13193         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13194
13195       /* Now create the namespace alias DIE.  */
13196       dw_die_ref namespace_die
13197         = new_die (DW_TAG_imported_declaration, context_die, decl);
13198       add_name_and_src_coords_attributes (namespace_die, decl);
13199       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13200       equate_decl_number_to_die (decl, namespace_die);
13201     }
13202 }
13203
13204 /* Generate Dwarf debug information for a decl described by DECL.  */
13205
13206 static void
13207 gen_decl_die (tree decl, dw_die_ref context_die)
13208 {
13209   tree origin;
13210
13211   if (DECL_P (decl) && DECL_IGNORED_P (decl))
13212     return;
13213
13214   switch (TREE_CODE (decl))
13215     {
13216     case ERROR_MARK:
13217       break;
13218
13219     case CONST_DECL:
13220       /* The individual enumerators of an enum type get output when we output
13221          the Dwarf representation of the relevant enum type itself.  */
13222       break;
13223
13224     case FUNCTION_DECL:
13225       /* Don't output any DIEs to represent mere function declarations,
13226          unless they are class members or explicit block externs.  */
13227       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13228           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13229         break;
13230
13231 #if 0
13232       /* FIXME */
13233       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13234          on local redeclarations of global functions.  That seems broken.  */
13235       if (current_function_decl != decl)
13236         /* This is only a declaration.  */;
13237 #endif
13238
13239       /* If we're emitting a clone, emit info for the abstract instance.  */
13240       if (DECL_ORIGIN (decl) != decl)
13241         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13242
13243       /* If we're emitting an out-of-line copy of an inline function,
13244          emit info for the abstract instance and set up to refer to it.  */
13245       else if (cgraph_function_possibly_inlined_p (decl)
13246                && ! DECL_ABSTRACT (decl)
13247                && ! class_or_namespace_scope_p (context_die)
13248                /* dwarf2out_abstract_function won't emit a die if this is just
13249                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
13250                   that case, because that works only if we have a die.  */
13251                && DECL_INITIAL (decl) != NULL_TREE)
13252         {
13253           dwarf2out_abstract_function (decl);
13254           set_decl_origin_self (decl);
13255         }
13256
13257       /* Otherwise we're emitting the primary DIE for this decl.  */
13258       else if (debug_info_level > DINFO_LEVEL_TERSE)
13259         {
13260           /* Before we describe the FUNCTION_DECL itself, make sure that we
13261              have described its return type.  */
13262           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13263
13264           /* And its virtual context.  */
13265           if (DECL_VINDEX (decl) != NULL_TREE)
13266             gen_type_die (DECL_CONTEXT (decl), context_die);
13267
13268           /* And its containing type.  */
13269           origin = decl_class_context (decl);
13270           if (origin != NULL_TREE)
13271             gen_type_die_for_member (origin, decl, context_die);
13272
13273           /* And its containing namespace.  */
13274           declare_in_namespace (decl, context_die);
13275         }
13276
13277       /* Now output a DIE to represent the function itself.  */
13278       gen_subprogram_die (decl, context_die);
13279       break;
13280
13281     case TYPE_DECL:
13282       /* If we are in terse mode, don't generate any DIEs to represent any
13283          actual typedefs.  */
13284       if (debug_info_level <= DINFO_LEVEL_TERSE)
13285         break;
13286
13287       /* In the special case of a TYPE_DECL node representing the declaration
13288          of some type tag, if the given TYPE_DECL is marked as having been
13289          instantiated from some other (original) TYPE_DECL node (e.g. one which
13290          was generated within the original definition of an inline function) we
13291          have to generate a special (abbreviated) DW_TAG_structure_type,
13292          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13293       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13294         {
13295           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13296           break;
13297         }
13298
13299       if (is_redundant_typedef (decl))
13300         gen_type_die (TREE_TYPE (decl), context_die);
13301       else
13302         /* Output a DIE to represent the typedef itself.  */
13303         gen_typedef_die (decl, context_die);
13304       break;
13305
13306     case LABEL_DECL:
13307       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13308         gen_label_die (decl, context_die);
13309       break;
13310
13311     case VAR_DECL:
13312     case RESULT_DECL:
13313       /* If we are in terse mode, don't generate any DIEs to represent any
13314          variable declarations or definitions.  */
13315       if (debug_info_level <= DINFO_LEVEL_TERSE)
13316         break;
13317
13318       /* Output any DIEs that are needed to specify the type of this data
13319          object.  */
13320       gen_type_die (TREE_TYPE (decl), context_die);
13321
13322       /* And its containing type.  */
13323       origin = decl_class_context (decl);
13324       if (origin != NULL_TREE)
13325         gen_type_die_for_member (origin, decl, context_die);
13326
13327       /* And its containing namespace.  */
13328       declare_in_namespace (decl, context_die);
13329
13330       /* Now output the DIE to represent the data object itself.  This gets
13331          complicated because of the possibility that the VAR_DECL really
13332          represents an inlined instance of a formal parameter for an inline
13333          function.  */
13334       origin = decl_ultimate_origin (decl);
13335       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13336         gen_formal_parameter_die (decl, context_die);
13337       else
13338         gen_variable_die (decl, context_die);
13339       break;
13340
13341     case FIELD_DECL:
13342       /* Ignore the nameless fields that are used to skip bits but handle C++
13343          anonymous unions and structs.  */
13344       if (DECL_NAME (decl) != NULL_TREE
13345           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13346           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13347         {
13348           gen_type_die (member_declared_type (decl), context_die);
13349           gen_field_die (decl, context_die);
13350         }
13351       break;
13352
13353     case PARM_DECL:
13354       gen_type_die (TREE_TYPE (decl), context_die);
13355       gen_formal_parameter_die (decl, context_die);
13356       break;
13357
13358     case NAMESPACE_DECL:
13359       gen_namespace_die (decl);
13360       break;
13361
13362     default:
13363       /* Probably some frontend-internal decl.  Assume we don't care.  */
13364       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13365       break;
13366     }
13367 }
13368 \f
13369 /* Output debug information for global decl DECL.  Called from toplev.c after
13370    compilation proper has finished.  */
13371
13372 static void
13373 dwarf2out_global_decl (tree decl)
13374 {
13375   /* Output DWARF2 information for file-scope tentative data object
13376      declarations, file-scope (extern) function declarations (which had no
13377      corresponding body) and file-scope tagged type declarations and
13378      definitions which have not yet been forced out.  */
13379   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13380     dwarf2out_decl (decl);
13381 }
13382
13383 /* Output debug information for type decl DECL.  Called from toplev.c
13384    and from language front ends (to record built-in types).  */
13385 static void
13386 dwarf2out_type_decl (tree decl, int local)
13387 {
13388   if (!local)
13389     dwarf2out_decl (decl);
13390 }
13391
13392 /* Output debug information for imported module or decl.  */
13393
13394 static void
13395 dwarf2out_imported_module_or_decl (tree decl, tree context)
13396 {
13397   dw_die_ref imported_die, at_import_die;
13398   dw_die_ref scope_die;
13399   expanded_location xloc;
13400
13401   if (debug_info_level <= DINFO_LEVEL_TERSE)
13402     return;
13403
13404   gcc_assert (decl);
13405
13406   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13407      We need decl DIE for reference and scope die. First, get DIE for the decl
13408      itself.  */
13409
13410   /* Get the scope die for decl context. Use comp_unit_die for global module
13411      or decl. If die is not found for non globals, force new die.  */
13412   if (!context)
13413     scope_die = comp_unit_die;
13414   else if (TYPE_P (context))
13415     scope_die = force_type_die (context);
13416   else
13417     scope_die = force_decl_die (context);
13418
13419   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13420   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13421     at_import_die = force_type_die (TREE_TYPE (decl));
13422   else
13423     {
13424       at_import_die = lookup_decl_die (decl);
13425       if (!at_import_die)
13426         {
13427           /* If we're trying to avoid duplicate debug info, we may not have
13428              emitted the member decl for this field.  Emit it now.  */
13429           if (TREE_CODE (decl) == FIELD_DECL)
13430             {
13431               tree type = DECL_CONTEXT (decl);
13432               dw_die_ref type_context_die;
13433
13434               if (TYPE_CONTEXT (type))
13435                 if (TYPE_P (TYPE_CONTEXT (type)))
13436                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13437               else
13438                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13439               else
13440                 type_context_die = comp_unit_die;
13441               gen_type_die_for_member (type, decl, type_context_die);
13442             }
13443           at_import_die = force_decl_die (decl);
13444         }
13445     }
13446
13447   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13448   if (TREE_CODE (decl) == NAMESPACE_DECL)
13449     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13450   else
13451     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13452
13453   xloc = expand_location (input_location);
13454   add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13455   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13456   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13457 }
13458
13459 /* Write the debugging output for DECL.  */
13460
13461 void
13462 dwarf2out_decl (tree decl)
13463 {
13464   dw_die_ref context_die = comp_unit_die;
13465
13466   switch (TREE_CODE (decl))
13467     {
13468     case ERROR_MARK:
13469       return;
13470
13471     case FUNCTION_DECL:
13472       /* What we would really like to do here is to filter out all mere
13473          file-scope declarations of file-scope functions which are never
13474          referenced later within this translation unit (and keep all of ones
13475          that *are* referenced later on) but we aren't clairvoyant, so we have
13476          no idea which functions will be referenced in the future (i.e. later
13477          on within the current translation unit). So here we just ignore all
13478          file-scope function declarations which are not also definitions.  If
13479          and when the debugger needs to know something about these functions,
13480          it will have to hunt around and find the DWARF information associated
13481          with the definition of the function.
13482
13483          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13484          nodes represent definitions and which ones represent mere
13485          declarations.  We have to check DECL_INITIAL instead. That's because
13486          the C front-end supports some weird semantics for "extern inline"
13487          function definitions.  These can get inlined within the current
13488          translation unit (and thus, we need to generate Dwarf info for their
13489          abstract instances so that the Dwarf info for the concrete inlined
13490          instances can have something to refer to) but the compiler never
13491          generates any out-of-lines instances of such things (despite the fact
13492          that they *are* definitions).
13493
13494          The important point is that the C front-end marks these "extern
13495          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13496          them anyway. Note that the C++ front-end also plays some similar games
13497          for inline function definitions appearing within include files which
13498          also contain `#pragma interface' pragmas.  */
13499       if (DECL_INITIAL (decl) == NULL_TREE)
13500         return;
13501
13502       /* If we're a nested function, initially use a parent of NULL; if we're
13503          a plain function, this will be fixed up in decls_for_scope.  If
13504          we're a method, it will be ignored, since we already have a DIE.  */
13505       if (decl_function_context (decl)
13506           /* But if we're in terse mode, we don't care about scope.  */
13507           && debug_info_level > DINFO_LEVEL_TERSE)
13508         context_die = NULL;
13509       break;
13510
13511     case VAR_DECL:
13512       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13513          declaration and if the declaration was never even referenced from
13514          within this entire compilation unit.  We suppress these DIEs in
13515          order to save space in the .debug section (by eliminating entries
13516          which are probably useless).  Note that we must not suppress
13517          block-local extern declarations (whether used or not) because that
13518          would screw-up the debugger's name lookup mechanism and cause it to
13519          miss things which really ought to be in scope at a given point.  */
13520       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13521         return;
13522
13523       /* For local statics lookup proper context die.  */
13524       if (TREE_STATIC (decl) && decl_function_context (decl))
13525         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13526
13527       /* If we are in terse mode, don't generate any DIEs to represent any
13528          variable declarations or definitions.  */
13529       if (debug_info_level <= DINFO_LEVEL_TERSE)
13530         return;
13531       break;
13532
13533     case NAMESPACE_DECL:
13534       if (debug_info_level <= DINFO_LEVEL_TERSE)
13535         return;
13536       if (lookup_decl_die (decl) != NULL)
13537         return;
13538       break;
13539
13540     case TYPE_DECL:
13541       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13542       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13543         return;
13544
13545       /* Don't bother trying to generate any DIEs to represent any of the
13546          normal built-in types for the language we are compiling.  */
13547       if (DECL_IS_BUILTIN (decl))
13548         {
13549           /* OK, we need to generate one for `bool' so GDB knows what type
13550              comparisons have.  */
13551           if (is_cxx ()
13552               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13553               && ! DECL_IGNORED_P (decl))
13554             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13555
13556           return;
13557         }
13558
13559       /* If we are in terse mode, don't generate any DIEs for types.  */
13560       if (debug_info_level <= DINFO_LEVEL_TERSE)
13561         return;
13562
13563       /* If we're a function-scope tag, initially use a parent of NULL;
13564          this will be fixed up in decls_for_scope.  */
13565       if (decl_function_context (decl))
13566         context_die = NULL;
13567
13568       break;
13569
13570     default:
13571       return;
13572     }
13573
13574   gen_decl_die (decl, context_die);
13575 }
13576
13577 /* Output a marker (i.e. a label) for the beginning of the generated code for
13578    a lexical block.  */
13579
13580 static void
13581 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13582                        unsigned int blocknum)
13583 {
13584   switch_to_section (current_function_section ());
13585   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13586 }
13587
13588 /* Output a marker (i.e. a label) for the end of the generated code for a
13589    lexical block.  */
13590
13591 static void
13592 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13593 {
13594   switch_to_section (current_function_section ());
13595   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13596 }
13597
13598 /* Returns nonzero if it is appropriate not to emit any debugging
13599    information for BLOCK, because it doesn't contain any instructions.
13600
13601    Don't allow this for blocks with nested functions or local classes
13602    as we would end up with orphans, and in the presence of scheduling
13603    we may end up calling them anyway.  */
13604
13605 static bool
13606 dwarf2out_ignore_block (tree block)
13607 {
13608   tree decl;
13609
13610   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13611     if (TREE_CODE (decl) == FUNCTION_DECL
13612         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13613       return 0;
13614
13615   return 1;
13616 }
13617
13618 /* Hash table routines for file_hash.  */
13619
13620 static int
13621 file_table_eq (const void *p1_p, const void *p2_p)
13622 {
13623   const struct dwarf_file_data * p1 = p1_p;
13624   const char * p2 = p2_p;
13625   return strcmp (p1->filename, p2) == 0;
13626 }
13627
13628 static hashval_t
13629 file_table_hash (const void *p_p)
13630 {
13631   const struct dwarf_file_data * p = p_p;
13632   return htab_hash_string (p->filename);
13633 }
13634
13635 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13636    dwarf2out.c) and return its "index".  The index of each (known) filename is
13637    just a unique number which is associated with only that one filename.  We
13638    need such numbers for the sake of generating labels (in the .debug_sfnames
13639    section) and references to those files numbers (in the .debug_srcinfo
13640    and.debug_macinfo sections).  If the filename given as an argument is not
13641    found in our current list, add it to the list and assign it the next
13642    available unique index number.  In order to speed up searches, we remember
13643    the index of the filename was looked up last.  This handles the majority of
13644    all searches.  */
13645
13646 static struct dwarf_file_data *
13647 lookup_filename (const char *file_name)
13648 {
13649   void ** slot;
13650   struct dwarf_file_data * created;
13651
13652   /* Check to see if the file name that was searched on the previous
13653      call matches this file name.  If so, return the index.  */
13654   if (file_table_last_lookup
13655       && (file_name == file_table_last_lookup->filename
13656           || strcmp (file_table_last_lookup->filename, file_name) == 0))
13657     return file_table_last_lookup;
13658
13659   /* Didn't match the previous lookup, search the table.  */
13660   slot = htab_find_slot_with_hash (file_table, file_name,
13661                                    htab_hash_string (file_name), INSERT);
13662   if (*slot)
13663     return *slot;
13664
13665   created = ggc_alloc (sizeof (struct dwarf_file_data));
13666   created->filename = file_name;
13667   created->emitted_number = 0;
13668   *slot = created;
13669   return created;
13670 }
13671
13672 /* If the assembler will construct the file table, then translate the compiler
13673    internal file table number into the assembler file table number, and emit
13674    a .file directive if we haven't already emitted one yet.  The file table
13675    numbers are different because we prune debug info for unused variables and
13676    types, which may include filenames.  */
13677
13678 static int
13679 maybe_emit_file (struct dwarf_file_data * fd)
13680 {
13681   if (! fd->emitted_number)
13682     {
13683       if (last_emitted_file)
13684         fd->emitted_number = last_emitted_file->emitted_number + 1;
13685       else
13686         fd->emitted_number = 1;
13687       last_emitted_file = fd;
13688
13689       if (DWARF2_ASM_LINE_DEBUG_INFO)
13690         {
13691           fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
13692           output_quoted_string (asm_out_file, fd->filename);
13693           fputc ('\n', asm_out_file);
13694         }
13695     }
13696
13697   return fd->emitted_number;
13698 }
13699
13700 /* Called by the final INSN scan whenever we see a var location.  We
13701    use it to drop labels in the right places, and throw the location in
13702    our lookup table.  */
13703
13704 static void
13705 dwarf2out_var_location (rtx loc_note)
13706 {
13707   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13708   struct var_loc_node *newloc;
13709   rtx prev_insn;
13710   static rtx last_insn;
13711   static const char *last_label;
13712   tree decl;
13713
13714   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13715     return;
13716   prev_insn = PREV_INSN (loc_note);
13717
13718   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13719   /* If the insn we processed last time is the previous insn
13720      and it is also a var location note, use the label we emitted
13721      last time.  */
13722   if (last_insn != NULL_RTX
13723       && last_insn == prev_insn
13724       && NOTE_P (prev_insn)
13725       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13726     {
13727       newloc->label = last_label;
13728     }
13729   else
13730     {
13731       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13732       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13733       loclabel_num++;
13734       newloc->label = ggc_strdup (loclabel);
13735     }
13736   newloc->var_loc_note = loc_note;
13737   newloc->next = NULL;
13738
13739   if (cfun && in_cold_section_p)
13740     newloc->section_label = cfun->cold_section_label;
13741   else
13742     newloc->section_label = text_section_label;
13743
13744   last_insn = loc_note;
13745   last_label = newloc->label;
13746   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13747   add_var_loc_to_decl (decl, newloc);
13748 }
13749
13750 /* We need to reset the locations at the beginning of each
13751    function. We can't do this in the end_function hook, because the
13752    declarations that use the locations won't have been output when
13753    that hook is called.  Also compute have_multiple_function_sections here.  */
13754
13755 static void
13756 dwarf2out_begin_function (tree fun)
13757 {
13758   htab_empty (decl_loc_table);
13759
13760   if (function_section (fun) != text_section)
13761     have_multiple_function_sections = true;
13762 }
13763
13764 /* Output a label to mark the beginning of a source code line entry
13765    and record information relating to this source line, in
13766    'line_info_table' for later output of the .debug_line section.  */
13767
13768 static void
13769 dwarf2out_source_line (unsigned int line, const char *filename)
13770 {
13771   if (debug_info_level >= DINFO_LEVEL_NORMAL
13772       && line != 0)
13773     {
13774       int file_num = maybe_emit_file (lookup_filename (filename));
13775
13776       switch_to_section (current_function_section ());
13777
13778       /* If requested, emit something human-readable.  */
13779       if (flag_debug_asm)
13780         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13781                  filename, line);
13782
13783       if (DWARF2_ASM_LINE_DEBUG_INFO)
13784         {
13785           /* Emit the .loc directive understood by GNU as.  */
13786           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13787
13788           /* Indicate that line number info exists.  */
13789           line_info_table_in_use++;
13790         }
13791       else if (function_section (current_function_decl) != text_section)
13792         {
13793           dw_separate_line_info_ref line_info;
13794           targetm.asm_out.internal_label (asm_out_file,
13795                                           SEPARATE_LINE_CODE_LABEL,
13796                                           separate_line_info_table_in_use);
13797
13798           /* Expand the line info table if necessary.  */
13799           if (separate_line_info_table_in_use
13800               == separate_line_info_table_allocated)
13801             {
13802               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13803               separate_line_info_table
13804                 = ggc_realloc (separate_line_info_table,
13805                                separate_line_info_table_allocated
13806                                * sizeof (dw_separate_line_info_entry));
13807               memset (separate_line_info_table
13808                        + separate_line_info_table_in_use,
13809                       0,
13810                       (LINE_INFO_TABLE_INCREMENT
13811                        * sizeof (dw_separate_line_info_entry)));
13812             }
13813
13814           /* Add the new entry at the end of the line_info_table.  */
13815           line_info
13816             = &separate_line_info_table[separate_line_info_table_in_use++];
13817           line_info->dw_file_num = file_num;
13818           line_info->dw_line_num = line;
13819           line_info->function = current_function_funcdef_no;
13820         }
13821       else
13822         {
13823           dw_line_info_ref line_info;
13824
13825           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13826                                      line_info_table_in_use);
13827
13828           /* Expand the line info table if necessary.  */
13829           if (line_info_table_in_use == line_info_table_allocated)
13830             {
13831               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13832               line_info_table
13833                 = ggc_realloc (line_info_table,
13834                                (line_info_table_allocated
13835                                 * sizeof (dw_line_info_entry)));
13836               memset (line_info_table + line_info_table_in_use, 0,
13837                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13838             }
13839
13840           /* Add the new entry at the end of the line_info_table.  */
13841           line_info = &line_info_table[line_info_table_in_use++];
13842           line_info->dw_file_num = file_num;
13843           line_info->dw_line_num = line;
13844         }
13845     }
13846 }
13847
13848 /* Record the beginning of a new source file.  */
13849
13850 static void
13851 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13852 {
13853   if (flag_eliminate_dwarf2_dups)
13854     {
13855       /* Record the beginning of the file for break_out_includes.  */
13856       dw_die_ref bincl_die;
13857
13858       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13859       add_AT_string (bincl_die, DW_AT_name, filename);
13860     }
13861
13862   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13863     {
13864       int file_num = maybe_emit_file (lookup_filename (filename));
13865
13866       switch_to_section (debug_macinfo_section);
13867       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13868       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13869                                    lineno);
13870
13871       dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
13872     }
13873 }
13874
13875 /* Record the end of a source file.  */
13876
13877 static void
13878 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13879 {
13880   if (flag_eliminate_dwarf2_dups)
13881     /* Record the end of the file for break_out_includes.  */
13882     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13883
13884   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13885     {
13886       switch_to_section (debug_macinfo_section);
13887       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13888     }
13889 }
13890
13891 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13892    the tail part of the directive line, i.e. the part which is past the
13893    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13894
13895 static void
13896 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13897                   const char *buffer ATTRIBUTE_UNUSED)
13898 {
13899   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13900     {
13901       switch_to_section (debug_macinfo_section);
13902       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13903       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13904       dw2_asm_output_nstring (buffer, -1, "The macro");
13905     }
13906 }
13907
13908 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13909    the tail part of the directive line, i.e. the part which is past the
13910    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13911
13912 static void
13913 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13914                  const char *buffer ATTRIBUTE_UNUSED)
13915 {
13916   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13917     {
13918       switch_to_section (debug_macinfo_section);
13919       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13920       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13921       dw2_asm_output_nstring (buffer, -1, "The macro");
13922     }
13923 }
13924
13925 /* Set up for Dwarf output at the start of compilation.  */
13926
13927 static void
13928 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13929 {
13930   /* Allocate the file_table.  */
13931   file_table = htab_create_ggc (50, file_table_hash,
13932                                 file_table_eq, NULL);
13933
13934   /* Allocate the decl_die_table.  */
13935   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13936                                     decl_die_table_eq, NULL);
13937
13938   /* Allocate the decl_loc_table.  */
13939   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13940                                     decl_loc_table_eq, NULL);
13941
13942   /* Allocate the initial hunk of the decl_scope_table.  */
13943   decl_scope_table = VEC_alloc (tree, gc, 256);
13944
13945   /* Allocate the initial hunk of the abbrev_die_table.  */
13946   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13947                                         * sizeof (dw_die_ref));
13948   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13949   /* Zero-th entry is allocated, but unused.  */
13950   abbrev_die_table_in_use = 1;
13951
13952   /* Allocate the initial hunk of the line_info_table.  */
13953   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13954                                        * sizeof (dw_line_info_entry));
13955   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13956
13957   /* Zero-th entry is allocated, but unused.  */
13958   line_info_table_in_use = 1;
13959
13960   /* Allocate the pubtypes and pubnames vectors.  */
13961   pubname_table = VEC_alloc (pubname_entry, gc, 32);
13962   pubtype_table = VEC_alloc (pubname_entry, gc, 32);
13963
13964   /* Generate the initial DIE for the .debug section.  Note that the (string)
13965      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13966      will (typically) be a relative pathname and that this pathname should be
13967      taken as being relative to the directory from which the compiler was
13968      invoked when the given (base) source file was compiled.  We will fill
13969      in this value in dwarf2out_finish.  */
13970   comp_unit_die = gen_compile_unit_die (NULL);
13971
13972   incomplete_types = VEC_alloc (tree, gc, 64);
13973
13974   used_rtx_array = VEC_alloc (rtx, gc, 32);
13975
13976   debug_info_section = get_section (DEBUG_INFO_SECTION,
13977                                     SECTION_DEBUG, NULL);
13978   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13979                                       SECTION_DEBUG, NULL);
13980   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13981                                        SECTION_DEBUG, NULL);
13982   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13983                                        SECTION_DEBUG, NULL);
13984   debug_line_section = get_section (DEBUG_LINE_SECTION,
13985                                     SECTION_DEBUG, NULL);
13986   debug_loc_section = get_section (DEBUG_LOC_SECTION,
13987                                    SECTION_DEBUG, NULL);
13988   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13989                                         SECTION_DEBUG, NULL);
13990 #ifdef DEBUG_PUBTYPES_SECTION
13991   debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
13992                                         SECTION_DEBUG, NULL);
13993 #endif
13994   debug_str_section = get_section (DEBUG_STR_SECTION,
13995                                    DEBUG_STR_SECTION_FLAGS, NULL);
13996   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13997                                       SECTION_DEBUG, NULL);
13998   debug_frame_section = get_section (DEBUG_FRAME_SECTION,
13999                                      SECTION_DEBUG, NULL);
14000
14001   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
14002   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
14003                                DEBUG_ABBREV_SECTION_LABEL, 0);
14004   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
14005   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
14006                                COLD_TEXT_SECTION_LABEL, 0);
14007   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
14008
14009   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
14010                                DEBUG_INFO_SECTION_LABEL, 0);
14011   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
14012                                DEBUG_LINE_SECTION_LABEL, 0);
14013   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
14014                                DEBUG_RANGES_SECTION_LABEL, 0);
14015   switch_to_section (debug_abbrev_section);
14016   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
14017   switch_to_section (debug_info_section);
14018   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
14019   switch_to_section (debug_line_section);
14020   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
14021
14022   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14023     {
14024       switch_to_section (debug_macinfo_section);
14025       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
14026                                    DEBUG_MACINFO_SECTION_LABEL, 0);
14027       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
14028     }
14029
14030   switch_to_section (text_section);
14031   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
14032   if (flag_reorder_blocks_and_partition)
14033     {
14034       switch_to_section (unlikely_text_section ());
14035       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
14036     }
14037 }
14038
14039 /* A helper function for dwarf2out_finish called through
14040    ht_forall.  Emit one queued .debug_str string.  */
14041
14042 static int
14043 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
14044 {
14045   struct indirect_string_node *node = (struct indirect_string_node *) *h;
14046
14047   if (node->form == DW_FORM_strp)
14048     {
14049       switch_to_section (debug_str_section);
14050       ASM_OUTPUT_LABEL (asm_out_file, node->label);
14051       assemble_string (node->str, strlen (node->str) + 1);
14052     }
14053
14054   return 1;
14055 }
14056
14057 #if ENABLE_ASSERT_CHECKING
14058 /* Verify that all marks are clear.  */
14059
14060 static void
14061 verify_marks_clear (dw_die_ref die)
14062 {
14063   dw_die_ref c;
14064
14065   gcc_assert (! die->die_mark);
14066   FOR_EACH_CHILD (die, c, verify_marks_clear (c));
14067 }
14068 #endif /* ENABLE_ASSERT_CHECKING */
14069
14070 /* Clear the marks for a die and its children.
14071    Be cool if the mark isn't set.  */
14072
14073 static void
14074 prune_unmark_dies (dw_die_ref die)
14075 {
14076   dw_die_ref c;
14077
14078   if (die->die_mark)
14079     die->die_mark = 0;
14080   FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
14081 }
14082
14083 /* Given DIE that we're marking as used, find any other dies
14084    it references as attributes and mark them as used.  */
14085
14086 static void
14087 prune_unused_types_walk_attribs (dw_die_ref die)
14088 {
14089   dw_attr_ref a;
14090   unsigned ix;
14091
14092   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14093     {
14094       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14095         {
14096           /* A reference to another DIE.
14097              Make sure that it will get emitted.  */
14098           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14099         }
14100       /* Set the string's refcount to 0 so that prune_unused_types_mark
14101          accounts properly for it.  */
14102       if (AT_class (a) == dw_val_class_str)
14103         a->dw_attr_val.v.val_str->refcount = 0;
14104     }
14105 }
14106
14107
14108 /* Mark DIE as being used.  If DOKIDS is true, then walk down
14109    to DIE's children.  */
14110
14111 static void
14112 prune_unused_types_mark (dw_die_ref die, int dokids)
14113 {
14114   dw_die_ref c;
14115
14116   if (die->die_mark == 0)
14117     {
14118       /* We haven't done this node yet.  Mark it as used.  */
14119       die->die_mark = 1;
14120
14121       /* We also have to mark its parents as used.
14122          (But we don't want to mark our parents' kids due to this.)  */
14123       if (die->die_parent)
14124         prune_unused_types_mark (die->die_parent, 0);
14125
14126       /* Mark any referenced nodes.  */
14127       prune_unused_types_walk_attribs (die);
14128
14129       /* If this node is a specification,
14130          also mark the definition, if it exists.  */
14131       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14132         prune_unused_types_mark (die->die_definition, 1);
14133     }
14134
14135   if (dokids && die->die_mark != 2)
14136     {
14137       /* We need to walk the children, but haven't done so yet.
14138          Remember that we've walked the kids.  */
14139       die->die_mark = 2;
14140
14141       /* If this is an array type, we need to make sure our
14142          kids get marked, even if they're types.  */
14143       if (die->die_tag == DW_TAG_array_type)
14144         FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14145       else
14146         FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14147     }
14148 }
14149
14150
14151 /* Walk the tree DIE and mark types that we actually use.  */
14152
14153 static void
14154 prune_unused_types_walk (dw_die_ref die)
14155 {
14156   dw_die_ref c;
14157
14158   /* Don't do anything if this node is already marked.  */
14159   if (die->die_mark)
14160     return;
14161
14162   switch (die->die_tag)
14163     {
14164     case DW_TAG_const_type:
14165     case DW_TAG_packed_type:
14166     case DW_TAG_pointer_type:
14167     case DW_TAG_reference_type:
14168     case DW_TAG_volatile_type:
14169     case DW_TAG_typedef:
14170     case DW_TAG_array_type:
14171     case DW_TAG_structure_type:
14172     case DW_TAG_union_type:
14173     case DW_TAG_class_type:
14174     case DW_TAG_friend:
14175     case DW_TAG_variant_part:
14176     case DW_TAG_enumeration_type:
14177     case DW_TAG_subroutine_type:
14178     case DW_TAG_string_type:
14179     case DW_TAG_set_type:
14180     case DW_TAG_subrange_type:
14181     case DW_TAG_ptr_to_member_type:
14182     case DW_TAG_file_type:
14183       if (die->die_perennial_p)
14184         break;
14185
14186       /* It's a type node --- don't mark it.  */
14187       return;
14188
14189     default:
14190       /* Mark everything else.  */
14191       break;
14192   }
14193
14194   die->die_mark = 1;
14195
14196   /* Now, mark any dies referenced from here.  */
14197   prune_unused_types_walk_attribs (die);
14198
14199   /* Mark children.  */
14200   FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14201 }
14202
14203 /* Increment the string counts on strings referred to from DIE's
14204    attributes.  */
14205
14206 static void
14207 prune_unused_types_update_strings (dw_die_ref die)
14208 {
14209   dw_attr_ref a;
14210   unsigned ix;
14211
14212   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14213     if (AT_class (a) == dw_val_class_str)
14214       {
14215         struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14216         s->refcount++;
14217         /* Avoid unnecessarily putting strings that are used less than
14218            twice in the hash table.  */
14219         if (s->refcount
14220             == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14221           {
14222             void ** slot;
14223             slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14224                                              htab_hash_string (s->str),
14225                                              INSERT);
14226             gcc_assert (*slot == NULL);
14227             *slot = s;
14228           }
14229       }
14230 }
14231
14232 /* Remove from the tree DIE any dies that aren't marked.  */
14233
14234 static void
14235 prune_unused_types_prune (dw_die_ref die)
14236 {
14237   dw_die_ref c;
14238
14239   gcc_assert (die->die_mark);
14240   prune_unused_types_update_strings (die);
14241
14242   if (! die->die_child)
14243     return;
14244
14245   c = die->die_child;
14246   do {
14247     dw_die_ref prev = c;
14248     for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14249       if (c == die->die_child)
14250         {
14251           /* No marked children between 'prev' and the end of the list.  */
14252           if (prev == c)
14253             /* No marked children at all.  */
14254             die->die_child = NULL;
14255           else
14256             {
14257               prev->die_sib = c->die_sib;
14258               die->die_child = prev;
14259             }
14260           return;
14261         }
14262
14263     if (c != prev->die_sib)
14264       prev->die_sib = c;
14265     prune_unused_types_prune (c);
14266   } while (c != die->die_child);
14267 }
14268
14269
14270 /* Remove dies representing declarations that we never use.  */
14271
14272 static void
14273 prune_unused_types (void)
14274 {
14275   unsigned int i;
14276   limbo_die_node *node;
14277   pubname_ref pub;
14278
14279 #if ENABLE_ASSERT_CHECKING
14280   /* All the marks should already be clear.  */
14281   verify_marks_clear (comp_unit_die);
14282   for (node = limbo_die_list; node; node = node->next)
14283     verify_marks_clear (node->die);
14284 #endif /* ENABLE_ASSERT_CHECKING */
14285
14286   /* Set the mark on nodes that are actually used.  */
14287   prune_unused_types_walk (comp_unit_die);
14288   for (node = limbo_die_list; node; node = node->next)
14289     prune_unused_types_walk (node->die);
14290
14291   /* Also set the mark on nodes referenced from the
14292      pubname_table or arange_table.  */
14293   for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
14294     prune_unused_types_mark (pub->die, 1);
14295   for (i = 0; i < arange_table_in_use; i++)
14296     prune_unused_types_mark (arange_table[i], 1);
14297
14298   /* Get rid of nodes that aren't marked; and update the string counts.  */
14299   if (debug_str_hash)
14300     htab_empty (debug_str_hash);
14301   prune_unused_types_prune (comp_unit_die);
14302   for (node = limbo_die_list; node; node = node->next)
14303     prune_unused_types_prune (node->die);
14304
14305   /* Leave the marks clear.  */
14306   prune_unmark_dies (comp_unit_die);
14307   for (node = limbo_die_list; node; node = node->next)
14308     prune_unmark_dies (node->die);
14309 }
14310
14311 /* Set the parameter to true if there are any relative pathnames in
14312    the file table.  */
14313 static int
14314 file_table_relative_p (void ** slot, void *param)
14315 {
14316   bool *p = param;
14317   struct dwarf_file_data *d = *slot;
14318   if (d->emitted_number && !IS_ABSOLUTE_PATH (d->filename))
14319     {
14320       *p = true;
14321       return 0;
14322     }
14323   return 1;
14324 }
14325
14326 /* Output stuff that dwarf requires at the end of every file,
14327    and generate the DWARF-2 debugging info.  */
14328
14329 static void
14330 dwarf2out_finish (const char *filename)
14331 {
14332   limbo_die_node *node, *next_node;
14333   dw_die_ref die = 0;
14334
14335   /* Add the name for the main input file now.  We delayed this from
14336      dwarf2out_init to avoid complications with PCH.  */
14337   add_name_attribute (comp_unit_die, filename);
14338   if (!IS_ABSOLUTE_PATH (filename))
14339     add_comp_dir_attribute (comp_unit_die);
14340   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14341     {
14342       bool p = false;
14343       htab_traverse (file_table, file_table_relative_p, &p);
14344       if (p)
14345         add_comp_dir_attribute (comp_unit_die);
14346     }
14347
14348   /* Traverse the limbo die list, and add parent/child links.  The only
14349      dies without parents that should be here are concrete instances of
14350      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14351      For concrete instances, we can get the parent die from the abstract
14352      instance.  */
14353   for (node = limbo_die_list; node; node = next_node)
14354     {
14355       next_node = node->next;
14356       die = node->die;
14357
14358       if (die->die_parent == NULL)
14359         {
14360           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14361
14362           if (origin)
14363             add_child_die (origin->die_parent, die);
14364           else if (die == comp_unit_die)
14365             ;
14366           else if (errorcount > 0 || sorrycount > 0)
14367             /* It's OK to be confused by errors in the input.  */
14368             add_child_die (comp_unit_die, die);
14369           else
14370             {
14371               /* In certain situations, the lexical block containing a
14372                  nested function can be optimized away, which results
14373                  in the nested function die being orphaned.  Likewise
14374                  with the return type of that nested function.  Force
14375                  this to be a child of the containing function.
14376
14377                  It may happen that even the containing function got fully
14378                  inlined and optimized out.  In that case we are lost and
14379                  assign the empty child.  This should not be big issue as
14380                  the function is likely unreachable too.  */
14381               tree context = NULL_TREE;
14382
14383               gcc_assert (node->created_for);
14384
14385               if (DECL_P (node->created_for))
14386                 context = DECL_CONTEXT (node->created_for);
14387               else if (TYPE_P (node->created_for))
14388                 context = TYPE_CONTEXT (node->created_for);
14389
14390               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14391
14392               origin = lookup_decl_die (context);
14393               if (origin)
14394                 add_child_die (origin, die);
14395               else
14396                 add_child_die (comp_unit_die, die);
14397             }
14398         }
14399     }
14400
14401   limbo_die_list = NULL;
14402
14403   /* Walk through the list of incomplete types again, trying once more to
14404      emit full debugging info for them.  */
14405   retry_incomplete_types ();
14406
14407   if (flag_eliminate_unused_debug_types)
14408     prune_unused_types ();
14409
14410   /* Generate separate CUs for each of the include files we've seen.
14411      They will go into limbo_die_list.  */
14412   if (flag_eliminate_dwarf2_dups)
14413     break_out_includes (comp_unit_die);
14414
14415   /* Traverse the DIE's and add add sibling attributes to those DIE's
14416      that have children.  */
14417   add_sibling_attributes (comp_unit_die);
14418   for (node = limbo_die_list; node; node = node->next)
14419     add_sibling_attributes (node->die);
14420
14421   /* Output a terminator label for the .text section.  */
14422   switch_to_section (text_section);
14423   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14424   if (flag_reorder_blocks_and_partition)
14425     {
14426       switch_to_section (unlikely_text_section ());
14427       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14428     }
14429
14430   /* We can only use the low/high_pc attributes if all of the code was
14431      in .text.  */
14432   if (!have_multiple_function_sections)
14433     {
14434       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14435       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14436     }
14437
14438   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14439      "base address".  Use zero so that these addresses become absolute.  */
14440   else if (have_location_lists || ranges_table_in_use)
14441     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14442
14443   /* Output location list section if necessary.  */
14444   if (have_location_lists)
14445     {
14446       /* Output the location lists info.  */
14447       switch_to_section (debug_loc_section);
14448       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14449                                    DEBUG_LOC_SECTION_LABEL, 0);
14450       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14451       output_location_lists (die);
14452     }
14453
14454   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14455     add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14456                     debug_line_section_label);
14457
14458   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14459     add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14460
14461   /* Output all of the compilation units.  We put the main one last so that
14462      the offsets are available to output_pubnames.  */
14463   for (node = limbo_die_list; node; node = node->next)
14464     output_comp_unit (node->die, 0);
14465
14466   output_comp_unit (comp_unit_die, 0);
14467
14468   /* Output the abbreviation table.  */
14469   switch_to_section (debug_abbrev_section);
14470   output_abbrev_section ();
14471
14472   /* Output public names table if necessary.  */
14473   if (!VEC_empty (pubname_entry, pubname_table))
14474     {
14475       switch_to_section (debug_pubnames_section);
14476       output_pubnames (pubname_table);
14477     }
14478
14479 #ifdef DEBUG_PUBTYPES_SECTION
14480   /* Output public types table if necessary.  */
14481   if (!VEC_empty (pubname_entry, pubtype_table))
14482     {
14483       switch_to_section (debug_pubtypes_section);
14484       output_pubnames (pubtype_table);
14485     }
14486 #endif
14487
14488   /* Output the address range information.  We only put functions in the arange
14489      table, so don't write it out if we don't have any.  */
14490   if (fde_table_in_use)
14491     {
14492       switch_to_section (debug_aranges_section);
14493       output_aranges ();
14494     }
14495
14496   /* Output ranges section if necessary.  */
14497   if (ranges_table_in_use)
14498     {
14499       switch_to_section (debug_ranges_section);
14500       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14501       output_ranges ();
14502     }
14503
14504   /* Output the source line correspondence table.  We must do this
14505      even if there is no line information.  Otherwise, on an empty
14506      translation unit, we will generate a present, but empty,
14507      .debug_info section.  IRIX 6.5 `nm' will then complain when
14508      examining the file.  This is done late so that any filenames
14509      used by the debug_info section are marked as 'used'.  */
14510   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14511     {
14512       switch_to_section (debug_line_section);
14513       output_line_info ();
14514     }
14515
14516   /* Have to end the macro section.  */
14517   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14518     {
14519       switch_to_section (debug_macinfo_section);
14520       dw2_asm_output_data (1, 0, "End compilation unit");
14521     }
14522
14523   /* If we emitted any DW_FORM_strp form attribute, output the string
14524      table too.  */
14525   if (debug_str_hash)
14526     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14527 }
14528 #else
14529
14530 /* This should never be used, but its address is needed for comparisons.  */
14531 const struct gcc_debug_hooks dwarf2_debug_hooks;
14532
14533 #endif /* DWARF2_DEBUGGING_INFO */
14534
14535 #include "gt-dwarf2out.h"