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 int is_base_type (tree);
4157 static bool is_subrange_type (tree);
4158 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4159 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4160 static int type_is_enum (tree);
4161 static unsigned int dbx_reg_number (rtx);
4162 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4163 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4164 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4165 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4166 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4167 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4168 static int is_based_loc (rtx);
4169 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4170 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4171 static dw_loc_descr_ref loc_descriptor (rtx);
4172 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4173 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4174 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4175 static tree field_type (tree);
4176 static unsigned int simple_type_align_in_bits (tree);
4177 static unsigned int simple_decl_align_in_bits (tree);
4178 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4179 static HOST_WIDE_INT field_byte_offset (tree);
4180 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4181                                          dw_loc_descr_ref);
4182 static void add_data_member_location_attribute (dw_die_ref, tree);
4183 static void add_const_value_attribute (dw_die_ref, rtx);
4184 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4185 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4186 static void insert_float (rtx, unsigned char *);
4187 static rtx rtl_for_decl_location (tree);
4188 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4189                                                    enum dwarf_attribute);
4190 static void tree_add_const_value_attribute (dw_die_ref, tree);
4191 static void add_name_attribute (dw_die_ref, const char *);
4192 static void add_comp_dir_attribute (dw_die_ref);
4193 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4194 static void add_subscript_info (dw_die_ref, tree);
4195 static void add_byte_size_attribute (dw_die_ref, tree);
4196 static void add_bit_offset_attribute (dw_die_ref, tree);
4197 static void add_bit_size_attribute (dw_die_ref, tree);
4198 static void add_prototyped_attribute (dw_die_ref, tree);
4199 static void add_abstract_origin_attribute (dw_die_ref, tree);
4200 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4201 static void add_src_coords_attributes (dw_die_ref, tree);
4202 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4203 static void push_decl_scope (tree);
4204 static void pop_decl_scope (void);
4205 static dw_die_ref scope_die_for (tree, dw_die_ref);
4206 static inline int local_scope_p (dw_die_ref);
4207 static inline int class_or_namespace_scope_p (dw_die_ref);
4208 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4209 static void add_calling_convention_attribute (dw_die_ref, tree);
4210 static const char *type_tag (tree);
4211 static tree member_declared_type (tree);
4212 #if 0
4213 static const char *decl_start_label (tree);
4214 #endif
4215 static void gen_array_type_die (tree, dw_die_ref);
4216 #if 0
4217 static void gen_entry_point_die (tree, dw_die_ref);
4218 #endif
4219 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4220 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4221 static void gen_inlined_union_type_die (tree, dw_die_ref);
4222 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4223 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4224 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4225 static void gen_formal_types_die (tree, dw_die_ref);
4226 static void gen_subprogram_die (tree, dw_die_ref);
4227 static void gen_variable_die (tree, dw_die_ref);
4228 static void gen_label_die (tree, dw_die_ref);
4229 static void gen_lexical_block_die (tree, dw_die_ref, int);
4230 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4231 static void gen_field_die (tree, dw_die_ref);
4232 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4233 static dw_die_ref gen_compile_unit_die (const char *);
4234 static void gen_inheritance_die (tree, tree, dw_die_ref);
4235 static void gen_member_die (tree, dw_die_ref);
4236 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4237 static void gen_subroutine_type_die (tree, dw_die_ref);
4238 static void gen_typedef_die (tree, dw_die_ref);
4239 static void gen_type_die (tree, dw_die_ref);
4240 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4241 static void gen_block_die (tree, dw_die_ref, int);
4242 static void decls_for_scope (tree, dw_die_ref, int);
4243 static int is_redundant_typedef (tree);
4244 static void gen_namespace_die (tree);
4245 static void gen_decl_die (tree, dw_die_ref);
4246 static dw_die_ref force_decl_die (tree);
4247 static dw_die_ref force_type_die (tree);
4248 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4249 static void declare_in_namespace (tree, dw_die_ref);
4250 static struct dwarf_file_data * lookup_filename (const char *);
4251 static void retry_incomplete_types (void);
4252 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4253 static void splice_child_die (dw_die_ref, dw_die_ref);
4254 static int file_info_cmp (const void *, const void *);
4255 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4256                                      const char *, const char *, unsigned);
4257 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4258                                        const char *, const char *,
4259                                        const char *);
4260 static void output_loc_list (dw_loc_list_ref);
4261 static char *gen_internal_sym (const char *);
4262
4263 static void prune_unmark_dies (dw_die_ref);
4264 static void prune_unused_types_mark (dw_die_ref, int);
4265 static void prune_unused_types_walk (dw_die_ref);
4266 static void prune_unused_types_walk_attribs (dw_die_ref);
4267 static void prune_unused_types_prune (dw_die_ref);
4268 static void prune_unused_types (void);
4269 static int maybe_emit_file (struct dwarf_file_data *fd);
4270
4271 /* Section names used to hold DWARF debugging information.  */
4272 #ifndef DEBUG_INFO_SECTION
4273 #define DEBUG_INFO_SECTION      ".debug_info"
4274 #endif
4275 #ifndef DEBUG_ABBREV_SECTION
4276 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4277 #endif
4278 #ifndef DEBUG_ARANGES_SECTION
4279 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4280 #endif
4281 #ifndef DEBUG_MACINFO_SECTION
4282 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4283 #endif
4284 #ifndef DEBUG_LINE_SECTION
4285 #define DEBUG_LINE_SECTION      ".debug_line"
4286 #endif
4287 #ifndef DEBUG_LOC_SECTION
4288 #define DEBUG_LOC_SECTION       ".debug_loc"
4289 #endif
4290 #ifndef DEBUG_PUBNAMES_SECTION
4291 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4292 #endif
4293 #ifndef DEBUG_STR_SECTION
4294 #define DEBUG_STR_SECTION       ".debug_str"
4295 #endif
4296 #ifndef DEBUG_RANGES_SECTION
4297 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4298 #endif
4299
4300 /* Standard ELF section names for compiled code and data.  */
4301 #ifndef TEXT_SECTION_NAME
4302 #define TEXT_SECTION_NAME       ".text"
4303 #endif
4304
4305 /* Section flags for .debug_str section.  */
4306 #define DEBUG_STR_SECTION_FLAGS \
4307   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4308    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4309    : SECTION_DEBUG)
4310
4311 /* Labels we insert at beginning sections we can reference instead of
4312    the section names themselves.  */
4313
4314 #ifndef TEXT_SECTION_LABEL
4315 #define TEXT_SECTION_LABEL              "Ltext"
4316 #endif
4317 #ifndef COLD_TEXT_SECTION_LABEL
4318 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4319 #endif
4320 #ifndef DEBUG_LINE_SECTION_LABEL
4321 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4322 #endif
4323 #ifndef DEBUG_INFO_SECTION_LABEL
4324 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4325 #endif
4326 #ifndef DEBUG_ABBREV_SECTION_LABEL
4327 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4328 #endif
4329 #ifndef DEBUG_LOC_SECTION_LABEL
4330 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4331 #endif
4332 #ifndef DEBUG_RANGES_SECTION_LABEL
4333 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4334 #endif
4335 #ifndef DEBUG_MACINFO_SECTION_LABEL
4336 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4337 #endif
4338
4339 /* Definitions of defaults for formats and names of various special
4340    (artificial) labels which may be generated within this file (when the -g
4341    options is used and DWARF2_DEBUGGING_INFO is in effect.
4342    If necessary, these may be overridden from within the tm.h file, but
4343    typically, overriding these defaults is unnecessary.  */
4344
4345 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4346 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4347 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4348 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4349 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4350 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4351 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4352 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4353 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4354 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4355
4356 #ifndef TEXT_END_LABEL
4357 #define TEXT_END_LABEL          "Letext"
4358 #endif
4359 #ifndef COLD_END_LABEL
4360 #define COLD_END_LABEL          "Letext_cold"
4361 #endif
4362 #ifndef BLOCK_BEGIN_LABEL
4363 #define BLOCK_BEGIN_LABEL       "LBB"
4364 #endif
4365 #ifndef BLOCK_END_LABEL
4366 #define BLOCK_END_LABEL         "LBE"
4367 #endif
4368 #ifndef LINE_CODE_LABEL
4369 #define LINE_CODE_LABEL         "LM"
4370 #endif
4371 #ifndef SEPARATE_LINE_CODE_LABEL
4372 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4373 #endif
4374 \f
4375 /* We allow a language front-end to designate a function that is to be
4376    called to "demangle" any name before it is put into a DIE.  */
4377
4378 static const char *(*demangle_name_func) (const char *);
4379
4380 void
4381 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4382 {
4383   demangle_name_func = func;
4384 }
4385
4386 /* Test if rtl node points to a pseudo register.  */
4387
4388 static inline int
4389 is_pseudo_reg (rtx rtl)
4390 {
4391   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4392           || (GET_CODE (rtl) == SUBREG
4393               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4394 }
4395
4396 /* Return a reference to a type, with its const and volatile qualifiers
4397    removed.  */
4398
4399 static inline tree
4400 type_main_variant (tree type)
4401 {
4402   type = TYPE_MAIN_VARIANT (type);
4403
4404   /* ??? There really should be only one main variant among any group of
4405      variants of a given type (and all of the MAIN_VARIANT values for all
4406      members of the group should point to that one type) but sometimes the C
4407      front-end messes this up for array types, so we work around that bug
4408      here.  */
4409   if (TREE_CODE (type) == ARRAY_TYPE)
4410     while (type != TYPE_MAIN_VARIANT (type))
4411       type = TYPE_MAIN_VARIANT (type);
4412
4413   return type;
4414 }
4415
4416 /* Return nonzero if the given type node represents a tagged type.  */
4417
4418 static inline int
4419 is_tagged_type (tree type)
4420 {
4421   enum tree_code code = TREE_CODE (type);
4422
4423   return (code == RECORD_TYPE || code == UNION_TYPE
4424           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4425 }
4426
4427 /* Convert a DIE tag into its string name.  */
4428
4429 static const char *
4430 dwarf_tag_name (unsigned int tag)
4431 {
4432   switch (tag)
4433     {
4434     case DW_TAG_padding:
4435       return "DW_TAG_padding";
4436     case DW_TAG_array_type:
4437       return "DW_TAG_array_type";
4438     case DW_TAG_class_type:
4439       return "DW_TAG_class_type";
4440     case DW_TAG_entry_point:
4441       return "DW_TAG_entry_point";
4442     case DW_TAG_enumeration_type:
4443       return "DW_TAG_enumeration_type";
4444     case DW_TAG_formal_parameter:
4445       return "DW_TAG_formal_parameter";
4446     case DW_TAG_imported_declaration:
4447       return "DW_TAG_imported_declaration";
4448     case DW_TAG_label:
4449       return "DW_TAG_label";
4450     case DW_TAG_lexical_block:
4451       return "DW_TAG_lexical_block";
4452     case DW_TAG_member:
4453       return "DW_TAG_member";
4454     case DW_TAG_pointer_type:
4455       return "DW_TAG_pointer_type";
4456     case DW_TAG_reference_type:
4457       return "DW_TAG_reference_type";
4458     case DW_TAG_compile_unit:
4459       return "DW_TAG_compile_unit";
4460     case DW_TAG_string_type:
4461       return "DW_TAG_string_type";
4462     case DW_TAG_structure_type:
4463       return "DW_TAG_structure_type";
4464     case DW_TAG_subroutine_type:
4465       return "DW_TAG_subroutine_type";
4466     case DW_TAG_typedef:
4467       return "DW_TAG_typedef";
4468     case DW_TAG_union_type:
4469       return "DW_TAG_union_type";
4470     case DW_TAG_unspecified_parameters:
4471       return "DW_TAG_unspecified_parameters";
4472     case DW_TAG_variant:
4473       return "DW_TAG_variant";
4474     case DW_TAG_common_block:
4475       return "DW_TAG_common_block";
4476     case DW_TAG_common_inclusion:
4477       return "DW_TAG_common_inclusion";
4478     case DW_TAG_inheritance:
4479       return "DW_TAG_inheritance";
4480     case DW_TAG_inlined_subroutine:
4481       return "DW_TAG_inlined_subroutine";
4482     case DW_TAG_module:
4483       return "DW_TAG_module";
4484     case DW_TAG_ptr_to_member_type:
4485       return "DW_TAG_ptr_to_member_type";
4486     case DW_TAG_set_type:
4487       return "DW_TAG_set_type";
4488     case DW_TAG_subrange_type:
4489       return "DW_TAG_subrange_type";
4490     case DW_TAG_with_stmt:
4491       return "DW_TAG_with_stmt";
4492     case DW_TAG_access_declaration:
4493       return "DW_TAG_access_declaration";
4494     case DW_TAG_base_type:
4495       return "DW_TAG_base_type";
4496     case DW_TAG_catch_block:
4497       return "DW_TAG_catch_block";
4498     case DW_TAG_const_type:
4499       return "DW_TAG_const_type";
4500     case DW_TAG_constant:
4501       return "DW_TAG_constant";
4502     case DW_TAG_enumerator:
4503       return "DW_TAG_enumerator";
4504     case DW_TAG_file_type:
4505       return "DW_TAG_file_type";
4506     case DW_TAG_friend:
4507       return "DW_TAG_friend";
4508     case DW_TAG_namelist:
4509       return "DW_TAG_namelist";
4510     case DW_TAG_namelist_item:
4511       return "DW_TAG_namelist_item";
4512     case DW_TAG_namespace:
4513       return "DW_TAG_namespace";
4514     case DW_TAG_packed_type:
4515       return "DW_TAG_packed_type";
4516     case DW_TAG_subprogram:
4517       return "DW_TAG_subprogram";
4518     case DW_TAG_template_type_param:
4519       return "DW_TAG_template_type_param";
4520     case DW_TAG_template_value_param:
4521       return "DW_TAG_template_value_param";
4522     case DW_TAG_thrown_type:
4523       return "DW_TAG_thrown_type";
4524     case DW_TAG_try_block:
4525       return "DW_TAG_try_block";
4526     case DW_TAG_variant_part:
4527       return "DW_TAG_variant_part";
4528     case DW_TAG_variable:
4529       return "DW_TAG_variable";
4530     case DW_TAG_volatile_type:
4531       return "DW_TAG_volatile_type";
4532     case DW_TAG_imported_module:
4533       return "DW_TAG_imported_module";
4534     case DW_TAG_MIPS_loop:
4535       return "DW_TAG_MIPS_loop";
4536     case DW_TAG_format_label:
4537       return "DW_TAG_format_label";
4538     case DW_TAG_function_template:
4539       return "DW_TAG_function_template";
4540     case DW_TAG_class_template:
4541       return "DW_TAG_class_template";
4542     case DW_TAG_GNU_BINCL:
4543       return "DW_TAG_GNU_BINCL";
4544     case DW_TAG_GNU_EINCL:
4545       return "DW_TAG_GNU_EINCL";
4546     default:
4547       return "DW_TAG_<unknown>";
4548     }
4549 }
4550
4551 /* Convert a DWARF attribute code into its string name.  */
4552
4553 static const char *
4554 dwarf_attr_name (unsigned int attr)
4555 {
4556   switch (attr)
4557     {
4558     case DW_AT_sibling:
4559       return "DW_AT_sibling";
4560     case DW_AT_location:
4561       return "DW_AT_location";
4562     case DW_AT_name:
4563       return "DW_AT_name";
4564     case DW_AT_ordering:
4565       return "DW_AT_ordering";
4566     case DW_AT_subscr_data:
4567       return "DW_AT_subscr_data";
4568     case DW_AT_byte_size:
4569       return "DW_AT_byte_size";
4570     case DW_AT_bit_offset:
4571       return "DW_AT_bit_offset";
4572     case DW_AT_bit_size:
4573       return "DW_AT_bit_size";
4574     case DW_AT_element_list:
4575       return "DW_AT_element_list";
4576     case DW_AT_stmt_list:
4577       return "DW_AT_stmt_list";
4578     case DW_AT_low_pc:
4579       return "DW_AT_low_pc";
4580     case DW_AT_high_pc:
4581       return "DW_AT_high_pc";
4582     case DW_AT_language:
4583       return "DW_AT_language";
4584     case DW_AT_member:
4585       return "DW_AT_member";
4586     case DW_AT_discr:
4587       return "DW_AT_discr";
4588     case DW_AT_discr_value:
4589       return "DW_AT_discr_value";
4590     case DW_AT_visibility:
4591       return "DW_AT_visibility";
4592     case DW_AT_import:
4593       return "DW_AT_import";
4594     case DW_AT_string_length:
4595       return "DW_AT_string_length";
4596     case DW_AT_common_reference:
4597       return "DW_AT_common_reference";
4598     case DW_AT_comp_dir:
4599       return "DW_AT_comp_dir";
4600     case DW_AT_const_value:
4601       return "DW_AT_const_value";
4602     case DW_AT_containing_type:
4603       return "DW_AT_containing_type";
4604     case DW_AT_default_value:
4605       return "DW_AT_default_value";
4606     case DW_AT_inline:
4607       return "DW_AT_inline";
4608     case DW_AT_is_optional:
4609       return "DW_AT_is_optional";
4610     case DW_AT_lower_bound:
4611       return "DW_AT_lower_bound";
4612     case DW_AT_producer:
4613       return "DW_AT_producer";
4614     case DW_AT_prototyped:
4615       return "DW_AT_prototyped";
4616     case DW_AT_return_addr:
4617       return "DW_AT_return_addr";
4618     case DW_AT_start_scope:
4619       return "DW_AT_start_scope";
4620     case DW_AT_stride_size:
4621       return "DW_AT_stride_size";
4622     case DW_AT_upper_bound:
4623       return "DW_AT_upper_bound";
4624     case DW_AT_abstract_origin:
4625       return "DW_AT_abstract_origin";
4626     case DW_AT_accessibility:
4627       return "DW_AT_accessibility";
4628     case DW_AT_address_class:
4629       return "DW_AT_address_class";
4630     case DW_AT_artificial:
4631       return "DW_AT_artificial";
4632     case DW_AT_base_types:
4633       return "DW_AT_base_types";
4634     case DW_AT_calling_convention:
4635       return "DW_AT_calling_convention";
4636     case DW_AT_count:
4637       return "DW_AT_count";
4638     case DW_AT_data_member_location:
4639       return "DW_AT_data_member_location";
4640     case DW_AT_decl_column:
4641       return "DW_AT_decl_column";
4642     case DW_AT_decl_file:
4643       return "DW_AT_decl_file";
4644     case DW_AT_decl_line:
4645       return "DW_AT_decl_line";
4646     case DW_AT_declaration:
4647       return "DW_AT_declaration";
4648     case DW_AT_discr_list:
4649       return "DW_AT_discr_list";
4650     case DW_AT_encoding:
4651       return "DW_AT_encoding";
4652     case DW_AT_external:
4653       return "DW_AT_external";
4654     case DW_AT_frame_base:
4655       return "DW_AT_frame_base";
4656     case DW_AT_friend:
4657       return "DW_AT_friend";
4658     case DW_AT_identifier_case:
4659       return "DW_AT_identifier_case";
4660     case DW_AT_macro_info:
4661       return "DW_AT_macro_info";
4662     case DW_AT_namelist_items:
4663       return "DW_AT_namelist_items";
4664     case DW_AT_priority:
4665       return "DW_AT_priority";
4666     case DW_AT_segment:
4667       return "DW_AT_segment";
4668     case DW_AT_specification:
4669       return "DW_AT_specification";
4670     case DW_AT_static_link:
4671       return "DW_AT_static_link";
4672     case DW_AT_type:
4673       return "DW_AT_type";
4674     case DW_AT_use_location:
4675       return "DW_AT_use_location";
4676     case DW_AT_variable_parameter:
4677       return "DW_AT_variable_parameter";
4678     case DW_AT_virtuality:
4679       return "DW_AT_virtuality";
4680     case DW_AT_vtable_elem_location:
4681       return "DW_AT_vtable_elem_location";
4682
4683     case DW_AT_allocated:
4684       return "DW_AT_allocated";
4685     case DW_AT_associated:
4686       return "DW_AT_associated";
4687     case DW_AT_data_location:
4688       return "DW_AT_data_location";
4689     case DW_AT_stride:
4690       return "DW_AT_stride";
4691     case DW_AT_entry_pc:
4692       return "DW_AT_entry_pc";
4693     case DW_AT_use_UTF8:
4694       return "DW_AT_use_UTF8";
4695     case DW_AT_extension:
4696       return "DW_AT_extension";
4697     case DW_AT_ranges:
4698       return "DW_AT_ranges";
4699     case DW_AT_trampoline:
4700       return "DW_AT_trampoline";
4701     case DW_AT_call_column:
4702       return "DW_AT_call_column";
4703     case DW_AT_call_file:
4704       return "DW_AT_call_file";
4705     case DW_AT_call_line:
4706       return "DW_AT_call_line";
4707
4708     case DW_AT_MIPS_fde:
4709       return "DW_AT_MIPS_fde";
4710     case DW_AT_MIPS_loop_begin:
4711       return "DW_AT_MIPS_loop_begin";
4712     case DW_AT_MIPS_tail_loop_begin:
4713       return "DW_AT_MIPS_tail_loop_begin";
4714     case DW_AT_MIPS_epilog_begin:
4715       return "DW_AT_MIPS_epilog_begin";
4716     case DW_AT_MIPS_loop_unroll_factor:
4717       return "DW_AT_MIPS_loop_unroll_factor";
4718     case DW_AT_MIPS_software_pipeline_depth:
4719       return "DW_AT_MIPS_software_pipeline_depth";
4720     case DW_AT_MIPS_linkage_name:
4721       return "DW_AT_MIPS_linkage_name";
4722     case DW_AT_MIPS_stride:
4723       return "DW_AT_MIPS_stride";
4724     case DW_AT_MIPS_abstract_name:
4725       return "DW_AT_MIPS_abstract_name";
4726     case DW_AT_MIPS_clone_origin:
4727       return "DW_AT_MIPS_clone_origin";
4728     case DW_AT_MIPS_has_inlines:
4729       return "DW_AT_MIPS_has_inlines";
4730
4731     case DW_AT_sf_names:
4732       return "DW_AT_sf_names";
4733     case DW_AT_src_info:
4734       return "DW_AT_src_info";
4735     case DW_AT_mac_info:
4736       return "DW_AT_mac_info";
4737     case DW_AT_src_coords:
4738       return "DW_AT_src_coords";
4739     case DW_AT_body_begin:
4740       return "DW_AT_body_begin";
4741     case DW_AT_body_end:
4742       return "DW_AT_body_end";
4743     case DW_AT_GNU_vector:
4744       return "DW_AT_GNU_vector";
4745
4746     case DW_AT_VMS_rtnbeg_pd_address:
4747       return "DW_AT_VMS_rtnbeg_pd_address";
4748
4749     default:
4750       return "DW_AT_<unknown>";
4751     }
4752 }
4753
4754 /* Convert a DWARF value form code into its string name.  */
4755
4756 static const char *
4757 dwarf_form_name (unsigned int form)
4758 {
4759   switch (form)
4760     {
4761     case DW_FORM_addr:
4762       return "DW_FORM_addr";
4763     case DW_FORM_block2:
4764       return "DW_FORM_block2";
4765     case DW_FORM_block4:
4766       return "DW_FORM_block4";
4767     case DW_FORM_data2:
4768       return "DW_FORM_data2";
4769     case DW_FORM_data4:
4770       return "DW_FORM_data4";
4771     case DW_FORM_data8:
4772       return "DW_FORM_data8";
4773     case DW_FORM_string:
4774       return "DW_FORM_string";
4775     case DW_FORM_block:
4776       return "DW_FORM_block";
4777     case DW_FORM_block1:
4778       return "DW_FORM_block1";
4779     case DW_FORM_data1:
4780       return "DW_FORM_data1";
4781     case DW_FORM_flag:
4782       return "DW_FORM_flag";
4783     case DW_FORM_sdata:
4784       return "DW_FORM_sdata";
4785     case DW_FORM_strp:
4786       return "DW_FORM_strp";
4787     case DW_FORM_udata:
4788       return "DW_FORM_udata";
4789     case DW_FORM_ref_addr:
4790       return "DW_FORM_ref_addr";
4791     case DW_FORM_ref1:
4792       return "DW_FORM_ref1";
4793     case DW_FORM_ref2:
4794       return "DW_FORM_ref2";
4795     case DW_FORM_ref4:
4796       return "DW_FORM_ref4";
4797     case DW_FORM_ref8:
4798       return "DW_FORM_ref8";
4799     case DW_FORM_ref_udata:
4800       return "DW_FORM_ref_udata";
4801     case DW_FORM_indirect:
4802       return "DW_FORM_indirect";
4803     default:
4804       return "DW_FORM_<unknown>";
4805     }
4806 }
4807 \f
4808 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4809    instance of an inlined instance of a decl which is local to an inline
4810    function, so we have to trace all of the way back through the origin chain
4811    to find out what sort of node actually served as the original seed for the
4812    given block.  */
4813
4814 static tree
4815 decl_ultimate_origin (tree decl)
4816 {
4817   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4818     return NULL_TREE;
4819
4820   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4821      nodes in the function to point to themselves; ignore that if
4822      we're trying to output the abstract instance of this function.  */
4823   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4824     return NULL_TREE;
4825
4826   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4827      most distant ancestor, this should never happen.  */
4828   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4829
4830   return DECL_ABSTRACT_ORIGIN (decl);
4831 }
4832
4833 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4834    instance of an inlined instance of a block which is local to an inline
4835    function, so we have to trace all of the way back through the origin chain
4836    to find out what sort of node actually served as the original seed for the
4837    given block.  */
4838
4839 static tree
4840 block_ultimate_origin (tree block)
4841 {
4842   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4843
4844   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4845      nodes in the function to point to themselves; ignore that if
4846      we're trying to output the abstract instance of this function.  */
4847   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4848     return NULL_TREE;
4849
4850   if (immediate_origin == NULL_TREE)
4851     return NULL_TREE;
4852   else
4853     {
4854       tree ret_val;
4855       tree lookahead = immediate_origin;
4856
4857       do
4858         {
4859           ret_val = lookahead;
4860           lookahead = (TREE_CODE (ret_val) == BLOCK
4861                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4862         }
4863       while (lookahead != NULL && lookahead != ret_val);
4864
4865       /* The block's abstract origin chain may not be the *ultimate* origin of
4866          the block. It could lead to a DECL that has an abstract origin set.
4867          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4868          will give us if it has one).  Note that DECL's abstract origins are
4869          supposed to be the most distant ancestor (or so decl_ultimate_origin
4870          claims), so we don't need to loop following the DECL origins.  */
4871       if (DECL_P (ret_val))
4872         return DECL_ORIGIN (ret_val);
4873
4874       return ret_val;
4875     }
4876 }
4877
4878 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4879    of a virtual function may refer to a base class, so we check the 'this'
4880    parameter.  */
4881
4882 static tree
4883 decl_class_context (tree decl)
4884 {
4885   tree context = NULL_TREE;
4886
4887   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4888     context = DECL_CONTEXT (decl);
4889   else
4890     context = TYPE_MAIN_VARIANT
4891       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4892
4893   if (context && !TYPE_P (context))
4894     context = NULL_TREE;
4895
4896   return context;
4897 }
4898 \f
4899 /* Add an attribute/value pair to a DIE.  */
4900
4901 static inline void
4902 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4903 {
4904   /* Maybe this should be an assert?  */
4905   if (die == NULL)
4906     return;
4907
4908   if (die->die_attr == NULL)
4909     die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4910   VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4911 }
4912
4913 static inline enum dw_val_class
4914 AT_class (dw_attr_ref a)
4915 {
4916   return a->dw_attr_val.val_class;
4917 }
4918
4919 /* Add a flag value attribute to a DIE.  */
4920
4921 static inline void
4922 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4923 {
4924   dw_attr_node attr;
4925
4926   attr.dw_attr = attr_kind;
4927   attr.dw_attr_val.val_class = dw_val_class_flag;
4928   attr.dw_attr_val.v.val_flag = flag;
4929   add_dwarf_attr (die, &attr);
4930 }
4931
4932 static inline unsigned
4933 AT_flag (dw_attr_ref a)
4934 {
4935   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4936   return a->dw_attr_val.v.val_flag;
4937 }
4938
4939 /* Add a signed integer attribute value to a DIE.  */
4940
4941 static inline void
4942 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4943 {
4944   dw_attr_node attr;
4945
4946   attr.dw_attr = attr_kind;
4947   attr.dw_attr_val.val_class = dw_val_class_const;
4948   attr.dw_attr_val.v.val_int = int_val;
4949   add_dwarf_attr (die, &attr);
4950 }
4951
4952 static inline HOST_WIDE_INT
4953 AT_int (dw_attr_ref a)
4954 {
4955   gcc_assert (a && AT_class (a) == dw_val_class_const);
4956   return a->dw_attr_val.v.val_int;
4957 }
4958
4959 /* Add an unsigned integer attribute value to a DIE.  */
4960
4961 static inline void
4962 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4963                  unsigned HOST_WIDE_INT unsigned_val)
4964 {
4965   dw_attr_node attr;
4966
4967   attr.dw_attr = attr_kind;
4968   attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4969   attr.dw_attr_val.v.val_unsigned = unsigned_val;
4970   add_dwarf_attr (die, &attr);
4971 }
4972
4973 static inline unsigned HOST_WIDE_INT
4974 AT_unsigned (dw_attr_ref a)
4975 {
4976   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4977   return a->dw_attr_val.v.val_unsigned;
4978 }
4979
4980 /* Add an unsigned double integer attribute value to a DIE.  */
4981
4982 static inline void
4983 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4984                   long unsigned int val_hi, long unsigned int val_low)
4985 {
4986   dw_attr_node attr;
4987
4988   attr.dw_attr = attr_kind;
4989   attr.dw_attr_val.val_class = dw_val_class_long_long;
4990   attr.dw_attr_val.v.val_long_long.hi = val_hi;
4991   attr.dw_attr_val.v.val_long_long.low = val_low;
4992   add_dwarf_attr (die, &attr);
4993 }
4994
4995 /* Add a floating point attribute value to a DIE and return it.  */
4996
4997 static inline void
4998 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4999             unsigned int length, unsigned int elt_size, unsigned char *array)
5000 {
5001   dw_attr_node attr;
5002
5003   attr.dw_attr = attr_kind;
5004   attr.dw_attr_val.val_class = dw_val_class_vec;
5005   attr.dw_attr_val.v.val_vec.length = length;
5006   attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5007   attr.dw_attr_val.v.val_vec.array = array;
5008   add_dwarf_attr (die, &attr);
5009 }
5010
5011 /* Hash and equality functions for debug_str_hash.  */
5012
5013 static hashval_t
5014 debug_str_do_hash (const void *x)
5015 {
5016   return htab_hash_string (((const struct indirect_string_node *)x)->str);
5017 }
5018
5019 static int
5020 debug_str_eq (const void *x1, const void *x2)
5021 {
5022   return strcmp ((((const struct indirect_string_node *)x1)->str),
5023                  (const char *)x2) == 0;
5024 }
5025
5026 /* Add a string attribute value to a DIE.  */
5027
5028 static inline void
5029 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5030 {
5031   dw_attr_node attr;
5032   struct indirect_string_node *node;
5033   void **slot;
5034
5035   if (! debug_str_hash)
5036     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5037                                       debug_str_eq, NULL);
5038
5039   slot = htab_find_slot_with_hash (debug_str_hash, str,
5040                                    htab_hash_string (str), INSERT);
5041   if (*slot == NULL)
5042     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
5043   node = (struct indirect_string_node *) *slot;
5044   node->str = ggc_strdup (str);
5045   node->refcount++;
5046
5047   attr.dw_attr = attr_kind;
5048   attr.dw_attr_val.val_class = dw_val_class_str;
5049   attr.dw_attr_val.v.val_str = node;
5050   add_dwarf_attr (die, &attr);
5051 }
5052
5053 static inline const char *
5054 AT_string (dw_attr_ref a)
5055 {
5056   gcc_assert (a && AT_class (a) == dw_val_class_str);
5057   return a->dw_attr_val.v.val_str->str;
5058 }
5059
5060 /* Find out whether a string should be output inline in DIE
5061    or out-of-line in .debug_str section.  */
5062
5063 static int
5064 AT_string_form (dw_attr_ref a)
5065 {
5066   struct indirect_string_node *node;
5067   unsigned int len;
5068   char label[32];
5069
5070   gcc_assert (a && AT_class (a) == dw_val_class_str);
5071
5072   node = a->dw_attr_val.v.val_str;
5073   if (node->form)
5074     return node->form;
5075
5076   len = strlen (node->str) + 1;
5077
5078   /* If the string is shorter or equal to the size of the reference, it is
5079      always better to put it inline.  */
5080   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5081     return node->form = DW_FORM_string;
5082
5083   /* If we cannot expect the linker to merge strings in .debug_str
5084      section, only put it into .debug_str if it is worth even in this
5085      single module.  */
5086   if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5087       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5088     return node->form = DW_FORM_string;
5089
5090   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5091   ++dw2_string_counter;
5092   node->label = xstrdup (label);
5093
5094   return node->form = DW_FORM_strp;
5095 }
5096
5097 /* Add a DIE reference attribute value to a DIE.  */
5098
5099 static inline void
5100 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5101 {
5102   dw_attr_node attr;
5103
5104   attr.dw_attr = attr_kind;
5105   attr.dw_attr_val.val_class = dw_val_class_die_ref;
5106   attr.dw_attr_val.v.val_die_ref.die = targ_die;
5107   attr.dw_attr_val.v.val_die_ref.external = 0;
5108   add_dwarf_attr (die, &attr);
5109 }
5110
5111 /* Add an AT_specification attribute to a DIE, and also make the back
5112    pointer from the specification to the definition.  */
5113
5114 static inline void
5115 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5116 {
5117   add_AT_die_ref (die, DW_AT_specification, targ_die);
5118   gcc_assert (!targ_die->die_definition);
5119   targ_die->die_definition = die;
5120 }
5121
5122 static inline dw_die_ref
5123 AT_ref (dw_attr_ref a)
5124 {
5125   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5126   return a->dw_attr_val.v.val_die_ref.die;
5127 }
5128
5129 static inline int
5130 AT_ref_external (dw_attr_ref a)
5131 {
5132   if (a && AT_class (a) == dw_val_class_die_ref)
5133     return a->dw_attr_val.v.val_die_ref.external;
5134
5135   return 0;
5136 }
5137
5138 static inline void
5139 set_AT_ref_external (dw_attr_ref a, int i)
5140 {
5141   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5142   a->dw_attr_val.v.val_die_ref.external = i;
5143 }
5144
5145 /* Add an FDE reference attribute value to a DIE.  */
5146
5147 static inline void
5148 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5149 {
5150   dw_attr_node attr;
5151
5152   attr.dw_attr = attr_kind;
5153   attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5154   attr.dw_attr_val.v.val_fde_index = targ_fde;
5155   add_dwarf_attr (die, &attr);
5156 }
5157
5158 /* Add a location description attribute value to a DIE.  */
5159
5160 static inline void
5161 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5162 {
5163   dw_attr_node attr;
5164
5165   attr.dw_attr = attr_kind;
5166   attr.dw_attr_val.val_class = dw_val_class_loc;
5167   attr.dw_attr_val.v.val_loc = loc;
5168   add_dwarf_attr (die, &attr);
5169 }
5170
5171 static inline dw_loc_descr_ref
5172 AT_loc (dw_attr_ref a)
5173 {
5174   gcc_assert (a && AT_class (a) == dw_val_class_loc);
5175   return a->dw_attr_val.v.val_loc;
5176 }
5177
5178 static inline void
5179 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5180 {
5181   dw_attr_node attr;
5182
5183   attr.dw_attr = attr_kind;
5184   attr.dw_attr_val.val_class = dw_val_class_loc_list;
5185   attr.dw_attr_val.v.val_loc_list = loc_list;
5186   add_dwarf_attr (die, &attr);
5187   have_location_lists = true;
5188 }
5189
5190 static inline dw_loc_list_ref
5191 AT_loc_list (dw_attr_ref a)
5192 {
5193   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5194   return a->dw_attr_val.v.val_loc_list;
5195 }
5196
5197 /* Add an address constant attribute value to a DIE.  */
5198
5199 static inline void
5200 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5201 {
5202   dw_attr_node attr;
5203
5204   attr.dw_attr = attr_kind;
5205   attr.dw_attr_val.val_class = dw_val_class_addr;
5206   attr.dw_attr_val.v.val_addr = addr;
5207   add_dwarf_attr (die, &attr);
5208 }
5209
5210 /* Get the RTX from to an address DIE attribute.  */
5211
5212 static inline rtx
5213 AT_addr (dw_attr_ref a)
5214 {
5215   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5216   return a->dw_attr_val.v.val_addr;
5217 }
5218
5219 /* Add a file attribute value to a DIE.  */
5220
5221 static inline void
5222 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5223              struct dwarf_file_data *fd)
5224 {
5225   dw_attr_node attr;
5226
5227   attr.dw_attr = attr_kind;
5228   attr.dw_attr_val.val_class = dw_val_class_file;
5229   attr.dw_attr_val.v.val_file = fd;
5230   add_dwarf_attr (die, &attr);
5231 }
5232
5233 /* Get the dwarf_file_data from a file DIE attribute.  */
5234
5235 static inline struct dwarf_file_data *
5236 AT_file (dw_attr_ref a)
5237 {
5238   gcc_assert (a && AT_class (a) == dw_val_class_file);
5239   return a->dw_attr_val.v.val_file;
5240 }
5241
5242 /* Add a label identifier attribute value to a DIE.  */
5243
5244 static inline void
5245 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5246 {
5247   dw_attr_node attr;
5248
5249   attr.dw_attr = attr_kind;
5250   attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5251   attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5252   add_dwarf_attr (die, &attr);
5253 }
5254
5255 /* Add a section offset attribute value to a DIE, an offset into the
5256    debug_line section.  */
5257
5258 static inline void
5259 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5260                 const char *label)
5261 {
5262   dw_attr_node attr;
5263
5264   attr.dw_attr = attr_kind;
5265   attr.dw_attr_val.val_class = dw_val_class_lineptr;
5266   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5267   add_dwarf_attr (die, &attr);
5268 }
5269
5270 /* Add a section offset attribute value to a DIE, an offset into the
5271    debug_macinfo section.  */
5272
5273 static inline void
5274 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5275                const char *label)
5276 {
5277   dw_attr_node attr;
5278
5279   attr.dw_attr = attr_kind;
5280   attr.dw_attr_val.val_class = dw_val_class_macptr;
5281   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5282   add_dwarf_attr (die, &attr);
5283 }
5284
5285 /* Add an offset attribute value to a DIE.  */
5286
5287 static inline void
5288 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5289                unsigned HOST_WIDE_INT offset)
5290 {
5291   dw_attr_node attr;
5292
5293   attr.dw_attr = attr_kind;
5294   attr.dw_attr_val.val_class = dw_val_class_offset;
5295   attr.dw_attr_val.v.val_offset = offset;
5296   add_dwarf_attr (die, &attr);
5297 }
5298
5299 /* Add an range_list attribute value to a DIE.  */
5300
5301 static void
5302 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5303                    long unsigned int offset)
5304 {
5305   dw_attr_node attr;
5306
5307   attr.dw_attr = attr_kind;
5308   attr.dw_attr_val.val_class = dw_val_class_range_list;
5309   attr.dw_attr_val.v.val_offset = offset;
5310   add_dwarf_attr (die, &attr);
5311 }
5312
5313 static inline const char *
5314 AT_lbl (dw_attr_ref a)
5315 {
5316   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5317                     || AT_class (a) == dw_val_class_lineptr
5318                     || AT_class (a) == dw_val_class_macptr));
5319   return a->dw_attr_val.v.val_lbl_id;
5320 }
5321
5322 /* Get the attribute of type attr_kind.  */
5323
5324 static dw_attr_ref
5325 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5326 {
5327   dw_attr_ref a;
5328   unsigned ix;
5329   dw_die_ref spec = NULL;
5330
5331   if (! die)
5332     return NULL;
5333
5334   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5335     if (a->dw_attr == attr_kind)
5336       return a;
5337     else if (a->dw_attr == DW_AT_specification
5338              || a->dw_attr == DW_AT_abstract_origin)
5339       spec = AT_ref (a);
5340
5341   if (spec)
5342     return get_AT (spec, attr_kind);
5343
5344   return NULL;
5345 }
5346
5347 /* Return the "low pc" attribute value, typically associated with a subprogram
5348    DIE.  Return null if the "low pc" attribute is either not present, or if it
5349    cannot be represented as an assembler label identifier.  */
5350
5351 static inline const char *
5352 get_AT_low_pc (dw_die_ref die)
5353 {
5354   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5355
5356   return a ? AT_lbl (a) : NULL;
5357 }
5358
5359 /* Return the "high pc" attribute value, typically associated with a subprogram
5360    DIE.  Return null if the "high pc" attribute is either not present, or if it
5361    cannot be represented as an assembler label identifier.  */
5362
5363 static inline const char *
5364 get_AT_hi_pc (dw_die_ref die)
5365 {
5366   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5367
5368   return a ? AT_lbl (a) : NULL;
5369 }
5370
5371 /* Return the value of the string attribute designated by ATTR_KIND, or
5372    NULL if it is not present.  */
5373
5374 static inline const char *
5375 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5376 {
5377   dw_attr_ref a = get_AT (die, attr_kind);
5378
5379   return a ? AT_string (a) : NULL;
5380 }
5381
5382 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5383    if it is not present.  */
5384
5385 static inline int
5386 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5387 {
5388   dw_attr_ref a = get_AT (die, attr_kind);
5389
5390   return a ? AT_flag (a) : 0;
5391 }
5392
5393 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5394    if it is not present.  */
5395
5396 static inline unsigned
5397 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5398 {
5399   dw_attr_ref a = get_AT (die, attr_kind);
5400
5401   return a ? AT_unsigned (a) : 0;
5402 }
5403
5404 static inline dw_die_ref
5405 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5406 {
5407   dw_attr_ref a = get_AT (die, attr_kind);
5408
5409   return a ? AT_ref (a) : NULL;
5410 }
5411
5412 static inline struct dwarf_file_data *
5413 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5414 {
5415   dw_attr_ref a = get_AT (die, attr_kind);
5416
5417   return a ? AT_file (a) : NULL;
5418 }
5419
5420 /* Return TRUE if the language is C or C++.  */
5421
5422 static inline bool
5423 is_c_family (void)
5424 {
5425   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5426
5427   return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5428           || lang == DW_LANG_C99
5429           || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5430 }
5431
5432 /* Return TRUE if the language is C++.  */
5433
5434 static inline bool
5435 is_cxx (void)
5436 {
5437   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5438
5439   return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5440 }
5441
5442 /* Return TRUE if the language is Fortran.  */
5443
5444 static inline bool
5445 is_fortran (void)
5446 {
5447   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5448
5449   return (lang == DW_LANG_Fortran77
5450           || lang == DW_LANG_Fortran90
5451           || lang == DW_LANG_Fortran95);
5452 }
5453
5454 /* Return TRUE if the language is Java.  */
5455
5456 static inline bool
5457 is_java (void)
5458 {
5459   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5460
5461   return lang == DW_LANG_Java;
5462 }
5463
5464 /* Return TRUE if the language is Ada.  */
5465
5466 static inline bool
5467 is_ada (void)
5468 {
5469   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5470
5471   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5472 }
5473
5474 /* Remove the specified attribute if present.  */
5475
5476 static void
5477 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5478 {
5479   dw_attr_ref a;
5480   unsigned ix;
5481
5482   if (! die)
5483     return;
5484
5485   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5486     if (a->dw_attr == attr_kind)
5487       {
5488         if (AT_class (a) == dw_val_class_str)
5489           if (a->dw_attr_val.v.val_str->refcount)
5490             a->dw_attr_val.v.val_str->refcount--;
5491
5492         /* VEC_ordered_remove should help reduce the number of abbrevs
5493            that are needed.  */
5494         VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5495         return;
5496       }
5497 }
5498
5499 /* Remove CHILD from its parent.  PREV must have the property that
5500    PREV->DIE_SIB == CHILD.  Does not alter CHILD.  */
5501
5502 static void
5503 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5504 {
5505   gcc_assert (child->die_parent == prev->die_parent);
5506   gcc_assert (prev->die_sib == child);
5507   if (prev == child)
5508     {
5509       gcc_assert (child->die_parent->die_child == child);
5510       prev = NULL;
5511     }
5512   else
5513     prev->die_sib = child->die_sib;
5514   if (child->die_parent->die_child == child)
5515     child->die_parent->die_child = prev;
5516 }
5517
5518 /* Remove child DIE whose die_tag is TAG.  Do nothing if no child
5519    matches TAG.  */
5520
5521 static void
5522 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5523 {
5524   dw_die_ref c;
5525
5526   c = die->die_child;
5527   if (c) do {
5528     dw_die_ref prev = c;
5529     c = c->die_sib;
5530     while (c->die_tag == tag)
5531       {
5532         remove_child_with_prev (c, prev);
5533         /* Might have removed every child.  */
5534         if (c == c->die_sib)
5535           return;
5536         c = c->die_sib;
5537       }
5538   } while (c != die->die_child);
5539 }
5540
5541 /* Add a CHILD_DIE as the last child of DIE.  */
5542
5543 static void
5544 add_child_die (dw_die_ref die, dw_die_ref child_die)
5545 {
5546   /* FIXME this should probably be an assert.  */
5547   if (! die || ! child_die)
5548     return;
5549   gcc_assert (die != child_die);
5550
5551   child_die->die_parent = die;
5552   if (die->die_child)
5553     {
5554       child_die->die_sib = die->die_child->die_sib;
5555       die->die_child->die_sib = child_die;
5556     }
5557   else
5558     child_die->die_sib = child_die;
5559   die->die_child = child_die;
5560 }
5561
5562 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5563    is the specification, to the end of PARENT's list of children.
5564    This is done by removing and re-adding it.  */
5565
5566 static void
5567 splice_child_die (dw_die_ref parent, dw_die_ref child)
5568 {
5569   dw_die_ref p;
5570
5571   /* We want the declaration DIE from inside the class, not the
5572      specification DIE at toplevel.  */
5573   if (child->die_parent != parent)
5574     {
5575       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5576
5577       if (tmp)
5578         child = tmp;
5579     }
5580
5581   gcc_assert (child->die_parent == parent
5582               || (child->die_parent
5583                   == get_AT_ref (parent, DW_AT_specification)));
5584
5585   for (p = child->die_parent->die_child; ; p = p->die_sib)
5586     if (p->die_sib == child)
5587       {
5588         remove_child_with_prev (child, p);
5589         break;
5590       }
5591
5592   add_child_die (parent, child);
5593 }
5594
5595 /* Return a pointer to a newly created DIE node.  */
5596
5597 static inline dw_die_ref
5598 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5599 {
5600   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5601
5602   die->die_tag = tag_value;
5603
5604   if (parent_die != NULL)
5605     add_child_die (parent_die, die);
5606   else
5607     {
5608       limbo_die_node *limbo_node;
5609
5610       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5611       limbo_node->die = die;
5612       limbo_node->created_for = t;
5613       limbo_node->next = limbo_die_list;
5614       limbo_die_list = limbo_node;
5615     }
5616
5617   return die;
5618 }
5619
5620 /* Return the DIE associated with the given type specifier.  */
5621
5622 static inline dw_die_ref
5623 lookup_type_die (tree type)
5624 {
5625   return TYPE_SYMTAB_DIE (type);
5626 }
5627
5628 /* Equate a DIE to a given type specifier.  */
5629
5630 static inline void
5631 equate_type_number_to_die (tree type, dw_die_ref type_die)
5632 {
5633   TYPE_SYMTAB_DIE (type) = type_die;
5634 }
5635
5636 /* Returns a hash value for X (which really is a die_struct).  */
5637
5638 static hashval_t
5639 decl_die_table_hash (const void *x)
5640 {
5641   return (hashval_t) ((const dw_die_ref) x)->decl_id;
5642 }
5643
5644 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5645
5646 static int
5647 decl_die_table_eq (const void *x, const void *y)
5648 {
5649   return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5650 }
5651
5652 /* Return the DIE associated with a given declaration.  */
5653
5654 static inline dw_die_ref
5655 lookup_decl_die (tree decl)
5656 {
5657   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5658 }
5659
5660 /* Returns a hash value for X (which really is a var_loc_list).  */
5661
5662 static hashval_t
5663 decl_loc_table_hash (const void *x)
5664 {
5665   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5666 }
5667
5668 /* Return nonzero if decl_id of var_loc_list X is the same as
5669    UID of decl *Y.  */
5670
5671 static int
5672 decl_loc_table_eq (const void *x, const void *y)
5673 {
5674   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5675 }
5676
5677 /* Return the var_loc list associated with a given declaration.  */
5678
5679 static inline var_loc_list *
5680 lookup_decl_loc (tree decl)
5681 {
5682   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5683 }
5684
5685 /* Equate a DIE to a particular declaration.  */
5686
5687 static void
5688 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5689 {
5690   unsigned int decl_id = DECL_UID (decl);
5691   void **slot;
5692
5693   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5694   *slot = decl_die;
5695   decl_die->decl_id = decl_id;
5696 }
5697
5698 /* Add a variable location node to the linked list for DECL.  */
5699
5700 static void
5701 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5702 {
5703   unsigned int decl_id = DECL_UID (decl);
5704   var_loc_list *temp;
5705   void **slot;
5706
5707   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5708   if (*slot == NULL)
5709     {
5710       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5711       temp->decl_id = decl_id;
5712       *slot = temp;
5713     }
5714   else
5715     temp = *slot;
5716
5717   if (temp->last)
5718     {
5719       /* If the current location is the same as the end of the list,
5720          we have nothing to do.  */
5721       if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5722                         NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5723         {
5724           /* Add LOC to the end of list and update LAST.  */
5725           temp->last->next = loc;
5726           temp->last = loc;
5727         }
5728     }
5729   /* Do not add empty location to the beginning of the list.  */
5730   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5731     {
5732       temp->first = loc;
5733       temp->last = loc;
5734     }
5735 }
5736 \f
5737 /* Keep track of the number of spaces used to indent the
5738    output of the debugging routines that print the structure of
5739    the DIE internal representation.  */
5740 static int print_indent;
5741
5742 /* Indent the line the number of spaces given by print_indent.  */
5743
5744 static inline void
5745 print_spaces (FILE *outfile)
5746 {
5747   fprintf (outfile, "%*s", print_indent, "");
5748 }
5749
5750 /* Print the information associated with a given DIE, and its children.
5751    This routine is a debugging aid only.  */
5752
5753 static void
5754 print_die (dw_die_ref die, FILE *outfile)
5755 {
5756   dw_attr_ref a;
5757   dw_die_ref c;
5758   unsigned ix;
5759
5760   print_spaces (outfile);
5761   fprintf (outfile, "DIE %4lu: %s\n",
5762            die->die_offset, dwarf_tag_name (die->die_tag));
5763   print_spaces (outfile);
5764   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5765   fprintf (outfile, " offset: %lu\n", die->die_offset);
5766
5767   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5768     {
5769       print_spaces (outfile);
5770       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5771
5772       switch (AT_class (a))
5773         {
5774         case dw_val_class_addr:
5775           fprintf (outfile, "address");
5776           break;
5777         case dw_val_class_offset:
5778           fprintf (outfile, "offset");
5779           break;
5780         case dw_val_class_loc:
5781           fprintf (outfile, "location descriptor");
5782           break;
5783         case dw_val_class_loc_list:
5784           fprintf (outfile, "location list -> label:%s",
5785                    AT_loc_list (a)->ll_symbol);
5786           break;
5787         case dw_val_class_range_list:
5788           fprintf (outfile, "range list");
5789           break;
5790         case dw_val_class_const:
5791           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5792           break;
5793         case dw_val_class_unsigned_const:
5794           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5795           break;
5796         case dw_val_class_long_long:
5797           fprintf (outfile, "constant (%lu,%lu)",
5798                    a->dw_attr_val.v.val_long_long.hi,
5799                    a->dw_attr_val.v.val_long_long.low);
5800           break;
5801         case dw_val_class_vec:
5802           fprintf (outfile, "floating-point or vector constant");
5803           break;
5804         case dw_val_class_flag:
5805           fprintf (outfile, "%u", AT_flag (a));
5806           break;
5807         case dw_val_class_die_ref:
5808           if (AT_ref (a) != NULL)
5809             {
5810               if (AT_ref (a)->die_symbol)
5811                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5812               else
5813                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5814             }
5815           else
5816             fprintf (outfile, "die -> <null>");
5817           break;
5818         case dw_val_class_lbl_id:
5819         case dw_val_class_lineptr:
5820         case dw_val_class_macptr:
5821           fprintf (outfile, "label: %s", AT_lbl (a));
5822           break;
5823         case dw_val_class_str:
5824           if (AT_string (a) != NULL)
5825             fprintf (outfile, "\"%s\"", AT_string (a));
5826           else
5827             fprintf (outfile, "<null>");
5828           break;
5829         case dw_val_class_file:
5830           fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5831                    AT_file (a)->emitted_number);
5832           break;
5833         default:
5834           break;
5835         }
5836
5837       fprintf (outfile, "\n");
5838     }
5839
5840   if (die->die_child != NULL)
5841     {
5842       print_indent += 4;
5843       FOR_EACH_CHILD (die, c, print_die (c, outfile));
5844       print_indent -= 4;
5845     }
5846   if (print_indent == 0)
5847     fprintf (outfile, "\n");
5848 }
5849
5850 /* Print the contents of the source code line number correspondence table.
5851    This routine is a debugging aid only.  */
5852
5853 static void
5854 print_dwarf_line_table (FILE *outfile)
5855 {
5856   unsigned i;
5857   dw_line_info_ref line_info;
5858
5859   fprintf (outfile, "\n\nDWARF source line information\n");
5860   for (i = 1; i < line_info_table_in_use; i++)
5861     {
5862       line_info = &line_info_table[i];
5863       fprintf (outfile, "%5d: %4ld %6ld\n", i,
5864                line_info->dw_file_num,
5865                line_info->dw_line_num);
5866     }
5867
5868   fprintf (outfile, "\n\n");
5869 }
5870
5871 /* Print the information collected for a given DIE.  */
5872
5873 void
5874 debug_dwarf_die (dw_die_ref die)
5875 {
5876   print_die (die, stderr);
5877 }
5878
5879 /* Print all DWARF information collected for the compilation unit.
5880    This routine is a debugging aid only.  */
5881
5882 void
5883 debug_dwarf (void)
5884 {
5885   print_indent = 0;
5886   print_die (comp_unit_die, stderr);
5887   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5888     print_dwarf_line_table (stderr);
5889 }
5890 \f
5891 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5892    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5893    DIE that marks the start of the DIEs for this include file.  */
5894
5895 static dw_die_ref
5896 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5897 {
5898   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5899   dw_die_ref new_unit = gen_compile_unit_die (filename);
5900
5901   new_unit->die_sib = old_unit;
5902   return new_unit;
5903 }
5904
5905 /* Close an include-file CU and reopen the enclosing one.  */
5906
5907 static dw_die_ref
5908 pop_compile_unit (dw_die_ref old_unit)
5909 {
5910   dw_die_ref new_unit = old_unit->die_sib;
5911
5912   old_unit->die_sib = NULL;
5913   return new_unit;
5914 }
5915
5916 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5917 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5918
5919 /* Calculate the checksum of a location expression.  */
5920
5921 static inline void
5922 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5923 {
5924   CHECKSUM (loc->dw_loc_opc);
5925   CHECKSUM (loc->dw_loc_oprnd1);
5926   CHECKSUM (loc->dw_loc_oprnd2);
5927 }
5928
5929 /* Calculate the checksum of an attribute.  */
5930
5931 static void
5932 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5933 {
5934   dw_loc_descr_ref loc;
5935   rtx r;
5936
5937   CHECKSUM (at->dw_attr);
5938
5939   /* We don't care that this was compiled with a different compiler
5940      snapshot; if the output is the same, that's what matters.  */
5941   if (at->dw_attr == DW_AT_producer)
5942     return;
5943
5944   switch (AT_class (at))
5945     {
5946     case dw_val_class_const:
5947       CHECKSUM (at->dw_attr_val.v.val_int);
5948       break;
5949     case dw_val_class_unsigned_const:
5950       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5951       break;
5952     case dw_val_class_long_long:
5953       CHECKSUM (at->dw_attr_val.v.val_long_long);
5954       break;
5955     case dw_val_class_vec:
5956       CHECKSUM (at->dw_attr_val.v.val_vec);
5957       break;
5958     case dw_val_class_flag:
5959       CHECKSUM (at->dw_attr_val.v.val_flag);
5960       break;
5961     case dw_val_class_str:
5962       CHECKSUM_STRING (AT_string (at));
5963       break;
5964
5965     case dw_val_class_addr:
5966       r = AT_addr (at);
5967       gcc_assert (GET_CODE (r) == SYMBOL_REF);
5968       CHECKSUM_STRING (XSTR (r, 0));
5969       break;
5970
5971     case dw_val_class_offset:
5972       CHECKSUM (at->dw_attr_val.v.val_offset);
5973       break;
5974
5975     case dw_val_class_loc:
5976       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5977         loc_checksum (loc, ctx);
5978       break;
5979
5980     case dw_val_class_die_ref:
5981       die_checksum (AT_ref (at), ctx, mark);
5982       break;
5983
5984     case dw_val_class_fde_ref:
5985     case dw_val_class_lbl_id:
5986     case dw_val_class_lineptr:
5987     case dw_val_class_macptr:
5988       break;
5989
5990     case dw_val_class_file:
5991       CHECKSUM_STRING (AT_file (at)->filename);
5992       break;
5993
5994     default:
5995       break;
5996     }
5997 }
5998
5999 /* Calculate the checksum of a DIE.  */
6000
6001 static void
6002 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6003 {
6004   dw_die_ref c;
6005   dw_attr_ref a;
6006   unsigned ix;
6007
6008   /* To avoid infinite recursion.  */
6009   if (die->die_mark)
6010     {
6011       CHECKSUM (die->die_mark);
6012       return;
6013     }
6014   die->die_mark = ++(*mark);
6015
6016   CHECKSUM (die->die_tag);
6017
6018   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6019     attr_checksum (a, ctx, mark);
6020
6021   FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6022 }
6023
6024 #undef CHECKSUM
6025 #undef CHECKSUM_STRING
6026
6027 /* Do the location expressions look same?  */
6028 static inline int
6029 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6030 {
6031   return loc1->dw_loc_opc == loc2->dw_loc_opc
6032          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6033          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6034 }
6035
6036 /* Do the values look the same?  */
6037 static int
6038 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6039 {
6040   dw_loc_descr_ref loc1, loc2;
6041   rtx r1, r2;
6042
6043   if (v1->val_class != v2->val_class)
6044     return 0;
6045
6046   switch (v1->val_class)
6047     {
6048     case dw_val_class_const:
6049       return v1->v.val_int == v2->v.val_int;
6050     case dw_val_class_unsigned_const:
6051       return v1->v.val_unsigned == v2->v.val_unsigned;
6052     case dw_val_class_long_long:
6053       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6054              && v1->v.val_long_long.low == v2->v.val_long_long.low;
6055     case dw_val_class_vec:
6056       if (v1->v.val_vec.length != v2->v.val_vec.length
6057           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6058         return 0;
6059       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6060                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
6061         return 0;
6062       return 1;
6063     case dw_val_class_flag:
6064       return v1->v.val_flag == v2->v.val_flag;
6065     case dw_val_class_str:
6066       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6067
6068     case dw_val_class_addr:
6069       r1 = v1->v.val_addr;
6070       r2 = v2->v.val_addr;
6071       if (GET_CODE (r1) != GET_CODE (r2))
6072         return 0;
6073       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6074       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6075
6076     case dw_val_class_offset:
6077       return v1->v.val_offset == v2->v.val_offset;
6078
6079     case dw_val_class_loc:
6080       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6081            loc1 && loc2;
6082            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6083         if (!same_loc_p (loc1, loc2, mark))
6084           return 0;
6085       return !loc1 && !loc2;
6086
6087     case dw_val_class_die_ref:
6088       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6089
6090     case dw_val_class_fde_ref:
6091     case dw_val_class_lbl_id:
6092     case dw_val_class_lineptr:
6093     case dw_val_class_macptr:
6094       return 1;
6095
6096     case dw_val_class_file:
6097       return v1->v.val_file == v2->v.val_file;
6098
6099     default:
6100       return 1;
6101     }
6102 }
6103
6104 /* Do the attributes look the same?  */
6105
6106 static int
6107 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6108 {
6109   if (at1->dw_attr != at2->dw_attr)
6110     return 0;
6111
6112   /* We don't care that this was compiled with a different compiler
6113      snapshot; if the output is the same, that's what matters. */
6114   if (at1->dw_attr == DW_AT_producer)
6115     return 1;
6116
6117   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6118 }
6119
6120 /* Do the dies look the same?  */
6121
6122 static int
6123 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6124 {
6125   dw_die_ref c1, c2;
6126   dw_attr_ref a1;
6127   unsigned ix;
6128
6129   /* To avoid infinite recursion.  */
6130   if (die1->die_mark)
6131     return die1->die_mark == die2->die_mark;
6132   die1->die_mark = die2->die_mark = ++(*mark);
6133
6134   if (die1->die_tag != die2->die_tag)
6135     return 0;
6136
6137   if (VEC_length (dw_attr_node, die1->die_attr)
6138       != VEC_length (dw_attr_node, die2->die_attr))
6139     return 0;
6140
6141   for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6142     if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6143       return 0;
6144
6145   c1 = die1->die_child;
6146   c2 = die2->die_child;
6147   if (! c1)
6148     {
6149       if (c2)
6150         return 0;
6151     }
6152   else
6153     for (;;)
6154       {
6155         if (!same_die_p (c1, c2, mark))
6156           return 0;
6157         c1 = c1->die_sib;
6158         c2 = c2->die_sib;
6159         if (c1 == die1->die_child)
6160           {
6161             if (c2 == die2->die_child)
6162               break;
6163             else
6164               return 0;
6165           }
6166     }
6167
6168   return 1;
6169 }
6170
6171 /* Do the dies look the same?  Wrapper around same_die_p.  */
6172
6173 static int
6174 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6175 {
6176   int mark = 0;
6177   int ret = same_die_p (die1, die2, &mark);
6178
6179   unmark_all_dies (die1);
6180   unmark_all_dies (die2);
6181
6182   return ret;
6183 }
6184
6185 /* The prefix to attach to symbols on DIEs in the current comdat debug
6186    info section.  */
6187 static char *comdat_symbol_id;
6188
6189 /* The index of the current symbol within the current comdat CU.  */
6190 static unsigned int comdat_symbol_number;
6191
6192 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6193    children, and set comdat_symbol_id accordingly.  */
6194
6195 static void
6196 compute_section_prefix (dw_die_ref unit_die)
6197 {
6198   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6199   const char *base = die_name ? lbasename (die_name) : "anonymous";
6200   char *name = alloca (strlen (base) + 64);
6201   char *p;
6202   int i, mark;
6203   unsigned char checksum[16];
6204   struct md5_ctx ctx;
6205
6206   /* Compute the checksum of the DIE, then append part of it as hex digits to
6207      the name filename of the unit.  */
6208
6209   md5_init_ctx (&ctx);
6210   mark = 0;
6211   die_checksum (unit_die, &ctx, &mark);
6212   unmark_all_dies (unit_die);
6213   md5_finish_ctx (&ctx, checksum);
6214
6215   sprintf (name, "%s.", base);
6216   clean_symbol_name (name);
6217
6218   p = name + strlen (name);
6219   for (i = 0; i < 4; i++)
6220     {
6221       sprintf (p, "%.2x", checksum[i]);
6222       p += 2;
6223     }
6224
6225   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6226   comdat_symbol_number = 0;
6227 }
6228
6229 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6230
6231 static int
6232 is_type_die (dw_die_ref die)
6233 {
6234   switch (die->die_tag)
6235     {
6236     case DW_TAG_array_type:
6237     case DW_TAG_class_type:
6238     case DW_TAG_enumeration_type:
6239     case DW_TAG_pointer_type:
6240     case DW_TAG_reference_type:
6241     case DW_TAG_string_type:
6242     case DW_TAG_structure_type:
6243     case DW_TAG_subroutine_type:
6244     case DW_TAG_union_type:
6245     case DW_TAG_ptr_to_member_type:
6246     case DW_TAG_set_type:
6247     case DW_TAG_subrange_type:
6248     case DW_TAG_base_type:
6249     case DW_TAG_const_type:
6250     case DW_TAG_file_type:
6251     case DW_TAG_packed_type:
6252     case DW_TAG_volatile_type:
6253     case DW_TAG_typedef:
6254       return 1;
6255     default:
6256       return 0;
6257     }
6258 }
6259
6260 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6261    Basically, we want to choose the bits that are likely to be shared between
6262    compilations (types) and leave out the bits that are specific to individual
6263    compilations (functions).  */
6264
6265 static int
6266 is_comdat_die (dw_die_ref c)
6267 {
6268   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6269      we do for stabs.  The advantage is a greater likelihood of sharing between
6270      objects that don't include headers in the same order (and therefore would
6271      put the base types in a different comdat).  jason 8/28/00 */
6272
6273   if (c->die_tag == DW_TAG_base_type)
6274     return 0;
6275
6276   if (c->die_tag == DW_TAG_pointer_type
6277       || c->die_tag == DW_TAG_reference_type
6278       || c->die_tag == DW_TAG_const_type
6279       || c->die_tag == DW_TAG_volatile_type)
6280     {
6281       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6282
6283       return t ? is_comdat_die (t) : 0;
6284     }
6285
6286   return is_type_die (c);
6287 }
6288
6289 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6290    compilation unit.  */
6291
6292 static int
6293 is_symbol_die (dw_die_ref c)
6294 {
6295   return (is_type_die (c)
6296           || (get_AT (c, DW_AT_declaration)
6297               && !get_AT (c, DW_AT_specification))
6298           || c->die_tag == DW_TAG_namespace);
6299 }
6300
6301 static char *
6302 gen_internal_sym (const char *prefix)
6303 {
6304   char buf[256];
6305
6306   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6307   return xstrdup (buf);
6308 }
6309
6310 /* Assign symbols to all worthy DIEs under DIE.  */
6311
6312 static void
6313 assign_symbol_names (dw_die_ref die)
6314 {
6315   dw_die_ref c;
6316
6317   if (is_symbol_die (die))
6318     {
6319       if (comdat_symbol_id)
6320         {
6321           char *p = alloca (strlen (comdat_symbol_id) + 64);
6322
6323           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6324                    comdat_symbol_id, comdat_symbol_number++);
6325           die->die_symbol = xstrdup (p);
6326         }
6327       else
6328         die->die_symbol = gen_internal_sym ("LDIE");
6329     }
6330
6331   FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6332 }
6333
6334 struct cu_hash_table_entry
6335 {
6336   dw_die_ref cu;
6337   unsigned min_comdat_num, max_comdat_num;
6338   struct cu_hash_table_entry *next;
6339 };
6340
6341 /* Routines to manipulate hash table of CUs.  */
6342 static hashval_t
6343 htab_cu_hash (const void *of)
6344 {
6345   const struct cu_hash_table_entry *entry = of;
6346
6347   return htab_hash_string (entry->cu->die_symbol);
6348 }
6349
6350 static int
6351 htab_cu_eq (const void *of1, const void *of2)
6352 {
6353   const struct cu_hash_table_entry *entry1 = of1;
6354   const struct die_struct *entry2 = of2;
6355
6356   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6357 }
6358
6359 static void
6360 htab_cu_del (void *what)
6361 {
6362   struct cu_hash_table_entry *next, *entry = what;
6363
6364   while (entry)
6365     {
6366       next = entry->next;
6367       free (entry);
6368       entry = next;
6369     }
6370 }
6371
6372 /* Check whether we have already seen this CU and set up SYM_NUM
6373    accordingly.  */
6374 static int
6375 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6376 {
6377   struct cu_hash_table_entry dummy;
6378   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6379
6380   dummy.max_comdat_num = 0;
6381
6382   slot = (struct cu_hash_table_entry **)
6383     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6384         INSERT);
6385   entry = *slot;
6386
6387   for (; entry; last = entry, entry = entry->next)
6388     {
6389       if (same_die_p_wrap (cu, entry->cu))
6390         break;
6391     }
6392
6393   if (entry)
6394     {
6395       *sym_num = entry->min_comdat_num;
6396       return 1;
6397     }
6398
6399   entry = XCNEW (struct cu_hash_table_entry);
6400   entry->cu = cu;
6401   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6402   entry->next = *slot;
6403   *slot = entry;
6404
6405   return 0;
6406 }
6407
6408 /* Record SYM_NUM to record of CU in HTABLE.  */
6409 static void
6410 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6411 {
6412   struct cu_hash_table_entry **slot, *entry;
6413
6414   slot = (struct cu_hash_table_entry **)
6415     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6416         NO_INSERT);
6417   entry = *slot;
6418
6419   entry->max_comdat_num = sym_num;
6420 }
6421
6422 /* Traverse the DIE (which is always comp_unit_die), and set up
6423    additional compilation units for each of the include files we see
6424    bracketed by BINCL/EINCL.  */
6425
6426 static void
6427 break_out_includes (dw_die_ref die)
6428 {
6429   dw_die_ref c;
6430   dw_die_ref unit = NULL;
6431   limbo_die_node *node, **pnode;
6432   htab_t cu_hash_table;
6433
6434   c = die->die_child;
6435   if (c) do {
6436     dw_die_ref prev = c;
6437     c = c->die_sib;
6438     while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6439            || (unit && is_comdat_die (c)))
6440       {
6441         dw_die_ref next = c->die_sib;
6442
6443         /* This DIE is for a secondary CU; remove it from the main one.  */
6444         remove_child_with_prev (c, prev);
6445
6446         if (c->die_tag == DW_TAG_GNU_BINCL)
6447           unit = push_new_compile_unit (unit, c);
6448         else if (c->die_tag == DW_TAG_GNU_EINCL)
6449           unit = pop_compile_unit (unit);
6450         else
6451           add_child_die (unit, c);
6452         c = next;
6453         if (c == die->die_child)
6454           break;
6455       }
6456   } while (c != die->die_child);
6457
6458 #if 0
6459   /* We can only use this in debugging, since the frontend doesn't check
6460      to make sure that we leave every include file we enter.  */
6461   gcc_assert (!unit);
6462 #endif
6463
6464   assign_symbol_names (die);
6465   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6466   for (node = limbo_die_list, pnode = &limbo_die_list;
6467        node;
6468        node = node->next)
6469     {
6470       int is_dupl;
6471
6472       compute_section_prefix (node->die);
6473       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6474                         &comdat_symbol_number);
6475       assign_symbol_names (node->die);
6476       if (is_dupl)
6477         *pnode = node->next;
6478       else
6479         {
6480           pnode = &node->next;
6481           record_comdat_symbol_number (node->die, cu_hash_table,
6482                 comdat_symbol_number);
6483         }
6484     }
6485   htab_delete (cu_hash_table);
6486 }
6487
6488 /* Traverse the DIE and add a sibling attribute if it may have the
6489    effect of speeding up access to siblings.  To save some space,
6490    avoid generating sibling attributes for DIE's without children.  */
6491
6492 static void
6493 add_sibling_attributes (dw_die_ref die)
6494 {
6495   dw_die_ref c;
6496
6497   if (! die->die_child)
6498     return;
6499
6500   if (die->die_parent && die != die->die_parent->die_child)
6501     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6502
6503   FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6504 }
6505
6506 /* Output all location lists for the DIE and its children.  */
6507
6508 static void
6509 output_location_lists (dw_die_ref die)
6510 {
6511   dw_die_ref c;
6512   dw_attr_ref a;
6513   unsigned ix;
6514
6515   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6516     if (AT_class (a) == dw_val_class_loc_list)
6517       output_loc_list (AT_loc_list (a));
6518
6519   FOR_EACH_CHILD (die, c, output_location_lists (c));
6520 }
6521
6522 /* The format of each DIE (and its attribute value pairs) is encoded in an
6523    abbreviation table.  This routine builds the abbreviation table and assigns
6524    a unique abbreviation id for each abbreviation entry.  The children of each
6525    die are visited recursively.  */
6526
6527 static void
6528 build_abbrev_table (dw_die_ref die)
6529 {
6530   unsigned long abbrev_id;
6531   unsigned int n_alloc;
6532   dw_die_ref c;
6533   dw_attr_ref a;
6534   unsigned ix;
6535
6536   /* Scan the DIE references, and mark as external any that refer to
6537      DIEs from other CUs (i.e. those which are not marked).  */
6538   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6539     if (AT_class (a) == dw_val_class_die_ref
6540         && AT_ref (a)->die_mark == 0)
6541       {
6542         gcc_assert (AT_ref (a)->die_symbol);
6543
6544         set_AT_ref_external (a, 1);
6545       }
6546
6547   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6548     {
6549       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6550       dw_attr_ref die_a, abbrev_a;
6551       unsigned ix;
6552       bool ok = true;
6553
6554       if (abbrev->die_tag != die->die_tag)
6555         continue;
6556       if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6557         continue;
6558
6559       if (VEC_length (dw_attr_node, abbrev->die_attr)
6560           != VEC_length (dw_attr_node, die->die_attr))
6561         continue;
6562
6563       for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6564         {
6565           abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6566           if ((abbrev_a->dw_attr != die_a->dw_attr)
6567               || (value_format (abbrev_a) != value_format (die_a)))
6568             {
6569               ok = false;
6570               break;
6571             }
6572         }
6573       if (ok)
6574         break;
6575     }
6576
6577   if (abbrev_id >= abbrev_die_table_in_use)
6578     {
6579       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6580         {
6581           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6582           abbrev_die_table = ggc_realloc (abbrev_die_table,
6583                                           sizeof (dw_die_ref) * n_alloc);
6584
6585           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6586                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6587           abbrev_die_table_allocated = n_alloc;
6588         }
6589
6590       ++abbrev_die_table_in_use;
6591       abbrev_die_table[abbrev_id] = die;
6592     }
6593
6594   die->die_abbrev = abbrev_id;
6595   FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6596 }
6597 \f
6598 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6599
6600 static int
6601 constant_size (long unsigned int value)
6602 {
6603   int log;
6604
6605   if (value == 0)
6606     log = 0;
6607   else
6608     log = floor_log2 (value);
6609
6610   log = log / 8;
6611   log = 1 << (floor_log2 (log) + 1);
6612
6613   return log;
6614 }
6615
6616 /* Return the size of a DIE as it is represented in the
6617    .debug_info section.  */
6618
6619 static unsigned long
6620 size_of_die (dw_die_ref die)
6621 {
6622   unsigned long size = 0;
6623   dw_attr_ref a;
6624   unsigned ix;
6625
6626   size += size_of_uleb128 (die->die_abbrev);
6627   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6628     {
6629       switch (AT_class (a))
6630         {
6631         case dw_val_class_addr:
6632           size += DWARF2_ADDR_SIZE;
6633           break;
6634         case dw_val_class_offset:
6635           size += DWARF_OFFSET_SIZE;
6636           break;
6637         case dw_val_class_loc:
6638           {
6639             unsigned long lsize = size_of_locs (AT_loc (a));
6640
6641             /* Block length.  */
6642             size += constant_size (lsize);
6643             size += lsize;
6644           }
6645           break;
6646         case dw_val_class_loc_list:
6647           size += DWARF_OFFSET_SIZE;
6648           break;
6649         case dw_val_class_range_list:
6650           size += DWARF_OFFSET_SIZE;
6651           break;
6652         case dw_val_class_const:
6653           size += size_of_sleb128 (AT_int (a));
6654           break;
6655         case dw_val_class_unsigned_const:
6656           size += constant_size (AT_unsigned (a));
6657           break;
6658         case dw_val_class_long_long:
6659           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6660           break;
6661         case dw_val_class_vec:
6662           size += 1 + (a->dw_attr_val.v.val_vec.length
6663                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6664           break;
6665         case dw_val_class_flag:
6666           size += 1;
6667           break;
6668         case dw_val_class_die_ref:
6669           if (AT_ref_external (a))
6670             size += DWARF2_ADDR_SIZE;
6671           else
6672             size += DWARF_OFFSET_SIZE;
6673           break;
6674         case dw_val_class_fde_ref:
6675           size += DWARF_OFFSET_SIZE;
6676           break;
6677         case dw_val_class_lbl_id:
6678           size += DWARF2_ADDR_SIZE;
6679           break;
6680         case dw_val_class_lineptr:
6681         case dw_val_class_macptr:
6682           size += DWARF_OFFSET_SIZE;
6683           break;
6684         case dw_val_class_str:
6685           if (AT_string_form (a) == DW_FORM_strp)
6686             size += DWARF_OFFSET_SIZE;
6687           else
6688             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6689           break;
6690         case dw_val_class_file:
6691           size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6692           break;
6693         default:
6694           gcc_unreachable ();
6695         }
6696     }
6697
6698   return size;
6699 }
6700
6701 /* Size the debugging information associated with a given DIE.  Visits the
6702    DIE's children recursively.  Updates the global variable next_die_offset, on
6703    each time through.  Uses the current value of next_die_offset to update the
6704    die_offset field in each DIE.  */
6705
6706 static void
6707 calc_die_sizes (dw_die_ref die)
6708 {
6709   dw_die_ref c;
6710
6711   die->die_offset = next_die_offset;
6712   next_die_offset += size_of_die (die);
6713
6714   FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6715
6716   if (die->die_child != NULL)
6717     /* Count the null byte used to terminate sibling lists.  */
6718     next_die_offset += 1;
6719 }
6720
6721 /* Set the marks for a die and its children.  We do this so
6722    that we know whether or not a reference needs to use FORM_ref_addr; only
6723    DIEs in the same CU will be marked.  We used to clear out the offset
6724    and use that as the flag, but ran into ordering problems.  */
6725
6726 static void
6727 mark_dies (dw_die_ref die)
6728 {
6729   dw_die_ref c;
6730
6731   gcc_assert (!die->die_mark);
6732
6733   die->die_mark = 1;
6734   FOR_EACH_CHILD (die, c, mark_dies (c));
6735 }
6736
6737 /* Clear the marks for a die and its children.  */
6738
6739 static void
6740 unmark_dies (dw_die_ref die)
6741 {
6742   dw_die_ref c;
6743
6744   gcc_assert (die->die_mark);
6745
6746   die->die_mark = 0;
6747   FOR_EACH_CHILD (die, c, unmark_dies (c));
6748 }
6749
6750 /* Clear the marks for a die, its children and referred dies.  */
6751
6752 static void
6753 unmark_all_dies (dw_die_ref die)
6754 {
6755   dw_die_ref c;
6756   dw_attr_ref a;
6757   unsigned ix;
6758
6759   if (!die->die_mark)
6760     return;
6761   die->die_mark = 0;
6762
6763   FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6764
6765   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6766     if (AT_class (a) == dw_val_class_die_ref)
6767       unmark_all_dies (AT_ref (a));
6768 }
6769
6770 /* Return the size of the .debug_pubnames or .debug_pubtypes table
6771    generated for the compilation unit.  */
6772
6773 static unsigned long
6774 size_of_pubnames (VEC (pubname_entry, gc) * names)
6775 {
6776   unsigned long size;
6777   unsigned i;
6778   pubname_ref p;
6779
6780   size = DWARF_PUBNAMES_HEADER_SIZE;
6781   for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
6782     if (names != pubtype_table
6783         || p->die->die_offset != 0
6784         || !flag_eliminate_unused_debug_types)
6785       size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
6786
6787   size += DWARF_OFFSET_SIZE;
6788   return size;
6789 }
6790
6791 /* Return the size of the information in the .debug_aranges section.  */
6792
6793 static unsigned long
6794 size_of_aranges (void)
6795 {
6796   unsigned long size;
6797
6798   size = DWARF_ARANGES_HEADER_SIZE;
6799
6800   /* Count the address/length pair for this compilation unit.  */
6801   size += 2 * DWARF2_ADDR_SIZE;
6802   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6803
6804   /* Count the two zero words used to terminated the address range table.  */
6805   size += 2 * DWARF2_ADDR_SIZE;
6806   return size;
6807 }
6808 \f
6809 /* Select the encoding of an attribute value.  */
6810
6811 static enum dwarf_form
6812 value_format (dw_attr_ref a)
6813 {
6814   switch (a->dw_attr_val.val_class)
6815     {
6816     case dw_val_class_addr:
6817       return DW_FORM_addr;
6818     case dw_val_class_range_list:
6819     case dw_val_class_offset:
6820     case dw_val_class_loc_list:
6821       switch (DWARF_OFFSET_SIZE)
6822         {
6823         case 4:
6824           return DW_FORM_data4;
6825         case 8:
6826           return DW_FORM_data8;
6827         default:
6828           gcc_unreachable ();
6829         }
6830     case dw_val_class_loc:
6831       switch (constant_size (size_of_locs (AT_loc (a))))
6832         {
6833         case 1:
6834           return DW_FORM_block1;
6835         case 2:
6836           return DW_FORM_block2;
6837         default:
6838           gcc_unreachable ();
6839         }
6840     case dw_val_class_const:
6841       return DW_FORM_sdata;
6842     case dw_val_class_unsigned_const:
6843       switch (constant_size (AT_unsigned (a)))
6844         {
6845         case 1:
6846           return DW_FORM_data1;
6847         case 2:
6848           return DW_FORM_data2;
6849         case 4:
6850           return DW_FORM_data4;
6851         case 8:
6852           return DW_FORM_data8;
6853         default:
6854           gcc_unreachable ();
6855         }
6856     case dw_val_class_long_long:
6857       return DW_FORM_block1;
6858     case dw_val_class_vec:
6859       return DW_FORM_block1;
6860     case dw_val_class_flag:
6861       return DW_FORM_flag;
6862     case dw_val_class_die_ref:
6863       if (AT_ref_external (a))
6864         return DW_FORM_ref_addr;
6865       else
6866         return DW_FORM_ref;
6867     case dw_val_class_fde_ref:
6868       return DW_FORM_data;
6869     case dw_val_class_lbl_id:
6870       return DW_FORM_addr;
6871     case dw_val_class_lineptr:
6872     case dw_val_class_macptr:
6873       return DW_FORM_data;
6874     case dw_val_class_str:
6875       return AT_string_form (a);
6876     case dw_val_class_file:
6877       switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6878         {
6879         case 1:
6880           return DW_FORM_data1;
6881         case 2:
6882           return DW_FORM_data2;
6883         case 4:
6884           return DW_FORM_data4;
6885         default:
6886           gcc_unreachable ();
6887         }
6888
6889     default:
6890       gcc_unreachable ();
6891     }
6892 }
6893
6894 /* Output the encoding of an attribute value.  */
6895
6896 static void
6897 output_value_format (dw_attr_ref a)
6898 {
6899   enum dwarf_form form = value_format (a);
6900
6901   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6902 }
6903
6904 /* Output the .debug_abbrev section which defines the DIE abbreviation
6905    table.  */
6906
6907 static void
6908 output_abbrev_section (void)
6909 {
6910   unsigned long abbrev_id;
6911
6912   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6913     {
6914       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6915       unsigned ix;
6916       dw_attr_ref a_attr;
6917
6918       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6919       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6920                                    dwarf_tag_name (abbrev->die_tag));
6921
6922       if (abbrev->die_child != NULL)
6923         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6924       else
6925         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6926
6927       for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6928            ix++)
6929         {
6930           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6931                                        dwarf_attr_name (a_attr->dw_attr));
6932           output_value_format (a_attr);
6933         }
6934
6935       dw2_asm_output_data (1, 0, NULL);
6936       dw2_asm_output_data (1, 0, NULL);
6937     }
6938
6939   /* Terminate the table.  */
6940   dw2_asm_output_data (1, 0, NULL);
6941 }
6942
6943 /* Output a symbol we can use to refer to this DIE from another CU.  */
6944
6945 static inline void
6946 output_die_symbol (dw_die_ref die)
6947 {
6948   char *sym = die->die_symbol;
6949
6950   if (sym == 0)
6951     return;
6952
6953   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6954     /* We make these global, not weak; if the target doesn't support
6955        .linkonce, it doesn't support combining the sections, so debugging
6956        will break.  */
6957     targetm.asm_out.globalize_label (asm_out_file, sym);
6958
6959   ASM_OUTPUT_LABEL (asm_out_file, sym);
6960 }
6961
6962 /* Return a new location list, given the begin and end range, and the
6963    expression. gensym tells us whether to generate a new internal symbol for
6964    this location list node, which is done for the head of the list only.  */
6965
6966 static inline dw_loc_list_ref
6967 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6968               const char *section, unsigned int gensym)
6969 {
6970   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6971
6972   retlist->begin = begin;
6973   retlist->end = end;
6974   retlist->expr = expr;
6975   retlist->section = section;
6976   if (gensym)
6977     retlist->ll_symbol = gen_internal_sym ("LLST");
6978
6979   return retlist;
6980 }
6981
6982 /* Add a location description expression to a location list.  */
6983
6984 static inline void
6985 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6986                            const char *begin, const char *end,
6987                            const char *section)
6988 {
6989   dw_loc_list_ref *d;
6990
6991   /* Find the end of the chain.  */
6992   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6993     ;
6994
6995   /* Add a new location list node to the list.  */
6996   *d = new_loc_list (descr, begin, end, section, 0);
6997 }
6998
6999 static void
7000 dwarf2out_switch_text_section (void)
7001 {
7002   dw_fde_ref fde;
7003
7004   gcc_assert (cfun);
7005
7006   fde = &fde_table[fde_table_in_use - 1];
7007   fde->dw_fde_switched_sections = true;
7008   fde->dw_fde_hot_section_label = cfun->hot_section_label;
7009   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
7010   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
7011   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
7012   have_multiple_function_sections = true;
7013
7014   /* Reset the current label on switching text sections, so that we
7015      don't attempt to advance_loc4 between labels in different sections.  */
7016   fde->dw_fde_current_label = NULL;
7017 }
7018
7019 /* Output the location list given to us.  */
7020
7021 static void
7022 output_loc_list (dw_loc_list_ref list_head)
7023 {
7024   dw_loc_list_ref curr = list_head;
7025
7026   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7027
7028   /* Walk the location list, and output each range + expression.  */
7029   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7030     {
7031       unsigned long size;
7032       if (!have_multiple_function_sections)
7033         {
7034           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7035                                 "Location list begin address (%s)",
7036                                 list_head->ll_symbol);
7037           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7038                                 "Location list end address (%s)",
7039                                 list_head->ll_symbol);
7040         }
7041       else
7042         {
7043           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7044                                "Location list begin address (%s)",
7045                                list_head->ll_symbol);
7046           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7047                                "Location list end address (%s)",
7048                                list_head->ll_symbol);
7049         }
7050       size = size_of_locs (curr->expr);
7051
7052       /* Output the block length for this list of location operations.  */
7053       gcc_assert (size <= 0xffff);
7054       dw2_asm_output_data (2, size, "%s", "Location expression size");
7055
7056       output_loc_sequence (curr->expr);
7057     }
7058
7059   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7060                        "Location list terminator begin (%s)",
7061                        list_head->ll_symbol);
7062   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7063                        "Location list terminator end (%s)",
7064                        list_head->ll_symbol);
7065 }
7066
7067 /* Output the DIE and its attributes.  Called recursively to generate
7068    the definitions of each child DIE.  */
7069
7070 static void
7071 output_die (dw_die_ref die)
7072 {
7073   dw_attr_ref a;
7074   dw_die_ref c;
7075   unsigned long size;
7076   unsigned ix;
7077
7078   /* If someone in another CU might refer to us, set up a symbol for
7079      them to point to.  */
7080   if (die->die_symbol)
7081     output_die_symbol (die);
7082
7083   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7084                                die->die_offset, dwarf_tag_name (die->die_tag));
7085
7086   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7087     {
7088       const char *name = dwarf_attr_name (a->dw_attr);
7089
7090       switch (AT_class (a))
7091         {
7092         case dw_val_class_addr:
7093           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7094           break;
7095
7096         case dw_val_class_offset:
7097           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7098                                "%s", name);
7099           break;
7100
7101         case dw_val_class_range_list:
7102           {
7103             char *p = strchr (ranges_section_label, '\0');
7104
7105             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7106                      a->dw_attr_val.v.val_offset);
7107             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7108                                    debug_ranges_section, "%s", name);
7109             *p = '\0';
7110           }
7111           break;
7112
7113         case dw_val_class_loc:
7114           size = size_of_locs (AT_loc (a));
7115
7116           /* Output the block length for this list of location operations.  */
7117           dw2_asm_output_data (constant_size (size), size, "%s", name);
7118
7119           output_loc_sequence (AT_loc (a));
7120           break;
7121
7122         case dw_val_class_const:
7123           /* ??? It would be slightly more efficient to use a scheme like is
7124              used for unsigned constants below, but gdb 4.x does not sign
7125              extend.  Gdb 5.x does sign extend.  */
7126           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7127           break;
7128
7129         case dw_val_class_unsigned_const:
7130           dw2_asm_output_data (constant_size (AT_unsigned (a)),
7131                                AT_unsigned (a), "%s", name);
7132           break;
7133
7134         case dw_val_class_long_long:
7135           {
7136             unsigned HOST_WIDE_INT first, second;
7137
7138             dw2_asm_output_data (1,
7139                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7140                                  "%s", name);
7141
7142             if (WORDS_BIG_ENDIAN)
7143               {
7144                 first = a->dw_attr_val.v.val_long_long.hi;
7145                 second = a->dw_attr_val.v.val_long_long.low;
7146               }
7147             else
7148               {
7149                 first = a->dw_attr_val.v.val_long_long.low;
7150                 second = a->dw_attr_val.v.val_long_long.hi;
7151               }
7152
7153             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7154                                  first, "long long constant");
7155             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7156                                  second, NULL);
7157           }
7158           break;
7159
7160         case dw_val_class_vec:
7161           {
7162             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7163             unsigned int len = a->dw_attr_val.v.val_vec.length;
7164             unsigned int i;
7165             unsigned char *p;
7166
7167             dw2_asm_output_data (1, len * elt_size, "%s", name);
7168             if (elt_size > sizeof (HOST_WIDE_INT))
7169               {
7170                 elt_size /= 2;
7171                 len *= 2;
7172               }
7173             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7174                  i < len;
7175                  i++, p += elt_size)
7176               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7177                                    "fp or vector constant word %u", i);
7178             break;
7179           }
7180
7181         case dw_val_class_flag:
7182           dw2_asm_output_data (1, AT_flag (a), "%s", name);
7183           break;
7184
7185         case dw_val_class_loc_list:
7186           {
7187             char *sym = AT_loc_list (a)->ll_symbol;
7188
7189             gcc_assert (sym);
7190             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7191                                    "%s", name);
7192           }
7193           break;
7194
7195         case dw_val_class_die_ref:
7196           if (AT_ref_external (a))
7197             {
7198               char *sym = AT_ref (a)->die_symbol;
7199
7200               gcc_assert (sym);
7201               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7202                                      "%s", name);
7203             }
7204           else
7205             {
7206               gcc_assert (AT_ref (a)->die_offset);
7207               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7208                                    "%s", name);
7209             }
7210           break;
7211
7212         case dw_val_class_fde_ref:
7213           {
7214             char l1[20];
7215
7216             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7217                                          a->dw_attr_val.v.val_fde_index * 2);
7218             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7219                                    "%s", name);
7220           }
7221           break;
7222
7223         case dw_val_class_lbl_id:
7224           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7225           break;
7226
7227         case dw_val_class_lineptr:
7228           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7229                                  debug_line_section, "%s", name);
7230           break;
7231
7232         case dw_val_class_macptr:
7233           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7234                                  debug_macinfo_section, "%s", name);
7235           break;
7236
7237         case dw_val_class_str:
7238           if (AT_string_form (a) == DW_FORM_strp)
7239             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7240                                    a->dw_attr_val.v.val_str->label,
7241                                    debug_str_section,
7242                                    "%s: \"%s\"", name, AT_string (a));
7243           else
7244             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7245           break;
7246
7247         case dw_val_class_file:
7248           {
7249             int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7250
7251             dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7252                                  a->dw_attr_val.v.val_file->filename);
7253             break;
7254           }
7255
7256         default:
7257           gcc_unreachable ();
7258         }
7259     }
7260
7261   FOR_EACH_CHILD (die, c, output_die (c));
7262
7263   /* Add null byte to terminate sibling list.  */
7264   if (die->die_child != NULL)
7265     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7266                          die->die_offset);
7267 }
7268
7269 /* Output the compilation unit that appears at the beginning of the
7270    .debug_info section, and precedes the DIE descriptions.  */
7271
7272 static void
7273 output_compilation_unit_header (void)
7274 {
7275   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7276     dw2_asm_output_data (4, 0xffffffff,
7277       "Initial length escape value indicating 64-bit DWARF extension");
7278   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7279                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7280                        "Length of Compilation Unit Info");
7281   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7282   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7283                          debug_abbrev_section,
7284                          "Offset Into Abbrev. Section");
7285   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7286 }
7287
7288 /* Output the compilation unit DIE and its children.  */
7289
7290 static void
7291 output_comp_unit (dw_die_ref die, int output_if_empty)
7292 {
7293   const char *secname;
7294   char *oldsym, *tmp;
7295
7296   /* Unless we are outputting main CU, we may throw away empty ones.  */
7297   if (!output_if_empty && die->die_child == NULL)
7298     return;
7299
7300   /* Even if there are no children of this DIE, we must output the information
7301      about the compilation unit.  Otherwise, on an empty translation unit, we
7302      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7303      will then complain when examining the file.  First mark all the DIEs in
7304      this CU so we know which get local refs.  */
7305   mark_dies (die);
7306
7307   build_abbrev_table (die);
7308
7309   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7310   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7311   calc_die_sizes (die);
7312
7313   oldsym = die->die_symbol;
7314   if (oldsym)
7315     {
7316       tmp = alloca (strlen (oldsym) + 24);
7317
7318       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7319       secname = tmp;
7320       die->die_symbol = NULL;
7321       switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7322     }
7323   else
7324     switch_to_section (debug_info_section);
7325
7326   /* Output debugging information.  */
7327   output_compilation_unit_header ();
7328   output_die (die);
7329
7330   /* Leave the marks on the main CU, so we can check them in
7331      output_pubnames.  */
7332   if (oldsym)
7333     {
7334       unmark_dies (die);
7335       die->die_symbol = oldsym;
7336     }
7337 }
7338
7339 /* Return the DWARF2/3 pubname associated with a decl.  */
7340
7341 static const char *
7342 dwarf2_name (tree decl, int scope)
7343 {
7344   return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7345 }
7346
7347 /* Add a new entry to .debug_pubnames if appropriate.  */
7348
7349 static void
7350 add_pubname (tree decl, dw_die_ref die)
7351 {
7352   pubname_entry e;
7353
7354   if (! TREE_PUBLIC (decl))
7355     return;
7356
7357   e.die = die;
7358   e.name = xstrdup (dwarf2_name (decl, 1));
7359   VEC_safe_push (pubname_entry, gc, pubname_table, &e);
7360 }
7361
7362 /* Add a new entry to .debug_pubtypes if appropriate.  */
7363
7364 static void
7365 add_pubtype (tree decl, dw_die_ref die)
7366 {
7367   pubname_entry e;
7368
7369   e.name = NULL;
7370   if ((TREE_PUBLIC (decl)
7371        || die->die_parent == comp_unit_die)
7372       && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
7373     {
7374       e.die = die;
7375       if (TYPE_P (decl))
7376         {
7377           if (TYPE_NAME (decl))
7378             {
7379               if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
7380                 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
7381               else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
7382                        && DECL_NAME (TYPE_NAME (decl)))
7383                 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
7384              else
7385                e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
7386             }
7387         }
7388       else
7389         e.name = xstrdup (dwarf2_name (decl, 1));
7390
7391       /* If we don't have a name for the type, there's no point in adding
7392          it to the table.  */
7393       if (e.name && e.name[0] != '\0')
7394         VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
7395     }
7396 }
7397
7398 /* Output the public names table used to speed up access to externally
7399    visible names; or the public types table used to find type definitions.  */
7400
7401 static void
7402 output_pubnames (VEC (pubname_entry, gc) * names)
7403 {
7404   unsigned i;
7405   unsigned long pubnames_length = size_of_pubnames (names);
7406   pubname_ref pub;
7407
7408   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7409     dw2_asm_output_data (4, 0xffffffff,
7410       "Initial length escape value indicating 64-bit DWARF extension");
7411   if (names == pubname_table)
7412     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7413                          "Length of Public Names Info");
7414   else
7415     dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7416                          "Length of Public Type Names Info");
7417   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7418   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7419                          debug_info_section,
7420                          "Offset of Compilation Unit Info");
7421   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7422                        "Compilation Unit Length");
7423
7424   for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
7425     {
7426       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7427       if (names == pubname_table)
7428         gcc_assert (pub->die->die_mark);
7429
7430       if (names != pubtype_table
7431           || pub->die->die_offset != 0
7432           || !flag_eliminate_unused_debug_types)
7433         {
7434           dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7435                                "DIE offset");
7436
7437           dw2_asm_output_nstring (pub->name, -1, "external name");
7438         }
7439     }
7440
7441   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7442 }
7443
7444 /* Add a new entry to .debug_aranges if appropriate.  */
7445
7446 static void
7447 add_arange (tree decl, dw_die_ref die)
7448 {
7449   if (! DECL_SECTION_NAME (decl))
7450     return;
7451
7452   if (arange_table_in_use == arange_table_allocated)
7453     {
7454       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7455       arange_table = ggc_realloc (arange_table,
7456                                   (arange_table_allocated
7457                                    * sizeof (dw_die_ref)));
7458       memset (arange_table + arange_table_in_use, 0,
7459               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7460     }
7461
7462   arange_table[arange_table_in_use++] = die;
7463 }
7464
7465 /* Output the information that goes into the .debug_aranges table.
7466    Namely, define the beginning and ending address range of the
7467    text section generated for this compilation unit.  */
7468
7469 static void
7470 output_aranges (void)
7471 {
7472   unsigned i;
7473   unsigned long aranges_length = size_of_aranges ();
7474
7475   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7476     dw2_asm_output_data (4, 0xffffffff,
7477       "Initial length escape value indicating 64-bit DWARF extension");
7478   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7479                        "Length of Address Ranges Info");
7480   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7481   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7482                          debug_info_section,
7483                          "Offset of Compilation Unit Info");
7484   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7485   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7486
7487   /* We need to align to twice the pointer size here.  */
7488   if (DWARF_ARANGES_PAD_SIZE)
7489     {
7490       /* Pad using a 2 byte words so that padding is correct for any
7491          pointer size.  */
7492       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7493                            2 * DWARF2_ADDR_SIZE);
7494       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7495         dw2_asm_output_data (2, 0, NULL);
7496     }
7497
7498   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7499   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7500                         text_section_label, "Length");
7501   if (flag_reorder_blocks_and_partition)
7502     {
7503       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7504                            "Address");
7505       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7506                             cold_text_section_label, "Length");
7507     }
7508
7509   for (i = 0; i < arange_table_in_use; i++)
7510     {
7511       dw_die_ref die = arange_table[i];
7512
7513       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7514       gcc_assert (die->die_mark);
7515
7516       if (die->die_tag == DW_TAG_subprogram)
7517         {
7518           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7519                                "Address");
7520           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7521                                 get_AT_low_pc (die), "Length");
7522         }
7523       else
7524         {
7525           /* A static variable; extract the symbol from DW_AT_location.
7526              Note that this code isn't currently hit, as we only emit
7527              aranges for functions (jason 9/23/99).  */
7528           dw_attr_ref a = get_AT (die, DW_AT_location);
7529           dw_loc_descr_ref loc;
7530
7531           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7532
7533           loc = AT_loc (a);
7534           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7535
7536           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7537                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7538           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7539                                get_AT_unsigned (die, DW_AT_byte_size),
7540                                "Length");
7541         }
7542     }
7543
7544   /* Output the terminator words.  */
7545   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7546   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7547 }
7548
7549 /* Add a new entry to .debug_ranges.  Return the offset at which it
7550    was placed.  */
7551
7552 static unsigned int
7553 add_ranges (tree block)
7554 {
7555   unsigned int in_use = ranges_table_in_use;
7556
7557   if (in_use == ranges_table_allocated)
7558     {
7559       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7560       ranges_table
7561         = ggc_realloc (ranges_table, (ranges_table_allocated
7562                                       * sizeof (struct dw_ranges_struct)));
7563       memset (ranges_table + ranges_table_in_use, 0,
7564               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7565     }
7566
7567   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7568   ranges_table_in_use = in_use + 1;
7569
7570   return in_use * 2 * DWARF2_ADDR_SIZE;
7571 }
7572
7573 static void
7574 output_ranges (void)
7575 {
7576   unsigned i;
7577   static const char *const start_fmt = "Offset 0x%x";
7578   const char *fmt = start_fmt;
7579
7580   for (i = 0; i < ranges_table_in_use; i++)
7581     {
7582       int block_num = ranges_table[i].block_num;
7583
7584       if (block_num)
7585         {
7586           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7587           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7588
7589           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7590           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7591
7592           /* If all code is in the text section, then the compilation
7593              unit base address defaults to DW_AT_low_pc, which is the
7594              base of the text section.  */
7595           if (!have_multiple_function_sections)
7596             {
7597               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7598                                     text_section_label,
7599                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7600               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7601                                     text_section_label, NULL);
7602             }
7603
7604           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7605              compilation unit base address to zero, which allows us to
7606              use absolute addresses, and not worry about whether the
7607              target supports cross-section arithmetic.  */
7608           else
7609             {
7610               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7611                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7612               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7613             }
7614
7615           fmt = NULL;
7616         }
7617       else
7618         {
7619           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7620           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7621           fmt = start_fmt;
7622         }
7623     }
7624 }
7625
7626 /* Data structure containing information about input files.  */
7627 struct file_info
7628 {
7629   const char *path;     /* Complete file name.  */
7630   const char *fname;    /* File name part.  */
7631   int length;           /* Length of entire string.  */
7632   struct dwarf_file_data * file_idx;    /* Index in input file table.  */
7633   int dir_idx;          /* Index in directory table.  */
7634 };
7635
7636 /* Data structure containing information about directories with source
7637    files.  */
7638 struct dir_info
7639 {
7640   const char *path;     /* Path including directory name.  */
7641   int length;           /* Path length.  */
7642   int prefix;           /* Index of directory entry which is a prefix.  */
7643   int count;            /* Number of files in this directory.  */
7644   int dir_idx;          /* Index of directory used as base.  */
7645 };
7646
7647 /* Callback function for file_info comparison.  We sort by looking at
7648    the directories in the path.  */
7649
7650 static int
7651 file_info_cmp (const void *p1, const void *p2)
7652 {
7653   const struct file_info *s1 = p1;
7654   const struct file_info *s2 = p2;
7655   unsigned char *cp1;
7656   unsigned char *cp2;
7657
7658   /* Take care of file names without directories.  We need to make sure that
7659      we return consistent values to qsort since some will get confused if
7660      we return the same value when identical operands are passed in opposite
7661      orders.  So if neither has a directory, return 0 and otherwise return
7662      1 or -1 depending on which one has the directory.  */
7663   if ((s1->path == s1->fname || s2->path == s2->fname))
7664     return (s2->path == s2->fname) - (s1->path == s1->fname);
7665
7666   cp1 = (unsigned char *) s1->path;
7667   cp2 = (unsigned char *) s2->path;
7668
7669   while (1)
7670     {
7671       ++cp1;
7672       ++cp2;
7673       /* Reached the end of the first path?  If so, handle like above.  */
7674       if ((cp1 == (unsigned char *) s1->fname)
7675           || (cp2 == (unsigned char *) s2->fname))
7676         return ((cp2 == (unsigned char *) s2->fname)
7677                 - (cp1 == (unsigned char *) s1->fname));
7678
7679       /* Character of current path component the same?  */
7680       else if (*cp1 != *cp2)
7681         return *cp1 - *cp2;
7682     }
7683 }
7684
7685 struct file_name_acquire_data
7686 {
7687   struct file_info *files;
7688   int used_files;
7689   int max_files;
7690 };
7691
7692 /* Traversal function for the hash table.  */
7693
7694 static int
7695 file_name_acquire (void ** slot, void *data)
7696 {
7697   struct file_name_acquire_data *fnad = data;
7698   struct dwarf_file_data *d = *slot;
7699   struct file_info *fi;
7700   const char *f;
7701
7702   gcc_assert (fnad->max_files >= d->emitted_number);
7703
7704   if (! d->emitted_number)
7705     return 1;
7706
7707   gcc_assert (fnad->max_files != fnad->used_files);
7708
7709   fi = fnad->files + fnad->used_files++;
7710
7711   /* Skip all leading "./".  */
7712   f = d->filename;
7713   while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
7714     f += 2;
7715
7716   /* Create a new array entry.  */
7717   fi->path = f;
7718   fi->length = strlen (f);
7719   fi->file_idx = d;
7720
7721   /* Search for the file name part.  */
7722   f = strrchr (f, DIR_SEPARATOR);
7723 #if defined (DIR_SEPARATOR_2)
7724   {
7725     char *g = strrchr (fi->path, DIR_SEPARATOR_2);
7726
7727     if (g != NULL)
7728       {
7729         if (f == NULL || f < g)
7730           f = g;
7731       }
7732   }
7733 #endif
7734
7735   fi->fname = f == NULL ? fi->path : f + 1;
7736   return 1;
7737 }
7738
7739 /* Output the directory table and the file name table.  We try to minimize
7740    the total amount of memory needed.  A heuristic is used to avoid large
7741    slowdowns with many input files.  */
7742
7743 static void
7744 output_file_names (void)
7745 {
7746   struct file_name_acquire_data fnad;
7747   int numfiles;
7748   struct file_info *files;
7749   struct dir_info *dirs;
7750   int *saved;
7751   int *savehere;
7752   int *backmap;
7753   int ndirs;
7754   int idx_offset;
7755   int i;
7756   int idx;
7757
7758   if (!last_emitted_file)
7759     {
7760       dw2_asm_output_data (1, 0, "End directory table");
7761       dw2_asm_output_data (1, 0, "End file name table");
7762       return;
7763     }
7764
7765   numfiles = last_emitted_file->emitted_number;
7766
7767   /* Allocate the various arrays we need.  */
7768   files = alloca (numfiles * sizeof (struct file_info));
7769   dirs = alloca (numfiles * sizeof (struct dir_info));
7770
7771   fnad.files = files;
7772   fnad.used_files = 0;
7773   fnad.max_files = numfiles;
7774   htab_traverse (file_table, file_name_acquire, &fnad);
7775   gcc_assert (fnad.used_files == fnad.max_files);
7776
7777   qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7778
7779   /* Find all the different directories used.  */
7780   dirs[0].path = files[0].path;
7781   dirs[0].length = files[0].fname - files[0].path;
7782   dirs[0].prefix = -1;
7783   dirs[0].count = 1;
7784   dirs[0].dir_idx = 0;
7785   files[0].dir_idx = 0;
7786   ndirs = 1;
7787
7788   for (i = 1; i < numfiles; i++)
7789     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7790         && memcmp (dirs[ndirs - 1].path, files[i].path,
7791                    dirs[ndirs - 1].length) == 0)
7792       {
7793         /* Same directory as last entry.  */
7794         files[i].dir_idx = ndirs - 1;
7795         ++dirs[ndirs - 1].count;
7796       }
7797     else
7798       {
7799         int j;
7800
7801         /* This is a new directory.  */
7802         dirs[ndirs].path = files[i].path;
7803         dirs[ndirs].length = files[i].fname - files[i].path;
7804         dirs[ndirs].count = 1;
7805         dirs[ndirs].dir_idx = ndirs;
7806         files[i].dir_idx = ndirs;
7807
7808         /* Search for a prefix.  */
7809         dirs[ndirs].prefix = -1;
7810         for (j = 0; j < ndirs; j++)
7811           if (dirs[j].length < dirs[ndirs].length
7812               && dirs[j].length > 1
7813               && (dirs[ndirs].prefix == -1
7814                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7815               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7816             dirs[ndirs].prefix = j;
7817
7818         ++ndirs;
7819       }
7820
7821   /* Now to the actual work.  We have to find a subset of the directories which
7822      allow expressing the file name using references to the directory table
7823      with the least amount of characters.  We do not do an exhaustive search
7824      where we would have to check out every combination of every single
7825      possible prefix.  Instead we use a heuristic which provides nearly optimal
7826      results in most cases and never is much off.  */
7827   saved = alloca (ndirs * sizeof (int));
7828   savehere = alloca (ndirs * sizeof (int));
7829
7830   memset (saved, '\0', ndirs * sizeof (saved[0]));
7831   for (i = 0; i < ndirs; i++)
7832     {
7833       int j;
7834       int total;
7835
7836       /* We can always save some space for the current directory.  But this
7837          does not mean it will be enough to justify adding the directory.  */
7838       savehere[i] = dirs[i].length;
7839       total = (savehere[i] - saved[i]) * dirs[i].count;
7840
7841       for (j = i + 1; j < ndirs; j++)
7842         {
7843           savehere[j] = 0;
7844           if (saved[j] < dirs[i].length)
7845             {
7846               /* Determine whether the dirs[i] path is a prefix of the
7847                  dirs[j] path.  */
7848               int k;
7849
7850               k = dirs[j].prefix;
7851               while (k != -1 && k != (int) i)
7852                 k = dirs[k].prefix;
7853
7854               if (k == (int) i)
7855                 {
7856                   /* Yes it is.  We can possibly save some memory by
7857                      writing the filenames in dirs[j] relative to
7858                      dirs[i].  */
7859                   savehere[j] = dirs[i].length;
7860                   total += (savehere[j] - saved[j]) * dirs[j].count;
7861                 }
7862             }
7863         }
7864
7865       /* Check whether we can save enough to justify adding the dirs[i]
7866          directory.  */
7867       if (total > dirs[i].length + 1)
7868         {
7869           /* It's worthwhile adding.  */
7870           for (j = i; j < ndirs; j++)
7871             if (savehere[j] > 0)
7872               {
7873                 /* Remember how much we saved for this directory so far.  */
7874                 saved[j] = savehere[j];
7875
7876                 /* Remember the prefix directory.  */
7877                 dirs[j].dir_idx = i;
7878               }
7879         }
7880     }
7881
7882   /* Emit the directory name table.  */
7883   idx = 1;
7884   idx_offset = dirs[0].length > 0 ? 1 : 0;
7885   for (i = 1 - idx_offset; i < ndirs; i++)
7886     dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7887                             "Directory Entry: 0x%x", i + idx_offset);
7888
7889   dw2_asm_output_data (1, 0, "End directory table");
7890
7891   /* We have to emit them in the order of emitted_number since that's
7892      used in the debug info generation.  To do this efficiently we
7893      generate a back-mapping of the indices first.  */
7894   backmap = alloca (numfiles * sizeof (int));
7895   for (i = 0; i < numfiles; i++)
7896     backmap[files[i].file_idx->emitted_number - 1] = i;
7897
7898   /* Now write all the file names.  */
7899   for (i = 0; i < numfiles; i++)
7900     {
7901       int file_idx = backmap[i];
7902       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7903
7904       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7905                               "File Entry: 0x%x", (unsigned) i + 1);
7906
7907       /* Include directory index.  */
7908       dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
7909
7910       /* Modification time.  */
7911       dw2_asm_output_data_uleb128 (0, NULL);
7912
7913       /* File length in bytes.  */
7914       dw2_asm_output_data_uleb128 (0, NULL);
7915     }
7916
7917   dw2_asm_output_data (1, 0, "End file name table");
7918 }
7919
7920
7921 /* Output the source line number correspondence information.  This
7922    information goes into the .debug_line section.  */
7923
7924 static void
7925 output_line_info (void)
7926 {
7927   char l1[20], l2[20], p1[20], p2[20];
7928   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7929   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7930   unsigned opc;
7931   unsigned n_op_args;
7932   unsigned long lt_index;
7933   unsigned long current_line;
7934   long line_offset;
7935   long line_delta;
7936   unsigned long current_file;
7937   unsigned long function;
7938
7939   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7940   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7941   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7942   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7943
7944   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7945     dw2_asm_output_data (4, 0xffffffff,
7946       "Initial length escape value indicating 64-bit DWARF extension");
7947   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7948                         "Length of Source Line Info");
7949   ASM_OUTPUT_LABEL (asm_out_file, l1);
7950
7951   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7952   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7953   ASM_OUTPUT_LABEL (asm_out_file, p1);
7954
7955   /* Define the architecture-dependent minimum instruction length (in
7956    bytes).  In this implementation of DWARF, this field is used for
7957    information purposes only.  Since GCC generates assembly language,
7958    we have no a priori knowledge of how many instruction bytes are
7959    generated for each source line, and therefore can use only the
7960    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7961    commands.  Accordingly, we fix this as `1', which is "correct
7962    enough" for all architectures, and don't let the target override.  */
7963   dw2_asm_output_data (1, 1,
7964                        "Minimum Instruction Length");
7965
7966   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7967                        "Default is_stmt_start flag");
7968   dw2_asm_output_data (1, DWARF_LINE_BASE,
7969                        "Line Base Value (Special Opcodes)");
7970   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7971                        "Line Range Value (Special Opcodes)");
7972   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7973                        "Special Opcode Base");
7974
7975   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7976     {
7977       switch (opc)
7978         {
7979         case DW_LNS_advance_pc:
7980         case DW_LNS_advance_line:
7981         case DW_LNS_set_file:
7982         case DW_LNS_set_column:
7983         case DW_LNS_fixed_advance_pc:
7984           n_op_args = 1;
7985           break;
7986         default:
7987           n_op_args = 0;
7988           break;
7989         }
7990
7991       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7992                            opc, n_op_args);
7993     }
7994
7995   /* Write out the information about the files we use.  */
7996   output_file_names ();
7997   ASM_OUTPUT_LABEL (asm_out_file, p2);
7998
7999   /* We used to set the address register to the first location in the text
8000      section here, but that didn't accomplish anything since we already
8001      have a line note for the opening brace of the first function.  */
8002
8003   /* Generate the line number to PC correspondence table, encoded as
8004      a series of state machine operations.  */
8005   current_file = 1;
8006   current_line = 1;
8007
8008   if (cfun && in_cold_section_p)
8009     strcpy (prev_line_label, cfun->cold_section_label);
8010   else
8011     strcpy (prev_line_label, text_section_label);
8012   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
8013     {
8014       dw_line_info_ref line_info = &line_info_table[lt_index];
8015
8016 #if 0
8017       /* Disable this optimization for now; GDB wants to see two line notes
8018          at the beginning of a function so it can find the end of the
8019          prologue.  */
8020
8021       /* Don't emit anything for redundant notes.  Just updating the
8022          address doesn't accomplish anything, because we already assume
8023          that anything after the last address is this line.  */
8024       if (line_info->dw_line_num == current_line
8025           && line_info->dw_file_num == current_file)
8026         continue;
8027 #endif
8028
8029       /* Emit debug info for the address of the current line.
8030
8031          Unfortunately, we have little choice here currently, and must always
8032          use the most general form.  GCC does not know the address delta
8033          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
8034          attributes which will give an upper bound on the address range.  We
8035          could perhaps use length attributes to determine when it is safe to
8036          use DW_LNS_fixed_advance_pc.  */
8037
8038       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
8039       if (0)
8040         {
8041           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
8042           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8043                                "DW_LNS_fixed_advance_pc");
8044           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8045         }
8046       else
8047         {
8048           /* This can handle any delta.  This takes
8049              4+DWARF2_ADDR_SIZE bytes.  */
8050           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8051           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8052           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8053           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8054         }
8055
8056       strcpy (prev_line_label, line_label);
8057
8058       /* Emit debug info for the source file of the current line, if
8059          different from the previous line.  */
8060       if (line_info->dw_file_num != current_file)
8061         {
8062           current_file = line_info->dw_file_num;
8063           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8064           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8065         }
8066
8067       /* Emit debug info for the current line number, choosing the encoding
8068          that uses the least amount of space.  */
8069       if (line_info->dw_line_num != current_line)
8070         {
8071           line_offset = line_info->dw_line_num - current_line;
8072           line_delta = line_offset - DWARF_LINE_BASE;
8073           current_line = line_info->dw_line_num;
8074           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8075             /* This can handle deltas from -10 to 234, using the current
8076                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
8077                takes 1 byte.  */
8078             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8079                                  "line %lu", current_line);
8080           else
8081             {
8082               /* This can handle any delta.  This takes at least 4 bytes,
8083                  depending on the value being encoded.  */
8084               dw2_asm_output_data (1, DW_LNS_advance_line,
8085                                    "advance to line %lu", current_line);
8086               dw2_asm_output_data_sleb128 (line_offset, NULL);
8087               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8088             }
8089         }
8090       else
8091         /* We still need to start a new row, so output a copy insn.  */
8092         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8093     }
8094
8095   /* Emit debug info for the address of the end of the function.  */
8096   if (0)
8097     {
8098       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8099                            "DW_LNS_fixed_advance_pc");
8100       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8101     }
8102   else
8103     {
8104       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8105       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8106       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8107       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8108     }
8109
8110   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8111   dw2_asm_output_data_uleb128 (1, NULL);
8112   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8113
8114   function = 0;
8115   current_file = 1;
8116   current_line = 1;
8117   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8118     {
8119       dw_separate_line_info_ref line_info
8120         = &separate_line_info_table[lt_index];
8121
8122 #if 0
8123       /* Don't emit anything for redundant notes.  */
8124       if (line_info->dw_line_num == current_line
8125           && line_info->dw_file_num == current_file
8126           && line_info->function == function)
8127         goto cont;
8128 #endif
8129
8130       /* Emit debug info for the address of the current line.  If this is
8131          a new function, or the first line of a function, then we need
8132          to handle it differently.  */
8133       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8134                                    lt_index);
8135       if (function != line_info->function)
8136         {
8137           function = line_info->function;
8138
8139           /* Set the address register to the first line in the function.  */
8140           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8141           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8142           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8143           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8144         }
8145       else
8146         {
8147           /* ??? See the DW_LNS_advance_pc comment above.  */
8148           if (0)
8149             {
8150               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8151                                    "DW_LNS_fixed_advance_pc");
8152               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8153             }
8154           else
8155             {
8156               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8157               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8158               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8159               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8160             }
8161         }
8162
8163       strcpy (prev_line_label, line_label);
8164
8165       /* Emit debug info for the source file of the current line, if
8166          different from the previous line.  */
8167       if (line_info->dw_file_num != current_file)
8168         {
8169           current_file = line_info->dw_file_num;
8170           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8171           dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8172         }
8173
8174       /* Emit debug info for the current line number, choosing the encoding
8175          that uses the least amount of space.  */
8176       if (line_info->dw_line_num != current_line)
8177         {
8178           line_offset = line_info->dw_line_num - current_line;
8179           line_delta = line_offset - DWARF_LINE_BASE;
8180           current_line = line_info->dw_line_num;
8181           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8182             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8183                                  "line %lu", current_line);
8184           else
8185             {
8186               dw2_asm_output_data (1, DW_LNS_advance_line,
8187                                    "advance to line %lu", current_line);
8188               dw2_asm_output_data_sleb128 (line_offset, NULL);
8189               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8190             }
8191         }
8192       else
8193         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8194
8195 #if 0
8196     cont:
8197 #endif
8198
8199       lt_index++;
8200
8201       /* If we're done with a function, end its sequence.  */
8202       if (lt_index == separate_line_info_table_in_use
8203           || separate_line_info_table[lt_index].function != function)
8204         {
8205           current_file = 1;
8206           current_line = 1;
8207
8208           /* Emit debug info for the address of the end of the function.  */
8209           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8210           if (0)
8211             {
8212               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8213                                    "DW_LNS_fixed_advance_pc");
8214               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8215             }
8216           else
8217             {
8218               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8219               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8220               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8221               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8222             }
8223
8224           /* Output the marker for the end of this sequence.  */
8225           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8226           dw2_asm_output_data_uleb128 (1, NULL);
8227           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8228         }
8229     }
8230
8231   /* Output the marker for the end of the line number info.  */
8232   ASM_OUTPUT_LABEL (asm_out_file, l2);
8233 }
8234 \f
8235 /* Given a pointer to a tree node for some base type, return a pointer to
8236    a DIE that describes the given type.
8237
8238    This routine must only be called for GCC type nodes that correspond to
8239    Dwarf base (fundamental) types.  */
8240
8241 static dw_die_ref
8242 base_type_die (tree type)
8243 {
8244   dw_die_ref base_type_result;
8245   enum dwarf_type encoding;
8246
8247   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8248     return 0;
8249
8250   switch (TREE_CODE (type))
8251     {
8252     case INTEGER_TYPE:
8253       if (TYPE_STRING_FLAG (type))
8254         {
8255           if (TYPE_UNSIGNED (type))
8256             encoding = DW_ATE_unsigned_char;
8257           else
8258             encoding = DW_ATE_signed_char;
8259         }
8260       else if (TYPE_UNSIGNED (type))
8261         encoding = DW_ATE_unsigned;
8262       else
8263         encoding = DW_ATE_signed;
8264       break;
8265
8266     case REAL_TYPE:
8267       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8268         encoding = DW_ATE_decimal_float;
8269       else
8270         encoding = DW_ATE_float;
8271       break;
8272
8273       /* Dwarf2 doesn't know anything about complex ints, so use
8274          a user defined type for it.  */
8275     case COMPLEX_TYPE:
8276       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8277         encoding = DW_ATE_complex_float;
8278       else
8279         encoding = DW_ATE_lo_user;
8280       break;
8281
8282     case BOOLEAN_TYPE:
8283       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8284       encoding = DW_ATE_boolean;
8285       break;
8286
8287     default:
8288       /* No other TREE_CODEs are Dwarf fundamental types.  */
8289       gcc_unreachable ();
8290     }
8291
8292   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8293
8294   /* This probably indicates a bug.  */
8295   if (! TYPE_NAME (type))
8296     add_name_attribute (base_type_result, "__unknown__");
8297
8298   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8299                    int_size_in_bytes (type));
8300   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8301
8302   return base_type_result;
8303 }
8304
8305 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8306    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8307
8308 static inline int
8309 is_base_type (tree type)
8310 {
8311   switch (TREE_CODE (type))
8312     {
8313     case ERROR_MARK:
8314     case VOID_TYPE:
8315     case INTEGER_TYPE:
8316     case REAL_TYPE:
8317     case COMPLEX_TYPE:
8318     case BOOLEAN_TYPE:
8319       return 1;
8320
8321     case ARRAY_TYPE:
8322     case RECORD_TYPE:
8323     case UNION_TYPE:
8324     case QUAL_UNION_TYPE:
8325     case ENUMERAL_TYPE:
8326     case FUNCTION_TYPE:
8327     case METHOD_TYPE:
8328     case POINTER_TYPE:
8329     case REFERENCE_TYPE:
8330     case OFFSET_TYPE:
8331     case LANG_TYPE:
8332     case VECTOR_TYPE:
8333       return 0;
8334
8335     default:
8336       gcc_unreachable ();
8337     }
8338
8339   return 0;
8340 }
8341
8342 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8343    node, return the size in bits for the type if it is a constant, or else
8344    return the alignment for the type if the type's size is not constant, or
8345    else return BITS_PER_WORD if the type actually turns out to be an
8346    ERROR_MARK node.  */
8347
8348 static inline unsigned HOST_WIDE_INT
8349 simple_type_size_in_bits (tree type)
8350 {
8351   if (TREE_CODE (type) == ERROR_MARK)
8352     return BITS_PER_WORD;
8353   else if (TYPE_SIZE (type) == NULL_TREE)
8354     return 0;
8355   else if (host_integerp (TYPE_SIZE (type), 1))
8356     return tree_low_cst (TYPE_SIZE (type), 1);
8357   else
8358     return TYPE_ALIGN (type);
8359 }
8360
8361 /* Return true if the debug information for the given type should be
8362    emitted as a subrange type.  */
8363
8364 static inline bool
8365 is_subrange_type (tree type)
8366 {
8367   tree subtype = TREE_TYPE (type);
8368
8369   /* Subrange types are identified by the fact that they are integer
8370      types, and that they have a subtype which is either an integer type
8371      or an enumeral type.  */
8372
8373   if (TREE_CODE (type) != INTEGER_TYPE
8374       || subtype == NULL_TREE)
8375     return false;
8376
8377   if (TREE_CODE (subtype) != INTEGER_TYPE
8378       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8379     return false;
8380
8381   if (TREE_CODE (type) == TREE_CODE (subtype)
8382       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8383       && TYPE_MIN_VALUE (type) != NULL
8384       && TYPE_MIN_VALUE (subtype) != NULL
8385       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8386       && TYPE_MAX_VALUE (type) != NULL
8387       && TYPE_MAX_VALUE (subtype) != NULL
8388       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8389     {
8390       /* The type and its subtype have the same representation.  If in
8391          addition the two types also have the same name, then the given
8392          type is not a subrange type, but rather a plain base type.  */
8393       /* FIXME: brobecker/2004-03-22:
8394          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8395          therefore be sufficient to check the TYPE_SIZE node pointers
8396          rather than checking the actual size.  Unfortunately, we have
8397          found some cases, such as in the Ada "integer" type, where
8398          this is not the case.  Until this problem is solved, we need to
8399          keep checking the actual size.  */
8400       tree type_name = TYPE_NAME (type);
8401       tree subtype_name = TYPE_NAME (subtype);
8402
8403       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8404         type_name = DECL_NAME (type_name);
8405
8406       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8407         subtype_name = DECL_NAME (subtype_name);
8408
8409       if (type_name == subtype_name)
8410         return false;
8411     }
8412
8413   return true;
8414 }
8415
8416 /*  Given a pointer to a tree node for a subrange type, return a pointer
8417     to a DIE that describes the given type.  */
8418
8419 static dw_die_ref
8420 subrange_type_die (tree type, dw_die_ref context_die)
8421 {
8422   dw_die_ref subrange_die;
8423   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8424
8425   if (context_die == NULL)
8426     context_die = comp_unit_die;
8427
8428   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8429
8430   if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8431     {
8432       /* The size of the subrange type and its base type do not match,
8433          so we need to generate a size attribute for the subrange type.  */
8434       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8435     }
8436
8437   if (TYPE_MIN_VALUE (type) != NULL)
8438     add_bound_info (subrange_die, DW_AT_lower_bound,
8439                     TYPE_MIN_VALUE (type));
8440   if (TYPE_MAX_VALUE (type) != NULL)
8441     add_bound_info (subrange_die, DW_AT_upper_bound,
8442                     TYPE_MAX_VALUE (type));
8443
8444   return subrange_die;
8445 }
8446
8447 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8448    entry that chains various modifiers in front of the given type.  */
8449
8450 static dw_die_ref
8451 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8452                    dw_die_ref context_die)
8453 {
8454   enum tree_code code = TREE_CODE (type);
8455   dw_die_ref mod_type_die;
8456   dw_die_ref sub_die = NULL;
8457   tree item_type = NULL;
8458   tree qualified_type;
8459   tree name;
8460
8461   if (code == ERROR_MARK)
8462     return NULL;
8463
8464   /* See if we already have the appropriately qualified variant of
8465      this type.  */
8466   qualified_type
8467     = get_qualified_type (type,
8468                           ((is_const_type ? TYPE_QUAL_CONST : 0)
8469                            | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8470
8471   /* If we do, then we can just use its DIE, if it exists.  */
8472   if (qualified_type)
8473     {
8474       mod_type_die = lookup_type_die (qualified_type);
8475       if (mod_type_die)
8476         return mod_type_die;
8477     }
8478
8479   name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8480
8481   /* Handle C typedef types.  */
8482   if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8483     {
8484       tree dtype = TREE_TYPE (name);
8485
8486       if (qualified_type == dtype)
8487         {
8488           /* For a named type, use the typedef.  */
8489           gen_type_die (qualified_type, context_die);
8490           return lookup_type_die (qualified_type);
8491         }
8492       else if (is_const_type < TYPE_READONLY (dtype)
8493                || is_volatile_type < TYPE_VOLATILE (dtype)
8494                || (is_const_type <= TYPE_READONLY (dtype)
8495                    && is_volatile_type <= TYPE_VOLATILE (dtype)
8496                    && DECL_ORIGINAL_TYPE (name) != type))
8497         /* cv-unqualified version of named type.  Just use the unnamed
8498            type to which it refers.  */
8499         return modified_type_die (DECL_ORIGINAL_TYPE (name),
8500                                   is_const_type, is_volatile_type,
8501                                   context_die);
8502       /* Else cv-qualified version of named type; fall through.  */
8503     }
8504
8505   if (is_const_type)
8506     {
8507       mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8508       sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8509     }
8510   else if (is_volatile_type)
8511     {
8512       mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8513       sub_die = modified_type_die (type, 0, 0, context_die);
8514     }
8515   else if (code == POINTER_TYPE)
8516     {
8517       mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8518       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8519                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8520       item_type = TREE_TYPE (type);
8521     }
8522   else if (code == REFERENCE_TYPE)
8523     {
8524       mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8525       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8526                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8527       item_type = TREE_TYPE (type);
8528     }
8529   else if (is_subrange_type (type))
8530     {
8531       mod_type_die = subrange_type_die (type, context_die);
8532       item_type = TREE_TYPE (type);
8533     }
8534   else if (is_base_type (type))
8535     mod_type_die = base_type_die (type);
8536   else
8537     {
8538       gen_type_die (type, context_die);
8539
8540       /* We have to get the type_main_variant here (and pass that to the
8541          `lookup_type_die' routine) because the ..._TYPE node we have
8542          might simply be a *copy* of some original type node (where the
8543          copy was created to help us keep track of typedef names) and
8544          that copy might have a different TYPE_UID from the original
8545          ..._TYPE node.  */
8546       if (TREE_CODE (type) != VECTOR_TYPE)
8547         return lookup_type_die (type_main_variant (type));
8548       else
8549         /* Vectors have the debugging information in the type,
8550            not the main variant.  */
8551         return lookup_type_die (type);
8552     }
8553
8554   /* Builtin types don't have a DECL_ORIGINAL_TYPE.  For those,
8555      don't output a DW_TAG_typedef, since there isn't one in the
8556      user's program; just attach a DW_AT_name to the type.  */
8557   if (name
8558       && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8559     {
8560       if (TREE_CODE (name) == TYPE_DECL)
8561         /* Could just call add_name_and_src_coords_attributes here,
8562            but since this is a builtin type it doesn't have any
8563            useful source coordinates anyway.  */
8564         name = DECL_NAME (name);
8565       add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8566     }
8567
8568   if (qualified_type)
8569     equate_type_number_to_die (qualified_type, mod_type_die);
8570
8571   if (item_type)
8572     /* We must do this after the equate_type_number_to_die call, in case
8573        this is a recursive type.  This ensures that the modified_type_die
8574        recursion will terminate even if the type is recursive.  Recursive
8575        types are possible in Ada.  */
8576     sub_die = modified_type_die (item_type,
8577                                  TYPE_READONLY (item_type),
8578                                  TYPE_VOLATILE (item_type),
8579                                  context_die);
8580
8581   if (sub_die != NULL)
8582     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8583
8584   return mod_type_die;
8585 }
8586
8587 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8588    an enumerated type.  */
8589
8590 static inline int
8591 type_is_enum (tree type)
8592 {
8593   return TREE_CODE (type) == ENUMERAL_TYPE;
8594 }
8595
8596 /* Return the DBX register number described by a given RTL node.  */
8597
8598 static unsigned int
8599 dbx_reg_number (rtx rtl)
8600 {
8601   unsigned regno = REGNO (rtl);
8602
8603   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8604
8605 #ifdef LEAF_REG_REMAP
8606   if (current_function_uses_only_leaf_regs)
8607     {
8608       int leaf_reg = LEAF_REG_REMAP (regno);
8609       if (leaf_reg != -1)
8610         regno = (unsigned) leaf_reg;
8611     }
8612 #endif
8613
8614   return DBX_REGISTER_NUMBER (regno);
8615 }
8616
8617 /* Optionally add a DW_OP_piece term to a location description expression.
8618    DW_OP_piece is only added if the location description expression already
8619    doesn't end with DW_OP_piece.  */
8620
8621 static void
8622 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8623 {
8624   dw_loc_descr_ref loc;
8625
8626   if (*list_head != NULL)
8627     {
8628       /* Find the end of the chain.  */
8629       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8630         ;
8631
8632       if (loc->dw_loc_opc != DW_OP_piece)
8633         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8634     }
8635 }
8636
8637 /* Return a location descriptor that designates a machine register or
8638    zero if there is none.  */
8639
8640 static dw_loc_descr_ref
8641 reg_loc_descriptor (rtx rtl)
8642 {
8643   rtx regs;
8644
8645   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8646     return 0;
8647
8648   regs = targetm.dwarf_register_span (rtl);
8649
8650   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8651     return multiple_reg_loc_descriptor (rtl, regs);
8652   else
8653     return one_reg_loc_descriptor (dbx_reg_number (rtl));
8654 }
8655
8656 /* Return a location descriptor that designates a machine register for
8657    a given hard register number.  */
8658
8659 static dw_loc_descr_ref
8660 one_reg_loc_descriptor (unsigned int regno)
8661 {
8662   if (regno <= 31)
8663     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8664   else
8665     return new_loc_descr (DW_OP_regx, regno, 0);
8666 }
8667
8668 /* Given an RTL of a register, return a location descriptor that
8669    designates a value that spans more than one register.  */
8670
8671 static dw_loc_descr_ref
8672 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8673 {
8674   int nregs, size, i;
8675   unsigned reg;
8676   dw_loc_descr_ref loc_result = NULL;
8677
8678   reg = REGNO (rtl);
8679 #ifdef LEAF_REG_REMAP
8680   if (current_function_uses_only_leaf_regs)
8681     {
8682       int leaf_reg = LEAF_REG_REMAP (reg);
8683       if (leaf_reg != -1)
8684         reg = (unsigned) leaf_reg;
8685     }
8686 #endif
8687   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8688   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8689
8690   /* Simple, contiguous registers.  */
8691   if (regs == NULL_RTX)
8692     {
8693       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8694
8695       loc_result = NULL;
8696       while (nregs--)
8697         {
8698           dw_loc_descr_ref t;
8699
8700           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8701           add_loc_descr (&loc_result, t);
8702           add_loc_descr_op_piece (&loc_result, size);
8703           ++reg;
8704         }
8705       return loc_result;
8706     }
8707
8708   /* Now onto stupid register sets in non contiguous locations.  */
8709
8710   gcc_assert (GET_CODE (regs) == PARALLEL);
8711
8712   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8713   loc_result = NULL;
8714
8715   for (i = 0; i < XVECLEN (regs, 0); ++i)
8716     {
8717       dw_loc_descr_ref t;
8718
8719       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8720       add_loc_descr (&loc_result, t);
8721       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8722       add_loc_descr_op_piece (&loc_result, size);
8723     }
8724   return loc_result;
8725 }
8726
8727 /* Return a location descriptor that designates a constant.  */
8728
8729 static dw_loc_descr_ref
8730 int_loc_descriptor (HOST_WIDE_INT i)
8731 {
8732   enum dwarf_location_atom op;
8733
8734   /* Pick the smallest representation of a constant, rather than just
8735      defaulting to the LEB encoding.  */
8736   if (i >= 0)
8737     {
8738       if (i <= 31)
8739         op = DW_OP_lit0 + i;
8740       else if (i <= 0xff)
8741         op = DW_OP_const1u;
8742       else if (i <= 0xffff)
8743         op = DW_OP_const2u;
8744       else if (HOST_BITS_PER_WIDE_INT == 32
8745                || i <= 0xffffffff)
8746         op = DW_OP_const4u;
8747       else
8748         op = DW_OP_constu;
8749     }
8750   else
8751     {
8752       if (i >= -0x80)
8753         op = DW_OP_const1s;
8754       else if (i >= -0x8000)
8755         op = DW_OP_const2s;
8756       else if (HOST_BITS_PER_WIDE_INT == 32
8757                || i >= -0x80000000)
8758         op = DW_OP_const4s;
8759       else
8760         op = DW_OP_consts;
8761     }
8762
8763   return new_loc_descr (op, i, 0);
8764 }
8765
8766 /* Return a location descriptor that designates a base+offset location.  */
8767
8768 static dw_loc_descr_ref
8769 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8770 {
8771   unsigned int regno;
8772
8773   /* We only use "frame base" when we're sure we're talking about the
8774      post-prologue local stack frame.  We do this by *not* running
8775      register elimination until this point, and recognizing the special
8776      argument pointer and soft frame pointer rtx's.  */
8777   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8778     {
8779       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8780
8781       if (elim != reg)
8782         {
8783           if (GET_CODE (elim) == PLUS)
8784             {
8785               offset += INTVAL (XEXP (elim, 1));
8786               elim = XEXP (elim, 0);
8787             }
8788           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8789                       : stack_pointer_rtx));
8790           offset += frame_pointer_fb_offset;
8791
8792           return new_loc_descr (DW_OP_fbreg, offset, 0);
8793         }
8794     }
8795
8796   regno = dbx_reg_number (reg);
8797   if (regno <= 31)
8798     return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8799   else
8800     return new_loc_descr (DW_OP_bregx, regno, offset);
8801 }
8802
8803 /* Return true if this RTL expression describes a base+offset calculation.  */
8804
8805 static inline int
8806 is_based_loc (rtx rtl)
8807 {
8808   return (GET_CODE (rtl) == PLUS
8809           && ((REG_P (XEXP (rtl, 0))
8810                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8811                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8812 }
8813
8814 /* The following routine converts the RTL for a variable or parameter
8815    (resident in memory) into an equivalent Dwarf representation of a
8816    mechanism for getting the address of that same variable onto the top of a
8817    hypothetical "address evaluation" stack.
8818
8819    When creating memory location descriptors, we are effectively transforming
8820    the RTL for a memory-resident object into its Dwarf postfix expression
8821    equivalent.  This routine recursively descends an RTL tree, turning
8822    it into Dwarf postfix code as it goes.
8823
8824    MODE is the mode of the memory reference, needed to handle some
8825    autoincrement addressing modes.
8826
8827    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8828    location list for RTL.
8829
8830    Return 0 if we can't represent the location.  */
8831
8832 static dw_loc_descr_ref
8833 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8834 {
8835   dw_loc_descr_ref mem_loc_result = NULL;
8836   enum dwarf_location_atom op;
8837
8838   /* Note that for a dynamically sized array, the location we will generate a
8839      description of here will be the lowest numbered location which is
8840      actually within the array.  That's *not* necessarily the same as the
8841      zeroth element of the array.  */
8842
8843   rtl = targetm.delegitimize_address (rtl);
8844
8845   switch (GET_CODE (rtl))
8846     {
8847     case POST_INC:
8848     case POST_DEC:
8849     case POST_MODIFY:
8850       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8851          just fall into the SUBREG code.  */
8852
8853       /* ... fall through ...  */
8854
8855     case SUBREG:
8856       /* The case of a subreg may arise when we have a local (register)
8857          variable or a formal (register) parameter which doesn't quite fill
8858          up an entire register.  For now, just assume that it is
8859          legitimate to make the Dwarf info refer to the whole register which
8860          contains the given subreg.  */
8861       rtl = XEXP (rtl, 0);
8862
8863       /* ... fall through ...  */
8864
8865     case REG:
8866       /* Whenever a register number forms a part of the description of the
8867          method for calculating the (dynamic) address of a memory resident
8868          object, DWARF rules require the register number be referred to as
8869          a "base register".  This distinction is not based in any way upon
8870          what category of register the hardware believes the given register
8871          belongs to.  This is strictly DWARF terminology we're dealing with
8872          here. Note that in cases where the location of a memory-resident
8873          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8874          OP_CONST (0)) the actual DWARF location descriptor that we generate
8875          may just be OP_BASEREG (basereg).  This may look deceptively like
8876          the object in question was allocated to a register (rather than in
8877          memory) so DWARF consumers need to be aware of the subtle
8878          distinction between OP_REG and OP_BASEREG.  */
8879       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8880         mem_loc_result = based_loc_descr (rtl, 0);
8881       break;
8882
8883     case MEM:
8884       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8885       if (mem_loc_result != 0)
8886         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8887       break;
8888
8889     case LO_SUM:
8890          rtl = XEXP (rtl, 1);
8891
8892       /* ... fall through ...  */
8893
8894     case LABEL_REF:
8895       /* Some ports can transform a symbol ref into a label ref, because
8896          the symbol ref is too far away and has to be dumped into a constant
8897          pool.  */
8898     case CONST:
8899     case SYMBOL_REF:
8900       /* Alternatively, the symbol in the constant pool might be referenced
8901          by a different symbol.  */
8902       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8903         {
8904           bool marked;
8905           rtx tmp = get_pool_constant_mark (rtl, &marked);
8906
8907           if (GET_CODE (tmp) == SYMBOL_REF)
8908             {
8909               rtl = tmp;
8910               if (CONSTANT_POOL_ADDRESS_P (tmp))
8911                 get_pool_constant_mark (tmp, &marked);
8912               else
8913                 marked = true;
8914             }
8915
8916           /* If all references to this pool constant were optimized away,
8917              it was not output and thus we can't represent it.
8918              FIXME: might try to use DW_OP_const_value here, though
8919              DW_OP_piece complicates it.  */
8920           if (!marked)
8921             return 0;
8922         }
8923
8924       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8925       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8926       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8927       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8928       break;
8929
8930     case PRE_MODIFY:
8931       /* Extract the PLUS expression nested inside and fall into
8932          PLUS code below.  */
8933       rtl = XEXP (rtl, 1);
8934       goto plus;
8935
8936     case PRE_INC:
8937     case PRE_DEC:
8938       /* Turn these into a PLUS expression and fall into the PLUS code
8939          below.  */
8940       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8941                           GEN_INT (GET_CODE (rtl) == PRE_INC
8942                                    ? GET_MODE_UNIT_SIZE (mode)
8943                                    : -GET_MODE_UNIT_SIZE (mode)));
8944
8945       /* ... fall through ...  */
8946
8947     case PLUS:
8948     plus:
8949       if (is_based_loc (rtl))
8950         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8951                                           INTVAL (XEXP (rtl, 1)));
8952       else
8953         {
8954           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8955           if (mem_loc_result == 0)
8956             break;
8957
8958           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8959               && INTVAL (XEXP (rtl, 1)) >= 0)
8960             add_loc_descr (&mem_loc_result,
8961                            new_loc_descr (DW_OP_plus_uconst,
8962                                           INTVAL (XEXP (rtl, 1)), 0));
8963           else
8964             {
8965               add_loc_descr (&mem_loc_result,
8966                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8967               add_loc_descr (&mem_loc_result,
8968                              new_loc_descr (DW_OP_plus, 0, 0));
8969             }
8970         }
8971       break;
8972
8973     /* If a pseudo-reg is optimized away, it is possible for it to
8974        be replaced with a MEM containing a multiply or shift.  */
8975     case MULT:
8976       op = DW_OP_mul;
8977       goto do_binop;
8978
8979     case ASHIFT:
8980       op = DW_OP_shl;
8981       goto do_binop;
8982
8983     case ASHIFTRT:
8984       op = DW_OP_shra;
8985       goto do_binop;
8986
8987     case LSHIFTRT:
8988       op = DW_OP_shr;
8989       goto do_binop;
8990
8991     do_binop:
8992       {
8993         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8994         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8995
8996         if (op0 == 0 || op1 == 0)
8997           break;
8998
8999         mem_loc_result = op0;
9000         add_loc_descr (&mem_loc_result, op1);
9001         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
9002         break;
9003       }
9004
9005     case CONST_INT:
9006       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
9007       break;
9008
9009     default:
9010       gcc_unreachable ();
9011     }
9012
9013   return mem_loc_result;
9014 }
9015
9016 /* Return a descriptor that describes the concatenation of two locations.
9017    This is typically a complex variable.  */
9018
9019 static dw_loc_descr_ref
9020 concat_loc_descriptor (rtx x0, rtx x1)
9021 {
9022   dw_loc_descr_ref cc_loc_result = NULL;
9023   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
9024   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
9025
9026   if (x0_ref == 0 || x1_ref == 0)
9027     return 0;
9028
9029   cc_loc_result = x0_ref;
9030   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
9031
9032   add_loc_descr (&cc_loc_result, x1_ref);
9033   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
9034
9035   return cc_loc_result;
9036 }
9037
9038 /* Return a descriptor that describes the concatenation of N
9039    locations.  */
9040
9041 static dw_loc_descr_ref
9042 concatn_loc_descriptor (rtx concatn)
9043 {
9044   unsigned int i;
9045   dw_loc_descr_ref cc_loc_result = NULL;
9046   unsigned int n = XVECLEN (concatn, 0);
9047
9048   for (i = 0; i < n; ++i)
9049     {
9050       dw_loc_descr_ref ref;
9051       rtx x = XVECEXP (concatn, 0, i);
9052
9053       ref = loc_descriptor (x);
9054       if (ref == NULL)
9055         return NULL;
9056
9057       add_loc_descr (&cc_loc_result, ref);
9058       add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9059     }
9060
9061   return cc_loc_result;
9062 }
9063
9064 /* Output a proper Dwarf location descriptor for a variable or parameter
9065    which is either allocated in a register or in a memory location.  For a
9066    register, we just generate an OP_REG and the register number.  For a
9067    memory location we provide a Dwarf postfix expression describing how to
9068    generate the (dynamic) address of the object onto the address stack.
9069
9070    If we don't know how to describe it, return 0.  */
9071
9072 static dw_loc_descr_ref
9073 loc_descriptor (rtx rtl)
9074 {
9075   dw_loc_descr_ref loc_result = NULL;
9076
9077   switch (GET_CODE (rtl))
9078     {
9079     case SUBREG:
9080       /* The case of a subreg may arise when we have a local (register)
9081          variable or a formal (register) parameter which doesn't quite fill
9082          up an entire register.  For now, just assume that it is
9083          legitimate to make the Dwarf info refer to the whole register which
9084          contains the given subreg.  */
9085       rtl = SUBREG_REG (rtl);
9086
9087       /* ... fall through ...  */
9088
9089     case REG:
9090       loc_result = reg_loc_descriptor (rtl);
9091       break;
9092
9093     case MEM:
9094       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
9095       break;
9096
9097     case CONCAT:
9098       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
9099       break;
9100
9101     case CONCATN:
9102       loc_result = concatn_loc_descriptor (rtl);
9103       break;
9104
9105     case VAR_LOCATION:
9106       /* Single part.  */
9107       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9108         {
9109           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
9110           break;
9111         }
9112
9113       rtl = XEXP (rtl, 1);
9114       /* FALLTHRU */
9115
9116     case PARALLEL:
9117       {
9118         rtvec par_elems = XVEC (rtl, 0);
9119         int num_elem = GET_NUM_ELEM (par_elems);
9120         enum machine_mode mode;
9121         int i;
9122
9123         /* Create the first one, so we have something to add to.  */
9124         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
9125         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9126         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9127         for (i = 1; i < num_elem; i++)
9128           {
9129             dw_loc_descr_ref temp;
9130
9131             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9132             add_loc_descr (&loc_result, temp);
9133             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9134             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9135           }
9136       }
9137       break;
9138
9139     default:
9140       gcc_unreachable ();
9141     }
9142
9143   return loc_result;
9144 }
9145
9146 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
9147    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
9148    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9149    top-level invocation, and we require the address of LOC; is 0 if we require
9150    the value of LOC.  */
9151
9152 static dw_loc_descr_ref
9153 loc_descriptor_from_tree_1 (tree loc, int want_address)
9154 {
9155   dw_loc_descr_ref ret, ret1;
9156   int have_address = 0;
9157   enum dwarf_location_atom op;
9158
9159   /* ??? Most of the time we do not take proper care for sign/zero
9160      extending the values properly.  Hopefully this won't be a real
9161      problem...  */
9162
9163   switch (TREE_CODE (loc))
9164     {
9165     case ERROR_MARK:
9166       return 0;
9167
9168     case PLACEHOLDER_EXPR:
9169       /* This case involves extracting fields from an object to determine the
9170          position of other fields.  We don't try to encode this here.  The
9171          only user of this is Ada, which encodes the needed information using
9172          the names of types.  */
9173       return 0;
9174
9175     case CALL_EXPR:
9176       return 0;
9177
9178     case PREINCREMENT_EXPR:
9179     case PREDECREMENT_EXPR:
9180     case POSTINCREMENT_EXPR:
9181     case POSTDECREMENT_EXPR:
9182       /* There are no opcodes for these operations.  */
9183       return 0;
9184
9185     case ADDR_EXPR:
9186       /* If we already want an address, there's nothing we can do.  */
9187       if (want_address)
9188         return 0;
9189
9190       /* Otherwise, process the argument and look for the address.  */
9191       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9192
9193     case VAR_DECL:
9194       if (DECL_THREAD_LOCAL_P (loc))
9195         {
9196           rtx rtl;
9197
9198           /* If this is not defined, we have no way to emit the data.  */
9199           if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
9200             return 0;
9201
9202           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9203              look up addresses of objects in the current module.  */
9204           if (DECL_EXTERNAL (loc))
9205             return 0;
9206
9207           rtl = rtl_for_decl_location (loc);
9208           if (rtl == NULL_RTX)
9209             return 0;
9210
9211           if (!MEM_P (rtl))
9212             return 0;
9213           rtl = XEXP (rtl, 0);
9214           if (! CONSTANT_P (rtl))
9215             return 0;
9216
9217           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9218           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9219           ret->dw_loc_oprnd1.v.val_addr = rtl;
9220
9221           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9222           add_loc_descr (&ret, ret1);
9223
9224           have_address = 1;
9225           break;
9226         }
9227       /* FALLTHRU */
9228
9229     case PARM_DECL:
9230       if (DECL_HAS_VALUE_EXPR_P (loc))
9231         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9232                                            want_address);
9233       /* FALLTHRU */
9234
9235     case RESULT_DECL:
9236     case FUNCTION_DECL:
9237       {
9238         rtx rtl = rtl_for_decl_location (loc);
9239
9240         if (rtl == NULL_RTX)
9241           return 0;
9242         else if (GET_CODE (rtl) == CONST_INT)
9243           {
9244             HOST_WIDE_INT val = INTVAL (rtl);
9245             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9246               val &= GET_MODE_MASK (DECL_MODE (loc));
9247             ret = int_loc_descriptor (val);
9248           }
9249         else if (GET_CODE (rtl) == CONST_STRING)
9250           return 0;
9251         else if (CONSTANT_P (rtl))
9252           {
9253             ret = new_loc_descr (DW_OP_addr, 0, 0);
9254             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9255             ret->dw_loc_oprnd1.v.val_addr = rtl;
9256           }
9257         else
9258           {
9259             enum machine_mode mode;
9260
9261             /* Certain constructs can only be represented at top-level.  */
9262             if (want_address == 2)
9263               return loc_descriptor (rtl);
9264
9265             mode = GET_MODE (rtl);
9266             if (MEM_P (rtl))
9267               {
9268                 rtl = XEXP (rtl, 0);
9269                 have_address = 1;
9270               }
9271             ret = mem_loc_descriptor (rtl, mode);
9272           }
9273       }
9274       break;
9275
9276     case INDIRECT_REF:
9277       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9278       have_address = 1;
9279       break;
9280
9281     case COMPOUND_EXPR:
9282       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9283
9284     case NOP_EXPR:
9285     case CONVERT_EXPR:
9286     case NON_LVALUE_EXPR:
9287     case VIEW_CONVERT_EXPR:
9288     case SAVE_EXPR:
9289     case GIMPLE_MODIFY_STMT:
9290       return loc_descriptor_from_tree_1 (GENERIC_TREE_OPERAND (loc, 0),
9291                                          want_address);
9292
9293     case COMPONENT_REF:
9294     case BIT_FIELD_REF:
9295     case ARRAY_REF:
9296     case ARRAY_RANGE_REF:
9297       {
9298         tree obj, offset;
9299         HOST_WIDE_INT bitsize, bitpos, bytepos;
9300         enum machine_mode mode;
9301         int volatilep;
9302         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9303
9304         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9305                                    &unsignedp, &volatilep, false);
9306
9307         if (obj == loc)
9308           return 0;
9309
9310         ret = loc_descriptor_from_tree_1 (obj, 1);
9311         if (ret == 0
9312             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9313           return 0;
9314
9315         if (offset != NULL_TREE)
9316           {
9317             /* Variable offset.  */
9318             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9319             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9320           }
9321
9322         bytepos = bitpos / BITS_PER_UNIT;
9323         if (bytepos > 0)
9324           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9325         else if (bytepos < 0)
9326           {
9327             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9328             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9329           }
9330
9331         have_address = 1;
9332         break;
9333       }
9334
9335     case INTEGER_CST:
9336       if (host_integerp (loc, 0))
9337         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9338       else
9339         return 0;
9340       break;
9341
9342     case CONSTRUCTOR:
9343       {
9344         /* Get an RTL for this, if something has been emitted.  */
9345         rtx rtl = lookup_constant_def (loc);
9346         enum machine_mode mode;
9347
9348         if (!rtl || !MEM_P (rtl))
9349           return 0;
9350         mode = GET_MODE (rtl);
9351         rtl = XEXP (rtl, 0);
9352         ret = mem_loc_descriptor (rtl, mode);
9353         have_address = 1;
9354         break;
9355       }
9356
9357     case TRUTH_AND_EXPR:
9358     case TRUTH_ANDIF_EXPR:
9359     case BIT_AND_EXPR:
9360       op = DW_OP_and;
9361       goto do_binop;
9362
9363     case TRUTH_XOR_EXPR:
9364     case BIT_XOR_EXPR:
9365       op = DW_OP_xor;
9366       goto do_binop;
9367
9368     case TRUTH_OR_EXPR:
9369     case TRUTH_ORIF_EXPR:
9370     case BIT_IOR_EXPR:
9371       op = DW_OP_or;
9372       goto do_binop;
9373
9374     case FLOOR_DIV_EXPR:
9375     case CEIL_DIV_EXPR:
9376     case ROUND_DIV_EXPR:
9377     case TRUNC_DIV_EXPR:
9378       op = DW_OP_div;
9379       goto do_binop;
9380
9381     case MINUS_EXPR:
9382       op = DW_OP_minus;
9383       goto do_binop;
9384
9385     case FLOOR_MOD_EXPR:
9386     case CEIL_MOD_EXPR:
9387     case ROUND_MOD_EXPR:
9388     case TRUNC_MOD_EXPR:
9389       op = DW_OP_mod;
9390       goto do_binop;
9391
9392     case MULT_EXPR:
9393       op = DW_OP_mul;
9394       goto do_binop;
9395
9396     case LSHIFT_EXPR:
9397       op = DW_OP_shl;
9398       goto do_binop;
9399
9400     case RSHIFT_EXPR:
9401       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9402       goto do_binop;
9403
9404     case PLUS_EXPR:
9405       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9406           && host_integerp (TREE_OPERAND (loc, 1), 0))
9407         {
9408           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9409           if (ret == 0)
9410             return 0;
9411
9412           add_loc_descr (&ret,
9413                          new_loc_descr (DW_OP_plus_uconst,
9414                                         tree_low_cst (TREE_OPERAND (loc, 1),
9415                                                       0),
9416                                         0));
9417           break;
9418         }
9419
9420       op = DW_OP_plus;
9421       goto do_binop;
9422
9423     case LE_EXPR:
9424       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9425         return 0;
9426
9427       op = DW_OP_le;
9428       goto do_binop;
9429
9430     case GE_EXPR:
9431       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9432         return 0;
9433
9434       op = DW_OP_ge;
9435       goto do_binop;
9436
9437     case LT_EXPR:
9438       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9439         return 0;
9440
9441       op = DW_OP_lt;
9442       goto do_binop;
9443
9444     case GT_EXPR:
9445       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9446         return 0;
9447
9448       op = DW_OP_gt;
9449       goto do_binop;
9450
9451     case EQ_EXPR:
9452       op = DW_OP_eq;
9453       goto do_binop;
9454
9455     case NE_EXPR:
9456       op = DW_OP_ne;
9457       goto do_binop;
9458
9459     do_binop:
9460       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9461       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9462       if (ret == 0 || ret1 == 0)
9463         return 0;
9464
9465       add_loc_descr (&ret, ret1);
9466       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9467       break;
9468
9469     case TRUTH_NOT_EXPR:
9470     case BIT_NOT_EXPR:
9471       op = DW_OP_not;
9472       goto do_unop;
9473
9474     case ABS_EXPR:
9475       op = DW_OP_abs;
9476       goto do_unop;
9477
9478     case NEGATE_EXPR:
9479       op = DW_OP_neg;
9480       goto do_unop;
9481
9482     do_unop:
9483       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9484       if (ret == 0)
9485         return 0;
9486
9487       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9488       break;
9489
9490     case MIN_EXPR:
9491     case MAX_EXPR:
9492       {
9493         const enum tree_code code =
9494           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9495
9496         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9497                       build2 (code, integer_type_node,
9498                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9499                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9500       }
9501
9502       /* ... fall through ...  */
9503
9504     case COND_EXPR:
9505       {
9506         dw_loc_descr_ref lhs
9507           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9508         dw_loc_descr_ref rhs
9509           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9510         dw_loc_descr_ref bra_node, jump_node, tmp;
9511
9512         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9513         if (ret == 0 || lhs == 0 || rhs == 0)
9514           return 0;
9515
9516         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9517         add_loc_descr (&ret, bra_node);
9518
9519         add_loc_descr (&ret, rhs);
9520         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9521         add_loc_descr (&ret, jump_node);
9522
9523         add_loc_descr (&ret, lhs);
9524         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9525         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9526
9527         /* ??? Need a node to point the skip at.  Use a nop.  */
9528         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9529         add_loc_descr (&ret, tmp);
9530         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9531         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9532       }
9533       break;
9534
9535     case FIX_TRUNC_EXPR:
9536       return 0;
9537
9538     default:
9539       /* Leave front-end specific codes as simply unknown.  This comes
9540          up, for instance, with the C STMT_EXPR.  */
9541       if ((unsigned int) TREE_CODE (loc)
9542           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9543         return 0;
9544
9545 #ifdef ENABLE_CHECKING
9546       /* Otherwise this is a generic code; we should just lists all of
9547          these explicitly.  We forgot one.  */
9548       gcc_unreachable ();
9549 #else
9550       /* In a release build, we want to degrade gracefully: better to
9551          generate incomplete debugging information than to crash.  */
9552       return NULL;
9553 #endif
9554     }
9555
9556   /* Show if we can't fill the request for an address.  */
9557   if (want_address && !have_address)
9558     return 0;
9559
9560   /* If we've got an address and don't want one, dereference.  */
9561   if (!want_address && have_address && ret)
9562     {
9563       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9564
9565       if (size > DWARF2_ADDR_SIZE || size == -1)
9566         return 0;
9567       else if (size == DWARF2_ADDR_SIZE)
9568         op = DW_OP_deref;
9569       else
9570         op = DW_OP_deref_size;
9571
9572       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9573     }
9574
9575   return ret;
9576 }
9577
9578 static inline dw_loc_descr_ref
9579 loc_descriptor_from_tree (tree loc)
9580 {
9581   return loc_descriptor_from_tree_1 (loc, 2);
9582 }
9583
9584 /* Given a value, round it up to the lowest multiple of `boundary'
9585    which is not less than the value itself.  */
9586
9587 static inline HOST_WIDE_INT
9588 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9589 {
9590   return (((value + boundary - 1) / boundary) * boundary);
9591 }
9592
9593 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9594    pointer to the declared type for the relevant field variable, or return
9595    `integer_type_node' if the given node turns out to be an
9596    ERROR_MARK node.  */
9597
9598 static inline tree
9599 field_type (tree decl)
9600 {
9601   tree type;
9602
9603   if (TREE_CODE (decl) == ERROR_MARK)
9604     return integer_type_node;
9605
9606   type = DECL_BIT_FIELD_TYPE (decl);
9607   if (type == NULL_TREE)
9608     type = TREE_TYPE (decl);
9609
9610   return type;
9611 }
9612
9613 /* Given a pointer to a tree node, return the alignment in bits for
9614    it, or else return BITS_PER_WORD if the node actually turns out to
9615    be an ERROR_MARK node.  */
9616
9617 static inline unsigned
9618 simple_type_align_in_bits (tree type)
9619 {
9620   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9621 }
9622
9623 static inline unsigned
9624 simple_decl_align_in_bits (tree decl)
9625 {
9626   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9627 }
9628
9629 /* Return the result of rounding T up to ALIGN.  */
9630
9631 static inline HOST_WIDE_INT
9632 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
9633 {
9634   /* We must be careful if T is negative because HOST_WIDE_INT can be
9635      either "above" or "below" unsigned int as per the C promotion
9636      rules, depending on the host, thus making the signedness of the
9637      direct multiplication and division unpredictable.  */
9638   unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
9639
9640   u += align - 1;
9641   u /= align;
9642   u *= align;
9643
9644   return (HOST_WIDE_INT) u;
9645 }
9646
9647 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9648    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9649    or return 0 if we are unable to determine what that offset is, either
9650    because the argument turns out to be a pointer to an ERROR_MARK node, or
9651    because the offset is actually variable.  (We can't handle the latter case
9652    just yet).  */
9653
9654 static HOST_WIDE_INT
9655 field_byte_offset (tree decl)
9656 {
9657   unsigned int type_align_in_bits;
9658   unsigned int decl_align_in_bits;
9659   unsigned HOST_WIDE_INT type_size_in_bits;
9660   HOST_WIDE_INT object_offset_in_bits;
9661   tree type;
9662   tree field_size_tree;
9663   HOST_WIDE_INT bitpos_int;
9664   HOST_WIDE_INT deepest_bitpos;
9665   unsigned HOST_WIDE_INT field_size_in_bits;
9666
9667   if (TREE_CODE (decl) == ERROR_MARK)
9668     return 0;
9669
9670   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9671
9672   type = field_type (decl);
9673   field_size_tree = DECL_SIZE (decl);
9674
9675   /* The size could be unspecified if there was an error, or for
9676      a flexible array member.  */
9677   if (! field_size_tree)
9678     field_size_tree = bitsize_zero_node;
9679
9680   /* We cannot yet cope with fields whose positions are variable, so
9681      for now, when we see such things, we simply return 0.  Someday, we may
9682      be able to handle such cases, but it will be damn difficult.  */
9683   if (! host_integerp (bit_position (decl), 0))
9684     return 0;
9685
9686   bitpos_int = int_bit_position (decl);
9687
9688   /* If we don't know the size of the field, pretend it's a full word.  */
9689   if (host_integerp (field_size_tree, 1))
9690     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9691   else
9692     field_size_in_bits = BITS_PER_WORD;
9693
9694   type_size_in_bits = simple_type_size_in_bits (type);
9695   type_align_in_bits = simple_type_align_in_bits (type);
9696   decl_align_in_bits = simple_decl_align_in_bits (decl);
9697
9698   /* The GCC front-end doesn't make any attempt to keep track of the starting
9699      bit offset (relative to the start of the containing structure type) of the
9700      hypothetical "containing object" for a bit-field.  Thus, when computing
9701      the byte offset value for the start of the "containing object" of a
9702      bit-field, we must deduce this information on our own. This can be rather
9703      tricky to do in some cases.  For example, handling the following structure
9704      type definition when compiling for an i386/i486 target (which only aligns
9705      long long's to 32-bit boundaries) can be very tricky:
9706
9707          struct S { int field1; long long field2:31; };
9708
9709      Fortunately, there is a simple rule-of-thumb which can be used in such
9710      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9711      structure shown above.  It decides to do this based upon one simple rule
9712      for bit-field allocation.  GCC allocates each "containing object" for each
9713      bit-field at the first (i.e. lowest addressed) legitimate alignment
9714      boundary (based upon the required minimum alignment for the declared type
9715      of the field) which it can possibly use, subject to the condition that
9716      there is still enough available space remaining in the containing object
9717      (when allocated at the selected point) to fully accommodate all of the
9718      bits of the bit-field itself.
9719
9720      This simple rule makes it obvious why GCC allocates 8 bytes for each
9721      object of the structure type shown above.  When looking for a place to
9722      allocate the "containing object" for `field2', the compiler simply tries
9723      to allocate a 64-bit "containing object" at each successive 32-bit
9724      boundary (starting at zero) until it finds a place to allocate that 64-
9725      bit field such that at least 31 contiguous (and previously unallocated)
9726      bits remain within that selected 64 bit field.  (As it turns out, for the
9727      example above, the compiler finds it is OK to allocate the "containing
9728      object" 64-bit field at bit-offset zero within the structure type.)
9729
9730      Here we attempt to work backwards from the limited set of facts we're
9731      given, and we try to deduce from those facts, where GCC must have believed
9732      that the containing object started (within the structure type). The value
9733      we deduce is then used (by the callers of this routine) to generate
9734      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9735      and, in the case of DW_AT_location, regular fields as well).  */
9736
9737   /* Figure out the bit-distance from the start of the structure to the
9738      "deepest" bit of the bit-field.  */
9739   deepest_bitpos = bitpos_int + field_size_in_bits;
9740
9741   /* This is the tricky part.  Use some fancy footwork to deduce where the
9742      lowest addressed bit of the containing object must be.  */
9743   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9744
9745   /* Round up to type_align by default.  This works best for bitfields.  */
9746   object_offset_in_bits
9747     = round_up_to_align (object_offset_in_bits, type_align_in_bits);
9748
9749   if (object_offset_in_bits > bitpos_int)
9750     {
9751       /* Sigh, the decl must be packed.  */
9752       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9753
9754       /* Round up to decl_align instead.  */
9755       object_offset_in_bits
9756         = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
9757     }
9758
9759   return object_offset_in_bits / BITS_PER_UNIT;
9760 }
9761 \f
9762 /* The following routines define various Dwarf attributes and any data
9763    associated with them.  */
9764
9765 /* Add a location description attribute value to a DIE.
9766
9767    This emits location attributes suitable for whole variables and
9768    whole parameters.  Note that the location attributes for struct fields are
9769    generated by the routine `data_member_location_attribute' below.  */
9770
9771 static inline void
9772 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9773                              dw_loc_descr_ref descr)
9774 {
9775   if (descr != 0)
9776     add_AT_loc (die, attr_kind, descr);
9777 }
9778
9779 /* Attach the specialized form of location attribute used for data members of
9780    struct and union types.  In the special case of a FIELD_DECL node which
9781    represents a bit-field, the "offset" part of this special location
9782    descriptor must indicate the distance in bytes from the lowest-addressed
9783    byte of the containing struct or union type to the lowest-addressed byte of
9784    the "containing object" for the bit-field.  (See the `field_byte_offset'
9785    function above).
9786
9787    For any given bit-field, the "containing object" is a hypothetical object
9788    (of some integral or enum type) within which the given bit-field lives.  The
9789    type of this hypothetical "containing object" is always the same as the
9790    declared type of the individual bit-field itself (for GCC anyway... the
9791    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9792    bytes) of the hypothetical "containing object" which will be given in the
9793    DW_AT_byte_size attribute for this bit-field.  (See the
9794    `byte_size_attribute' function below.)  It is also used when calculating the
9795    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9796    function below.)  */
9797
9798 static void
9799 add_data_member_location_attribute (dw_die_ref die, tree decl)
9800 {
9801   HOST_WIDE_INT offset;
9802   dw_loc_descr_ref loc_descr = 0;
9803
9804   if (TREE_CODE (decl) == TREE_BINFO)
9805     {
9806       /* We're working on the TAG_inheritance for a base class.  */
9807       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9808         {
9809           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9810              aren't at a fixed offset from all (sub)objects of the same
9811              type.  We need to extract the appropriate offset from our
9812              vtable.  The following dwarf expression means
9813
9814                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9815
9816              This is specific to the V3 ABI, of course.  */
9817
9818           dw_loc_descr_ref tmp;
9819
9820           /* Make a copy of the object address.  */
9821           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9822           add_loc_descr (&loc_descr, tmp);
9823
9824           /* Extract the vtable address.  */
9825           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9826           add_loc_descr (&loc_descr, tmp);
9827
9828           /* Calculate the address of the offset.  */
9829           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9830           gcc_assert (offset < 0);
9831
9832           tmp = int_loc_descriptor (-offset);
9833           add_loc_descr (&loc_descr, tmp);
9834           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9835           add_loc_descr (&loc_descr, tmp);
9836
9837           /* Extract the offset.  */
9838           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9839           add_loc_descr (&loc_descr, tmp);
9840
9841           /* Add it to the object address.  */
9842           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9843           add_loc_descr (&loc_descr, tmp);
9844         }
9845       else
9846         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9847     }
9848   else
9849     offset = field_byte_offset (decl);
9850
9851   if (! loc_descr)
9852     {
9853       enum dwarf_location_atom op;
9854
9855       /* The DWARF2 standard says that we should assume that the structure
9856          address is already on the stack, so we can specify a structure field
9857          address by using DW_OP_plus_uconst.  */
9858
9859 #ifdef MIPS_DEBUGGING_INFO
9860       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9861          operator correctly.  It works only if we leave the offset on the
9862          stack.  */
9863       op = DW_OP_constu;
9864 #else
9865       op = DW_OP_plus_uconst;
9866 #endif
9867
9868       loc_descr = new_loc_descr (op, offset, 0);
9869     }
9870
9871   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9872 }
9873
9874 /* Writes integer values to dw_vec_const array.  */
9875
9876 static void
9877 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9878 {
9879   while (size != 0)
9880     {
9881       *dest++ = val & 0xff;
9882       val >>= 8;
9883       --size;
9884     }
9885 }
9886
9887 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9888
9889 static HOST_WIDE_INT
9890 extract_int (const unsigned char *src, unsigned int size)
9891 {
9892   HOST_WIDE_INT val = 0;
9893
9894   src += size;
9895   while (size != 0)
9896     {
9897       val <<= 8;
9898       val |= *--src & 0xff;
9899       --size;
9900     }
9901   return val;
9902 }
9903
9904 /* Writes floating point values to dw_vec_const array.  */
9905
9906 static void
9907 insert_float (rtx rtl, unsigned char *array)
9908 {
9909   REAL_VALUE_TYPE rv;
9910   long val[4];
9911   int i;
9912
9913   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9914   real_to_target (val, &rv, GET_MODE (rtl));
9915
9916   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9917   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9918     {
9919       insert_int (val[i], 4, array);
9920       array += 4;
9921     }
9922 }
9923
9924 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9925    does not have a "location" either in memory or in a register.  These
9926    things can arise in GNU C when a constant is passed as an actual parameter
9927    to an inlined function.  They can also arise in C++ where declared
9928    constants do not necessarily get memory "homes".  */
9929
9930 static void
9931 add_const_value_attribute (dw_die_ref die, rtx rtl)
9932 {
9933   switch (GET_CODE (rtl))
9934     {
9935     case CONST_INT:
9936       {
9937         HOST_WIDE_INT val = INTVAL (rtl);
9938
9939         if (val < 0)
9940           add_AT_int (die, DW_AT_const_value, val);
9941         else
9942           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9943       }
9944       break;
9945
9946     case CONST_DOUBLE:
9947       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9948          floating-point constant.  A CONST_DOUBLE is used whenever the
9949          constant requires more than one word in order to be adequately
9950          represented.  We output CONST_DOUBLEs as blocks.  */
9951       {
9952         enum machine_mode mode = GET_MODE (rtl);
9953
9954         if (SCALAR_FLOAT_MODE_P (mode))
9955           {
9956             unsigned int length = GET_MODE_SIZE (mode);
9957             unsigned char *array = ggc_alloc (length);
9958
9959             insert_float (rtl, array);
9960             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9961           }
9962         else
9963           {
9964             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9965             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9966
9967             add_AT_long_long (die, DW_AT_const_value,
9968                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9969           }
9970       }
9971       break;
9972
9973     case CONST_VECTOR:
9974       {
9975         enum machine_mode mode = GET_MODE (rtl);
9976         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9977         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9978         unsigned char *array = ggc_alloc (length * elt_size);
9979         unsigned int i;
9980         unsigned char *p;
9981
9982         switch (GET_MODE_CLASS (mode))
9983           {
9984           case MODE_VECTOR_INT:
9985             for (i = 0, p = array; i < length; i++, p += elt_size)
9986               {
9987                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9988                 HOST_WIDE_INT lo, hi;
9989
9990                 switch (GET_CODE (elt))
9991                   {
9992                   case CONST_INT:
9993                     lo = INTVAL (elt);
9994                     hi = -(lo < 0);
9995                     break;
9996
9997                   case CONST_DOUBLE:
9998                     lo = CONST_DOUBLE_LOW (elt);
9999                     hi = CONST_DOUBLE_HIGH (elt);
10000                     break;
10001
10002                   default:
10003                     gcc_unreachable ();
10004                   }
10005
10006                 if (elt_size <= sizeof (HOST_WIDE_INT))
10007                   insert_int (lo, elt_size, p);
10008                 else
10009                   {
10010                     unsigned char *p0 = p;
10011                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
10012
10013                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
10014                     if (WORDS_BIG_ENDIAN)
10015                       {
10016                         p0 = p1;
10017                         p1 = p;
10018                       }
10019                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
10020                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
10021                   }
10022               }
10023             break;
10024
10025           case MODE_VECTOR_FLOAT:
10026             for (i = 0, p = array; i < length; i++, p += elt_size)
10027               {
10028                 rtx elt = CONST_VECTOR_ELT (rtl, i);
10029                 insert_float (elt, p);
10030               }
10031             break;
10032
10033           default:
10034             gcc_unreachable ();
10035           }
10036
10037         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
10038       }
10039       break;
10040
10041     case CONST_STRING:
10042       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
10043       break;
10044
10045     case SYMBOL_REF:
10046     case LABEL_REF:
10047     case CONST:
10048       add_AT_addr (die, DW_AT_const_value, rtl);
10049       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10050       break;
10051
10052     case PLUS:
10053       /* In cases where an inlined instance of an inline function is passed
10054          the address of an `auto' variable (which is local to the caller) we
10055          can get a situation where the DECL_RTL of the artificial local
10056          variable (for the inlining) which acts as a stand-in for the
10057          corresponding formal parameter (of the inline function) will look
10058          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
10059          exactly a compile-time constant expression, but it isn't the address
10060          of the (artificial) local variable either.  Rather, it represents the
10061          *value* which the artificial local variable always has during its
10062          lifetime.  We currently have no way to represent such quasi-constant
10063          values in Dwarf, so for now we just punt and generate nothing.  */
10064       break;
10065
10066     default:
10067       /* No other kinds of rtx should be possible here.  */
10068       gcc_unreachable ();
10069     }
10070
10071 }
10072
10073 /* Determine whether the evaluation of EXPR references any variables
10074    or functions which aren't otherwise used (and therefore may not be
10075    output).  */
10076 static tree
10077 reference_to_unused (tree * tp, int * walk_subtrees,
10078                      void * data ATTRIBUTE_UNUSED)
10079 {
10080   if (! EXPR_P (*tp) && ! GIMPLE_STMT_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10081     *walk_subtrees = 0;
10082
10083   if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10084       && ! TREE_ASM_WRITTEN (*tp))
10085     return *tp;
10086   else if (DECL_P (*tp) && TREE_CODE (*tp) != FUNCTION_DECL)
10087     {
10088       struct varpool_node *node = varpool_node (*tp);
10089       if (!node->needed)
10090         return *tp;
10091     }
10092
10093   return NULL_TREE;
10094 }
10095
10096 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10097    for use in a later add_const_value_attribute call.  */
10098
10099 static rtx
10100 rtl_for_decl_init (tree init, tree type)
10101 {
10102   rtx rtl = NULL_RTX;
10103
10104   /* If a variable is initialized with a string constant without embedded
10105      zeros, build CONST_STRING.  */
10106   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10107     {
10108       tree enttype = TREE_TYPE (type);
10109       tree domain = TYPE_DOMAIN (type);
10110       enum machine_mode mode = TYPE_MODE (enttype);
10111
10112       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10113           && domain
10114           && integer_zerop (TYPE_MIN_VALUE (domain))
10115           && compare_tree_int (TYPE_MAX_VALUE (domain),
10116                                TREE_STRING_LENGTH (init) - 1) == 0
10117           && ((size_t) TREE_STRING_LENGTH (init)
10118               == strlen (TREE_STRING_POINTER (init)) + 1))
10119         rtl = gen_rtx_CONST_STRING (VOIDmode,
10120                                     ggc_strdup (TREE_STRING_POINTER (init)));
10121     }
10122   /* Other aggregates, and complex values, could be represented using
10123      CONCAT: FIXME!  */
10124   else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10125     ;
10126   /* Vectors only work if their mode is supported by the target.
10127      FIXME: generic vectors ought to work too.  */
10128   else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10129     ;
10130   /* If the initializer is something that we know will expand into an
10131      immediate RTL constant, expand it now.  We must be careful not to
10132      reference variables which won't be output.  */
10133   else if (initializer_constant_valid_p (init, type)
10134            && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10135     {
10136       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10137
10138       /* If expand_expr returns a MEM, it wasn't immediate.  */
10139       gcc_assert (!rtl || !MEM_P (rtl));
10140     }
10141
10142   return rtl;
10143 }
10144
10145 /* Generate RTL for the variable DECL to represent its location.  */
10146
10147 static rtx
10148 rtl_for_decl_location (tree decl)
10149 {
10150   rtx rtl;
10151
10152   /* Here we have to decide where we are going to say the parameter "lives"
10153      (as far as the debugger is concerned).  We only have a couple of
10154      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10155
10156      DECL_RTL normally indicates where the parameter lives during most of the
10157      activation of the function.  If optimization is enabled however, this
10158      could be either NULL or else a pseudo-reg.  Both of those cases indicate
10159      that the parameter doesn't really live anywhere (as far as the code
10160      generation parts of GCC are concerned) during most of the function's
10161      activation.  That will happen (for example) if the parameter is never
10162      referenced within the function.
10163
10164      We could just generate a location descriptor here for all non-NULL
10165      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10166      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10167      where DECL_RTL is NULL or is a pseudo-reg.
10168
10169      Note however that we can only get away with using DECL_INCOMING_RTL as
10170      a backup substitute for DECL_RTL in certain limited cases.  In cases
10171      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10172      we can be sure that the parameter was passed using the same type as it is
10173      declared to have within the function, and that its DECL_INCOMING_RTL
10174      points us to a place where a value of that type is passed.
10175
10176      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10177      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10178      because in these cases DECL_INCOMING_RTL points us to a value of some
10179      type which is *different* from the type of the parameter itself.  Thus,
10180      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10181      such cases, the debugger would end up (for example) trying to fetch a
10182      `float' from a place which actually contains the first part of a
10183      `double'.  That would lead to really incorrect and confusing
10184      output at debug-time.
10185
10186      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10187      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
10188      are a couple of exceptions however.  On little-endian machines we can
10189      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10190      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10191      an integral type that is smaller than TREE_TYPE (decl). These cases arise
10192      when (on a little-endian machine) a non-prototyped function has a
10193      parameter declared to be of type `short' or `char'.  In such cases,
10194      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10195      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10196      passed `int' value.  If the debugger then uses that address to fetch
10197      a `short' or a `char' (on a little-endian machine) the result will be
10198      the correct data, so we allow for such exceptional cases below.
10199
10200      Note that our goal here is to describe the place where the given formal
10201      parameter lives during most of the function's activation (i.e. between the
10202      end of the prologue and the start of the epilogue).  We'll do that as best
10203      as we can. Note however that if the given formal parameter is modified
10204      sometime during the execution of the function, then a stack backtrace (at
10205      debug-time) will show the function as having been called with the *new*
10206      value rather than the value which was originally passed in.  This happens
10207      rarely enough that it is not a major problem, but it *is* a problem, and
10208      I'd like to fix it.
10209
10210      A future version of dwarf2out.c may generate two additional attributes for
10211      any given DW_TAG_formal_parameter DIE which will describe the "passed
10212      type" and the "passed location" for the given formal parameter in addition
10213      to the attributes we now generate to indicate the "declared type" and the
10214      "active location" for each parameter.  This additional set of attributes
10215      could be used by debuggers for stack backtraces. Separately, note that
10216      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10217      This happens (for example) for inlined-instances of inline function formal
10218      parameters which are never referenced.  This really shouldn't be
10219      happening.  All PARM_DECL nodes should get valid non-NULL
10220      DECL_INCOMING_RTL values.  FIXME.  */
10221
10222   /* Use DECL_RTL as the "location" unless we find something better.  */
10223   rtl = DECL_RTL_IF_SET (decl);
10224
10225   /* When generating abstract instances, ignore everything except
10226      constants, symbols living in memory, and symbols living in
10227      fixed registers.  */
10228   if (! reload_completed)
10229     {
10230       if (rtl
10231           && (CONSTANT_P (rtl)
10232               || (MEM_P (rtl)
10233                   && CONSTANT_P (XEXP (rtl, 0)))
10234               || (REG_P (rtl)
10235                   && TREE_CODE (decl) == VAR_DECL
10236                   && TREE_STATIC (decl))))
10237         {
10238           rtl = targetm.delegitimize_address (rtl);
10239           return rtl;
10240         }
10241       rtl = NULL_RTX;
10242     }
10243   else if (TREE_CODE (decl) == PARM_DECL)
10244     {
10245       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10246         {
10247           tree declared_type = TREE_TYPE (decl);
10248           tree passed_type = DECL_ARG_TYPE (decl);
10249           enum machine_mode dmode = TYPE_MODE (declared_type);
10250           enum machine_mode pmode = TYPE_MODE (passed_type);
10251
10252           /* This decl represents a formal parameter which was optimized out.
10253              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10254              all cases where (rtl == NULL_RTX) just below.  */
10255           if (dmode == pmode)
10256             rtl = DECL_INCOMING_RTL (decl);
10257           else if (SCALAR_INT_MODE_P (dmode)
10258                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10259                    && DECL_INCOMING_RTL (decl))
10260             {
10261               rtx inc = DECL_INCOMING_RTL (decl);
10262               if (REG_P (inc))
10263                 rtl = inc;
10264               else if (MEM_P (inc))
10265                 {
10266                   if (BYTES_BIG_ENDIAN)
10267                     rtl = adjust_address_nv (inc, dmode,
10268                                              GET_MODE_SIZE (pmode)
10269                                              - GET_MODE_SIZE (dmode));
10270                   else
10271                     rtl = inc;
10272                 }
10273             }
10274         }
10275
10276       /* If the parm was passed in registers, but lives on the stack, then
10277          make a big endian correction if the mode of the type of the
10278          parameter is not the same as the mode of the rtl.  */
10279       /* ??? This is the same series of checks that are made in dbxout.c before
10280          we reach the big endian correction code there.  It isn't clear if all
10281          of these checks are necessary here, but keeping them all is the safe
10282          thing to do.  */
10283       else if (MEM_P (rtl)
10284                && XEXP (rtl, 0) != const0_rtx
10285                && ! CONSTANT_P (XEXP (rtl, 0))
10286                /* Not passed in memory.  */
10287                && !MEM_P (DECL_INCOMING_RTL (decl))
10288                /* Not passed by invisible reference.  */
10289                && (!REG_P (XEXP (rtl, 0))
10290                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10291                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10292 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10293                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10294 #endif
10295                      )
10296                /* Big endian correction check.  */
10297                && BYTES_BIG_ENDIAN
10298                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10299                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10300                    < UNITS_PER_WORD))
10301         {
10302           int offset = (UNITS_PER_WORD
10303                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10304
10305           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10306                              plus_constant (XEXP (rtl, 0), offset));
10307         }
10308     }
10309   else if (TREE_CODE (decl) == VAR_DECL
10310            && rtl
10311            && MEM_P (rtl)
10312            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10313            && BYTES_BIG_ENDIAN)
10314     {
10315       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10316       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10317
10318       /* If a variable is declared "register" yet is smaller than
10319          a register, then if we store the variable to memory, it
10320          looks like we're storing a register-sized value, when in
10321          fact we are not.  We need to adjust the offset of the
10322          storage location to reflect the actual value's bytes,
10323          else gdb will not be able to display it.  */
10324       if (rsize > dsize)
10325         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10326                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10327     }
10328
10329   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10330      and will have been substituted directly into all expressions that use it.
10331      C does not have such a concept, but C++ and other languages do.  */
10332   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10333     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10334
10335   if (rtl)
10336     rtl = targetm.delegitimize_address (rtl);
10337
10338   /* If we don't look past the constant pool, we risk emitting a
10339      reference to a constant pool entry that isn't referenced from
10340      code, and thus is not emitted.  */
10341   if (rtl)
10342     rtl = avoid_constant_pool_reference (rtl);
10343
10344   return rtl;
10345 }
10346
10347 /* We need to figure out what section we should use as the base for the
10348    address ranges where a given location is valid.
10349    1. If this particular DECL has a section associated with it, use that.
10350    2. If this function has a section associated with it, use that.
10351    3. Otherwise, use the text section.
10352    XXX: If you split a variable across multiple sections, we won't notice.  */
10353
10354 static const char *
10355 secname_for_decl (tree decl)
10356 {
10357   const char *secname;
10358
10359   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10360     {
10361       tree sectree = DECL_SECTION_NAME (decl);
10362       secname = TREE_STRING_POINTER (sectree);
10363     }
10364   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10365     {
10366       tree sectree = DECL_SECTION_NAME (current_function_decl);
10367       secname = TREE_STRING_POINTER (sectree);
10368     }
10369   else if (cfun && in_cold_section_p)
10370     secname = cfun->cold_section_label;
10371   else
10372     secname = text_section_label;
10373
10374   return secname;
10375 }
10376
10377 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10378    data attribute for a variable or a parameter.  We generate the
10379    DW_AT_const_value attribute only in those cases where the given variable
10380    or parameter does not have a true "location" either in memory or in a
10381    register.  This can happen (for example) when a constant is passed as an
10382    actual argument in a call to an inline function.  (It's possible that
10383    these things can crop up in other ways also.)  Note that one type of
10384    constant value which can be passed into an inlined function is a constant
10385    pointer.  This can happen for example if an actual argument in an inlined
10386    function call evaluates to a compile-time constant address.  */
10387
10388 static void
10389 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10390                                        enum dwarf_attribute attr)
10391 {
10392   rtx rtl;
10393   dw_loc_descr_ref descr;
10394   var_loc_list *loc_list;
10395   struct var_loc_node *node;
10396   if (TREE_CODE (decl) == ERROR_MARK)
10397     return;
10398
10399   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10400               || TREE_CODE (decl) == RESULT_DECL);
10401
10402   /* See if we possibly have multiple locations for this variable.  */
10403   loc_list = lookup_decl_loc (decl);
10404
10405   /* If it truly has multiple locations, the first and last node will
10406      differ.  */
10407   if (loc_list && loc_list->first != loc_list->last)
10408     {
10409       const char *endname, *secname;
10410       dw_loc_list_ref list;
10411       rtx varloc;
10412
10413       /* Now that we know what section we are using for a base,
10414          actually construct the list of locations.
10415          The first location information is what is passed to the
10416          function that creates the location list, and the remaining
10417          locations just get added on to that list.
10418          Note that we only know the start address for a location
10419          (IE location changes), so to build the range, we use
10420          the range [current location start, next location start].
10421          This means we have to special case the last node, and generate
10422          a range of [last location start, end of function label].  */
10423
10424       node = loc_list->first;
10425       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10426       secname = secname_for_decl (decl);
10427
10428       list = new_loc_list (loc_descriptor (varloc),
10429                            node->label, node->next->label, secname, 1);
10430       node = node->next;
10431
10432       for (; node->next; node = node->next)
10433         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10434           {
10435             /* The variable has a location between NODE->LABEL and
10436                NODE->NEXT->LABEL.  */
10437             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10438             add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10439                                        node->label, node->next->label, secname);
10440           }
10441
10442       /* If the variable has a location at the last label
10443          it keeps its location until the end of function.  */
10444       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10445         {
10446           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10447
10448           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10449           if (!current_function_decl)
10450             endname = text_end_label;
10451           else
10452             {
10453               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10454                                            current_function_funcdef_no);
10455               endname = ggc_strdup (label_id);
10456             }
10457           add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10458                                      node->label, endname, secname);
10459         }
10460
10461       /* Finally, add the location list to the DIE, and we are done.  */
10462       add_AT_loc_list (die, attr, list);
10463       return;
10464     }
10465
10466   /* Try to get some constant RTL for this decl, and use that as the value of
10467      the location.  */
10468
10469   rtl = rtl_for_decl_location (decl);
10470   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10471     {
10472       add_const_value_attribute (die, rtl);
10473       return;
10474     }
10475
10476   /* If we have tried to generate the location otherwise, and it
10477      didn't work out (we wouldn't be here if we did), and we have a one entry
10478      location list, try generating a location from that.  */
10479   if (loc_list && loc_list->first)
10480     {
10481       node = loc_list->first;
10482       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10483       if (descr)
10484         {
10485           add_AT_location_description (die, attr, descr);
10486           return;
10487         }
10488     }
10489
10490   /* We couldn't get any rtl, so try directly generating the location
10491      description from the tree.  */
10492   descr = loc_descriptor_from_tree (decl);
10493   if (descr)
10494     {
10495       add_AT_location_description (die, attr, descr);
10496       return;
10497     }
10498   /* None of that worked, so it must not really have a location;
10499      try adding a constant value attribute from the DECL_INITIAL.  */
10500   tree_add_const_value_attribute (die, decl);
10501 }
10502
10503 /* If we don't have a copy of this variable in memory for some reason (such
10504    as a C++ member constant that doesn't have an out-of-line definition),
10505    we should tell the debugger about the constant value.  */
10506
10507 static void
10508 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10509 {
10510   tree init = DECL_INITIAL (decl);
10511   tree type = TREE_TYPE (decl);
10512   rtx rtl;
10513
10514   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10515     /* OK */;
10516   else
10517     return;
10518
10519   rtl = rtl_for_decl_init (init, type);
10520   if (rtl)
10521     add_const_value_attribute (var_die, rtl);
10522 }
10523
10524 /* Convert the CFI instructions for the current function into a
10525    location list.  This is used for DW_AT_frame_base when we targeting
10526    a dwarf2 consumer that does not support the dwarf3
10527    DW_OP_call_frame_cfa.  OFFSET is a constant to be added to all CFA
10528    expressions.  */
10529
10530 static dw_loc_list_ref
10531 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10532 {
10533   dw_fde_ref fde;
10534   dw_loc_list_ref list, *list_tail;
10535   dw_cfi_ref cfi;
10536   dw_cfa_location last_cfa, next_cfa;
10537   const char *start_label, *last_label, *section;
10538
10539   fde = &fde_table[fde_table_in_use - 1];
10540
10541   section = secname_for_decl (current_function_decl);
10542   list_tail = &list;
10543   list = NULL;
10544
10545   next_cfa.reg = INVALID_REGNUM;
10546   next_cfa.offset = 0;
10547   next_cfa.indirect = 0;
10548   next_cfa.base_offset = 0;
10549
10550   start_label = fde->dw_fde_begin;
10551
10552   /* ??? Bald assumption that the CIE opcode list does not contain
10553      advance opcodes.  */
10554   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10555     lookup_cfa_1 (cfi, &next_cfa);
10556
10557   last_cfa = next_cfa;
10558   last_label = start_label;
10559
10560   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10561     switch (cfi->dw_cfi_opc)
10562       {
10563       case DW_CFA_set_loc:
10564       case DW_CFA_advance_loc1:
10565       case DW_CFA_advance_loc2:
10566       case DW_CFA_advance_loc4:
10567         if (!cfa_equal_p (&last_cfa, &next_cfa))
10568           {
10569             *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10570                                        start_label, last_label, section,
10571                                        list == NULL);
10572
10573             list_tail = &(*list_tail)->dw_loc_next;
10574             last_cfa = next_cfa;
10575             start_label = last_label;
10576           }
10577         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10578         break;
10579
10580       case DW_CFA_advance_loc:
10581         /* The encoding is complex enough that we should never emit this.  */
10582       case DW_CFA_remember_state:
10583       case DW_CFA_restore_state:
10584         /* We don't handle these two in this function.  It would be possible
10585            if it were to be required.  */
10586         gcc_unreachable ();
10587
10588       default:
10589         lookup_cfa_1 (cfi, &next_cfa);
10590         break;
10591       }
10592
10593   if (!cfa_equal_p (&last_cfa, &next_cfa))
10594     {
10595       *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10596                                  start_label, last_label, section,
10597                                  list == NULL);
10598       list_tail = &(*list_tail)->dw_loc_next;
10599       start_label = last_label;
10600     }
10601   *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10602                              start_label, fde->dw_fde_end, section,
10603                              list == NULL);
10604
10605   return list;
10606 }
10607
10608 /* Compute a displacement from the "steady-state frame pointer" to the
10609    frame base (often the same as the CFA), and store it in
10610    frame_pointer_fb_offset.  OFFSET is added to the displacement
10611    before the latter is negated.  */
10612
10613 static void
10614 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10615 {
10616   rtx reg, elim;
10617
10618 #ifdef FRAME_POINTER_CFA_OFFSET
10619   reg = frame_pointer_rtx;
10620   offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10621 #else
10622   reg = arg_pointer_rtx;
10623   offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10624 #endif
10625
10626   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10627   if (GET_CODE (elim) == PLUS)
10628     {
10629       offset += INTVAL (XEXP (elim, 1));
10630       elim = XEXP (elim, 0);
10631     }
10632   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10633                        : stack_pointer_rtx));
10634
10635   frame_pointer_fb_offset = -offset;
10636 }
10637
10638 /* Generate a DW_AT_name attribute given some string value to be included as
10639    the value of the attribute.  */
10640
10641 static void
10642 add_name_attribute (dw_die_ref die, const char *name_string)
10643 {
10644   if (name_string != NULL && *name_string != 0)
10645     {
10646       if (demangle_name_func)
10647         name_string = (*demangle_name_func) (name_string);
10648
10649       add_AT_string (die, DW_AT_name, name_string);
10650     }
10651 }
10652
10653 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10654
10655 static void
10656 add_comp_dir_attribute (dw_die_ref die)
10657 {
10658   const char *wd = get_src_pwd ();
10659   if (wd != NULL)
10660     add_AT_string (die, DW_AT_comp_dir, wd);
10661 }
10662
10663 /* Given a tree node describing an array bound (either lower or upper) output
10664    a representation for that bound.  */
10665
10666 static void
10667 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10668 {
10669   switch (TREE_CODE (bound))
10670     {
10671     case ERROR_MARK:
10672       return;
10673
10674     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10675     case INTEGER_CST:
10676       if (! host_integerp (bound, 0)
10677           || (bound_attr == DW_AT_lower_bound
10678               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10679                   || (is_fortran () && integer_onep (bound)))))
10680         /* Use the default.  */
10681         ;
10682       else
10683         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10684       break;
10685
10686     case CONVERT_EXPR:
10687     case NOP_EXPR:
10688     case NON_LVALUE_EXPR:
10689     case VIEW_CONVERT_EXPR:
10690       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10691       break;
10692
10693     case SAVE_EXPR:
10694       break;
10695
10696     case VAR_DECL:
10697     case PARM_DECL:
10698     case RESULT_DECL:
10699       {
10700         dw_die_ref decl_die = lookup_decl_die (bound);
10701
10702         /* ??? Can this happen, or should the variable have been bound
10703            first?  Probably it can, since I imagine that we try to create
10704            the types of parameters in the order in which they exist in
10705            the list, and won't have created a forward reference to a
10706            later parameter.  */
10707         if (decl_die != NULL)
10708           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10709         break;
10710       }
10711
10712     default:
10713       {
10714         /* Otherwise try to create a stack operation procedure to
10715            evaluate the value of the array bound.  */
10716
10717         dw_die_ref ctx, decl_die;
10718         dw_loc_descr_ref loc;
10719
10720         loc = loc_descriptor_from_tree (bound);
10721         if (loc == NULL)
10722           break;
10723
10724         if (current_function_decl == 0)
10725           ctx = comp_unit_die;
10726         else
10727           ctx = lookup_decl_die (current_function_decl);
10728
10729         decl_die = new_die (DW_TAG_variable, ctx, bound);
10730         add_AT_flag (decl_die, DW_AT_artificial, 1);
10731         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10732         add_AT_loc (decl_die, DW_AT_location, loc);
10733
10734         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10735         break;
10736       }
10737     }
10738 }
10739
10740 /* Note that the block of subscript information for an array type also
10741    includes information about the element type of type given array type.  */
10742
10743 static void
10744 add_subscript_info (dw_die_ref type_die, tree type)
10745 {
10746 #ifndef MIPS_DEBUGGING_INFO
10747   unsigned dimension_number;
10748 #endif
10749   tree lower, upper;
10750   dw_die_ref subrange_die;
10751
10752   /* The GNU compilers represent multidimensional array types as sequences of
10753      one dimensional array types whose element types are themselves array
10754      types.  Here we squish that down, so that each multidimensional array
10755      type gets only one array_type DIE in the Dwarf debugging info. The draft
10756      Dwarf specification say that we are allowed to do this kind of
10757      compression in C (because there is no difference between an array or
10758      arrays and a multidimensional array in C) but for other source languages
10759      (e.g. Ada) we probably shouldn't do this.  */
10760
10761   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10762      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10763      We work around this by disabling this feature.  See also
10764      gen_array_type_die.  */
10765 #ifndef MIPS_DEBUGGING_INFO
10766   for (dimension_number = 0;
10767        TREE_CODE (type) == ARRAY_TYPE;
10768        type = TREE_TYPE (type), dimension_number++)
10769 #endif
10770     {
10771       tree domain = TYPE_DOMAIN (type);
10772
10773       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10774          and (in GNU C only) variable bounds.  Handle all three forms
10775          here.  */
10776       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10777       if (domain)
10778         {
10779           /* We have an array type with specified bounds.  */
10780           lower = TYPE_MIN_VALUE (domain);
10781           upper = TYPE_MAX_VALUE (domain);
10782
10783           /* Define the index type.  */
10784           if (TREE_TYPE (domain))
10785             {
10786               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10787                  TREE_TYPE field.  We can't emit debug info for this
10788                  because it is an unnamed integral type.  */
10789               if (TREE_CODE (domain) == INTEGER_TYPE
10790                   && TYPE_NAME (domain) == NULL_TREE
10791                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10792                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10793                 ;
10794               else
10795                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10796                                     type_die);
10797             }
10798
10799           /* ??? If upper is NULL, the array has unspecified length,
10800              but it does have a lower bound.  This happens with Fortran
10801                dimension arr(N:*)
10802              Since the debugger is definitely going to need to know N
10803              to produce useful results, go ahead and output the lower
10804              bound solo, and hope the debugger can cope.  */
10805
10806           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10807           if (upper)
10808             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10809         }
10810
10811       /* Otherwise we have an array type with an unspecified length.  The
10812          DWARF-2 spec does not say how to handle this; let's just leave out the
10813          bounds.  */
10814     }
10815 }
10816
10817 static void
10818 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10819 {
10820   unsigned size;
10821
10822   switch (TREE_CODE (tree_node))
10823     {
10824     case ERROR_MARK:
10825       size = 0;
10826       break;
10827     case ENUMERAL_TYPE:
10828     case RECORD_TYPE:
10829     case UNION_TYPE:
10830     case QUAL_UNION_TYPE:
10831       size = int_size_in_bytes (tree_node);
10832       break;
10833     case FIELD_DECL:
10834       /* For a data member of a struct or union, the DW_AT_byte_size is
10835          generally given as the number of bytes normally allocated for an
10836          object of the *declared* type of the member itself.  This is true
10837          even for bit-fields.  */
10838       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10839       break;
10840     default:
10841       gcc_unreachable ();
10842     }
10843
10844   /* Note that `size' might be -1 when we get to this point.  If it is, that
10845      indicates that the byte size of the entity in question is variable.  We
10846      have no good way of expressing this fact in Dwarf at the present time,
10847      so just let the -1 pass on through.  */
10848   add_AT_unsigned (die, DW_AT_byte_size, size);
10849 }
10850
10851 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10852    which specifies the distance in bits from the highest order bit of the
10853    "containing object" for the bit-field to the highest order bit of the
10854    bit-field itself.
10855
10856    For any given bit-field, the "containing object" is a hypothetical object
10857    (of some integral or enum type) within which the given bit-field lives.  The
10858    type of this hypothetical "containing object" is always the same as the
10859    declared type of the individual bit-field itself.  The determination of the
10860    exact location of the "containing object" for a bit-field is rather
10861    complicated.  It's handled by the `field_byte_offset' function (above).
10862
10863    Note that it is the size (in bytes) of the hypothetical "containing object"
10864    which will be given in the DW_AT_byte_size attribute for this bit-field.
10865    (See `byte_size_attribute' above).  */
10866
10867 static inline void
10868 add_bit_offset_attribute (dw_die_ref die, tree decl)
10869 {
10870   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10871   tree type = DECL_BIT_FIELD_TYPE (decl);
10872   HOST_WIDE_INT bitpos_int;
10873   HOST_WIDE_INT highest_order_object_bit_offset;
10874   HOST_WIDE_INT highest_order_field_bit_offset;
10875   HOST_WIDE_INT unsigned bit_offset;
10876
10877   /* Must be a field and a bit field.  */
10878   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10879
10880   /* We can't yet handle bit-fields whose offsets are variable, so if we
10881      encounter such things, just return without generating any attribute
10882      whatsoever.  Likewise for variable or too large size.  */
10883   if (! host_integerp (bit_position (decl), 0)
10884       || ! host_integerp (DECL_SIZE (decl), 1))
10885     return;
10886
10887   bitpos_int = int_bit_position (decl);
10888
10889   /* Note that the bit offset is always the distance (in bits) from the
10890      highest-order bit of the "containing object" to the highest-order bit of
10891      the bit-field itself.  Since the "high-order end" of any object or field
10892      is different on big-endian and little-endian machines, the computation
10893      below must take account of these differences.  */
10894   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10895   highest_order_field_bit_offset = bitpos_int;
10896
10897   if (! BYTES_BIG_ENDIAN)
10898     {
10899       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10900       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10901     }
10902
10903   bit_offset
10904     = (! BYTES_BIG_ENDIAN
10905        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10906        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10907
10908   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10909 }
10910
10911 /* For a FIELD_DECL node which represents a bit field, output an attribute
10912    which specifies the length in bits of the given field.  */
10913
10914 static inline void
10915 add_bit_size_attribute (dw_die_ref die, tree decl)
10916 {
10917   /* Must be a field and a bit field.  */
10918   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10919               && DECL_BIT_FIELD_TYPE (decl));
10920
10921   if (host_integerp (DECL_SIZE (decl), 1))
10922     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10923 }
10924
10925 /* If the compiled language is ANSI C, then add a 'prototyped'
10926    attribute, if arg types are given for the parameters of a function.  */
10927
10928 static inline void
10929 add_prototyped_attribute (dw_die_ref die, tree func_type)
10930 {
10931   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10932       && TYPE_ARG_TYPES (func_type) != NULL)
10933     add_AT_flag (die, DW_AT_prototyped, 1);
10934 }
10935
10936 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10937    by looking in either the type declaration or object declaration
10938    equate table.  */
10939
10940 static inline void
10941 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10942 {
10943   dw_die_ref origin_die = NULL;
10944
10945   if (TREE_CODE (origin) != FUNCTION_DECL)
10946     {
10947       /* We may have gotten separated from the block for the inlined
10948          function, if we're in an exception handler or some such; make
10949          sure that the abstract function has been written out.
10950
10951          Doing this for nested functions is wrong, however; functions are
10952          distinct units, and our context might not even be inline.  */
10953       tree fn = origin;
10954
10955       if (TYPE_P (fn))
10956         fn = TYPE_STUB_DECL (fn);
10957
10958       fn = decl_function_context (fn);
10959       if (fn)
10960         dwarf2out_abstract_function (fn);
10961     }
10962
10963   if (DECL_P (origin))
10964     origin_die = lookup_decl_die (origin);
10965   else if (TYPE_P (origin))
10966     origin_die = lookup_type_die (origin);
10967
10968   /* XXX: Functions that are never lowered don't always have correct block
10969      trees (in the case of java, they simply have no block tree, in some other
10970      languages).  For these functions, there is nothing we can really do to
10971      output correct debug info for inlined functions in all cases.  Rather
10972      than die, we'll just produce deficient debug info now, in that we will
10973      have variables without a proper abstract origin.  In the future, when all
10974      functions are lowered, we should re-add a gcc_assert (origin_die)
10975      here.  */
10976
10977   if (origin_die)
10978       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10979 }
10980
10981 /* We do not currently support the pure_virtual attribute.  */
10982
10983 static inline void
10984 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10985 {
10986   if (DECL_VINDEX (func_decl))
10987     {
10988       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10989
10990       if (host_integerp (DECL_VINDEX (func_decl), 0))
10991         add_AT_loc (die, DW_AT_vtable_elem_location,
10992                     new_loc_descr (DW_OP_constu,
10993                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10994                                    0));
10995
10996       /* GNU extension: Record what type this method came from originally.  */
10997       if (debug_info_level > DINFO_LEVEL_TERSE)
10998         add_AT_die_ref (die, DW_AT_containing_type,
10999                         lookup_type_die (DECL_CONTEXT (func_decl)));
11000     }
11001 }
11002 \f
11003 /* Add source coordinate attributes for the given decl.  */
11004
11005 static void
11006 add_src_coords_attributes (dw_die_ref die, tree decl)
11007 {
11008   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11009
11010   add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
11011   add_AT_unsigned (die, DW_AT_decl_line, s.line);
11012 }
11013
11014 /* Add a DW_AT_name attribute and source coordinate attribute for the
11015    given decl, but only if it actually has a name.  */
11016
11017 static void
11018 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
11019 {
11020   tree decl_name;
11021
11022   decl_name = DECL_NAME (decl);
11023   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
11024     {
11025       add_name_attribute (die, dwarf2_name (decl, 0));
11026       if (! DECL_ARTIFICIAL (decl))
11027         add_src_coords_attributes (die, decl);
11028
11029       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
11030           && TREE_PUBLIC (decl)
11031           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
11032           && !DECL_ABSTRACT (decl)
11033           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
11034         add_AT_string (die, DW_AT_MIPS_linkage_name,
11035                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
11036     }
11037
11038 #ifdef VMS_DEBUGGING_INFO
11039   /* Get the function's name, as described by its RTL.  This may be different
11040      from the DECL_NAME name used in the source file.  */
11041   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
11042     {
11043       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
11044                    XEXP (DECL_RTL (decl), 0));
11045       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
11046     }
11047 #endif
11048 }
11049
11050 /* Push a new declaration scope.  */
11051
11052 static void
11053 push_decl_scope (tree scope)
11054 {
11055   VEC_safe_push (tree, gc, decl_scope_table, scope);
11056 }
11057
11058 /* Pop a declaration scope.  */
11059
11060 static inline void
11061 pop_decl_scope (void)
11062 {
11063   VEC_pop (tree, decl_scope_table);
11064 }
11065
11066 /* Return the DIE for the scope that immediately contains this type.
11067    Non-named types get global scope.  Named types nested in other
11068    types get their containing scope if it's open, or global scope
11069    otherwise.  All other types (i.e. function-local named types) get
11070    the current active scope.  */
11071
11072 static dw_die_ref
11073 scope_die_for (tree t, dw_die_ref context_die)
11074 {
11075   dw_die_ref scope_die = NULL;
11076   tree containing_scope;
11077   int i;
11078
11079   /* Non-types always go in the current scope.  */
11080   gcc_assert (TYPE_P (t));
11081
11082   containing_scope = TYPE_CONTEXT (t);
11083
11084   /* Use the containing namespace if it was passed in (for a declaration).  */
11085   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11086     {
11087       if (context_die == lookup_decl_die (containing_scope))
11088         /* OK */;
11089       else
11090         containing_scope = NULL_TREE;
11091     }
11092
11093   /* Ignore function type "scopes" from the C frontend.  They mean that
11094      a tagged type is local to a parmlist of a function declarator, but
11095      that isn't useful to DWARF.  */
11096   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11097     containing_scope = NULL_TREE;
11098
11099   if (containing_scope == NULL_TREE)
11100     scope_die = comp_unit_die;
11101   else if (TYPE_P (containing_scope))
11102     {
11103       /* For types, we can just look up the appropriate DIE.  But
11104          first we check to see if we're in the middle of emitting it
11105          so we know where the new DIE should go.  */
11106       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11107         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11108           break;
11109
11110       if (i < 0)
11111         {
11112           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11113                       || TREE_ASM_WRITTEN (containing_scope));
11114
11115           /* If none of the current dies are suitable, we get file scope.  */
11116           scope_die = comp_unit_die;
11117         }
11118       else
11119         scope_die = lookup_type_die (containing_scope);
11120     }
11121   else
11122     scope_die = context_die;
11123
11124   return scope_die;
11125 }
11126
11127 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
11128
11129 static inline int
11130 local_scope_p (dw_die_ref context_die)
11131 {
11132   for (; context_die; context_die = context_die->die_parent)
11133     if (context_die->die_tag == DW_TAG_inlined_subroutine
11134         || context_die->die_tag == DW_TAG_subprogram)
11135       return 1;
11136
11137   return 0;
11138 }
11139
11140 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11141    whether or not to treat a DIE in this context as a declaration.  */
11142
11143 static inline int
11144 class_or_namespace_scope_p (dw_die_ref context_die)
11145 {
11146   return (context_die
11147           && (context_die->die_tag == DW_TAG_structure_type
11148               || context_die->die_tag == DW_TAG_union_type
11149               || context_die->die_tag == DW_TAG_namespace));
11150 }
11151
11152 /* Many forms of DIEs require a "type description" attribute.  This
11153    routine locates the proper "type descriptor" die for the type given
11154    by 'type', and adds a DW_AT_type attribute below the given die.  */
11155
11156 static void
11157 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11158                     int decl_volatile, dw_die_ref context_die)
11159 {
11160   enum tree_code code  = TREE_CODE (type);
11161   dw_die_ref type_die  = NULL;
11162
11163   /* ??? If this type is an unnamed subrange type of an integral or
11164      floating-point type, use the inner type.  This is because we have no
11165      support for unnamed types in base_type_die.  This can happen if this is
11166      an Ada subrange type.  Correct solution is emit a subrange type die.  */
11167   if ((code == INTEGER_TYPE || code == REAL_TYPE)
11168       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11169     type = TREE_TYPE (type), code = TREE_CODE (type);
11170
11171   if (code == ERROR_MARK
11172       /* Handle a special case.  For functions whose return type is void, we
11173          generate *no* type attribute.  (Note that no object may have type
11174          `void', so this only applies to function return types).  */
11175       || code == VOID_TYPE)
11176     return;
11177
11178   type_die = modified_type_die (type,
11179                                 decl_const || TYPE_READONLY (type),
11180                                 decl_volatile || TYPE_VOLATILE (type),
11181                                 context_die);
11182
11183   if (type_die != NULL)
11184     add_AT_die_ref (object_die, DW_AT_type, type_die);
11185 }
11186
11187 /* Given an object die, add the calling convention attribute for the
11188    function call type.  */
11189 static void
11190 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11191 {
11192   enum dwarf_calling_convention value = DW_CC_normal;
11193
11194   value = targetm.dwarf_calling_convention (type);
11195
11196   /* Only add the attribute if the backend requests it, and
11197      is not DW_CC_normal.  */
11198   if (value && (value != DW_CC_normal))
11199     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11200 }
11201
11202 /* Given a tree pointer to a struct, class, union, or enum type node, return
11203    a pointer to the (string) tag name for the given type, or zero if the type
11204    was declared without a tag.  */
11205
11206 static const char *
11207 type_tag (tree type)
11208 {
11209   const char *name = 0;
11210
11211   if (TYPE_NAME (type) != 0)
11212     {
11213       tree t = 0;
11214
11215       /* Find the IDENTIFIER_NODE for the type name.  */
11216       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11217         t = TYPE_NAME (type);
11218
11219       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11220          a TYPE_DECL node, regardless of whether or not a `typedef' was
11221          involved.  */
11222       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11223                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11224         t = DECL_NAME (TYPE_NAME (type));
11225
11226       /* Now get the name as a string, or invent one.  */
11227       if (t != 0)
11228         name = IDENTIFIER_POINTER (t);
11229     }
11230
11231   return (name == 0 || *name == '\0') ? 0 : name;
11232 }
11233
11234 /* Return the type associated with a data member, make a special check
11235    for bit field types.  */
11236
11237 static inline tree
11238 member_declared_type (tree member)
11239 {
11240   return (DECL_BIT_FIELD_TYPE (member)
11241           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11242 }
11243
11244 /* Get the decl's label, as described by its RTL. This may be different
11245    from the DECL_NAME name used in the source file.  */
11246
11247 #if 0
11248 static const char *
11249 decl_start_label (tree decl)
11250 {
11251   rtx x;
11252   const char *fnname;
11253
11254   x = DECL_RTL (decl);
11255   gcc_assert (MEM_P (x));
11256
11257   x = XEXP (x, 0);
11258   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11259
11260   fnname = XSTR (x, 0);
11261   return fnname;
11262 }
11263 #endif
11264 \f
11265 /* These routines generate the internal representation of the DIE's for
11266    the compilation unit.  Debugging information is collected by walking
11267    the declaration trees passed in from dwarf2out_decl().  */
11268
11269 static void
11270 gen_array_type_die (tree type, dw_die_ref context_die)
11271 {
11272   dw_die_ref scope_die = scope_die_for (type, context_die);
11273   dw_die_ref array_die;
11274   tree element_type;
11275
11276   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11277      the inner array type comes before the outer array type.  Thus we must
11278      call gen_type_die before we call new_die.  See below also.  */
11279 #ifdef MIPS_DEBUGGING_INFO
11280   gen_type_die (TREE_TYPE (type), context_die);
11281 #endif
11282
11283   array_die = new_die (DW_TAG_array_type, scope_die, type);
11284   add_name_attribute (array_die, type_tag (type));
11285   equate_type_number_to_die (type, array_die);
11286
11287   if (TREE_CODE (type) == VECTOR_TYPE)
11288     {
11289       /* The frontend feeds us a representation for the vector as a struct
11290          containing an array.  Pull out the array type.  */
11291       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11292       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11293     }
11294
11295 #if 0
11296   /* We default the array ordering.  SDB will probably do
11297      the right things even if DW_AT_ordering is not present.  It's not even
11298      an issue until we start to get into multidimensional arrays anyway.  If
11299      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11300      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11301      and when we find out that we need to put these in, we will only do so
11302      for multidimensional arrays.  */
11303   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11304 #endif
11305
11306 #ifdef MIPS_DEBUGGING_INFO
11307   /* The SGI compilers handle arrays of unknown bound by setting
11308      AT_declaration and not emitting any subrange DIEs.  */
11309   if (! TYPE_DOMAIN (type))
11310     add_AT_flag (array_die, DW_AT_declaration, 1);
11311   else
11312 #endif
11313     add_subscript_info (array_die, type);
11314
11315   /* Add representation of the type of the elements of this array type.  */
11316   element_type = TREE_TYPE (type);
11317
11318   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11319      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11320      We work around this by disabling this feature.  See also
11321      add_subscript_info.  */
11322 #ifndef MIPS_DEBUGGING_INFO
11323   while (TREE_CODE (element_type) == ARRAY_TYPE)
11324     element_type = TREE_TYPE (element_type);
11325
11326   gen_type_die (element_type, context_die);
11327 #endif
11328
11329   add_type_attribute (array_die, element_type, 0, 0, context_die);
11330
11331   if (get_AT (array_die, DW_AT_name))
11332     add_pubtype (type, array_die);
11333 }
11334
11335 #if 0
11336 static void
11337 gen_entry_point_die (tree decl, dw_die_ref context_die)
11338 {
11339   tree origin = decl_ultimate_origin (decl);
11340   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11341
11342   if (origin != NULL)
11343     add_abstract_origin_attribute (decl_die, origin);
11344   else
11345     {
11346       add_name_and_src_coords_attributes (decl_die, decl);
11347       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11348                           0, 0, context_die);
11349     }
11350
11351   if (DECL_ABSTRACT (decl))
11352     equate_decl_number_to_die (decl, decl_die);
11353   else
11354     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11355 }
11356 #endif
11357
11358 /* Walk through the list of incomplete types again, trying once more to
11359    emit full debugging info for them.  */
11360
11361 static void
11362 retry_incomplete_types (void)
11363 {
11364   int i;
11365
11366   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11367     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11368 }
11369
11370 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11371
11372 static void
11373 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11374 {
11375   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11376
11377   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11378      be incomplete and such types are not marked.  */
11379   add_abstract_origin_attribute (type_die, type);
11380 }
11381
11382 /* Generate a DIE to represent an inlined instance of a structure type.  */
11383
11384 static void
11385 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11386 {
11387   dw_die_ref type_die = new_die (DW_TAG_structure_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 union type.  */
11395
11396 static void
11397 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11398 {
11399   dw_die_ref type_die = new_die (DW_TAG_union_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 enumeration type.  Note that these DIEs
11407    include all of the information about the enumeration values also. Each
11408    enumerated type name/value is listed as a child of the enumerated type
11409    DIE.  */
11410
11411 static dw_die_ref
11412 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11413 {
11414   dw_die_ref type_die = lookup_type_die (type);
11415
11416   if (type_die == NULL)
11417     {
11418       type_die = new_die (DW_TAG_enumeration_type,
11419                           scope_die_for (type, context_die), type);
11420       equate_type_number_to_die (type, type_die);
11421       add_name_attribute (type_die, type_tag (type));
11422     }
11423   else if (! TYPE_SIZE (type))
11424     return type_die;
11425   else
11426     remove_AT (type_die, DW_AT_declaration);
11427
11428   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11429      given enum type is incomplete, do not generate the DW_AT_byte_size
11430      attribute or the DW_AT_element_list attribute.  */
11431   if (TYPE_SIZE (type))
11432     {
11433       tree link;
11434
11435       TREE_ASM_WRITTEN (type) = 1;
11436       add_byte_size_attribute (type_die, type);
11437       if (TYPE_STUB_DECL (type) != NULL_TREE)
11438         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11439
11440       /* If the first reference to this type was as the return type of an
11441          inline function, then it may not have a parent.  Fix this now.  */
11442       if (type_die->die_parent == NULL)
11443         add_child_die (scope_die_for (type, context_die), type_die);
11444
11445       for (link = TYPE_VALUES (type);
11446            link != NULL; link = TREE_CHAIN (link))
11447         {
11448           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11449           tree value = TREE_VALUE (link);
11450
11451           add_name_attribute (enum_die,
11452                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11453
11454           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11455             /* DWARF2 does not provide a way of indicating whether or
11456                not enumeration constants are signed or unsigned.  GDB
11457                always assumes the values are signed, so we output all
11458                values as if they were signed.  That means that
11459                enumeration constants with very large unsigned values
11460                will appear to have negative values in the debugger.  */
11461             add_AT_int (enum_die, DW_AT_const_value,
11462                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11463         }
11464     }
11465   else
11466     add_AT_flag (type_die, DW_AT_declaration, 1);
11467
11468   if (get_AT (type_die, DW_AT_name))
11469     add_pubtype (type, type_die);
11470
11471   return type_die;
11472 }
11473
11474 /* Generate a DIE to represent either a real live formal parameter decl or to
11475    represent just the type of some formal parameter position in some function
11476    type.
11477
11478    Note that this routine is a bit unusual because its argument may be a
11479    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11480    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11481    node.  If it's the former then this function is being called to output a
11482    DIE to represent a formal parameter object (or some inlining thereof).  If
11483    it's the latter, then this function is only being called to output a
11484    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11485    argument type of some subprogram type.  */
11486
11487 static dw_die_ref
11488 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11489 {
11490   dw_die_ref parm_die
11491     = new_die (DW_TAG_formal_parameter, context_die, node);
11492   tree origin;
11493
11494   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11495     {
11496     case tcc_declaration:
11497       origin = decl_ultimate_origin (node);
11498       if (origin != NULL)
11499         add_abstract_origin_attribute (parm_die, origin);
11500       else
11501         {
11502           add_name_and_src_coords_attributes (parm_die, node);
11503           add_type_attribute (parm_die, TREE_TYPE (node),
11504                               TREE_READONLY (node),
11505                               TREE_THIS_VOLATILE (node),
11506                               context_die);
11507           if (DECL_ARTIFICIAL (node))
11508             add_AT_flag (parm_die, DW_AT_artificial, 1);
11509         }
11510
11511       equate_decl_number_to_die (node, parm_die);
11512       if (! DECL_ABSTRACT (node))
11513         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11514
11515       break;
11516
11517     case tcc_type:
11518       /* We were called with some kind of a ..._TYPE node.  */
11519       add_type_attribute (parm_die, node, 0, 0, context_die);
11520       break;
11521
11522     default:
11523       gcc_unreachable ();
11524     }
11525
11526   return parm_die;
11527 }
11528
11529 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11530    at the end of an (ANSI prototyped) formal parameters list.  */
11531
11532 static void
11533 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11534 {
11535   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11536 }
11537
11538 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11539    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11540    parameters as specified in some function type specification (except for
11541    those which appear as part of a function *definition*).  */
11542
11543 static void
11544 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11545 {
11546   tree link;
11547   tree formal_type = NULL;
11548   tree first_parm_type;
11549   tree arg;
11550
11551   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11552     {
11553       arg = DECL_ARGUMENTS (function_or_method_type);
11554       function_or_method_type = TREE_TYPE (function_or_method_type);
11555     }
11556   else
11557     arg = NULL_TREE;
11558
11559   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11560
11561   /* Make our first pass over the list of formal parameter types and output a
11562      DW_TAG_formal_parameter DIE for each one.  */
11563   for (link = first_parm_type; link; )
11564     {
11565       dw_die_ref parm_die;
11566
11567       formal_type = TREE_VALUE (link);
11568       if (formal_type == void_type_node)
11569         break;
11570
11571       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11572       parm_die = gen_formal_parameter_die (formal_type, context_die);
11573       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11574            && link == first_parm_type)
11575           || (arg && DECL_ARTIFICIAL (arg)))
11576         add_AT_flag (parm_die, DW_AT_artificial, 1);
11577
11578       link = TREE_CHAIN (link);
11579       if (arg)
11580         arg = TREE_CHAIN (arg);
11581     }
11582
11583   /* If this function type has an ellipsis, add a
11584      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11585   if (formal_type != void_type_node)
11586     gen_unspecified_parameters_die (function_or_method_type, context_die);
11587
11588   /* Make our second (and final) pass over the list of formal parameter types
11589      and output DIEs to represent those types (as necessary).  */
11590   for (link = TYPE_ARG_TYPES (function_or_method_type);
11591        link && TREE_VALUE (link);
11592        link = TREE_CHAIN (link))
11593     gen_type_die (TREE_VALUE (link), context_die);
11594 }
11595
11596 /* We want to generate the DIE for TYPE so that we can generate the
11597    die for MEMBER, which has been defined; we will need to refer back
11598    to the member declaration nested within TYPE.  If we're trying to
11599    generate minimal debug info for TYPE, processing TYPE won't do the
11600    trick; we need to attach the member declaration by hand.  */
11601
11602 static void
11603 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11604 {
11605   gen_type_die (type, context_die);
11606
11607   /* If we're trying to avoid duplicate debug info, we may not have
11608      emitted the member decl for this function.  Emit it now.  */
11609   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11610       && ! lookup_decl_die (member))
11611     {
11612       dw_die_ref type_die;
11613       gcc_assert (!decl_ultimate_origin (member));
11614
11615       push_decl_scope (type);
11616       type_die = lookup_type_die (type);
11617       if (TREE_CODE (member) == FUNCTION_DECL)
11618         gen_subprogram_die (member, type_die);
11619       else if (TREE_CODE (member) == FIELD_DECL)
11620         {
11621           /* Ignore the nameless fields that are used to skip bits but handle
11622              C++ anonymous unions and structs.  */
11623           if (DECL_NAME (member) != NULL_TREE
11624               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11625               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11626             {
11627               gen_type_die (member_declared_type (member), type_die);
11628               gen_field_die (member, type_die);
11629             }
11630         }
11631       else
11632         gen_variable_die (member, type_die);
11633
11634       pop_decl_scope ();
11635     }
11636 }
11637
11638 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11639    may later generate inlined and/or out-of-line instances of.  */
11640
11641 static void
11642 dwarf2out_abstract_function (tree decl)
11643 {
11644   dw_die_ref old_die;
11645   tree save_fn;
11646   struct function *save_cfun;
11647   tree context;
11648   int was_abstract = DECL_ABSTRACT (decl);
11649
11650   /* Make sure we have the actual abstract inline, not a clone.  */
11651   decl = DECL_ORIGIN (decl);
11652
11653   old_die = lookup_decl_die (decl);
11654   if (old_die && get_AT (old_die, DW_AT_inline))
11655     /* We've already generated the abstract instance.  */
11656     return;
11657
11658   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11659      we don't get confused by DECL_ABSTRACT.  */
11660   if (debug_info_level > DINFO_LEVEL_TERSE)
11661     {
11662       context = decl_class_context (decl);
11663       if (context)
11664         gen_type_die_for_member
11665           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11666     }
11667
11668   /* Pretend we've just finished compiling this function.  */
11669   save_fn = current_function_decl;
11670   save_cfun = cfun;
11671   current_function_decl = decl;
11672   cfun = DECL_STRUCT_FUNCTION (decl);
11673
11674   set_decl_abstract_flags (decl, 1);
11675   dwarf2out_decl (decl);
11676   if (! was_abstract)
11677     set_decl_abstract_flags (decl, 0);
11678
11679   current_function_decl = save_fn;
11680   cfun = save_cfun;
11681 }
11682
11683 /* Helper function of premark_used_types() which gets called through
11684    htab_traverse_resize().
11685
11686    Marks the DIE of a given type in *SLOT as perennial, so it never gets
11687    marked as unused by prune_unused_types.  */
11688 static int
11689 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
11690 {
11691   tree type;
11692   dw_die_ref die;
11693
11694   type = *slot;
11695   die = lookup_type_die (type);
11696   if (die != NULL)
11697     die->die_perennial_p = 1;
11698   return 1;
11699 }
11700
11701 /* Mark all members of used_types_hash as perennial.  */
11702 static void
11703 premark_used_types (void)
11704 {
11705   if (cfun && cfun->used_types_hash)
11706     htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
11707 }
11708
11709 /* Generate a DIE to represent a declared function (either file-scope or
11710    block-local).  */
11711
11712 static void
11713 gen_subprogram_die (tree decl, dw_die_ref context_die)
11714 {
11715   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11716   tree origin = decl_ultimate_origin (decl);
11717   dw_die_ref subr_die;
11718   tree fn_arg_types;
11719   tree outer_scope;
11720   dw_die_ref old_die = lookup_decl_die (decl);
11721   int declaration = (current_function_decl != decl
11722                      || class_or_namespace_scope_p (context_die));
11723
11724   premark_used_types ();
11725
11726   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11727      started to generate the abstract instance of an inline, decided to output
11728      its containing class, and proceeded to emit the declaration of the inline
11729      from the member list for the class.  If so, DECLARATION takes priority;
11730      we'll get back to the abstract instance when done with the class.  */
11731
11732   /* The class-scope declaration DIE must be the primary DIE.  */
11733   if (origin && declaration && class_or_namespace_scope_p (context_die))
11734     {
11735       origin = NULL;
11736       gcc_assert (!old_die);
11737     }
11738
11739   /* Now that the C++ front end lazily declares artificial member fns, we
11740      might need to retrofit the declaration into its class.  */
11741   if (!declaration && !origin && !old_die
11742       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11743       && !class_or_namespace_scope_p (context_die)
11744       && debug_info_level > DINFO_LEVEL_TERSE)
11745     old_die = force_decl_die (decl);
11746
11747   if (origin != NULL)
11748     {
11749       gcc_assert (!declaration || local_scope_p (context_die));
11750
11751       /* Fixup die_parent for the abstract instance of a nested
11752          inline function.  */
11753       if (old_die && old_die->die_parent == NULL)
11754         add_child_die (context_die, old_die);
11755
11756       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11757       add_abstract_origin_attribute (subr_die, origin);
11758     }
11759   else if (old_die)
11760     {
11761       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11762       struct dwarf_file_data * file_index = lookup_filename (s.file);
11763
11764       if (!get_AT_flag (old_die, DW_AT_declaration)
11765           /* We can have a normal definition following an inline one in the
11766              case of redefinition of GNU C extern inlines.
11767              It seems reasonable to use AT_specification in this case.  */
11768           && !get_AT (old_die, DW_AT_inline))
11769         {
11770           /* Detect and ignore this case, where we are trying to output
11771              something we have already output.  */
11772           return;
11773         }
11774
11775       /* If the definition comes from the same place as the declaration,
11776          maybe use the old DIE.  We always want the DIE for this function
11777          that has the *_pc attributes to be under comp_unit_die so the
11778          debugger can find it.  We also need to do this for abstract
11779          instances of inlines, since the spec requires the out-of-line copy
11780          to have the same parent.  For local class methods, this doesn't
11781          apply; we just use the old DIE.  */
11782       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11783           && (DECL_ARTIFICIAL (decl)
11784               || (get_AT_file (old_die, DW_AT_decl_file) == file_index
11785                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11786                       == (unsigned) s.line))))
11787         {
11788           subr_die = old_die;
11789
11790           /* Clear out the declaration attribute and the formal parameters.
11791              Do not remove all children, because it is possible that this
11792              declaration die was forced using force_decl_die(). In such
11793              cases die that forced declaration die (e.g. TAG_imported_module)
11794              is one of the children that we do not want to remove.  */
11795           remove_AT (subr_die, DW_AT_declaration);
11796           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11797         }
11798       else
11799         {
11800           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11801           add_AT_specification (subr_die, old_die);
11802           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
11803             add_AT_file (subr_die, DW_AT_decl_file, file_index);
11804           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
11805             add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
11806         }
11807     }
11808   else
11809     {
11810       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11811
11812       if (TREE_PUBLIC (decl))
11813         add_AT_flag (subr_die, DW_AT_external, 1);
11814
11815       add_name_and_src_coords_attributes (subr_die, decl);
11816       if (debug_info_level > DINFO_LEVEL_TERSE)
11817         {
11818           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11819           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11820                               0, 0, context_die);
11821         }
11822
11823       add_pure_or_virtual_attribute (subr_die, decl);
11824       if (DECL_ARTIFICIAL (decl))
11825         add_AT_flag (subr_die, DW_AT_artificial, 1);
11826
11827       if (TREE_PROTECTED (decl))
11828         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11829       else if (TREE_PRIVATE (decl))
11830         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11831     }
11832
11833   if (declaration)
11834     {
11835       if (!old_die || !get_AT (old_die, DW_AT_inline))
11836         {
11837           add_AT_flag (subr_die, DW_AT_declaration, 1);
11838
11839           /* The first time we see a member function, it is in the context of
11840              the class to which it belongs.  We make sure of this by emitting
11841              the class first.  The next time is the definition, which is
11842              handled above.  The two may come from the same source text.
11843
11844              Note that force_decl_die() forces function declaration die. It is
11845              later reused to represent definition.  */
11846           equate_decl_number_to_die (decl, subr_die);
11847         }
11848     }
11849   else if (DECL_ABSTRACT (decl))
11850     {
11851       if (DECL_DECLARED_INLINE_P (decl))
11852         {
11853           if (cgraph_function_possibly_inlined_p (decl))
11854             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11855           else
11856             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11857         }
11858       else
11859         {
11860           if (cgraph_function_possibly_inlined_p (decl))
11861             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11862           else
11863             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11864         }
11865
11866       equate_decl_number_to_die (decl, subr_die);
11867     }
11868   else if (!DECL_EXTERNAL (decl))
11869     {
11870       HOST_WIDE_INT cfa_fb_offset;
11871
11872       if (!old_die || !get_AT (old_die, DW_AT_inline))
11873         equate_decl_number_to_die (decl, subr_die);
11874
11875       if (!flag_reorder_blocks_and_partition)
11876         {
11877           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11878                                        current_function_funcdef_no);
11879           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11880           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11881                                        current_function_funcdef_no);
11882           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11883
11884           add_pubname (decl, subr_die);
11885           add_arange (decl, subr_die);
11886         }
11887       else
11888         {  /* Do nothing for now; maybe need to duplicate die, one for
11889               hot section and ond for cold section, then use the hot/cold
11890               section begin/end labels to generate the aranges...  */
11891           /*
11892             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11893             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11894             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11895             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11896
11897             add_pubname (decl, subr_die);
11898             add_arange (decl, subr_die);
11899             add_arange (decl, subr_die);
11900            */
11901         }
11902
11903 #ifdef MIPS_DEBUGGING_INFO
11904       /* Add a reference to the FDE for this routine.  */
11905       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11906 #endif
11907
11908       cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11909
11910       /* We define the "frame base" as the function's CFA.  This is more
11911          convenient for several reasons: (1) It's stable across the prologue
11912          and epilogue, which makes it better than just a frame pointer,
11913          (2) With dwarf3, there exists a one-byte encoding that allows us
11914          to reference the .debug_frame data by proxy, but failing that,
11915          (3) We can at least reuse the code inspection and interpretation
11916          code that determines the CFA position at various points in the
11917          function.  */
11918       /* ??? Use some command-line or configury switch to enable the use
11919          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
11920          consumers that understand it; fall back to "pure" dwarf2 and
11921          convert the CFA data into a location list.  */
11922       {
11923         dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11924         if (list->dw_loc_next)
11925           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11926         else
11927           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11928       }
11929
11930       /* Compute a displacement from the "steady-state frame pointer" to
11931          the CFA.  The former is what all stack slots and argument slots
11932          will reference in the rtl; the later is what we've told the
11933          debugger about.  We'll need to adjust all frame_base references
11934          by this displacement.  */
11935       compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11936
11937       if (cfun->static_chain_decl)
11938         add_AT_location_description (subr_die, DW_AT_static_link,
11939                  loc_descriptor_from_tree (cfun->static_chain_decl));
11940     }
11941
11942   /* Now output descriptions of the arguments for this function. This gets
11943      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11944      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11945      `...' at the end of the formal parameter list.  In order to find out if
11946      there was a trailing ellipsis or not, we must instead look at the type
11947      associated with the FUNCTION_DECL.  This will be a node of type
11948      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11949      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11950      an ellipsis at the end.  */
11951
11952   /* In the case where we are describing a mere function declaration, all we
11953      need to do here (and all we *can* do here) is to describe the *types* of
11954      its formal parameters.  */
11955   if (debug_info_level <= DINFO_LEVEL_TERSE)
11956     ;
11957   else if (declaration)
11958     gen_formal_types_die (decl, subr_die);
11959   else
11960     {
11961       /* Generate DIEs to represent all known formal parameters.  */
11962       tree arg_decls = DECL_ARGUMENTS (decl);
11963       tree parm;
11964
11965       /* When generating DIEs, generate the unspecified_parameters DIE
11966          instead if we come across the arg "__builtin_va_alist" */
11967       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11968         if (TREE_CODE (parm) == PARM_DECL)
11969           {
11970             if (DECL_NAME (parm)
11971                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11972                             "__builtin_va_alist"))
11973               gen_unspecified_parameters_die (parm, subr_die);
11974             else
11975               gen_decl_die (parm, subr_die);
11976           }
11977
11978       /* Decide whether we need an unspecified_parameters DIE at the end.
11979          There are 2 more cases to do this for: 1) the ansi ... declaration -
11980          this is detectable when the end of the arg list is not a
11981          void_type_node 2) an unprototyped function declaration (not a
11982          definition).  This just means that we have no info about the
11983          parameters at all.  */
11984       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11985       if (fn_arg_types != NULL)
11986         {
11987           /* This is the prototyped case, check for....  */
11988           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11989             gen_unspecified_parameters_die (decl, subr_die);
11990         }
11991       else if (DECL_INITIAL (decl) == NULL_TREE)
11992         gen_unspecified_parameters_die (decl, subr_die);
11993     }
11994
11995   /* Output Dwarf info for all of the stuff within the body of the function
11996      (if it has one - it may be just a declaration).  */
11997   outer_scope = DECL_INITIAL (decl);
11998
11999   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
12000      a function.  This BLOCK actually represents the outermost binding contour
12001      for the function, i.e. the contour in which the function's formal
12002      parameters and labels get declared. Curiously, it appears that the front
12003      end doesn't actually put the PARM_DECL nodes for the current function onto
12004      the BLOCK_VARS list for this outer scope, but are strung off of the
12005      DECL_ARGUMENTS list for the function instead.
12006
12007      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
12008      the LABEL_DECL nodes for the function however, and we output DWARF info
12009      for those in decls_for_scope.  Just within the `outer_scope' there will be
12010      a BLOCK node representing the function's outermost pair of curly braces,
12011      and any blocks used for the base and member initializers of a C++
12012      constructor function.  */
12013   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
12014     {
12015       /* Emit a DW_TAG_variable DIE for a named return value.  */
12016       if (DECL_NAME (DECL_RESULT (decl)))
12017         gen_decl_die (DECL_RESULT (decl), subr_die);
12018
12019       current_function_has_inlines = 0;
12020       decls_for_scope (outer_scope, subr_die, 0);
12021
12022 #if 0 && defined (MIPS_DEBUGGING_INFO)
12023       if (current_function_has_inlines)
12024         {
12025           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
12026           if (! comp_unit_has_inlines)
12027             {
12028               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
12029               comp_unit_has_inlines = 1;
12030             }
12031         }
12032 #endif
12033     }
12034   /* Add the calling convention attribute if requested.  */
12035   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
12036
12037 }
12038
12039 /* Generate a DIE to represent a declared data object.  */
12040
12041 static void
12042 gen_variable_die (tree decl, dw_die_ref context_die)
12043 {
12044   tree origin = decl_ultimate_origin (decl);
12045   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
12046
12047   dw_die_ref old_die = lookup_decl_die (decl);
12048   int declaration = (DECL_EXTERNAL (decl)
12049                      /* If DECL is COMDAT and has not actually been
12050                         emitted, we cannot take its address; there
12051                         might end up being no definition anywhere in
12052                         the program.  For example, consider the C++
12053                         test case:
12054
12055                           template <class T>
12056                           struct S { static const int i = 7; };
12057
12058                           template <class T>
12059                           const int S<T>::i;
12060
12061                           int f() { return S<int>::i; }
12062
12063                         Here, S<int>::i is not DECL_EXTERNAL, but no
12064                         definition is required, so the compiler will
12065                         not emit a definition.  */
12066                      || (TREE_CODE (decl) == VAR_DECL
12067                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
12068                      || class_or_namespace_scope_p (context_die));
12069
12070   if (origin != NULL)
12071     add_abstract_origin_attribute (var_die, origin);
12072
12073   /* Loop unrolling can create multiple blocks that refer to the same
12074      static variable, so we must test for the DW_AT_declaration flag.
12075
12076      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12077      copy decls and set the DECL_ABSTRACT flag on them instead of
12078      sharing them.
12079
12080      ??? Duplicated blocks have been rewritten to use .debug_ranges.
12081
12082      ??? The declare_in_namespace support causes us to get two DIEs for one
12083      variable, both of which are declarations.  We want to avoid considering
12084      one to be a specification, so we must test that this DIE is not a
12085      declaration.  */
12086   else if (old_die && TREE_STATIC (decl) && ! declaration
12087            && get_AT_flag (old_die, DW_AT_declaration) == 1)
12088     {
12089       /* This is a definition of a C++ class level static.  */
12090       add_AT_specification (var_die, old_die);
12091       if (DECL_NAME (decl))
12092         {
12093           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12094           struct dwarf_file_data * file_index = lookup_filename (s.file);
12095
12096           if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12097             add_AT_file (var_die, DW_AT_decl_file, file_index);
12098
12099           if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12100             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12101         }
12102     }
12103   else
12104     {
12105       add_name_and_src_coords_attributes (var_die, decl);
12106       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12107                           TREE_THIS_VOLATILE (decl), context_die);
12108
12109       if (TREE_PUBLIC (decl))
12110         add_AT_flag (var_die, DW_AT_external, 1);
12111
12112       if (DECL_ARTIFICIAL (decl))
12113         add_AT_flag (var_die, DW_AT_artificial, 1);
12114
12115       if (TREE_PROTECTED (decl))
12116         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12117       else if (TREE_PRIVATE (decl))
12118         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12119     }
12120
12121   if (declaration)
12122     add_AT_flag (var_die, DW_AT_declaration, 1);
12123
12124   if (DECL_ABSTRACT (decl) || declaration)
12125     equate_decl_number_to_die (decl, var_die);
12126
12127   if (! declaration && ! DECL_ABSTRACT (decl))
12128     {
12129       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12130       add_pubname (decl, var_die);
12131     }
12132   else
12133     tree_add_const_value_attribute (var_die, decl);
12134 }
12135
12136 /* Generate a DIE to represent a label identifier.  */
12137
12138 static void
12139 gen_label_die (tree decl, dw_die_ref context_die)
12140 {
12141   tree origin = decl_ultimate_origin (decl);
12142   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12143   rtx insn;
12144   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12145
12146   if (origin != NULL)
12147     add_abstract_origin_attribute (lbl_die, origin);
12148   else
12149     add_name_and_src_coords_attributes (lbl_die, decl);
12150
12151   if (DECL_ABSTRACT (decl))
12152     equate_decl_number_to_die (decl, lbl_die);
12153   else
12154     {
12155       insn = DECL_RTL_IF_SET (decl);
12156
12157       /* Deleted labels are programmer specified labels which have been
12158          eliminated because of various optimizations.  We still emit them
12159          here so that it is possible to put breakpoints on them.  */
12160       if (insn
12161           && (LABEL_P (insn)
12162               || ((NOTE_P (insn)
12163                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
12164         {
12165           /* When optimization is enabled (via -O) some parts of the compiler
12166              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12167              represent source-level labels which were explicitly declared by
12168              the user.  This really shouldn't be happening though, so catch
12169              it if it ever does happen.  */
12170           gcc_assert (!INSN_DELETED_P (insn));
12171
12172           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12173           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12174         }
12175     }
12176 }
12177
12178 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
12179    attributes to the DIE for a block STMT, to describe where the inlined
12180    function was called from.  This is similar to add_src_coords_attributes.  */
12181
12182 static inline void
12183 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12184 {
12185   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12186
12187   add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12188   add_AT_unsigned (die, DW_AT_call_line, s.line);
12189 }
12190
12191 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12192    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
12193
12194 static inline void
12195 add_high_low_attributes (tree stmt, dw_die_ref die)
12196 {
12197   char label[MAX_ARTIFICIAL_LABEL_BYTES];
12198
12199   if (BLOCK_FRAGMENT_CHAIN (stmt))
12200     {
12201       tree chain;
12202
12203       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12204
12205       chain = BLOCK_FRAGMENT_CHAIN (stmt);
12206       do
12207         {
12208           add_ranges (chain);
12209           chain = BLOCK_FRAGMENT_CHAIN (chain);
12210         }
12211       while (chain);
12212       add_ranges (NULL);
12213     }
12214   else
12215     {
12216       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12217                                    BLOCK_NUMBER (stmt));
12218       add_AT_lbl_id (die, DW_AT_low_pc, label);
12219       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12220                                    BLOCK_NUMBER (stmt));
12221       add_AT_lbl_id (die, DW_AT_high_pc, label);
12222     }
12223 }
12224
12225 /* Generate a DIE for a lexical block.  */
12226
12227 static void
12228 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12229 {
12230   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12231
12232   if (! BLOCK_ABSTRACT (stmt))
12233     add_high_low_attributes (stmt, stmt_die);
12234
12235   decls_for_scope (stmt, stmt_die, depth);
12236 }
12237
12238 /* Generate a DIE for an inlined subprogram.  */
12239
12240 static void
12241 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12242 {
12243   tree decl = block_ultimate_origin (stmt);
12244
12245   /* Emit info for the abstract instance first, if we haven't yet.  We
12246      must emit this even if the block is abstract, otherwise when we
12247      emit the block below (or elsewhere), we may end up trying to emit
12248      a die whose origin die hasn't been emitted, and crashing.  */
12249   dwarf2out_abstract_function (decl);
12250
12251   if (! BLOCK_ABSTRACT (stmt))
12252     {
12253       dw_die_ref subr_die
12254         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12255
12256       add_abstract_origin_attribute (subr_die, decl);
12257       add_high_low_attributes (stmt, subr_die);
12258       add_call_src_coords_attributes (stmt, subr_die);
12259
12260       decls_for_scope (stmt, subr_die, depth);
12261       current_function_has_inlines = 1;
12262     }
12263   else
12264     /* We may get here if we're the outer block of function A that was
12265        inlined into function B that was inlined into function C.  When
12266        generating debugging info for C, dwarf2out_abstract_function(B)
12267        would mark all inlined blocks as abstract, including this one.
12268        So, we wouldn't (and shouldn't) expect labels to be generated
12269        for this one.  Instead, just emit debugging info for
12270        declarations within the block.  This is particularly important
12271        in the case of initializers of arguments passed from B to us:
12272        if they're statement expressions containing declarations, we
12273        wouldn't generate dies for their abstract variables, and then,
12274        when generating dies for the real variables, we'd die (pun
12275        intended :-)  */
12276     gen_lexical_block_die (stmt, context_die, depth);
12277 }
12278
12279 /* Generate a DIE for a field in a record, or structure.  */
12280
12281 static void
12282 gen_field_die (tree decl, dw_die_ref context_die)
12283 {
12284   dw_die_ref decl_die;
12285
12286   if (TREE_TYPE (decl) == error_mark_node)
12287     return;
12288
12289   decl_die = new_die (DW_TAG_member, context_die, decl);
12290   add_name_and_src_coords_attributes (decl_die, decl);
12291   add_type_attribute (decl_die, member_declared_type (decl),
12292                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12293                       context_die);
12294
12295   if (DECL_BIT_FIELD_TYPE (decl))
12296     {
12297       add_byte_size_attribute (decl_die, decl);
12298       add_bit_size_attribute (decl_die, decl);
12299       add_bit_offset_attribute (decl_die, decl);
12300     }
12301
12302   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12303     add_data_member_location_attribute (decl_die, decl);
12304
12305   if (DECL_ARTIFICIAL (decl))
12306     add_AT_flag (decl_die, DW_AT_artificial, 1);
12307
12308   if (TREE_PROTECTED (decl))
12309     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12310   else if (TREE_PRIVATE (decl))
12311     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12312
12313   /* Equate decl number to die, so that we can look up this decl later on.  */
12314   equate_decl_number_to_die (decl, decl_die);
12315 }
12316
12317 #if 0
12318 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12319    Use modified_type_die instead.
12320    We keep this code here just in case these types of DIEs may be needed to
12321    represent certain things in other languages (e.g. Pascal) someday.  */
12322
12323 static void
12324 gen_pointer_type_die (tree type, dw_die_ref context_die)
12325 {
12326   dw_die_ref ptr_die
12327     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12328
12329   equate_type_number_to_die (type, ptr_die);
12330   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12331   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12332 }
12333
12334 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12335    Use modified_type_die instead.
12336    We keep this code here just in case these types of DIEs may be needed to
12337    represent certain things in other languages (e.g. Pascal) someday.  */
12338
12339 static void
12340 gen_reference_type_die (tree type, dw_die_ref context_die)
12341 {
12342   dw_die_ref ref_die
12343     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12344
12345   equate_type_number_to_die (type, ref_die);
12346   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12347   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12348 }
12349 #endif
12350
12351 /* Generate a DIE for a pointer to a member type.  */
12352
12353 static void
12354 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12355 {
12356   dw_die_ref ptr_die
12357     = new_die (DW_TAG_ptr_to_member_type,
12358                scope_die_for (type, context_die), type);
12359
12360   equate_type_number_to_die (type, ptr_die);
12361   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12362                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12363   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12364 }
12365
12366 /* Generate the DIE for the compilation unit.  */
12367
12368 static dw_die_ref
12369 gen_compile_unit_die (const char *filename)
12370 {
12371   dw_die_ref die;
12372   char producer[250];
12373   const char *language_string = lang_hooks.name;
12374   int language;
12375
12376   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12377
12378   if (filename)
12379     {
12380       add_name_attribute (die, filename);
12381       /* Don't add cwd for <built-in>.  */
12382       if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
12383         add_comp_dir_attribute (die);
12384     }
12385
12386   sprintf (producer, "%s %s", language_string, version_string);
12387
12388 #ifdef MIPS_DEBUGGING_INFO
12389   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12390      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12391      not appear in the producer string, the debugger reaches the conclusion
12392      that the object file is stripped and has no debugging information.
12393      To get the MIPS/SGI debugger to believe that there is debugging
12394      information in the object file, we add a -g to the producer string.  */
12395   if (debug_info_level > DINFO_LEVEL_TERSE)
12396     strcat (producer, " -g");
12397 #endif
12398
12399   add_AT_string (die, DW_AT_producer, producer);
12400
12401   if (strcmp (language_string, "GNU C++") == 0)
12402     language = DW_LANG_C_plus_plus;
12403   else if (strcmp (language_string, "GNU Ada") == 0)
12404     language = DW_LANG_Ada95;
12405   else if (strcmp (language_string, "GNU F77") == 0)
12406     language = DW_LANG_Fortran77;
12407   else if (strcmp (language_string, "GNU F95") == 0)
12408     language = DW_LANG_Fortran95;
12409   else if (strcmp (language_string, "GNU Pascal") == 0)
12410     language = DW_LANG_Pascal83;
12411   else if (strcmp (language_string, "GNU Java") == 0)
12412     language = DW_LANG_Java;
12413   else if (strcmp (language_string, "GNU Objective-C") == 0)
12414     language = DW_LANG_ObjC;
12415   else if (strcmp (language_string, "GNU Objective-C++") == 0)
12416     language = DW_LANG_ObjC_plus_plus;
12417   else
12418     language = DW_LANG_C89;
12419
12420   add_AT_unsigned (die, DW_AT_language, language);
12421   return die;
12422 }
12423
12424 /* Generate the DIE for a base class.  */
12425
12426 static void
12427 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12428 {
12429   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12430
12431   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12432   add_data_member_location_attribute (die, binfo);
12433
12434   if (BINFO_VIRTUAL_P (binfo))
12435     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12436
12437   if (access == access_public_node)
12438     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12439   else if (access == access_protected_node)
12440     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12441 }
12442
12443 /* Generate a DIE for a class member.  */
12444
12445 static void
12446 gen_member_die (tree type, dw_die_ref context_die)
12447 {
12448   tree member;
12449   tree binfo = TYPE_BINFO (type);
12450   dw_die_ref child;
12451
12452   /* If this is not an incomplete type, output descriptions of each of its
12453      members. Note that as we output the DIEs necessary to represent the
12454      members of this record or union type, we will also be trying to output
12455      DIEs to represent the *types* of those members. However the `type'
12456      function (above) will specifically avoid generating type DIEs for member
12457      types *within* the list of member DIEs for this (containing) type except
12458      for those types (of members) which are explicitly marked as also being
12459      members of this (containing) type themselves.  The g++ front- end can
12460      force any given type to be treated as a member of some other (containing)
12461      type by setting the TYPE_CONTEXT of the given (member) type to point to
12462      the TREE node representing the appropriate (containing) type.  */
12463
12464   /* First output info about the base classes.  */
12465   if (binfo)
12466     {
12467       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12468       int i;
12469       tree base;
12470
12471       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12472         gen_inheritance_die (base,
12473                              (accesses ? VEC_index (tree, accesses, i)
12474                               : access_public_node), context_die);
12475     }
12476
12477   /* Now output info about the data members and type members.  */
12478   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12479     {
12480       /* If we thought we were generating minimal debug info for TYPE
12481          and then changed our minds, some of the member declarations
12482          may have already been defined.  Don't define them again, but
12483          do put them in the right order.  */
12484
12485       child = lookup_decl_die (member);
12486       if (child)
12487         splice_child_die (context_die, child);
12488       else
12489         gen_decl_die (member, context_die);
12490     }
12491
12492   /* Now output info about the function members (if any).  */
12493   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12494     {
12495       /* Don't include clones in the member list.  */
12496       if (DECL_ABSTRACT_ORIGIN (member))
12497         continue;
12498
12499       child = lookup_decl_die (member);
12500       if (child)
12501         splice_child_die (context_die, child);
12502       else
12503         gen_decl_die (member, context_die);
12504     }
12505 }
12506
12507 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12508    is set, we pretend that the type was never defined, so we only get the
12509    member DIEs needed by later specification DIEs.  */
12510
12511 static void
12512 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12513 {
12514   dw_die_ref type_die = lookup_type_die (type);
12515   dw_die_ref scope_die = 0;
12516   int nested = 0;
12517   int complete = (TYPE_SIZE (type)
12518                   && (! TYPE_STUB_DECL (type)
12519                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12520   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12521
12522   if (type_die && ! complete)
12523     return;
12524
12525   if (TYPE_CONTEXT (type) != NULL_TREE
12526       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12527           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12528     nested = 1;
12529
12530   scope_die = scope_die_for (type, context_die);
12531
12532   if (! type_die || (nested && scope_die == comp_unit_die))
12533     /* First occurrence of type or toplevel definition of nested class.  */
12534     {
12535       dw_die_ref old_die = type_die;
12536
12537       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12538                           ? DW_TAG_structure_type : DW_TAG_union_type,
12539                           scope_die, type);
12540       equate_type_number_to_die (type, type_die);
12541       if (old_die)
12542         add_AT_specification (type_die, old_die);
12543       else
12544         add_name_attribute (type_die, type_tag (type));
12545     }
12546   else
12547     remove_AT (type_die, DW_AT_declaration);
12548
12549   /* If this type has been completed, then give it a byte_size attribute and
12550      then give a list of members.  */
12551   if (complete && !ns_decl)
12552     {
12553       /* Prevent infinite recursion in cases where the type of some member of
12554          this type is expressed in terms of this type itself.  */
12555       TREE_ASM_WRITTEN (type) = 1;
12556       add_byte_size_attribute (type_die, type);
12557       if (TYPE_STUB_DECL (type) != NULL_TREE)
12558         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12559
12560       /* If the first reference to this type was as the return type of an
12561          inline function, then it may not have a parent.  Fix this now.  */
12562       if (type_die->die_parent == NULL)
12563         add_child_die (scope_die, type_die);
12564
12565       push_decl_scope (type);
12566       gen_member_die (type, type_die);
12567       pop_decl_scope ();
12568
12569       /* GNU extension: Record what type our vtable lives in.  */
12570       if (TYPE_VFIELD (type))
12571         {
12572           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12573
12574           gen_type_die (vtype, context_die);
12575           add_AT_die_ref (type_die, DW_AT_containing_type,
12576                           lookup_type_die (vtype));
12577         }
12578     }
12579   else
12580     {
12581       add_AT_flag (type_die, DW_AT_declaration, 1);
12582
12583       /* We don't need to do this for function-local types.  */
12584       if (TYPE_STUB_DECL (type)
12585           && ! decl_function_context (TYPE_STUB_DECL (type)))
12586         VEC_safe_push (tree, gc, incomplete_types, type);
12587     }
12588
12589   if (get_AT (type_die, DW_AT_name))
12590     add_pubtype (type, type_die);
12591 }
12592
12593 /* Generate a DIE for a subroutine _type_.  */
12594
12595 static void
12596 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12597 {
12598   tree return_type = TREE_TYPE (type);
12599   dw_die_ref subr_die
12600     = new_die (DW_TAG_subroutine_type,
12601                scope_die_for (type, context_die), type);
12602
12603   equate_type_number_to_die (type, subr_die);
12604   add_prototyped_attribute (subr_die, type);
12605   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12606   gen_formal_types_die (type, subr_die);
12607
12608   if (get_AT (subr_die, DW_AT_name))
12609     add_pubtype (type, subr_die);
12610 }
12611
12612 /* Generate a DIE for a type definition.  */
12613
12614 static void
12615 gen_typedef_die (tree decl, dw_die_ref context_die)
12616 {
12617   dw_die_ref type_die;
12618   tree origin;
12619
12620   if (TREE_ASM_WRITTEN (decl))
12621     return;
12622
12623   TREE_ASM_WRITTEN (decl) = 1;
12624   type_die = new_die (DW_TAG_typedef, context_die, decl);
12625   origin = decl_ultimate_origin (decl);
12626   if (origin != NULL)
12627     add_abstract_origin_attribute (type_die, origin);
12628   else
12629     {
12630       tree type;
12631
12632       add_name_and_src_coords_attributes (type_die, decl);
12633       if (DECL_ORIGINAL_TYPE (decl))
12634         {
12635           type = DECL_ORIGINAL_TYPE (decl);
12636
12637           gcc_assert (type != TREE_TYPE (decl));
12638           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12639         }
12640       else
12641         type = TREE_TYPE (decl);
12642
12643       add_type_attribute (type_die, type, TREE_READONLY (decl),
12644                           TREE_THIS_VOLATILE (decl), context_die);
12645     }
12646
12647   if (DECL_ABSTRACT (decl))
12648     equate_decl_number_to_die (decl, type_die);
12649
12650   if (get_AT (type_die, DW_AT_name))
12651     add_pubtype (decl, type_die);
12652 }
12653
12654 /* Generate a type description DIE.  */
12655
12656 static void
12657 gen_type_die (tree type, dw_die_ref context_die)
12658 {
12659   int need_pop;
12660
12661   if (type == NULL_TREE || type == error_mark_node)
12662     return;
12663
12664   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12665       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12666     {
12667       if (TREE_ASM_WRITTEN (type))
12668         return;
12669
12670       /* Prevent broken recursion; we can't hand off to the same type.  */
12671       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12672
12673       TREE_ASM_WRITTEN (type) = 1;
12674       gen_decl_die (TYPE_NAME (type), context_die);
12675       return;
12676     }
12677
12678   /* We are going to output a DIE to represent the unqualified version
12679      of this type (i.e. without any const or volatile qualifiers) so
12680      get the main variant (i.e. the unqualified version) of this type
12681      now.  (Vectors are special because the debugging info is in the
12682      cloned type itself).  */
12683   if (TREE_CODE (type) != VECTOR_TYPE)
12684     type = type_main_variant (type);
12685
12686   if (TREE_ASM_WRITTEN (type))
12687     return;
12688
12689   switch (TREE_CODE (type))
12690     {
12691     case ERROR_MARK:
12692       break;
12693
12694     case POINTER_TYPE:
12695     case REFERENCE_TYPE:
12696       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12697          ensures that the gen_type_die recursion will terminate even if the
12698          type is recursive.  Recursive types are possible in Ada.  */
12699       /* ??? We could perhaps do this for all types before the switch
12700          statement.  */
12701       TREE_ASM_WRITTEN (type) = 1;
12702
12703       /* For these types, all that is required is that we output a DIE (or a
12704          set of DIEs) to represent the "basis" type.  */
12705       gen_type_die (TREE_TYPE (type), context_die);
12706       break;
12707
12708     case OFFSET_TYPE:
12709       /* This code is used for C++ pointer-to-data-member types.
12710          Output a description of the relevant class type.  */
12711       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12712
12713       /* Output a description of the type of the object pointed to.  */
12714       gen_type_die (TREE_TYPE (type), context_die);
12715
12716       /* Now output a DIE to represent this pointer-to-data-member type
12717          itself.  */
12718       gen_ptr_to_mbr_type_die (type, context_die);
12719       break;
12720
12721     case FUNCTION_TYPE:
12722       /* Force out return type (in case it wasn't forced out already).  */
12723       gen_type_die (TREE_TYPE (type), context_die);
12724       gen_subroutine_type_die (type, context_die);
12725       break;
12726
12727     case METHOD_TYPE:
12728       /* Force out return type (in case it wasn't forced out already).  */
12729       gen_type_die (TREE_TYPE (type), context_die);
12730       gen_subroutine_type_die (type, context_die);
12731       break;
12732
12733     case ARRAY_TYPE:
12734       gen_array_type_die (type, context_die);
12735       break;
12736
12737     case VECTOR_TYPE:
12738       gen_array_type_die (type, context_die);
12739       break;
12740
12741     case ENUMERAL_TYPE:
12742     case RECORD_TYPE:
12743     case UNION_TYPE:
12744     case QUAL_UNION_TYPE:
12745       /* If this is a nested type whose containing class hasn't been written
12746          out yet, writing it out will cover this one, too.  This does not apply
12747          to instantiations of member class templates; they need to be added to
12748          the containing class as they are generated.  FIXME: This hurts the
12749          idea of combining type decls from multiple TUs, since we can't predict
12750          what set of template instantiations we'll get.  */
12751       if (TYPE_CONTEXT (type)
12752           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12753           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12754         {
12755           gen_type_die (TYPE_CONTEXT (type), context_die);
12756
12757           if (TREE_ASM_WRITTEN (type))
12758             return;
12759
12760           /* If that failed, attach ourselves to the stub.  */
12761           push_decl_scope (TYPE_CONTEXT (type));
12762           context_die = lookup_type_die (TYPE_CONTEXT (type));
12763           need_pop = 1;
12764         }
12765       else
12766         {
12767           declare_in_namespace (type, context_die);
12768           need_pop = 0;
12769         }
12770
12771       if (TREE_CODE (type) == ENUMERAL_TYPE)
12772         {
12773           /* This might have been written out by the call to
12774              declare_in_namespace.  */
12775           if (!TREE_ASM_WRITTEN (type))
12776             gen_enumeration_type_die (type, context_die);
12777         }
12778       else
12779         gen_struct_or_union_type_die (type, context_die);
12780
12781       if (need_pop)
12782         pop_decl_scope ();
12783
12784       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12785          it up if it is ever completed.  gen_*_type_die will set it for us
12786          when appropriate.  */
12787       return;
12788
12789     case VOID_TYPE:
12790     case INTEGER_TYPE:
12791     case REAL_TYPE:
12792     case COMPLEX_TYPE:
12793     case BOOLEAN_TYPE:
12794       /* No DIEs needed for fundamental types.  */
12795       break;
12796
12797     case LANG_TYPE:
12798       /* No Dwarf representation currently defined.  */
12799       break;
12800
12801     default:
12802       gcc_unreachable ();
12803     }
12804
12805   TREE_ASM_WRITTEN (type) = 1;
12806 }
12807
12808 /* Generate a DIE for a tagged type instantiation.  */
12809
12810 static void
12811 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12812 {
12813   if (type == NULL_TREE || type == error_mark_node)
12814     return;
12815
12816   /* We are going to output a DIE to represent the unqualified version of
12817      this type (i.e. without any const or volatile qualifiers) so make sure
12818      that we have the main variant (i.e. the unqualified version) of this
12819      type now.  */
12820   gcc_assert (type == type_main_variant (type));
12821
12822   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12823      an instance of an unresolved type.  */
12824
12825   switch (TREE_CODE (type))
12826     {
12827     case ERROR_MARK:
12828       break;
12829
12830     case ENUMERAL_TYPE:
12831       gen_inlined_enumeration_type_die (type, context_die);
12832       break;
12833
12834     case RECORD_TYPE:
12835       gen_inlined_structure_type_die (type, context_die);
12836       break;
12837
12838     case UNION_TYPE:
12839     case QUAL_UNION_TYPE:
12840       gen_inlined_union_type_die (type, context_die);
12841       break;
12842
12843     default:
12844       gcc_unreachable ();
12845     }
12846 }
12847
12848 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12849    things which are local to the given block.  */
12850
12851 static void
12852 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12853 {
12854   int must_output_die = 0;
12855   tree origin;
12856   tree decl;
12857   enum tree_code origin_code;
12858
12859   /* Ignore blocks that are NULL.  */
12860   if (stmt == NULL_TREE)
12861     return;
12862
12863   /* If the block is one fragment of a non-contiguous block, do not
12864      process the variables, since they will have been done by the
12865      origin block.  Do process subblocks.  */
12866   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12867     {
12868       tree sub;
12869
12870       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12871         gen_block_die (sub, context_die, depth + 1);
12872
12873       return;
12874     }
12875
12876   /* Determine the "ultimate origin" of this block.  This block may be an
12877      inlined instance of an inlined instance of inline function, so we have
12878      to trace all of the way back through the origin chain to find out what
12879      sort of node actually served as the original seed for the creation of
12880      the current block.  */
12881   origin = block_ultimate_origin (stmt);
12882   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12883
12884   /* Determine if we need to output any Dwarf DIEs at all to represent this
12885      block.  */
12886   if (origin_code == FUNCTION_DECL)
12887     /* The outer scopes for inlinings *must* always be represented.  We
12888        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12889     must_output_die = 1;
12890   else
12891     {
12892       /* In the case where the current block represents an inlining of the
12893          "body block" of an inline function, we must *NOT* output any DIE for
12894          this block because we have already output a DIE to represent the whole
12895          inlined function scope and the "body block" of any function doesn't
12896          really represent a different scope according to ANSI C rules.  So we
12897          check here to make sure that this block does not represent a "body
12898          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12899       if (! is_body_block (origin ? origin : stmt))
12900         {
12901           /* Determine if this block directly contains any "significant"
12902              local declarations which we will need to output DIEs for.  */
12903           if (debug_info_level > DINFO_LEVEL_TERSE)
12904             /* We are not in terse mode so *any* local declaration counts
12905                as being a "significant" one.  */
12906             must_output_die = (BLOCK_VARS (stmt) != NULL
12907                                && (TREE_USED (stmt)
12908                                    || TREE_ASM_WRITTEN (stmt)
12909                                    || BLOCK_ABSTRACT (stmt)));
12910           else
12911             /* We are in terse mode, so only local (nested) function
12912                definitions count as "significant" local declarations.  */
12913             for (decl = BLOCK_VARS (stmt);
12914                  decl != NULL; decl = TREE_CHAIN (decl))
12915               if (TREE_CODE (decl) == FUNCTION_DECL
12916                   && DECL_INITIAL (decl))
12917                 {
12918                   must_output_die = 1;
12919                   break;
12920                 }
12921         }
12922     }
12923
12924   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12925      DIE for any block which contains no significant local declarations at
12926      all.  Rather, in such cases we just call `decls_for_scope' so that any
12927      needed Dwarf info for any sub-blocks will get properly generated. Note
12928      that in terse mode, our definition of what constitutes a "significant"
12929      local declaration gets restricted to include only inlined function
12930      instances and local (nested) function definitions.  */
12931   if (must_output_die)
12932     {
12933       if (origin_code == FUNCTION_DECL)
12934         gen_inlined_subroutine_die (stmt, context_die, depth);
12935       else
12936         gen_lexical_block_die (stmt, context_die, depth);
12937     }
12938   else
12939     decls_for_scope (stmt, context_die, depth);
12940 }
12941
12942 /* Generate all of the decls declared within a given scope and (recursively)
12943    all of its sub-blocks.  */
12944
12945 static void
12946 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12947 {
12948   tree decl;
12949   tree subblocks;
12950
12951   /* Ignore NULL blocks.  */
12952   if (stmt == NULL_TREE)
12953     return;
12954
12955   if (TREE_USED (stmt))
12956     {
12957       /* Output the DIEs to represent all of the data objects and typedefs
12958          declared directly within this block but not within any nested
12959          sub-blocks.  Also, nested function and tag DIEs have been
12960          generated with a parent of NULL; fix that up now.  */
12961       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12962         {
12963           dw_die_ref die;
12964
12965           if (TREE_CODE (decl) == FUNCTION_DECL)
12966             die = lookup_decl_die (decl);
12967           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12968             die = lookup_type_die (TREE_TYPE (decl));
12969           else
12970             die = NULL;
12971
12972           if (die != NULL && die->die_parent == NULL)
12973             add_child_die (context_die, die);
12974           /* Do not produce debug information for static variables since
12975              these might be optimized out.  We are called for these later
12976              in varpool_analyze_pending_decls. */
12977           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12978             ;
12979           else
12980             gen_decl_die (decl, context_die);
12981         }
12982     }
12983
12984   /* If we're at -g1, we're not interested in subblocks.  */
12985   if (debug_info_level <= DINFO_LEVEL_TERSE)
12986     return;
12987
12988   /* Output the DIEs to represent all sub-blocks (and the items declared
12989      therein) of this block.  */
12990   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12991        subblocks != NULL;
12992        subblocks = BLOCK_CHAIN (subblocks))
12993     gen_block_die (subblocks, context_die, depth + 1);
12994 }
12995
12996 /* Is this a typedef we can avoid emitting?  */
12997
12998 static inline int
12999 is_redundant_typedef (tree decl)
13000 {
13001   if (TYPE_DECL_IS_STUB (decl))
13002     return 1;
13003
13004   if (DECL_ARTIFICIAL (decl)
13005       && DECL_CONTEXT (decl)
13006       && is_tagged_type (DECL_CONTEXT (decl))
13007       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
13008       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
13009     /* Also ignore the artificial member typedef for the class name.  */
13010     return 1;
13011
13012   return 0;
13013 }
13014
13015 /* Returns the DIE for decl.  A DIE will always be returned.  */
13016
13017 static dw_die_ref
13018 force_decl_die (tree decl)
13019 {
13020   dw_die_ref decl_die;
13021   unsigned saved_external_flag;
13022   tree save_fn = NULL_TREE;
13023   decl_die = lookup_decl_die (decl);
13024   if (!decl_die)
13025     {
13026       dw_die_ref context_die;
13027       tree decl_context = DECL_CONTEXT (decl);
13028       if (decl_context)
13029         {
13030           /* Find die that represents this context.  */
13031           if (TYPE_P (decl_context))
13032             context_die = force_type_die (decl_context);
13033           else
13034             context_die = force_decl_die (decl_context);
13035         }
13036       else
13037         context_die = comp_unit_die;
13038
13039       decl_die = lookup_decl_die (decl);
13040       if (decl_die)
13041         return decl_die;
13042
13043       switch (TREE_CODE (decl))
13044         {
13045         case FUNCTION_DECL:
13046           /* Clear current_function_decl, so that gen_subprogram_die thinks
13047              that this is a declaration. At this point, we just want to force
13048              declaration die.  */
13049           save_fn = current_function_decl;
13050           current_function_decl = NULL_TREE;
13051           gen_subprogram_die (decl, context_die);
13052           current_function_decl = save_fn;
13053           break;
13054
13055         case VAR_DECL:
13056           /* Set external flag to force declaration die. Restore it after
13057            gen_decl_die() call.  */
13058           saved_external_flag = DECL_EXTERNAL (decl);
13059           DECL_EXTERNAL (decl) = 1;
13060           gen_decl_die (decl, context_die);
13061           DECL_EXTERNAL (decl) = saved_external_flag;
13062           break;
13063
13064         case NAMESPACE_DECL:
13065           dwarf2out_decl (decl);
13066           break;
13067
13068         default:
13069           gcc_unreachable ();
13070         }
13071
13072       /* We should be able to find the DIE now.  */
13073       if (!decl_die)
13074         decl_die = lookup_decl_die (decl);
13075       gcc_assert (decl_die);
13076     }
13077
13078   return decl_die;
13079 }
13080
13081 /* Returns the DIE for TYPE.  A DIE is always returned.  */
13082
13083 static dw_die_ref
13084 force_type_die (tree type)
13085 {
13086   dw_die_ref type_die;
13087
13088   type_die = lookup_type_die (type);
13089   if (!type_die)
13090     {
13091       dw_die_ref context_die;
13092       if (TYPE_CONTEXT (type))
13093         {
13094           if (TYPE_P (TYPE_CONTEXT (type)))
13095             context_die = force_type_die (TYPE_CONTEXT (type));
13096           else
13097             context_die = force_decl_die (TYPE_CONTEXT (type));
13098         }
13099       else
13100         context_die = comp_unit_die;
13101
13102       type_die = lookup_type_die (type);
13103       if (type_die)
13104         return type_die;
13105       gen_type_die (type, context_die);
13106       type_die = lookup_type_die (type);
13107       gcc_assert (type_die);
13108     }
13109   return type_die;
13110 }
13111
13112 /* Force out any required namespaces to be able to output DECL,
13113    and return the new context_die for it, if it's changed.  */
13114
13115 static dw_die_ref
13116 setup_namespace_context (tree thing, dw_die_ref context_die)
13117 {
13118   tree context = (DECL_P (thing)
13119                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13120   if (context && TREE_CODE (context) == NAMESPACE_DECL)
13121     /* Force out the namespace.  */
13122     context_die = force_decl_die (context);
13123
13124   return context_die;
13125 }
13126
13127 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
13128    type) within its namespace, if appropriate.
13129
13130    For compatibility with older debuggers, namespace DIEs only contain
13131    declarations; all definitions are emitted at CU scope.  */
13132
13133 static void
13134 declare_in_namespace (tree thing, dw_die_ref context_die)
13135 {
13136   dw_die_ref ns_context;
13137
13138   if (debug_info_level <= DINFO_LEVEL_TERSE)
13139     return;
13140
13141   /* If this decl is from an inlined function, then don't try to emit it in its
13142      namespace, as we will get confused.  It would have already been emitted
13143      when the abstract instance of the inline function was emitted anyways.  */
13144   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13145     return;
13146
13147   ns_context = setup_namespace_context (thing, context_die);
13148
13149   if (ns_context != context_die)
13150     {
13151       if (DECL_P (thing))
13152         gen_decl_die (thing, ns_context);
13153       else
13154         gen_type_die (thing, ns_context);
13155     }
13156 }
13157
13158 /* Generate a DIE for a namespace or namespace alias.  */
13159
13160 static void
13161 gen_namespace_die (tree decl)
13162 {
13163   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13164
13165   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13166      they are an alias of.  */
13167   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13168     {
13169       /* Output a real namespace.  */
13170       dw_die_ref namespace_die
13171         = new_die (DW_TAG_namespace, context_die, decl);
13172       add_name_and_src_coords_attributes (namespace_die, decl);
13173       equate_decl_number_to_die (decl, namespace_die);
13174     }
13175   else
13176     {
13177       /* Output a namespace alias.  */
13178
13179       /* Force out the namespace we are an alias of, if necessary.  */
13180       dw_die_ref origin_die
13181         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13182
13183       /* Now create the namespace alias DIE.  */
13184       dw_die_ref namespace_die
13185         = new_die (DW_TAG_imported_declaration, context_die, decl);
13186       add_name_and_src_coords_attributes (namespace_die, decl);
13187       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13188       equate_decl_number_to_die (decl, namespace_die);
13189     }
13190 }
13191
13192 /* Generate Dwarf debug information for a decl described by DECL.  */
13193
13194 static void
13195 gen_decl_die (tree decl, dw_die_ref context_die)
13196 {
13197   tree origin;
13198
13199   if (DECL_P (decl) && DECL_IGNORED_P (decl))
13200     return;
13201
13202   switch (TREE_CODE (decl))
13203     {
13204     case ERROR_MARK:
13205       break;
13206
13207     case CONST_DECL:
13208       /* The individual enumerators of an enum type get output when we output
13209          the Dwarf representation of the relevant enum type itself.  */
13210       break;
13211
13212     case FUNCTION_DECL:
13213       /* Don't output any DIEs to represent mere function declarations,
13214          unless they are class members or explicit block externs.  */
13215       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13216           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13217         break;
13218
13219 #if 0
13220       /* FIXME */
13221       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13222          on local redeclarations of global functions.  That seems broken.  */
13223       if (current_function_decl != decl)
13224         /* This is only a declaration.  */;
13225 #endif
13226
13227       /* If we're emitting a clone, emit info for the abstract instance.  */
13228       if (DECL_ORIGIN (decl) != decl)
13229         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13230
13231       /* If we're emitting an out-of-line copy of an inline function,
13232          emit info for the abstract instance and set up to refer to it.  */
13233       else if (cgraph_function_possibly_inlined_p (decl)
13234                && ! DECL_ABSTRACT (decl)
13235                && ! class_or_namespace_scope_p (context_die)
13236                /* dwarf2out_abstract_function won't emit a die if this is just
13237                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
13238                   that case, because that works only if we have a die.  */
13239                && DECL_INITIAL (decl) != NULL_TREE)
13240         {
13241           dwarf2out_abstract_function (decl);
13242           set_decl_origin_self (decl);
13243         }
13244
13245       /* Otherwise we're emitting the primary DIE for this decl.  */
13246       else if (debug_info_level > DINFO_LEVEL_TERSE)
13247         {
13248           /* Before we describe the FUNCTION_DECL itself, make sure that we
13249              have described its return type.  */
13250           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13251
13252           /* And its virtual context.  */
13253           if (DECL_VINDEX (decl) != NULL_TREE)
13254             gen_type_die (DECL_CONTEXT (decl), context_die);
13255
13256           /* And its containing type.  */
13257           origin = decl_class_context (decl);
13258           if (origin != NULL_TREE)
13259             gen_type_die_for_member (origin, decl, context_die);
13260
13261           /* And its containing namespace.  */
13262           declare_in_namespace (decl, context_die);
13263         }
13264
13265       /* Now output a DIE to represent the function itself.  */
13266       gen_subprogram_die (decl, context_die);
13267       break;
13268
13269     case TYPE_DECL:
13270       /* If we are in terse mode, don't generate any DIEs to represent any
13271          actual typedefs.  */
13272       if (debug_info_level <= DINFO_LEVEL_TERSE)
13273         break;
13274
13275       /* In the special case of a TYPE_DECL node representing the declaration
13276          of some type tag, if the given TYPE_DECL is marked as having been
13277          instantiated from some other (original) TYPE_DECL node (e.g. one which
13278          was generated within the original definition of an inline function) we
13279          have to generate a special (abbreviated) DW_TAG_structure_type,
13280          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13281       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13282         {
13283           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13284           break;
13285         }
13286
13287       if (is_redundant_typedef (decl))
13288         gen_type_die (TREE_TYPE (decl), context_die);
13289       else
13290         /* Output a DIE to represent the typedef itself.  */
13291         gen_typedef_die (decl, context_die);
13292       break;
13293
13294     case LABEL_DECL:
13295       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13296         gen_label_die (decl, context_die);
13297       break;
13298
13299     case VAR_DECL:
13300     case RESULT_DECL:
13301       /* If we are in terse mode, don't generate any DIEs to represent any
13302          variable declarations or definitions.  */
13303       if (debug_info_level <= DINFO_LEVEL_TERSE)
13304         break;
13305
13306       /* Output any DIEs that are needed to specify the type of this data
13307          object.  */
13308       gen_type_die (TREE_TYPE (decl), context_die);
13309
13310       /* And its containing type.  */
13311       origin = decl_class_context (decl);
13312       if (origin != NULL_TREE)
13313         gen_type_die_for_member (origin, decl, context_die);
13314
13315       /* And its containing namespace.  */
13316       declare_in_namespace (decl, context_die);
13317
13318       /* Now output the DIE to represent the data object itself.  This gets
13319          complicated because of the possibility that the VAR_DECL really
13320          represents an inlined instance of a formal parameter for an inline
13321          function.  */
13322       origin = decl_ultimate_origin (decl);
13323       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13324         gen_formal_parameter_die (decl, context_die);
13325       else
13326         gen_variable_die (decl, context_die);
13327       break;
13328
13329     case FIELD_DECL:
13330       /* Ignore the nameless fields that are used to skip bits but handle C++
13331          anonymous unions and structs.  */
13332       if (DECL_NAME (decl) != NULL_TREE
13333           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13334           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13335         {
13336           gen_type_die (member_declared_type (decl), context_die);
13337           gen_field_die (decl, context_die);
13338         }
13339       break;
13340
13341     case PARM_DECL:
13342       gen_type_die (TREE_TYPE (decl), context_die);
13343       gen_formal_parameter_die (decl, context_die);
13344       break;
13345
13346     case NAMESPACE_DECL:
13347       gen_namespace_die (decl);
13348       break;
13349
13350     default:
13351       /* Probably some frontend-internal decl.  Assume we don't care.  */
13352       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13353       break;
13354     }
13355 }
13356 \f
13357 /* Output debug information for global decl DECL.  Called from toplev.c after
13358    compilation proper has finished.  */
13359
13360 static void
13361 dwarf2out_global_decl (tree decl)
13362 {
13363   /* Output DWARF2 information for file-scope tentative data object
13364      declarations, file-scope (extern) function declarations (which had no
13365      corresponding body) and file-scope tagged type declarations and
13366      definitions which have not yet been forced out.  */
13367   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13368     dwarf2out_decl (decl);
13369 }
13370
13371 /* Output debug information for type decl DECL.  Called from toplev.c
13372    and from language front ends (to record built-in types).  */
13373 static void
13374 dwarf2out_type_decl (tree decl, int local)
13375 {
13376   if (!local)
13377     dwarf2out_decl (decl);
13378 }
13379
13380 /* Output debug information for imported module or decl.  */
13381
13382 static void
13383 dwarf2out_imported_module_or_decl (tree decl, tree context)
13384 {
13385   dw_die_ref imported_die, at_import_die;
13386   dw_die_ref scope_die;
13387   expanded_location xloc;
13388
13389   if (debug_info_level <= DINFO_LEVEL_TERSE)
13390     return;
13391
13392   gcc_assert (decl);
13393
13394   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13395      We need decl DIE for reference and scope die. First, get DIE for the decl
13396      itself.  */
13397
13398   /* Get the scope die for decl context. Use comp_unit_die for global module
13399      or decl. If die is not found for non globals, force new die.  */
13400   if (!context)
13401     scope_die = comp_unit_die;
13402   else if (TYPE_P (context))
13403     scope_die = force_type_die (context);
13404   else
13405     scope_die = force_decl_die (context);
13406
13407   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13408   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13409     at_import_die = force_type_die (TREE_TYPE (decl));
13410   else
13411     {
13412       at_import_die = lookup_decl_die (decl);
13413       if (!at_import_die)
13414         {
13415           /* If we're trying to avoid duplicate debug info, we may not have
13416              emitted the member decl for this field.  Emit it now.  */
13417           if (TREE_CODE (decl) == FIELD_DECL)
13418             {
13419               tree type = DECL_CONTEXT (decl);
13420               dw_die_ref type_context_die;
13421
13422               if (TYPE_CONTEXT (type))
13423                 if (TYPE_P (TYPE_CONTEXT (type)))
13424                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13425               else
13426                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13427               else
13428                 type_context_die = comp_unit_die;
13429               gen_type_die_for_member (type, decl, type_context_die);
13430             }
13431           at_import_die = force_decl_die (decl);
13432         }
13433     }
13434
13435   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13436   if (TREE_CODE (decl) == NAMESPACE_DECL)
13437     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13438   else
13439     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13440
13441   xloc = expand_location (input_location);
13442   add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13443   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13444   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13445 }
13446
13447 /* Write the debugging output for DECL.  */
13448
13449 void
13450 dwarf2out_decl (tree decl)
13451 {
13452   dw_die_ref context_die = comp_unit_die;
13453
13454   switch (TREE_CODE (decl))
13455     {
13456     case ERROR_MARK:
13457       return;
13458
13459     case FUNCTION_DECL:
13460       /* What we would really like to do here is to filter out all mere
13461          file-scope declarations of file-scope functions which are never
13462          referenced later within this translation unit (and keep all of ones
13463          that *are* referenced later on) but we aren't clairvoyant, so we have
13464          no idea which functions will be referenced in the future (i.e. later
13465          on within the current translation unit). So here we just ignore all
13466          file-scope function declarations which are not also definitions.  If
13467          and when the debugger needs to know something about these functions,
13468          it will have to hunt around and find the DWARF information associated
13469          with the definition of the function.
13470
13471          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13472          nodes represent definitions and which ones represent mere
13473          declarations.  We have to check DECL_INITIAL instead. That's because
13474          the C front-end supports some weird semantics for "extern inline"
13475          function definitions.  These can get inlined within the current
13476          translation unit (and thus, we need to generate Dwarf info for their
13477          abstract instances so that the Dwarf info for the concrete inlined
13478          instances can have something to refer to) but the compiler never
13479          generates any out-of-lines instances of such things (despite the fact
13480          that they *are* definitions).
13481
13482          The important point is that the C front-end marks these "extern
13483          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13484          them anyway. Note that the C++ front-end also plays some similar games
13485          for inline function definitions appearing within include files which
13486          also contain `#pragma interface' pragmas.  */
13487       if (DECL_INITIAL (decl) == NULL_TREE)
13488         return;
13489
13490       /* If we're a nested function, initially use a parent of NULL; if we're
13491          a plain function, this will be fixed up in decls_for_scope.  If
13492          we're a method, it will be ignored, since we already have a DIE.  */
13493       if (decl_function_context (decl)
13494           /* But if we're in terse mode, we don't care about scope.  */
13495           && debug_info_level > DINFO_LEVEL_TERSE)
13496         context_die = NULL;
13497       break;
13498
13499     case VAR_DECL:
13500       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13501          declaration and if the declaration was never even referenced from
13502          within this entire compilation unit.  We suppress these DIEs in
13503          order to save space in the .debug section (by eliminating entries
13504          which are probably useless).  Note that we must not suppress
13505          block-local extern declarations (whether used or not) because that
13506          would screw-up the debugger's name lookup mechanism and cause it to
13507          miss things which really ought to be in scope at a given point.  */
13508       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13509         return;
13510
13511       /* For local statics lookup proper context die.  */
13512       if (TREE_STATIC (decl) && decl_function_context (decl))
13513         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13514
13515       /* If we are in terse mode, don't generate any DIEs to represent any
13516          variable declarations or definitions.  */
13517       if (debug_info_level <= DINFO_LEVEL_TERSE)
13518         return;
13519       break;
13520
13521     case NAMESPACE_DECL:
13522       if (debug_info_level <= DINFO_LEVEL_TERSE)
13523         return;
13524       if (lookup_decl_die (decl) != NULL)
13525         return;
13526       break;
13527
13528     case TYPE_DECL:
13529       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13530       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13531         return;
13532
13533       /* Don't bother trying to generate any DIEs to represent any of the
13534          normal built-in types for the language we are compiling.  */
13535       if (DECL_IS_BUILTIN (decl))
13536         {
13537           /* OK, we need to generate one for `bool' so GDB knows what type
13538              comparisons have.  */
13539           if (is_cxx ()
13540               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13541               && ! DECL_IGNORED_P (decl))
13542             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13543
13544           return;
13545         }
13546
13547       /* If we are in terse mode, don't generate any DIEs for types.  */
13548       if (debug_info_level <= DINFO_LEVEL_TERSE)
13549         return;
13550
13551       /* If we're a function-scope tag, initially use a parent of NULL;
13552          this will be fixed up in decls_for_scope.  */
13553       if (decl_function_context (decl))
13554         context_die = NULL;
13555
13556       break;
13557
13558     default:
13559       return;
13560     }
13561
13562   gen_decl_die (decl, context_die);
13563 }
13564
13565 /* Output a marker (i.e. a label) for the beginning of the generated code for
13566    a lexical block.  */
13567
13568 static void
13569 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13570                        unsigned int blocknum)
13571 {
13572   switch_to_section (current_function_section ());
13573   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13574 }
13575
13576 /* Output a marker (i.e. a label) for the end of the generated code for a
13577    lexical block.  */
13578
13579 static void
13580 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13581 {
13582   switch_to_section (current_function_section ());
13583   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13584 }
13585
13586 /* Returns nonzero if it is appropriate not to emit any debugging
13587    information for BLOCK, because it doesn't contain any instructions.
13588
13589    Don't allow this for blocks with nested functions or local classes
13590    as we would end up with orphans, and in the presence of scheduling
13591    we may end up calling them anyway.  */
13592
13593 static bool
13594 dwarf2out_ignore_block (tree block)
13595 {
13596   tree decl;
13597
13598   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13599     if (TREE_CODE (decl) == FUNCTION_DECL
13600         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13601       return 0;
13602
13603   return 1;
13604 }
13605
13606 /* Hash table routines for file_hash.  */
13607
13608 static int
13609 file_table_eq (const void *p1_p, const void *p2_p)
13610 {
13611   const struct dwarf_file_data * p1 = p1_p;
13612   const char * p2 = p2_p;
13613   return strcmp (p1->filename, p2) == 0;
13614 }
13615
13616 static hashval_t
13617 file_table_hash (const void *p_p)
13618 {
13619   const struct dwarf_file_data * p = p_p;
13620   return htab_hash_string (p->filename);
13621 }
13622
13623 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13624    dwarf2out.c) and return its "index".  The index of each (known) filename is
13625    just a unique number which is associated with only that one filename.  We
13626    need such numbers for the sake of generating labels (in the .debug_sfnames
13627    section) and references to those files numbers (in the .debug_srcinfo
13628    and.debug_macinfo sections).  If the filename given as an argument is not
13629    found in our current list, add it to the list and assign it the next
13630    available unique index number.  In order to speed up searches, we remember
13631    the index of the filename was looked up last.  This handles the majority of
13632    all searches.  */
13633
13634 static struct dwarf_file_data *
13635 lookup_filename (const char *file_name)
13636 {
13637   void ** slot;
13638   struct dwarf_file_data * created;
13639
13640   /* Check to see if the file name that was searched on the previous
13641      call matches this file name.  If so, return the index.  */
13642   if (file_table_last_lookup
13643       && (file_name == file_table_last_lookup->filename
13644           || strcmp (file_table_last_lookup->filename, file_name) == 0))
13645     return file_table_last_lookup;
13646
13647   /* Didn't match the previous lookup, search the table.  */
13648   slot = htab_find_slot_with_hash (file_table, file_name,
13649                                    htab_hash_string (file_name), INSERT);
13650   if (*slot)
13651     return *slot;
13652
13653   created = ggc_alloc (sizeof (struct dwarf_file_data));
13654   created->filename = file_name;
13655   created->emitted_number = 0;
13656   *slot = created;
13657   return created;
13658 }
13659
13660 /* If the assembler will construct the file table, then translate the compiler
13661    internal file table number into the assembler file table number, and emit
13662    a .file directive if we haven't already emitted one yet.  The file table
13663    numbers are different because we prune debug info for unused variables and
13664    types, which may include filenames.  */
13665
13666 static int
13667 maybe_emit_file (struct dwarf_file_data * fd)
13668 {
13669   if (! fd->emitted_number)
13670     {
13671       if (last_emitted_file)
13672         fd->emitted_number = last_emitted_file->emitted_number + 1;
13673       else
13674         fd->emitted_number = 1;
13675       last_emitted_file = fd;
13676
13677       if (DWARF2_ASM_LINE_DEBUG_INFO)
13678         {
13679           fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
13680           output_quoted_string (asm_out_file, fd->filename);
13681           fputc ('\n', asm_out_file);
13682         }
13683     }
13684
13685   return fd->emitted_number;
13686 }
13687
13688 /* Called by the final INSN scan whenever we see a var location.  We
13689    use it to drop labels in the right places, and throw the location in
13690    our lookup table.  */
13691
13692 static void
13693 dwarf2out_var_location (rtx loc_note)
13694 {
13695   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13696   struct var_loc_node *newloc;
13697   rtx prev_insn;
13698   static rtx last_insn;
13699   static const char *last_label;
13700   tree decl;
13701
13702   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13703     return;
13704   prev_insn = PREV_INSN (loc_note);
13705
13706   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13707   /* If the insn we processed last time is the previous insn
13708      and it is also a var location note, use the label we emitted
13709      last time.  */
13710   if (last_insn != NULL_RTX
13711       && last_insn == prev_insn
13712       && NOTE_P (prev_insn)
13713       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13714     {
13715       newloc->label = last_label;
13716     }
13717   else
13718     {
13719       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13720       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13721       loclabel_num++;
13722       newloc->label = ggc_strdup (loclabel);
13723     }
13724   newloc->var_loc_note = loc_note;
13725   newloc->next = NULL;
13726
13727   if (cfun && in_cold_section_p)
13728     newloc->section_label = cfun->cold_section_label;
13729   else
13730     newloc->section_label = text_section_label;
13731
13732   last_insn = loc_note;
13733   last_label = newloc->label;
13734   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13735   add_var_loc_to_decl (decl, newloc);
13736 }
13737
13738 /* We need to reset the locations at the beginning of each
13739    function. We can't do this in the end_function hook, because the
13740    declarations that use the locations won't have been output when
13741    that hook is called.  Also compute have_multiple_function_sections here.  */
13742
13743 static void
13744 dwarf2out_begin_function (tree fun)
13745 {
13746   htab_empty (decl_loc_table);
13747
13748   if (function_section (fun) != text_section)
13749     have_multiple_function_sections = true;
13750 }
13751
13752 /* Output a label to mark the beginning of a source code line entry
13753    and record information relating to this source line, in
13754    'line_info_table' for later output of the .debug_line section.  */
13755
13756 static void
13757 dwarf2out_source_line (unsigned int line, const char *filename)
13758 {
13759   if (debug_info_level >= DINFO_LEVEL_NORMAL
13760       && line != 0)
13761     {
13762       int file_num = maybe_emit_file (lookup_filename (filename));
13763
13764       switch_to_section (current_function_section ());
13765
13766       /* If requested, emit something human-readable.  */
13767       if (flag_debug_asm)
13768         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13769                  filename, line);
13770
13771       if (DWARF2_ASM_LINE_DEBUG_INFO)
13772         {
13773           /* Emit the .loc directive understood by GNU as.  */
13774           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13775
13776           /* Indicate that line number info exists.  */
13777           line_info_table_in_use++;
13778         }
13779       else if (function_section (current_function_decl) != text_section)
13780         {
13781           dw_separate_line_info_ref line_info;
13782           targetm.asm_out.internal_label (asm_out_file,
13783                                           SEPARATE_LINE_CODE_LABEL,
13784                                           separate_line_info_table_in_use);
13785
13786           /* Expand the line info table if necessary.  */
13787           if (separate_line_info_table_in_use
13788               == separate_line_info_table_allocated)
13789             {
13790               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13791               separate_line_info_table
13792                 = ggc_realloc (separate_line_info_table,
13793                                separate_line_info_table_allocated
13794                                * sizeof (dw_separate_line_info_entry));
13795               memset (separate_line_info_table
13796                        + separate_line_info_table_in_use,
13797                       0,
13798                       (LINE_INFO_TABLE_INCREMENT
13799                        * sizeof (dw_separate_line_info_entry)));
13800             }
13801
13802           /* Add the new entry at the end of the line_info_table.  */
13803           line_info
13804             = &separate_line_info_table[separate_line_info_table_in_use++];
13805           line_info->dw_file_num = file_num;
13806           line_info->dw_line_num = line;
13807           line_info->function = current_function_funcdef_no;
13808         }
13809       else
13810         {
13811           dw_line_info_ref line_info;
13812
13813           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13814                                      line_info_table_in_use);
13815
13816           /* Expand the line info table if necessary.  */
13817           if (line_info_table_in_use == line_info_table_allocated)
13818             {
13819               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13820               line_info_table
13821                 = ggc_realloc (line_info_table,
13822                                (line_info_table_allocated
13823                                 * sizeof (dw_line_info_entry)));
13824               memset (line_info_table + line_info_table_in_use, 0,
13825                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13826             }
13827
13828           /* Add the new entry at the end of the line_info_table.  */
13829           line_info = &line_info_table[line_info_table_in_use++];
13830           line_info->dw_file_num = file_num;
13831           line_info->dw_line_num = line;
13832         }
13833     }
13834 }
13835
13836 /* Record the beginning of a new source file.  */
13837
13838 static void
13839 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13840 {
13841   if (flag_eliminate_dwarf2_dups)
13842     {
13843       /* Record the beginning of the file for break_out_includes.  */
13844       dw_die_ref bincl_die;
13845
13846       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13847       add_AT_string (bincl_die, DW_AT_name, filename);
13848     }
13849
13850   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13851     {
13852       int file_num = maybe_emit_file (lookup_filename (filename));
13853
13854       switch_to_section (debug_macinfo_section);
13855       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13856       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13857                                    lineno);
13858
13859       dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
13860     }
13861 }
13862
13863 /* Record the end of a source file.  */
13864
13865 static void
13866 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13867 {
13868   if (flag_eliminate_dwarf2_dups)
13869     /* Record the end of the file for break_out_includes.  */
13870     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13871
13872   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13873     {
13874       switch_to_section (debug_macinfo_section);
13875       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13876     }
13877 }
13878
13879 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13880    the tail part of the directive line, i.e. the part which is past the
13881    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13882
13883 static void
13884 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13885                   const char *buffer ATTRIBUTE_UNUSED)
13886 {
13887   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13888     {
13889       switch_to_section (debug_macinfo_section);
13890       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13891       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13892       dw2_asm_output_nstring (buffer, -1, "The macro");
13893     }
13894 }
13895
13896 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13897    the tail part of the directive line, i.e. the part which is past the
13898    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13899
13900 static void
13901 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13902                  const char *buffer ATTRIBUTE_UNUSED)
13903 {
13904   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13905     {
13906       switch_to_section (debug_macinfo_section);
13907       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13908       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13909       dw2_asm_output_nstring (buffer, -1, "The macro");
13910     }
13911 }
13912
13913 /* Set up for Dwarf output at the start of compilation.  */
13914
13915 static void
13916 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13917 {
13918   /* Allocate the file_table.  */
13919   file_table = htab_create_ggc (50, file_table_hash,
13920                                 file_table_eq, NULL);
13921
13922   /* Allocate the decl_die_table.  */
13923   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13924                                     decl_die_table_eq, NULL);
13925
13926   /* Allocate the decl_loc_table.  */
13927   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13928                                     decl_loc_table_eq, NULL);
13929
13930   /* Allocate the initial hunk of the decl_scope_table.  */
13931   decl_scope_table = VEC_alloc (tree, gc, 256);
13932
13933   /* Allocate the initial hunk of the abbrev_die_table.  */
13934   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13935                                         * sizeof (dw_die_ref));
13936   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13937   /* Zero-th entry is allocated, but unused.  */
13938   abbrev_die_table_in_use = 1;
13939
13940   /* Allocate the initial hunk of the line_info_table.  */
13941   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13942                                        * sizeof (dw_line_info_entry));
13943   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13944
13945   /* Zero-th entry is allocated, but unused.  */
13946   line_info_table_in_use = 1;
13947
13948   /* Allocate the pubtypes and pubnames vectors.  */
13949   pubname_table = VEC_alloc (pubname_entry, gc, 32);
13950   pubtype_table = VEC_alloc (pubname_entry, gc, 32);
13951
13952   /* Generate the initial DIE for the .debug section.  Note that the (string)
13953      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13954      will (typically) be a relative pathname and that this pathname should be
13955      taken as being relative to the directory from which the compiler was
13956      invoked when the given (base) source file was compiled.  We will fill
13957      in this value in dwarf2out_finish.  */
13958   comp_unit_die = gen_compile_unit_die (NULL);
13959
13960   incomplete_types = VEC_alloc (tree, gc, 64);
13961
13962   used_rtx_array = VEC_alloc (rtx, gc, 32);
13963
13964   debug_info_section = get_section (DEBUG_INFO_SECTION,
13965                                     SECTION_DEBUG, NULL);
13966   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13967                                       SECTION_DEBUG, NULL);
13968   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13969                                        SECTION_DEBUG, NULL);
13970   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13971                                        SECTION_DEBUG, NULL);
13972   debug_line_section = get_section (DEBUG_LINE_SECTION,
13973                                     SECTION_DEBUG, NULL);
13974   debug_loc_section = get_section (DEBUG_LOC_SECTION,
13975                                    SECTION_DEBUG, NULL);
13976   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13977                                         SECTION_DEBUG, NULL);
13978 #ifdef DEBUG_PUBTYPES_SECTION
13979   debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
13980                                         SECTION_DEBUG, NULL);
13981 #endif
13982   debug_str_section = get_section (DEBUG_STR_SECTION,
13983                                    DEBUG_STR_SECTION_FLAGS, NULL);
13984   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13985                                       SECTION_DEBUG, NULL);
13986   debug_frame_section = get_section (DEBUG_FRAME_SECTION,
13987                                      SECTION_DEBUG, NULL);
13988
13989   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13990   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13991                                DEBUG_ABBREV_SECTION_LABEL, 0);
13992   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13993   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13994                                COLD_TEXT_SECTION_LABEL, 0);
13995   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13996
13997   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13998                                DEBUG_INFO_SECTION_LABEL, 0);
13999   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
14000                                DEBUG_LINE_SECTION_LABEL, 0);
14001   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
14002                                DEBUG_RANGES_SECTION_LABEL, 0);
14003   switch_to_section (debug_abbrev_section);
14004   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
14005   switch_to_section (debug_info_section);
14006   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
14007   switch_to_section (debug_line_section);
14008   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
14009
14010   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14011     {
14012       switch_to_section (debug_macinfo_section);
14013       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
14014                                    DEBUG_MACINFO_SECTION_LABEL, 0);
14015       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
14016     }
14017
14018   switch_to_section (text_section);
14019   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
14020   if (flag_reorder_blocks_and_partition)
14021     {
14022       switch_to_section (unlikely_text_section ());
14023       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
14024     }
14025 }
14026
14027 /* A helper function for dwarf2out_finish called through
14028    ht_forall.  Emit one queued .debug_str string.  */
14029
14030 static int
14031 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
14032 {
14033   struct indirect_string_node *node = (struct indirect_string_node *) *h;
14034
14035   if (node->form == DW_FORM_strp)
14036     {
14037       switch_to_section (debug_str_section);
14038       ASM_OUTPUT_LABEL (asm_out_file, node->label);
14039       assemble_string (node->str, strlen (node->str) + 1);
14040     }
14041
14042   return 1;
14043 }
14044
14045 #if ENABLE_ASSERT_CHECKING
14046 /* Verify that all marks are clear.  */
14047
14048 static void
14049 verify_marks_clear (dw_die_ref die)
14050 {
14051   dw_die_ref c;
14052
14053   gcc_assert (! die->die_mark);
14054   FOR_EACH_CHILD (die, c, verify_marks_clear (c));
14055 }
14056 #endif /* ENABLE_ASSERT_CHECKING */
14057
14058 /* Clear the marks for a die and its children.
14059    Be cool if the mark isn't set.  */
14060
14061 static void
14062 prune_unmark_dies (dw_die_ref die)
14063 {
14064   dw_die_ref c;
14065
14066   if (die->die_mark)
14067     die->die_mark = 0;
14068   FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
14069 }
14070
14071 /* Given DIE that we're marking as used, find any other dies
14072    it references as attributes and mark them as used.  */
14073
14074 static void
14075 prune_unused_types_walk_attribs (dw_die_ref die)
14076 {
14077   dw_attr_ref a;
14078   unsigned ix;
14079
14080   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14081     {
14082       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14083         {
14084           /* A reference to another DIE.
14085              Make sure that it will get emitted.  */
14086           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14087         }
14088       /* Set the string's refcount to 0 so that prune_unused_types_mark
14089          accounts properly for it.  */
14090       if (AT_class (a) == dw_val_class_str)
14091         a->dw_attr_val.v.val_str->refcount = 0;
14092     }
14093 }
14094
14095
14096 /* Mark DIE as being used.  If DOKIDS is true, then walk down
14097    to DIE's children.  */
14098
14099 static void
14100 prune_unused_types_mark (dw_die_ref die, int dokids)
14101 {
14102   dw_die_ref c;
14103
14104   if (die->die_mark == 0)
14105     {
14106       /* We haven't done this node yet.  Mark it as used.  */
14107       die->die_mark = 1;
14108
14109       /* We also have to mark its parents as used.
14110          (But we don't want to mark our parents' kids due to this.)  */
14111       if (die->die_parent)
14112         prune_unused_types_mark (die->die_parent, 0);
14113
14114       /* Mark any referenced nodes.  */
14115       prune_unused_types_walk_attribs (die);
14116
14117       /* If this node is a specification,
14118          also mark the definition, if it exists.  */
14119       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14120         prune_unused_types_mark (die->die_definition, 1);
14121     }
14122
14123   if (dokids && die->die_mark != 2)
14124     {
14125       /* We need to walk the children, but haven't done so yet.
14126          Remember that we've walked the kids.  */
14127       die->die_mark = 2;
14128
14129       /* If this is an array type, we need to make sure our
14130          kids get marked, even if they're types.  */
14131       if (die->die_tag == DW_TAG_array_type)
14132         FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14133       else
14134         FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14135     }
14136 }
14137
14138
14139 /* Walk the tree DIE and mark types that we actually use.  */
14140
14141 static void
14142 prune_unused_types_walk (dw_die_ref die)
14143 {
14144   dw_die_ref c;
14145
14146   /* Don't do anything if this node is already marked.  */
14147   if (die->die_mark)
14148     return;
14149
14150   switch (die->die_tag)
14151     {
14152     case DW_TAG_const_type:
14153     case DW_TAG_packed_type:
14154     case DW_TAG_pointer_type:
14155     case DW_TAG_reference_type:
14156     case DW_TAG_volatile_type:
14157     case DW_TAG_typedef:
14158     case DW_TAG_array_type:
14159     case DW_TAG_structure_type:
14160     case DW_TAG_union_type:
14161     case DW_TAG_class_type:
14162     case DW_TAG_friend:
14163     case DW_TAG_variant_part:
14164     case DW_TAG_enumeration_type:
14165     case DW_TAG_subroutine_type:
14166     case DW_TAG_string_type:
14167     case DW_TAG_set_type:
14168     case DW_TAG_subrange_type:
14169     case DW_TAG_ptr_to_member_type:
14170     case DW_TAG_file_type:
14171       if (die->die_perennial_p)
14172         break;
14173
14174       /* It's a type node --- don't mark it.  */
14175       return;
14176
14177     default:
14178       /* Mark everything else.  */
14179       break;
14180   }
14181
14182   die->die_mark = 1;
14183
14184   /* Now, mark any dies referenced from here.  */
14185   prune_unused_types_walk_attribs (die);
14186
14187   /* Mark children.  */
14188   FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14189 }
14190
14191 /* Increment the string counts on strings referred to from DIE's
14192    attributes.  */
14193
14194 static void
14195 prune_unused_types_update_strings (dw_die_ref die)
14196 {
14197   dw_attr_ref a;
14198   unsigned ix;
14199
14200   for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14201     if (AT_class (a) == dw_val_class_str)
14202       {
14203         struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14204         s->refcount++;
14205         /* Avoid unnecessarily putting strings that are used less than
14206            twice in the hash table.  */
14207         if (s->refcount
14208             == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14209           {
14210             void ** slot;
14211             slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14212                                              htab_hash_string (s->str),
14213                                              INSERT);
14214             gcc_assert (*slot == NULL);
14215             *slot = s;
14216           }
14217       }
14218 }
14219
14220 /* Remove from the tree DIE any dies that aren't marked.  */
14221
14222 static void
14223 prune_unused_types_prune (dw_die_ref die)
14224 {
14225   dw_die_ref c;
14226
14227   gcc_assert (die->die_mark);
14228   prune_unused_types_update_strings (die);
14229
14230   if (! die->die_child)
14231     return;
14232
14233   c = die->die_child;
14234   do {
14235     dw_die_ref prev = c;
14236     for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14237       if (c == die->die_child)
14238         {
14239           /* No marked children between 'prev' and the end of the list.  */
14240           if (prev == c)
14241             /* No marked children at all.  */
14242             die->die_child = NULL;
14243           else
14244             {
14245               prev->die_sib = c->die_sib;
14246               die->die_child = prev;
14247             }
14248           return;
14249         }
14250
14251     if (c != prev->die_sib)
14252       prev->die_sib = c;
14253     prune_unused_types_prune (c);
14254   } while (c != die->die_child);
14255 }
14256
14257
14258 /* Remove dies representing declarations that we never use.  */
14259
14260 static void
14261 prune_unused_types (void)
14262 {
14263   unsigned int i;
14264   limbo_die_node *node;
14265   pubname_ref pub;
14266
14267 #if ENABLE_ASSERT_CHECKING
14268   /* All the marks should already be clear.  */
14269   verify_marks_clear (comp_unit_die);
14270   for (node = limbo_die_list; node; node = node->next)
14271     verify_marks_clear (node->die);
14272 #endif /* ENABLE_ASSERT_CHECKING */
14273
14274   /* Set the mark on nodes that are actually used.  */
14275   prune_unused_types_walk (comp_unit_die);
14276   for (node = limbo_die_list; node; node = node->next)
14277     prune_unused_types_walk (node->die);
14278
14279   /* Also set the mark on nodes referenced from the
14280      pubname_table or arange_table.  */
14281   for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
14282     prune_unused_types_mark (pub->die, 1);
14283   for (i = 0; i < arange_table_in_use; i++)
14284     prune_unused_types_mark (arange_table[i], 1);
14285
14286   /* Get rid of nodes that aren't marked; and update the string counts.  */
14287   if (debug_str_hash)
14288     htab_empty (debug_str_hash);
14289   prune_unused_types_prune (comp_unit_die);
14290   for (node = limbo_die_list; node; node = node->next)
14291     prune_unused_types_prune (node->die);
14292
14293   /* Leave the marks clear.  */
14294   prune_unmark_dies (comp_unit_die);
14295   for (node = limbo_die_list; node; node = node->next)
14296     prune_unmark_dies (node->die);
14297 }
14298
14299 /* Set the parameter to true if there are any relative pathnames in
14300    the file table.  */
14301 static int
14302 file_table_relative_p (void ** slot, void *param)
14303 {
14304   bool *p = param;
14305   struct dwarf_file_data *d = *slot;
14306   if (d->emitted_number && !IS_ABSOLUTE_PATH (d->filename))
14307     {
14308       *p = true;
14309       return 0;
14310     }
14311   return 1;
14312 }
14313
14314 /* Output stuff that dwarf requires at the end of every file,
14315    and generate the DWARF-2 debugging info.  */
14316
14317 static void
14318 dwarf2out_finish (const char *filename)
14319 {
14320   limbo_die_node *node, *next_node;
14321   dw_die_ref die = 0;
14322
14323   /* Add the name for the main input file now.  We delayed this from
14324      dwarf2out_init to avoid complications with PCH.  */
14325   add_name_attribute (comp_unit_die, filename);
14326   if (!IS_ABSOLUTE_PATH (filename))
14327     add_comp_dir_attribute (comp_unit_die);
14328   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14329     {
14330       bool p = false;
14331       htab_traverse (file_table, file_table_relative_p, &p);
14332       if (p)
14333         add_comp_dir_attribute (comp_unit_die);
14334     }
14335
14336   /* Traverse the limbo die list, and add parent/child links.  The only
14337      dies without parents that should be here are concrete instances of
14338      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14339      For concrete instances, we can get the parent die from the abstract
14340      instance.  */
14341   for (node = limbo_die_list; node; node = next_node)
14342     {
14343       next_node = node->next;
14344       die = node->die;
14345
14346       if (die->die_parent == NULL)
14347         {
14348           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14349
14350           if (origin)
14351             add_child_die (origin->die_parent, die);
14352           else if (die == comp_unit_die)
14353             ;
14354           else if (errorcount > 0 || sorrycount > 0)
14355             /* It's OK to be confused by errors in the input.  */
14356             add_child_die (comp_unit_die, die);
14357           else
14358             {
14359               /* In certain situations, the lexical block containing a
14360                  nested function can be optimized away, which results
14361                  in the nested function die being orphaned.  Likewise
14362                  with the return type of that nested function.  Force
14363                  this to be a child of the containing function.
14364
14365                  It may happen that even the containing function got fully
14366                  inlined and optimized out.  In that case we are lost and
14367                  assign the empty child.  This should not be big issue as
14368                  the function is likely unreachable too.  */
14369               tree context = NULL_TREE;
14370
14371               gcc_assert (node->created_for);
14372
14373               if (DECL_P (node->created_for))
14374                 context = DECL_CONTEXT (node->created_for);
14375               else if (TYPE_P (node->created_for))
14376                 context = TYPE_CONTEXT (node->created_for);
14377
14378               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14379
14380               origin = lookup_decl_die (context);
14381               if (origin)
14382                 add_child_die (origin, die);
14383               else
14384                 add_child_die (comp_unit_die, die);
14385             }
14386         }
14387     }
14388
14389   limbo_die_list = NULL;
14390
14391   /* Walk through the list of incomplete types again, trying once more to
14392      emit full debugging info for them.  */
14393   retry_incomplete_types ();
14394
14395   if (flag_eliminate_unused_debug_types)
14396     prune_unused_types ();
14397
14398   /* Generate separate CUs for each of the include files we've seen.
14399      They will go into limbo_die_list.  */
14400   if (flag_eliminate_dwarf2_dups)
14401     break_out_includes (comp_unit_die);
14402
14403   /* Traverse the DIE's and add add sibling attributes to those DIE's
14404      that have children.  */
14405   add_sibling_attributes (comp_unit_die);
14406   for (node = limbo_die_list; node; node = node->next)
14407     add_sibling_attributes (node->die);
14408
14409   /* Output a terminator label for the .text section.  */
14410   switch_to_section (text_section);
14411   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14412   if (flag_reorder_blocks_and_partition)
14413     {
14414       switch_to_section (unlikely_text_section ());
14415       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14416     }
14417
14418   /* We can only use the low/high_pc attributes if all of the code was
14419      in .text.  */
14420   if (!have_multiple_function_sections)
14421     {
14422       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14423       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14424     }
14425
14426   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14427      "base address".  Use zero so that these addresses become absolute.  */
14428   else if (have_location_lists || ranges_table_in_use)
14429     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14430
14431   /* Output location list section if necessary.  */
14432   if (have_location_lists)
14433     {
14434       /* Output the location lists info.  */
14435       switch_to_section (debug_loc_section);
14436       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14437                                    DEBUG_LOC_SECTION_LABEL, 0);
14438       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14439       output_location_lists (die);
14440     }
14441
14442   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14443     add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14444                     debug_line_section_label);
14445
14446   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14447     add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14448
14449   /* Output all of the compilation units.  We put the main one last so that
14450      the offsets are available to output_pubnames.  */
14451   for (node = limbo_die_list; node; node = node->next)
14452     output_comp_unit (node->die, 0);
14453
14454   output_comp_unit (comp_unit_die, 0);
14455
14456   /* Output the abbreviation table.  */
14457   switch_to_section (debug_abbrev_section);
14458   output_abbrev_section ();
14459
14460   /* Output public names table if necessary.  */
14461   if (!VEC_empty (pubname_entry, pubname_table))
14462     {
14463       switch_to_section (debug_pubnames_section);
14464       output_pubnames (pubname_table);
14465     }
14466
14467 #ifdef DEBUG_PUBTYPES_SECTION
14468   /* Output public types table if necessary.  */
14469   if (!VEC_empty (pubname_entry, pubtype_table))
14470     {
14471       switch_to_section (debug_pubtypes_section);
14472       output_pubnames (pubtype_table);
14473     }
14474 #endif
14475
14476   /* Output the address range information.  We only put functions in the arange
14477      table, so don't write it out if we don't have any.  */
14478   if (fde_table_in_use)
14479     {
14480       switch_to_section (debug_aranges_section);
14481       output_aranges ();
14482     }
14483
14484   /* Output ranges section if necessary.  */
14485   if (ranges_table_in_use)
14486     {
14487       switch_to_section (debug_ranges_section);
14488       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14489       output_ranges ();
14490     }
14491
14492   /* Output the source line correspondence table.  We must do this
14493      even if there is no line information.  Otherwise, on an empty
14494      translation unit, we will generate a present, but empty,
14495      .debug_info section.  IRIX 6.5 `nm' will then complain when
14496      examining the file.  This is done late so that any filenames
14497      used by the debug_info section are marked as 'used'.  */
14498   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14499     {
14500       switch_to_section (debug_line_section);
14501       output_line_info ();
14502     }
14503
14504   /* Have to end the macro section.  */
14505   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14506     {
14507       switch_to_section (debug_macinfo_section);
14508       dw2_asm_output_data (1, 0, "End compilation unit");
14509     }
14510
14511   /* If we emitted any DW_FORM_strp form attribute, output the string
14512      table too.  */
14513   if (debug_str_hash)
14514     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14515 }
14516 #else
14517
14518 /* This should never be used, but its address is needed for comparisons.  */
14519 const struct gcc_debug_hooks dwarf2_debug_hooks;
14520
14521 #endif /* DWARF2_DEBUGGING_INFO */
14522
14523 #include "gt-dwarf2out.h"