gcc/dwarf2out.c

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