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 = XNEWVEC (char, 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 = XCNEW (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 CHAR_TYPE:
8101     case INTEGER_TYPE:
8102       if (TYPE_STRING_FLAG (type))
8103         {
8104           if (TYPE_UNSIGNED (type))
8105             encoding = DW_ATE_unsigned_char;
8106           else
8107             encoding = DW_ATE_signed_char;
8108         }
8109       else if (TYPE_UNSIGNED (type))
8110         encoding = DW_ATE_unsigned;
8111       else
8112         encoding = DW_ATE_signed;
8113       break;
8114
8115     case REAL_TYPE:
8116       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8117         encoding = DW_ATE_decimal_float;
8118       else
8119         encoding = DW_ATE_float;
8120       break;
8121
8122       /* Dwarf2 doesn't know anything about complex ints, so use
8123          a user defined type for it.  */
8124     case COMPLEX_TYPE:
8125       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8126         encoding = DW_ATE_complex_float;
8127       else
8128         encoding = DW_ATE_lo_user;
8129       break;
8130
8131     case BOOLEAN_TYPE:
8132       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8133       encoding = DW_ATE_boolean;
8134       break;
8135
8136     default:
8137       /* No other TREE_CODEs are Dwarf fundamental types.  */
8138       gcc_unreachable ();
8139     }
8140
8141   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8142   if (demangle_name_func)
8143     type_name = (*demangle_name_func) (type_name);
8144
8145   add_AT_string (base_type_result, DW_AT_name, type_name);
8146   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8147                    int_size_in_bytes (type));
8148   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8149
8150   return base_type_result;
8151 }
8152
8153 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8154    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
8155    a given type is generally the same as the given type, except that if the
8156    given type is a pointer or reference type, then the root type of the given
8157    type is the root type of the "basis" type for the pointer or reference
8158    type.  (This definition of the "root" type is recursive.) Also, the root
8159    type of a `const' qualified type or a `volatile' qualified type is the
8160    root type of the given type without the qualifiers.  */
8161
8162 static tree
8163 root_type (tree type)
8164 {
8165   if (TREE_CODE (type) == ERROR_MARK)
8166     return error_mark_node;
8167
8168   switch (TREE_CODE (type))
8169     {
8170     case ERROR_MARK:
8171       return error_mark_node;
8172
8173     case POINTER_TYPE:
8174     case REFERENCE_TYPE:
8175       return type_main_variant (root_type (TREE_TYPE (type)));
8176
8177     default:
8178       return type_main_variant (type);
8179     }
8180 }
8181
8182 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8183    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8184
8185 static inline int
8186 is_base_type (tree type)
8187 {
8188   switch (TREE_CODE (type))
8189     {
8190     case ERROR_MARK:
8191     case VOID_TYPE:
8192     case INTEGER_TYPE:
8193     case REAL_TYPE:
8194     case COMPLEX_TYPE:
8195     case BOOLEAN_TYPE:
8196     case CHAR_TYPE:
8197       return 1;
8198
8199     case ARRAY_TYPE:
8200     case RECORD_TYPE:
8201     case UNION_TYPE:
8202     case QUAL_UNION_TYPE:
8203     case ENUMERAL_TYPE:
8204     case FUNCTION_TYPE:
8205     case METHOD_TYPE:
8206     case POINTER_TYPE:
8207     case REFERENCE_TYPE:
8208     case OFFSET_TYPE:
8209     case LANG_TYPE:
8210     case VECTOR_TYPE:
8211       return 0;
8212
8213     default:
8214       gcc_unreachable ();
8215     }
8216
8217   return 0;
8218 }
8219
8220 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8221    node, return the size in bits for the type if it is a constant, or else
8222    return the alignment for the type if the type's size is not constant, or
8223    else return BITS_PER_WORD if the type actually turns out to be an
8224    ERROR_MARK node.  */
8225
8226 static inline unsigned HOST_WIDE_INT
8227 simple_type_size_in_bits (tree type)
8228 {
8229   if (TREE_CODE (type) == ERROR_MARK)
8230     return BITS_PER_WORD;
8231   else if (TYPE_SIZE (type) == NULL_TREE)
8232     return 0;
8233   else if (host_integerp (TYPE_SIZE (type), 1))
8234     return tree_low_cst (TYPE_SIZE (type), 1);
8235   else
8236     return TYPE_ALIGN (type);
8237 }
8238
8239 /* Return true if the debug information for the given type should be
8240    emitted as a subrange type.  */
8241
8242 static inline bool
8243 is_subrange_type (tree type)
8244 {
8245   tree subtype = TREE_TYPE (type);
8246
8247   /* Subrange types are identified by the fact that they are integer
8248      types, and that they have a subtype which is either an integer type
8249      or an enumeral type.  */
8250
8251   if (TREE_CODE (type) != INTEGER_TYPE
8252       || subtype == NULL_TREE)
8253     return false;
8254
8255   if (TREE_CODE (subtype) != INTEGER_TYPE
8256       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8257     return false;
8258
8259   if (TREE_CODE (type) == TREE_CODE (subtype)
8260       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8261       && TYPE_MIN_VALUE (type) != NULL
8262       && TYPE_MIN_VALUE (subtype) != NULL
8263       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8264       && TYPE_MAX_VALUE (type) != NULL
8265       && TYPE_MAX_VALUE (subtype) != NULL
8266       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8267     {
8268       /* The type and its subtype have the same representation.  If in
8269          addition the two types also have the same name, then the given
8270          type is not a subrange type, but rather a plain base type.  */
8271       /* FIXME: brobecker/2004-03-22:
8272          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8273          therefore be sufficient to check the TYPE_SIZE node pointers
8274          rather than checking the actual size.  Unfortunately, we have
8275          found some cases, such as in the Ada "integer" type, where
8276          this is not the case.  Until this problem is solved, we need to
8277          keep checking the actual size.  */
8278       tree type_name = TYPE_NAME (type);
8279       tree subtype_name = TYPE_NAME (subtype);
8280
8281       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8282         type_name = DECL_NAME (type_name);
8283
8284       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8285         subtype_name = DECL_NAME (subtype_name);
8286
8287       if (type_name == subtype_name)
8288         return false;
8289     }
8290
8291   return true;
8292 }
8293
8294 /*  Given a pointer to a tree node for a subrange type, return a pointer
8295     to a DIE that describes the given type.  */
8296
8297 static dw_die_ref
8298 subrange_type_die (tree type, dw_die_ref context_die)
8299 {
8300   dw_die_ref subtype_die;
8301   dw_die_ref subrange_die;
8302   tree name = TYPE_NAME (type);
8303   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8304   tree subtype = TREE_TYPE (type);
8305
8306   if (context_die == NULL)
8307     context_die = comp_unit_die;
8308
8309   if (TREE_CODE (subtype) == ENUMERAL_TYPE)
8310     subtype_die = gen_enumeration_type_die (subtype, context_die);
8311   else
8312     subtype_die = base_type_die (subtype);
8313
8314   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8315
8316   if (name != NULL)
8317     {
8318       if (TREE_CODE (name) == TYPE_DECL)
8319         name = DECL_NAME (name);
8320       add_name_attribute (subrange_die, IDENTIFIER_POINTER (name));
8321     }
8322
8323   if (int_size_in_bytes (subtype) != size_in_bytes)
8324     {
8325       /* The size of the subrange type and its base type do not match,
8326          so we need to generate a size attribute for the subrange type.  */
8327       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8328     }
8329
8330   if (TYPE_MIN_VALUE (type) != NULL)
8331     add_bound_info (subrange_die, DW_AT_lower_bound,
8332                     TYPE_MIN_VALUE (type));
8333   if (TYPE_MAX_VALUE (type) != NULL)
8334     add_bound_info (subrange_die, DW_AT_upper_bound,
8335                     TYPE_MAX_VALUE (type));
8336   add_AT_die_ref (subrange_die, DW_AT_type, subtype_die);
8337
8338   return subrange_die;
8339 }
8340
8341 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8342    entry that chains various modifiers in front of the given type.  */
8343
8344 static dw_die_ref
8345 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8346                    dw_die_ref context_die)
8347 {
8348   enum tree_code code = TREE_CODE (type);
8349   dw_die_ref mod_type_die = NULL;
8350   dw_die_ref sub_die = NULL;
8351   tree item_type = NULL;
8352
8353   if (code != ERROR_MARK)
8354     {
8355       tree qualified_type;
8356
8357       /* See if we already have the appropriately qualified variant of
8358          this type.  */
8359       qualified_type
8360         = get_qualified_type (type,
8361                               ((is_const_type ? TYPE_QUAL_CONST : 0)
8362                                | (is_volatile_type
8363                                   ? TYPE_QUAL_VOLATILE : 0)));
8364
8365       /* If we do, then we can just use its DIE, if it exists.  */
8366       if (qualified_type)
8367         {
8368           mod_type_die = lookup_type_die (qualified_type);
8369           if (mod_type_die)
8370             return mod_type_die;
8371         }
8372
8373       /* Handle C typedef types.  */
8374       if (qualified_type && TYPE_NAME (qualified_type)
8375           && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
8376           && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
8377         {
8378           tree type_name = TYPE_NAME (qualified_type);
8379           tree dtype = TREE_TYPE (type_name);
8380
8381           if (qualified_type == dtype)
8382             {
8383               /* For a named type, use the typedef.  */
8384               gen_type_die (qualified_type, context_die);
8385               mod_type_die = lookup_type_die (qualified_type);
8386             }
8387           else if (is_const_type < TYPE_READONLY (dtype)
8388                    || is_volatile_type < TYPE_VOLATILE (dtype))
8389             /* cv-unqualified version of named type.  Just use the unnamed
8390                type to which it refers.  */
8391             mod_type_die
8392               = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
8393                                    is_const_type, is_volatile_type,
8394                                    context_die);
8395
8396           /* Else cv-qualified version of named type; fall through.  */
8397         }
8398
8399       if (mod_type_die)
8400         /* OK.  */
8401         ;
8402       else if (is_const_type)
8403         {
8404           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8405           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8406         }
8407       else if (is_volatile_type)
8408         {
8409           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8410           sub_die = modified_type_die (type, 0, 0, context_die);
8411         }
8412       else if (code == POINTER_TYPE)
8413         {
8414           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8415           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8416                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8417 #if 0
8418           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8419 #endif
8420           item_type = TREE_TYPE (type);
8421         }
8422       else if (code == REFERENCE_TYPE)
8423         {
8424           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8425           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8426                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8427 #if 0
8428           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8429 #endif
8430           item_type = TREE_TYPE (type);
8431         }
8432       else if (is_subrange_type (type))
8433         mod_type_die = subrange_type_die (type, context_die);
8434       else if (is_base_type (type))
8435         mod_type_die = base_type_die (type);
8436       else
8437         {
8438           gen_type_die (type, context_die);
8439
8440           /* We have to get the type_main_variant here (and pass that to the
8441              `lookup_type_die' routine) because the ..._TYPE node we have
8442              might simply be a *copy* of some original type node (where the
8443              copy was created to help us keep track of typedef names) and
8444              that copy might have a different TYPE_UID from the original
8445              ..._TYPE node.  */
8446           if (TREE_CODE (type) != VECTOR_TYPE)
8447             mod_type_die = lookup_type_die (type_main_variant (type));
8448           else
8449             /* Vectors have the debugging information in the type,
8450                not the main variant.  */
8451             mod_type_die = lookup_type_die (type);
8452           gcc_assert (mod_type_die);
8453         }
8454
8455       /* We want to equate the qualified type to the die below.  */
8456       type = qualified_type;
8457     }
8458
8459   if (type)
8460     equate_type_number_to_die (type, mod_type_die);
8461   if (item_type)
8462     /* We must do this after the equate_type_number_to_die call, in case
8463        this is a recursive type.  This ensures that the modified_type_die
8464        recursion will terminate even if the type is recursive.  Recursive
8465        types are possible in Ada.  */
8466     sub_die = modified_type_die (item_type,
8467                                  TYPE_READONLY (item_type),
8468                                  TYPE_VOLATILE (item_type),
8469                                  context_die);
8470
8471   if (sub_die != NULL)
8472     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8473
8474   return mod_type_die;
8475 }
8476
8477 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8478    an enumerated type.  */
8479
8480 static inline int
8481 type_is_enum (tree type)
8482 {
8483   return TREE_CODE (type) == ENUMERAL_TYPE;
8484 }
8485
8486 /* Return the DBX register number described by a given RTL node.  */
8487
8488 static unsigned int
8489 dbx_reg_number (rtx rtl)
8490 {
8491   unsigned regno = REGNO (rtl);
8492
8493   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8494
8495 #ifdef LEAF_REG_REMAP
8496   regno = LEAF_REG_REMAP (regno);
8497 #endif
8498
8499   return DBX_REGISTER_NUMBER (regno);
8500 }
8501
8502 /* Optionally add a DW_OP_piece term to a location description expression.
8503    DW_OP_piece is only added if the location description expression already
8504    doesn't end with DW_OP_piece.  */
8505
8506 static void
8507 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8508 {
8509   dw_loc_descr_ref loc;
8510
8511   if (*list_head != NULL)
8512     {
8513       /* Find the end of the chain.  */
8514       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8515         ;
8516
8517       if (loc->dw_loc_opc != DW_OP_piece)
8518         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8519     }
8520 }
8521
8522 /* Return a location descriptor that designates a machine register or
8523    zero if there is none.  */
8524
8525 static dw_loc_descr_ref
8526 reg_loc_descriptor (rtx rtl)
8527 {
8528   rtx regs;
8529
8530   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8531     return 0;
8532
8533   regs = targetm.dwarf_register_span (rtl);
8534
8535   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8536     return multiple_reg_loc_descriptor (rtl, regs);
8537   else
8538     return one_reg_loc_descriptor (dbx_reg_number (rtl));
8539 }
8540
8541 /* Return a location descriptor that designates a machine register for
8542    a given hard register number.  */
8543
8544 static dw_loc_descr_ref
8545 one_reg_loc_descriptor (unsigned int regno)
8546 {
8547   if (regno <= 31)
8548     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8549   else
8550     return new_loc_descr (DW_OP_regx, regno, 0);
8551 }
8552
8553 /* Given an RTL of a register, return a location descriptor that
8554    designates a value that spans more than one register.  */
8555
8556 static dw_loc_descr_ref
8557 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8558 {
8559   int nregs, size, i;
8560   unsigned reg;
8561   dw_loc_descr_ref loc_result = NULL;
8562
8563   reg = REGNO (rtl);
8564 #ifdef LEAF_REG_REMAP
8565   reg = LEAF_REG_REMAP (reg);
8566 #endif
8567   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8568   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8569
8570   /* Simple, contiguous registers.  */
8571   if (regs == NULL_RTX)
8572     {
8573       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8574
8575       loc_result = NULL;
8576       while (nregs--)
8577         {
8578           dw_loc_descr_ref t;
8579
8580           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8581           add_loc_descr (&loc_result, t);
8582           add_loc_descr_op_piece (&loc_result, size);
8583           ++reg;
8584         }
8585       return loc_result;
8586     }
8587
8588   /* Now onto stupid register sets in non contiguous locations.  */
8589
8590   gcc_assert (GET_CODE (regs) == PARALLEL);
8591
8592   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8593   loc_result = NULL;
8594
8595   for (i = 0; i < XVECLEN (regs, 0); ++i)
8596     {
8597       dw_loc_descr_ref t;
8598
8599       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8600       add_loc_descr (&loc_result, t);
8601       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8602       add_loc_descr_op_piece (&loc_result, size);
8603     }
8604   return loc_result;
8605 }
8606
8607 /* Return a location descriptor that designates a constant.  */
8608
8609 static dw_loc_descr_ref
8610 int_loc_descriptor (HOST_WIDE_INT i)
8611 {
8612   enum dwarf_location_atom op;
8613
8614   /* Pick the smallest representation of a constant, rather than just
8615      defaulting to the LEB encoding.  */
8616   if (i >= 0)
8617     {
8618       if (i <= 31)
8619         op = DW_OP_lit0 + i;
8620       else if (i <= 0xff)
8621         op = DW_OP_const1u;
8622       else if (i <= 0xffff)
8623         op = DW_OP_const2u;
8624       else if (HOST_BITS_PER_WIDE_INT == 32
8625                || i <= 0xffffffff)
8626         op = DW_OP_const4u;
8627       else
8628         op = DW_OP_constu;
8629     }
8630   else
8631     {
8632       if (i >= -0x80)
8633         op = DW_OP_const1s;
8634       else if (i >= -0x8000)
8635         op = DW_OP_const2s;
8636       else if (HOST_BITS_PER_WIDE_INT == 32
8637                || i >= -0x80000000)
8638         op = DW_OP_const4s;
8639       else
8640         op = DW_OP_consts;
8641     }
8642
8643   return new_loc_descr (op, i, 0);
8644 }
8645
8646 /* Return a location descriptor that designates a base+offset location.  */
8647
8648 static dw_loc_descr_ref
8649 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8650 {
8651   unsigned int regno;
8652
8653   /* We only use "frame base" when we're sure we're talking about the
8654      post-prologue local stack frame.  We do this by *not* running
8655      register elimination until this point, and recognizing the special
8656      argument pointer and soft frame pointer rtx's.  */
8657   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8658     {
8659       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8660
8661       if (elim != reg)
8662         {
8663           if (GET_CODE (elim) == PLUS)
8664             {
8665               offset += INTVAL (XEXP (elim, 1));
8666               elim = XEXP (elim, 0);
8667             }
8668           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8669                       : stack_pointer_rtx));
8670           offset += frame_pointer_cfa_offset;
8671
8672           return new_loc_descr (DW_OP_fbreg, offset, 0);
8673         }
8674     }
8675
8676   regno = dbx_reg_number (reg);
8677   if (regno <= 31)
8678     return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8679   else
8680     return new_loc_descr (DW_OP_bregx, regno, offset);
8681 }
8682
8683 /* Return true if this RTL expression describes a base+offset calculation.  */
8684
8685 static inline int
8686 is_based_loc (rtx rtl)
8687 {
8688   return (GET_CODE (rtl) == PLUS
8689           && ((REG_P (XEXP (rtl, 0))
8690                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8691                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8692 }
8693
8694 /* The following routine converts the RTL for a variable or parameter
8695    (resident in memory) into an equivalent Dwarf representation of a
8696    mechanism for getting the address of that same variable onto the top of a
8697    hypothetical "address evaluation" stack.
8698
8699    When creating memory location descriptors, we are effectively transforming
8700    the RTL for a memory-resident object into its Dwarf postfix expression
8701    equivalent.  This routine recursively descends an RTL tree, turning
8702    it into Dwarf postfix code as it goes.
8703
8704    MODE is the mode of the memory reference, needed to handle some
8705    autoincrement addressing modes.
8706
8707    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8708    location list for RTL.
8709
8710    Return 0 if we can't represent the location.  */
8711
8712 static dw_loc_descr_ref
8713 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8714 {
8715   dw_loc_descr_ref mem_loc_result = NULL;
8716   enum dwarf_location_atom op;
8717
8718   /* Note that for a dynamically sized array, the location we will generate a
8719      description of here will be the lowest numbered location which is
8720      actually within the array.  That's *not* necessarily the same as the
8721      zeroth element of the array.  */
8722
8723   rtl = targetm.delegitimize_address (rtl);
8724
8725   switch (GET_CODE (rtl))
8726     {
8727     case POST_INC:
8728     case POST_DEC:
8729     case POST_MODIFY:
8730       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8731          just fall into the SUBREG code.  */
8732
8733       /* ... fall through ...  */
8734
8735     case SUBREG:
8736       /* The case of a subreg may arise when we have a local (register)
8737          variable or a formal (register) parameter which doesn't quite fill
8738          up an entire register.  For now, just assume that it is
8739          legitimate to make the Dwarf info refer to the whole register which
8740          contains the given subreg.  */
8741       rtl = XEXP (rtl, 0);
8742
8743       /* ... fall through ...  */
8744
8745     case REG:
8746       /* Whenever a register number forms a part of the description of the
8747          method for calculating the (dynamic) address of a memory resident
8748          object, DWARF rules require the register number be referred to as
8749          a "base register".  This distinction is not based in any way upon
8750          what category of register the hardware believes the given register
8751          belongs to.  This is strictly DWARF terminology we're dealing with
8752          here. Note that in cases where the location of a memory-resident
8753          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8754          OP_CONST (0)) the actual DWARF location descriptor that we generate
8755          may just be OP_BASEREG (basereg).  This may look deceptively like
8756          the object in question was allocated to a register (rather than in
8757          memory) so DWARF consumers need to be aware of the subtle
8758          distinction between OP_REG and OP_BASEREG.  */
8759       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8760         mem_loc_result = based_loc_descr (rtl, 0);
8761       break;
8762
8763     case MEM:
8764       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8765       if (mem_loc_result != 0)
8766         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8767       break;
8768
8769     case LO_SUM:
8770          rtl = XEXP (rtl, 1);
8771
8772       /* ... fall through ...  */
8773
8774     case LABEL_REF:
8775       /* Some ports can transform a symbol ref into a label ref, because
8776          the symbol ref is too far away and has to be dumped into a constant
8777          pool.  */
8778     case CONST:
8779     case SYMBOL_REF:
8780       /* Alternatively, the symbol in the constant pool might be referenced
8781          by a different symbol.  */
8782       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8783         {
8784           bool marked;
8785           rtx tmp = get_pool_constant_mark (rtl, &marked);
8786
8787           if (GET_CODE (tmp) == SYMBOL_REF)
8788             {
8789               rtl = tmp;
8790               if (CONSTANT_POOL_ADDRESS_P (tmp))
8791                 get_pool_constant_mark (tmp, &marked);
8792               else
8793                 marked = true;
8794             }
8795
8796           /* If all references to this pool constant were optimized away,
8797              it was not output and thus we can't represent it.
8798              FIXME: might try to use DW_OP_const_value here, though
8799              DW_OP_piece complicates it.  */
8800           if (!marked)
8801             return 0;
8802         }
8803
8804       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8805       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8806       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8807       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8808       break;
8809
8810     case PRE_MODIFY:
8811       /* Extract the PLUS expression nested inside and fall into
8812          PLUS code below.  */
8813       rtl = XEXP (rtl, 1);
8814       goto plus;
8815
8816     case PRE_INC:
8817     case PRE_DEC:
8818       /* Turn these into a PLUS expression and fall into the PLUS code
8819          below.  */
8820       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8821                           GEN_INT (GET_CODE (rtl) == PRE_INC
8822                                    ? GET_MODE_UNIT_SIZE (mode)
8823                                    : -GET_MODE_UNIT_SIZE (mode)));
8824
8825       /* ... fall through ...  */
8826
8827     case PLUS:
8828     plus:
8829       if (is_based_loc (rtl))
8830         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8831                                           INTVAL (XEXP (rtl, 1)));
8832       else
8833         {
8834           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8835           if (mem_loc_result == 0)
8836             break;
8837
8838           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8839               && INTVAL (XEXP (rtl, 1)) >= 0)
8840             add_loc_descr (&mem_loc_result,
8841                            new_loc_descr (DW_OP_plus_uconst,
8842                                           INTVAL (XEXP (rtl, 1)), 0));
8843           else
8844             {
8845               add_loc_descr (&mem_loc_result,
8846                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8847               add_loc_descr (&mem_loc_result,
8848                              new_loc_descr (DW_OP_plus, 0, 0));
8849             }
8850         }
8851       break;
8852
8853     /* If a pseudo-reg is optimized away, it is possible for it to
8854        be replaced with a MEM containing a multiply or shift.  */
8855     case MULT:
8856       op = DW_OP_mul;
8857       goto do_binop;
8858
8859     case ASHIFT:
8860       op = DW_OP_shl;
8861       goto do_binop;
8862
8863     case ASHIFTRT:
8864       op = DW_OP_shra;
8865       goto do_binop;
8866
8867     case LSHIFTRT:
8868       op = DW_OP_shr;
8869       goto do_binop;
8870
8871     do_binop:
8872       {
8873         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8874         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8875
8876         if (op0 == 0 || op1 == 0)
8877           break;
8878
8879         mem_loc_result = op0;
8880         add_loc_descr (&mem_loc_result, op1);
8881         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8882         break;
8883       }
8884
8885     case CONST_INT:
8886       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8887       break;
8888
8889     default:
8890       gcc_unreachable ();
8891     }
8892
8893   return mem_loc_result;
8894 }
8895
8896 /* Return a descriptor that describes the concatenation of two locations.
8897    This is typically a complex variable.  */
8898
8899 static dw_loc_descr_ref
8900 concat_loc_descriptor (rtx x0, rtx x1)
8901 {
8902   dw_loc_descr_ref cc_loc_result = NULL;
8903   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8904   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8905
8906   if (x0_ref == 0 || x1_ref == 0)
8907     return 0;
8908
8909   cc_loc_result = x0_ref;
8910   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8911
8912   add_loc_descr (&cc_loc_result, x1_ref);
8913   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8914
8915   return cc_loc_result;
8916 }
8917
8918 /* Output a proper Dwarf location descriptor for a variable or parameter
8919    which is either allocated in a register or in a memory location.  For a
8920    register, we just generate an OP_REG and the register number.  For a
8921    memory location we provide a Dwarf postfix expression describing how to
8922    generate the (dynamic) address of the object onto the address stack.
8923
8924    If we don't know how to describe it, return 0.  */
8925
8926 static dw_loc_descr_ref
8927 loc_descriptor (rtx rtl)
8928 {
8929   dw_loc_descr_ref loc_result = NULL;
8930
8931   switch (GET_CODE (rtl))
8932     {
8933     case SUBREG:
8934       /* The case of a subreg may arise when we have a local (register)
8935          variable or a formal (register) parameter which doesn't quite fill
8936          up an entire register.  For now, just assume that it is
8937          legitimate to make the Dwarf info refer to the whole register which
8938          contains the given subreg.  */
8939       rtl = SUBREG_REG (rtl);
8940
8941       /* ... fall through ...  */
8942
8943     case REG:
8944       loc_result = reg_loc_descriptor (rtl);
8945       break;
8946
8947     case MEM:
8948       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8949       break;
8950
8951     case CONCAT:
8952       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8953       break;
8954
8955     case VAR_LOCATION:
8956       /* Single part.  */
8957       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8958         {
8959           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
8960           break;
8961         }
8962
8963       rtl = XEXP (rtl, 1);
8964       /* FALLTHRU */
8965
8966     case PARALLEL:
8967       {
8968         rtvec par_elems = XVEC (rtl, 0);
8969         int num_elem = GET_NUM_ELEM (par_elems);
8970         enum machine_mode mode;
8971         int i;
8972
8973         /* Create the first one, so we have something to add to.  */
8974         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
8975         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
8976         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8977         for (i = 1; i < num_elem; i++)
8978           {
8979             dw_loc_descr_ref temp;
8980
8981             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
8982             add_loc_descr (&loc_result, temp);
8983             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
8984             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8985           }
8986       }
8987       break;
8988
8989     default:
8990       gcc_unreachable ();
8991     }
8992
8993   return loc_result;
8994 }
8995
8996 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8997    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
8998    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
8999    top-level invocation, and we require the address of LOC; is 0 if we require
9000    the value of LOC.  */
9001
9002 static dw_loc_descr_ref
9003 loc_descriptor_from_tree_1 (tree loc, int want_address)
9004 {
9005   dw_loc_descr_ref ret, ret1;
9006   int have_address = 0;
9007   enum dwarf_location_atom op;
9008
9009   /* ??? Most of the time we do not take proper care for sign/zero
9010      extending the values properly.  Hopefully this won't be a real
9011      problem...  */
9012
9013   switch (TREE_CODE (loc))
9014     {
9015     case ERROR_MARK:
9016       return 0;
9017
9018     case PLACEHOLDER_EXPR:
9019       /* This case involves extracting fields from an object to determine the
9020          position of other fields.  We don't try to encode this here.  The
9021          only user of this is Ada, which encodes the needed information using
9022          the names of types.  */
9023       return 0;
9024
9025     case CALL_EXPR:
9026       return 0;
9027
9028     case PREINCREMENT_EXPR:
9029     case PREDECREMENT_EXPR:
9030     case POSTINCREMENT_EXPR:
9031     case POSTDECREMENT_EXPR:
9032       /* There are no opcodes for these operations.  */
9033       return 0;
9034
9035     case ADDR_EXPR:
9036       /* If we already want an address, there's nothing we can do.  */
9037       if (want_address)
9038         return 0;
9039
9040       /* Otherwise, process the argument and look for the address.  */
9041       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9042
9043     case VAR_DECL:
9044       if (DECL_THREAD_LOCAL_P (loc))
9045         {
9046           rtx rtl;
9047
9048           /* If this is not defined, we have no way to emit the data.  */
9049           if (!targetm.asm_out.output_dwarf_dtprel)
9050             return 0;
9051
9052           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9053              look up addresses of objects in the current module.  */
9054           if (DECL_EXTERNAL (loc))
9055             return 0;
9056
9057           rtl = rtl_for_decl_location (loc);
9058           if (rtl == NULL_RTX)
9059             return 0;
9060
9061           if (!MEM_P (rtl))
9062             return 0;
9063           rtl = XEXP (rtl, 0);
9064           if (! CONSTANT_P (rtl))
9065             return 0;
9066
9067           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9068           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9069           ret->dw_loc_oprnd1.v.val_addr = rtl;
9070
9071           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9072           add_loc_descr (&ret, ret1);
9073
9074           have_address = 1;
9075           break;
9076         }
9077       /* FALLTHRU */
9078
9079     case PARM_DECL:
9080       if (DECL_HAS_VALUE_EXPR_P (loc))
9081         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9082                                            want_address);
9083       /* FALLTHRU */
9084
9085     case RESULT_DECL:
9086       {
9087         rtx rtl = rtl_for_decl_location (loc);
9088
9089         if (rtl == NULL_RTX)
9090           return 0;
9091         else if (GET_CODE (rtl) == CONST_INT)
9092           {
9093             HOST_WIDE_INT val = INTVAL (rtl);
9094             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9095               val &= GET_MODE_MASK (DECL_MODE (loc));
9096             ret = int_loc_descriptor (val);
9097           }
9098         else if (GET_CODE (rtl) == CONST_STRING)
9099           return 0;
9100         else if (CONSTANT_P (rtl))
9101           {
9102             ret = new_loc_descr (DW_OP_addr, 0, 0);
9103             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9104             ret->dw_loc_oprnd1.v.val_addr = rtl;
9105           }
9106         else
9107           {
9108             enum machine_mode mode;
9109
9110             /* Certain constructs can only be represented at top-level.  */
9111             if (want_address == 2)
9112               return loc_descriptor (rtl);
9113
9114             mode = GET_MODE (rtl);
9115             if (MEM_P (rtl))
9116               {
9117                 rtl = XEXP (rtl, 0);
9118                 have_address = 1;
9119               }
9120             ret = mem_loc_descriptor (rtl, mode);
9121           }
9122       }
9123       break;
9124
9125     case INDIRECT_REF:
9126       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9127       have_address = 1;
9128       break;
9129
9130     case COMPOUND_EXPR:
9131       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9132
9133     case NOP_EXPR:
9134     case CONVERT_EXPR:
9135     case NON_LVALUE_EXPR:
9136     case VIEW_CONVERT_EXPR:
9137     case SAVE_EXPR:
9138     case MODIFY_EXPR:
9139       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9140
9141     case COMPONENT_REF:
9142     case BIT_FIELD_REF:
9143     case ARRAY_REF:
9144     case ARRAY_RANGE_REF:
9145       {
9146         tree obj, offset;
9147         HOST_WIDE_INT bitsize, bitpos, bytepos;
9148         enum machine_mode mode;
9149         int volatilep;
9150         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9151
9152         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9153                                    &unsignedp, &volatilep, false);
9154
9155         if (obj == loc)
9156           return 0;
9157
9158         ret = loc_descriptor_from_tree_1 (obj, 1);
9159         if (ret == 0
9160             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9161           return 0;
9162
9163         if (offset != NULL_TREE)
9164           {
9165             /* Variable offset.  */
9166             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9167             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9168           }
9169
9170         bytepos = bitpos / BITS_PER_UNIT;
9171         if (bytepos > 0)
9172           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9173         else if (bytepos < 0)
9174           {
9175             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9176             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9177           }
9178
9179         have_address = 1;
9180         break;
9181       }
9182
9183     case INTEGER_CST:
9184       if (host_integerp (loc, 0))
9185         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9186       else
9187         return 0;
9188       break;
9189
9190     case CONSTRUCTOR:
9191       {
9192         /* Get an RTL for this, if something has been emitted.  */
9193         rtx rtl = lookup_constant_def (loc);
9194         enum machine_mode mode;
9195
9196         if (!rtl || !MEM_P (rtl))
9197           return 0;
9198         mode = GET_MODE (rtl);
9199         rtl = XEXP (rtl, 0);
9200         ret = mem_loc_descriptor (rtl, mode);
9201         have_address = 1;
9202         break;
9203       }
9204
9205     case TRUTH_AND_EXPR:
9206     case TRUTH_ANDIF_EXPR:
9207     case BIT_AND_EXPR:
9208       op = DW_OP_and;
9209       goto do_binop;
9210
9211     case TRUTH_XOR_EXPR:
9212     case BIT_XOR_EXPR:
9213       op = DW_OP_xor;
9214       goto do_binop;
9215
9216     case TRUTH_OR_EXPR:
9217     case TRUTH_ORIF_EXPR:
9218     case BIT_IOR_EXPR:
9219       op = DW_OP_or;
9220       goto do_binop;
9221
9222     case FLOOR_DIV_EXPR:
9223     case CEIL_DIV_EXPR:
9224     case ROUND_DIV_EXPR:
9225     case TRUNC_DIV_EXPR:
9226       op = DW_OP_div;
9227       goto do_binop;
9228
9229     case MINUS_EXPR:
9230       op = DW_OP_minus;
9231       goto do_binop;
9232
9233     case FLOOR_MOD_EXPR:
9234     case CEIL_MOD_EXPR:
9235     case ROUND_MOD_EXPR:
9236     case TRUNC_MOD_EXPR:
9237       op = DW_OP_mod;
9238       goto do_binop;
9239
9240     case MULT_EXPR:
9241       op = DW_OP_mul;
9242       goto do_binop;
9243
9244     case LSHIFT_EXPR:
9245       op = DW_OP_shl;
9246       goto do_binop;
9247
9248     case RSHIFT_EXPR:
9249       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9250       goto do_binop;
9251
9252     case PLUS_EXPR:
9253       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9254           && host_integerp (TREE_OPERAND (loc, 1), 0))
9255         {
9256           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9257           if (ret == 0)
9258             return 0;
9259
9260           add_loc_descr (&ret,
9261                          new_loc_descr (DW_OP_plus_uconst,
9262                                         tree_low_cst (TREE_OPERAND (loc, 1),
9263                                                       0),
9264                                         0));
9265           break;
9266         }
9267
9268       op = DW_OP_plus;
9269       goto do_binop;
9270
9271     case LE_EXPR:
9272       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9273         return 0;
9274
9275       op = DW_OP_le;
9276       goto do_binop;
9277
9278     case GE_EXPR:
9279       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9280         return 0;
9281
9282       op = DW_OP_ge;
9283       goto do_binop;
9284
9285     case LT_EXPR:
9286       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9287         return 0;
9288
9289       op = DW_OP_lt;
9290       goto do_binop;
9291
9292     case GT_EXPR:
9293       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9294         return 0;
9295
9296       op = DW_OP_gt;
9297       goto do_binop;
9298
9299     case EQ_EXPR:
9300       op = DW_OP_eq;
9301       goto do_binop;
9302
9303     case NE_EXPR:
9304       op = DW_OP_ne;
9305       goto do_binop;
9306
9307     do_binop:
9308       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9309       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9310       if (ret == 0 || ret1 == 0)
9311         return 0;
9312
9313       add_loc_descr (&ret, ret1);
9314       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9315       break;
9316
9317     case TRUTH_NOT_EXPR:
9318     case BIT_NOT_EXPR:
9319       op = DW_OP_not;
9320       goto do_unop;
9321
9322     case ABS_EXPR:
9323       op = DW_OP_abs;
9324       goto do_unop;
9325
9326     case NEGATE_EXPR:
9327       op = DW_OP_neg;
9328       goto do_unop;
9329
9330     do_unop:
9331       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9332       if (ret == 0)
9333         return 0;
9334
9335       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9336       break;
9337
9338     case MIN_EXPR:
9339     case MAX_EXPR:
9340       {
9341         const enum tree_code code =
9342           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9343
9344         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9345                       build2 (code, integer_type_node,
9346                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9347                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9348       }
9349
9350       /* ... fall through ...  */
9351
9352     case COND_EXPR:
9353       {
9354         dw_loc_descr_ref lhs
9355           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9356         dw_loc_descr_ref rhs
9357           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9358         dw_loc_descr_ref bra_node, jump_node, tmp;
9359
9360         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9361         if (ret == 0 || lhs == 0 || rhs == 0)
9362           return 0;
9363
9364         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9365         add_loc_descr (&ret, bra_node);
9366
9367         add_loc_descr (&ret, rhs);
9368         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9369         add_loc_descr (&ret, jump_node);
9370
9371         add_loc_descr (&ret, lhs);
9372         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9373         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9374
9375         /* ??? Need a node to point the skip at.  Use a nop.  */
9376         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9377         add_loc_descr (&ret, tmp);
9378         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9379         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9380       }
9381       break;
9382
9383     case FIX_TRUNC_EXPR:
9384     case FIX_CEIL_EXPR:
9385     case FIX_FLOOR_EXPR:
9386     case FIX_ROUND_EXPR:
9387       return 0;
9388
9389     default:
9390       /* Leave front-end specific codes as simply unknown.  This comes
9391          up, for instance, with the C STMT_EXPR.  */
9392       if ((unsigned int) TREE_CODE (loc)
9393           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9394         return 0;
9395
9396 #ifdef ENABLE_CHECKING
9397       /* Otherwise this is a generic code; we should just lists all of
9398          these explicitly.  We forgot one.  */
9399       gcc_unreachable ();
9400 #else
9401       /* In a release build, we want to degrade gracefully: better to
9402          generate incomplete debugging information than to crash.  */
9403       return NULL;
9404 #endif
9405     }
9406
9407   /* Show if we can't fill the request for an address.  */
9408   if (want_address && !have_address)
9409     return 0;
9410
9411   /* If we've got an address and don't want one, dereference.  */
9412   if (!want_address && have_address && ret)
9413     {
9414       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9415
9416       if (size > DWARF2_ADDR_SIZE || size == -1)
9417         return 0;
9418       else if (size == DWARF2_ADDR_SIZE)
9419         op = DW_OP_deref;
9420       else
9421         op = DW_OP_deref_size;
9422
9423       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9424     }
9425
9426   return ret;
9427 }
9428
9429 static inline dw_loc_descr_ref
9430 loc_descriptor_from_tree (tree loc)
9431 {
9432   return loc_descriptor_from_tree_1 (loc, 2);
9433 }
9434
9435 /* Given a value, round it up to the lowest multiple of `boundary'
9436    which is not less than the value itself.  */
9437
9438 static inline HOST_WIDE_INT
9439 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9440 {
9441   return (((value + boundary - 1) / boundary) * boundary);
9442 }
9443
9444 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9445    pointer to the declared type for the relevant field variable, or return
9446    `integer_type_node' if the given node turns out to be an
9447    ERROR_MARK node.  */
9448
9449 static inline tree
9450 field_type (tree decl)
9451 {
9452   tree type;
9453
9454   if (TREE_CODE (decl) == ERROR_MARK)
9455     return integer_type_node;
9456
9457   type = DECL_BIT_FIELD_TYPE (decl);
9458   if (type == NULL_TREE)
9459     type = TREE_TYPE (decl);
9460
9461   return type;
9462 }
9463
9464 /* Given a pointer to a tree node, return the alignment in bits for
9465    it, or else return BITS_PER_WORD if the node actually turns out to
9466    be an ERROR_MARK node.  */
9467
9468 static inline unsigned
9469 simple_type_align_in_bits (tree type)
9470 {
9471   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9472 }
9473
9474 static inline unsigned
9475 simple_decl_align_in_bits (tree decl)
9476 {
9477   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9478 }
9479
9480 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9481    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9482    or return 0 if we are unable to determine what that offset is, either
9483    because the argument turns out to be a pointer to an ERROR_MARK node, or
9484    because the offset is actually variable.  (We can't handle the latter case
9485    just yet).  */
9486
9487 static HOST_WIDE_INT
9488 field_byte_offset (tree decl)
9489 {
9490   unsigned int type_align_in_bits;
9491   unsigned int decl_align_in_bits;
9492   unsigned HOST_WIDE_INT type_size_in_bits;
9493   HOST_WIDE_INT object_offset_in_bits;
9494   tree type;
9495   tree field_size_tree;
9496   HOST_WIDE_INT bitpos_int;
9497   HOST_WIDE_INT deepest_bitpos;
9498   unsigned HOST_WIDE_INT field_size_in_bits;
9499
9500   if (TREE_CODE (decl) == ERROR_MARK)
9501     return 0;
9502
9503   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9504
9505   type = field_type (decl);
9506   field_size_tree = DECL_SIZE (decl);
9507
9508   /* The size could be unspecified if there was an error, or for
9509      a flexible array member.  */
9510   if (! field_size_tree)
9511     field_size_tree = bitsize_zero_node;
9512
9513   /* We cannot yet cope with fields whose positions are variable, so
9514      for now, when we see such things, we simply return 0.  Someday, we may
9515      be able to handle such cases, but it will be damn difficult.  */
9516   if (! host_integerp (bit_position (decl), 0))
9517     return 0;
9518
9519   bitpos_int = int_bit_position (decl);
9520
9521   /* If we don't know the size of the field, pretend it's a full word.  */
9522   if (host_integerp (field_size_tree, 1))
9523     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9524   else
9525     field_size_in_bits = BITS_PER_WORD;
9526
9527   type_size_in_bits = simple_type_size_in_bits (type);
9528   type_align_in_bits = simple_type_align_in_bits (type);
9529   decl_align_in_bits = simple_decl_align_in_bits (decl);
9530
9531   /* The GCC front-end doesn't make any attempt to keep track of the starting
9532      bit offset (relative to the start of the containing structure type) of the
9533      hypothetical "containing object" for a bit-field.  Thus, when computing
9534      the byte offset value for the start of the "containing object" of a
9535      bit-field, we must deduce this information on our own. This can be rather
9536      tricky to do in some cases.  For example, handling the following structure
9537      type definition when compiling for an i386/i486 target (which only aligns
9538      long long's to 32-bit boundaries) can be very tricky:
9539
9540          struct S { int field1; long long field2:31; };
9541
9542      Fortunately, there is a simple rule-of-thumb which can be used in such
9543      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9544      structure shown above.  It decides to do this based upon one simple rule
9545      for bit-field allocation.  GCC allocates each "containing object" for each
9546      bit-field at the first (i.e. lowest addressed) legitimate alignment
9547      boundary (based upon the required minimum alignment for the declared type
9548      of the field) which it can possibly use, subject to the condition that
9549      there is still enough available space remaining in the containing object
9550      (when allocated at the selected point) to fully accommodate all of the
9551      bits of the bit-field itself.
9552
9553      This simple rule makes it obvious why GCC allocates 8 bytes for each
9554      object of the structure type shown above.  When looking for a place to
9555      allocate the "containing object" for `field2', the compiler simply tries
9556      to allocate a 64-bit "containing object" at each successive 32-bit
9557      boundary (starting at zero) until it finds a place to allocate that 64-
9558      bit field such that at least 31 contiguous (and previously unallocated)
9559      bits remain within that selected 64 bit field.  (As it turns out, for the
9560      example above, the compiler finds it is OK to allocate the "containing
9561      object" 64-bit field at bit-offset zero within the structure type.)
9562
9563      Here we attempt to work backwards from the limited set of facts we're
9564      given, and we try to deduce from those facts, where GCC must have believed
9565      that the containing object started (within the structure type). The value
9566      we deduce is then used (by the callers of this routine) to generate
9567      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9568      and, in the case of DW_AT_location, regular fields as well).  */
9569
9570   /* Figure out the bit-distance from the start of the structure to the
9571      "deepest" bit of the bit-field.  */
9572   deepest_bitpos = bitpos_int + field_size_in_bits;
9573
9574   /* This is the tricky part.  Use some fancy footwork to deduce where the
9575      lowest addressed bit of the containing object must be.  */
9576   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9577
9578   /* Round up to type_align by default.  This works best for bitfields.  */
9579   object_offset_in_bits += type_align_in_bits - 1;
9580   object_offset_in_bits /= type_align_in_bits;
9581   object_offset_in_bits *= type_align_in_bits;
9582
9583   if (object_offset_in_bits > bitpos_int)
9584     {
9585       /* Sigh, the decl must be packed.  */
9586       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9587
9588       /* Round up to decl_align instead.  */
9589       object_offset_in_bits += decl_align_in_bits - 1;
9590       object_offset_in_bits /= decl_align_in_bits;
9591       object_offset_in_bits *= decl_align_in_bits;
9592     }
9593
9594   return object_offset_in_bits / BITS_PER_UNIT;
9595 }
9596 \f
9597 /* The following routines define various Dwarf attributes and any data
9598    associated with them.  */
9599
9600 /* Add a location description attribute value to a DIE.
9601
9602    This emits location attributes suitable for whole variables and
9603    whole parameters.  Note that the location attributes for struct fields are
9604    generated by the routine `data_member_location_attribute' below.  */
9605
9606 static inline void
9607 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9608                              dw_loc_descr_ref descr)
9609 {
9610   if (descr != 0)
9611     add_AT_loc (die, attr_kind, descr);
9612 }
9613
9614 /* Attach the specialized form of location attribute used for data members of
9615    struct and union types.  In the special case of a FIELD_DECL node which
9616    represents a bit-field, the "offset" part of this special location
9617    descriptor must indicate the distance in bytes from the lowest-addressed
9618    byte of the containing struct or union type to the lowest-addressed byte of
9619    the "containing object" for the bit-field.  (See the `field_byte_offset'
9620    function above).
9621
9622    For any given bit-field, the "containing object" is a hypothetical object
9623    (of some integral or enum type) within which the given bit-field lives.  The
9624    type of this hypothetical "containing object" is always the same as the
9625    declared type of the individual bit-field itself (for GCC anyway... the
9626    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9627    bytes) of the hypothetical "containing object" which will be given in the
9628    DW_AT_byte_size attribute for this bit-field.  (See the
9629    `byte_size_attribute' function below.)  It is also used when calculating the
9630    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9631    function below.)  */
9632
9633 static void
9634 add_data_member_location_attribute (dw_die_ref die, tree decl)
9635 {
9636   HOST_WIDE_INT offset;
9637   dw_loc_descr_ref loc_descr = 0;
9638
9639   if (TREE_CODE (decl) == TREE_BINFO)
9640     {
9641       /* We're working on the TAG_inheritance for a base class.  */
9642       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9643         {
9644           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9645              aren't at a fixed offset from all (sub)objects of the same
9646              type.  We need to extract the appropriate offset from our
9647              vtable.  The following dwarf expression means
9648
9649                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9650
9651              This is specific to the V3 ABI, of course.  */
9652
9653           dw_loc_descr_ref tmp;
9654
9655           /* Make a copy of the object address.  */
9656           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9657           add_loc_descr (&loc_descr, tmp);
9658
9659           /* Extract the vtable address.  */
9660           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9661           add_loc_descr (&loc_descr, tmp);
9662
9663           /* Calculate the address of the offset.  */
9664           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9665           gcc_assert (offset < 0);
9666
9667           tmp = int_loc_descriptor (-offset);
9668           add_loc_descr (&loc_descr, tmp);
9669           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9670           add_loc_descr (&loc_descr, tmp);
9671
9672           /* Extract the offset.  */
9673           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9674           add_loc_descr (&loc_descr, tmp);
9675
9676           /* Add it to the object address.  */
9677           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9678           add_loc_descr (&loc_descr, tmp);
9679         }
9680       else
9681         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9682     }
9683   else
9684     offset = field_byte_offset (decl);
9685
9686   if (! loc_descr)
9687     {
9688       enum dwarf_location_atom op;
9689
9690       /* The DWARF2 standard says that we should assume that the structure
9691          address is already on the stack, so we can specify a structure field
9692          address by using DW_OP_plus_uconst.  */
9693
9694 #ifdef MIPS_DEBUGGING_INFO
9695       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9696          operator correctly.  It works only if we leave the offset on the
9697          stack.  */
9698       op = DW_OP_constu;
9699 #else
9700       op = DW_OP_plus_uconst;
9701 #endif
9702
9703       loc_descr = new_loc_descr (op, offset, 0);
9704     }
9705
9706   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9707 }
9708
9709 /* Writes integer values to dw_vec_const array.  */
9710
9711 static void
9712 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9713 {
9714   while (size != 0)
9715     {
9716       *dest++ = val & 0xff;
9717       val >>= 8;
9718       --size;
9719     }
9720 }
9721
9722 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9723
9724 static HOST_WIDE_INT
9725 extract_int (const unsigned char *src, unsigned int size)
9726 {
9727   HOST_WIDE_INT val = 0;
9728
9729   src += size;
9730   while (size != 0)
9731     {
9732       val <<= 8;
9733       val |= *--src & 0xff;
9734       --size;
9735     }
9736   return val;
9737 }
9738
9739 /* Writes floating point values to dw_vec_const array.  */
9740
9741 static void
9742 insert_float (rtx rtl, unsigned char *array)
9743 {
9744   REAL_VALUE_TYPE rv;
9745   long val[4];
9746   int i;
9747
9748   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9749   real_to_target (val, &rv, GET_MODE (rtl));
9750
9751   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9752   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9753     {
9754       insert_int (val[i], 4, array);
9755       array += 4;
9756     }
9757 }
9758
9759 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9760    does not have a "location" either in memory or in a register.  These
9761    things can arise in GNU C when a constant is passed as an actual parameter
9762    to an inlined function.  They can also arise in C++ where declared
9763    constants do not necessarily get memory "homes".  */
9764
9765 static void
9766 add_const_value_attribute (dw_die_ref die, rtx rtl)
9767 {
9768   switch (GET_CODE (rtl))
9769     {
9770     case CONST_INT:
9771       {
9772         HOST_WIDE_INT val = INTVAL (rtl);
9773
9774         if (val < 0)
9775           add_AT_int (die, DW_AT_const_value, val);
9776         else
9777           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9778       }
9779       break;
9780
9781     case CONST_DOUBLE:
9782       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9783          floating-point constant.  A CONST_DOUBLE is used whenever the
9784          constant requires more than one word in order to be adequately
9785          represented.  We output CONST_DOUBLEs as blocks.  */
9786       {
9787         enum machine_mode mode = GET_MODE (rtl);
9788
9789         if (SCALAR_FLOAT_MODE_P (mode))
9790           {
9791             unsigned int length = GET_MODE_SIZE (mode);
9792             unsigned char *array = ggc_alloc (length);
9793
9794             insert_float (rtl, array);
9795             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9796           }
9797         else
9798           {
9799             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9800             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9801
9802             add_AT_long_long (die, DW_AT_const_value,
9803                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9804           }
9805       }
9806       break;
9807
9808     case CONST_VECTOR:
9809       {
9810         enum machine_mode mode = GET_MODE (rtl);
9811         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9812         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9813         unsigned char *array = ggc_alloc (length * elt_size);
9814         unsigned int i;
9815         unsigned char *p;
9816
9817         switch (GET_MODE_CLASS (mode))
9818           {
9819           case MODE_VECTOR_INT:
9820             for (i = 0, p = array; i < length; i++, p += elt_size)
9821               {
9822                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9823                 HOST_WIDE_INT lo, hi;
9824
9825                 switch (GET_CODE (elt))
9826                   {
9827                   case CONST_INT:
9828                     lo = INTVAL (elt);
9829                     hi = -(lo < 0);
9830                     break;
9831
9832                   case CONST_DOUBLE:
9833                     lo = CONST_DOUBLE_LOW (elt);
9834                     hi = CONST_DOUBLE_HIGH (elt);
9835                     break;
9836
9837                   default:
9838                     gcc_unreachable ();
9839                   }
9840
9841                 if (elt_size <= sizeof (HOST_WIDE_INT))
9842                   insert_int (lo, elt_size, p);
9843                 else
9844                   {
9845                     unsigned char *p0 = p;
9846                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9847
9848                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9849                     if (WORDS_BIG_ENDIAN)
9850                       {
9851                         p0 = p1;
9852                         p1 = p;
9853                       }
9854                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9855                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9856                   }
9857               }
9858             break;
9859
9860           case MODE_VECTOR_FLOAT:
9861             for (i = 0, p = array; i < length; i++, p += elt_size)
9862               {
9863                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9864                 insert_float (elt, p);
9865               }
9866             break;
9867
9868           default:
9869             gcc_unreachable ();
9870           }
9871
9872         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9873       }
9874       break;
9875
9876     case CONST_STRING:
9877       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9878       break;
9879
9880     case SYMBOL_REF:
9881     case LABEL_REF:
9882     case CONST:
9883       add_AT_addr (die, DW_AT_const_value, rtl);
9884       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9885       break;
9886
9887     case PLUS:
9888       /* In cases where an inlined instance of an inline function is passed
9889          the address of an `auto' variable (which is local to the caller) we
9890          can get a situation where the DECL_RTL of the artificial local
9891          variable (for the inlining) which acts as a stand-in for the
9892          corresponding formal parameter (of the inline function) will look
9893          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9894          exactly a compile-time constant expression, but it isn't the address
9895          of the (artificial) local variable either.  Rather, it represents the
9896          *value* which the artificial local variable always has during its
9897          lifetime.  We currently have no way to represent such quasi-constant
9898          values in Dwarf, so for now we just punt and generate nothing.  */
9899       break;
9900
9901     default:
9902       /* No other kinds of rtx should be possible here.  */
9903       gcc_unreachable ();
9904     }
9905
9906 }
9907
9908 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9909    for use in a later add_const_value_attribute call.  */
9910
9911 static rtx
9912 rtl_for_decl_init (tree init, tree type)
9913 {
9914   rtx rtl = NULL_RTX;
9915
9916   /* If a variable is initialized with a string constant without embedded
9917      zeros, build CONST_STRING.  */
9918   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9919     {
9920       tree enttype = TREE_TYPE (type);
9921       tree domain = TYPE_DOMAIN (type);
9922       enum machine_mode mode = TYPE_MODE (enttype);
9923
9924       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9925           && domain
9926           && integer_zerop (TYPE_MIN_VALUE (domain))
9927           && compare_tree_int (TYPE_MAX_VALUE (domain),
9928                                TREE_STRING_LENGTH (init) - 1) == 0
9929           && ((size_t) TREE_STRING_LENGTH (init)
9930               == strlen (TREE_STRING_POINTER (init)) + 1))
9931         rtl = gen_rtx_CONST_STRING (VOIDmode,
9932                                     ggc_strdup (TREE_STRING_POINTER (init)));
9933     }
9934   /* If the initializer is something that we know will expand into an
9935      immediate RTL constant, expand it now.  Expanding anything else
9936      tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9937   /* Aggregate, vector, and complex types may contain constructors that may
9938      result in code being generated when expand_expr is called, so we can't
9939      handle them here.  Integer and float are useful and safe types to handle
9940      here.  */
9941   else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
9942            && initializer_constant_valid_p (init, type) == null_pointer_node)
9943     {
9944       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9945
9946       /* If expand_expr returns a MEM, it wasn't immediate.  */
9947       gcc_assert (!rtl || !MEM_P (rtl));
9948     }
9949
9950   return rtl;
9951 }
9952
9953 /* Generate RTL for the variable DECL to represent its location.  */
9954
9955 static rtx
9956 rtl_for_decl_location (tree decl)
9957 {
9958   rtx rtl;
9959
9960   /* Here we have to decide where we are going to say the parameter "lives"
9961      (as far as the debugger is concerned).  We only have a couple of
9962      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9963
9964      DECL_RTL normally indicates where the parameter lives during most of the
9965      activation of the function.  If optimization is enabled however, this
9966      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9967      that the parameter doesn't really live anywhere (as far as the code
9968      generation parts of GCC are concerned) during most of the function's
9969      activation.  That will happen (for example) if the parameter is never
9970      referenced within the function.
9971
9972      We could just generate a location descriptor here for all non-NULL
9973      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9974      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9975      where DECL_RTL is NULL or is a pseudo-reg.
9976
9977      Note however that we can only get away with using DECL_INCOMING_RTL as
9978      a backup substitute for DECL_RTL in certain limited cases.  In cases
9979      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9980      we can be sure that the parameter was passed using the same type as it is
9981      declared to have within the function, and that its DECL_INCOMING_RTL
9982      points us to a place where a value of that type is passed.
9983
9984      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9985      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9986      because in these cases DECL_INCOMING_RTL points us to a value of some
9987      type which is *different* from the type of the parameter itself.  Thus,
9988      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9989      such cases, the debugger would end up (for example) trying to fetch a
9990      `float' from a place which actually contains the first part of a
9991      `double'.  That would lead to really incorrect and confusing
9992      output at debug-time.
9993
9994      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9995      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9996      are a couple of exceptions however.  On little-endian machines we can
9997      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9998      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9999      an integral type that is smaller than TREE_TYPE (decl). These cases arise
10000      when (on a little-endian machine) a non-prototyped function has a
10001      parameter declared to be of type `short' or `char'.  In such cases,
10002      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10003      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10004      passed `int' value.  If the debugger then uses that address to fetch
10005      a `short' or a `char' (on a little-endian machine) the result will be
10006      the correct data, so we allow for such exceptional cases below.
10007
10008      Note that our goal here is to describe the place where the given formal
10009      parameter lives during most of the function's activation (i.e. between the
10010      end of the prologue and the start of the epilogue).  We'll do that as best
10011      as we can. Note however that if the given formal parameter is modified
10012      sometime during the execution of the function, then a stack backtrace (at
10013      debug-time) will show the function as having been called with the *new*
10014      value rather than the value which was originally passed in.  This happens
10015      rarely enough that it is not a major problem, but it *is* a problem, and
10016      I'd like to fix it.
10017
10018      A future version of dwarf2out.c may generate two additional attributes for
10019      any given DW_TAG_formal_parameter DIE which will describe the "passed
10020      type" and the "passed location" for the given formal parameter in addition
10021      to the attributes we now generate to indicate the "declared type" and the
10022      "active location" for each parameter.  This additional set of attributes
10023      could be used by debuggers for stack backtraces. Separately, note that
10024      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10025      This happens (for example) for inlined-instances of inline function formal
10026      parameters which are never referenced.  This really shouldn't be
10027      happening.  All PARM_DECL nodes should get valid non-NULL
10028      DECL_INCOMING_RTL values.  FIXME.  */
10029
10030   /* Use DECL_RTL as the "location" unless we find something better.  */
10031   rtl = DECL_RTL_IF_SET (decl);
10032
10033   /* When generating abstract instances, ignore everything except
10034      constants, symbols living in memory, and symbols living in
10035      fixed registers.  */
10036   if (! reload_completed)
10037     {
10038       if (rtl
10039           && (CONSTANT_P (rtl)
10040               || (MEM_P (rtl)
10041                   && CONSTANT_P (XEXP (rtl, 0)))
10042               || (REG_P (rtl)
10043                   && TREE_CODE (decl) == VAR_DECL
10044                   && TREE_STATIC (decl))))
10045         {
10046           rtl = targetm.delegitimize_address (rtl);
10047           return rtl;
10048         }
10049       rtl = NULL_RTX;
10050     }
10051   else if (TREE_CODE (decl) == PARM_DECL)
10052     {
10053       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10054         {
10055           tree declared_type = TREE_TYPE (decl);
10056           tree passed_type = DECL_ARG_TYPE (decl);
10057           enum machine_mode dmode = TYPE_MODE (declared_type);
10058           enum machine_mode pmode = TYPE_MODE (passed_type);
10059
10060           /* This decl represents a formal parameter which was optimized out.
10061              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10062              all cases where (rtl == NULL_RTX) just below.  */
10063           if (dmode == pmode)
10064             rtl = DECL_INCOMING_RTL (decl);
10065           else if (SCALAR_INT_MODE_P (dmode)
10066                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10067                    && DECL_INCOMING_RTL (decl))
10068             {
10069               rtx inc = DECL_INCOMING_RTL (decl);
10070               if (REG_P (inc))
10071                 rtl = inc;
10072               else if (MEM_P (inc))
10073                 {
10074                   if (BYTES_BIG_ENDIAN)
10075                     rtl = adjust_address_nv (inc, dmode,
10076                                              GET_MODE_SIZE (pmode)
10077                                              - GET_MODE_SIZE (dmode));
10078                   else
10079                     rtl = inc;
10080                 }
10081             }
10082         }
10083
10084       /* If the parm was passed in registers, but lives on the stack, then
10085          make a big endian correction if the mode of the type of the
10086          parameter is not the same as the mode of the rtl.  */
10087       /* ??? This is the same series of checks that are made in dbxout.c before
10088          we reach the big endian correction code there.  It isn't clear if all
10089          of these checks are necessary here, but keeping them all is the safe
10090          thing to do.  */
10091       else if (MEM_P (rtl)
10092                && XEXP (rtl, 0) != const0_rtx
10093                && ! CONSTANT_P (XEXP (rtl, 0))
10094                /* Not passed in memory.  */
10095                && !MEM_P (DECL_INCOMING_RTL (decl))
10096                /* Not passed by invisible reference.  */
10097                && (!REG_P (XEXP (rtl, 0))
10098                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10099                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10100 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10101                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10102 #endif
10103                      )
10104                /* Big endian correction check.  */
10105                && BYTES_BIG_ENDIAN
10106                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10107                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10108                    < UNITS_PER_WORD))
10109         {
10110           int offset = (UNITS_PER_WORD
10111                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10112
10113           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10114                              plus_constant (XEXP (rtl, 0), offset));
10115         }
10116     }
10117   else if (TREE_CODE (decl) == VAR_DECL
10118            && rtl
10119            && MEM_P (rtl)
10120            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10121            && BYTES_BIG_ENDIAN)
10122     {
10123       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10124       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10125
10126       /* If a variable is declared "register" yet is smaller than
10127          a register, then if we store the variable to memory, it
10128          looks like we're storing a register-sized value, when in
10129          fact we are not.  We need to adjust the offset of the
10130          storage location to reflect the actual value's bytes,
10131          else gdb will not be able to display it.  */
10132       if (rsize > dsize)
10133         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10134                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10135     }
10136
10137   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10138      and will have been substituted directly into all expressions that use it.
10139      C does not have such a concept, but C++ and other languages do.  */
10140   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10141     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10142
10143   if (rtl)
10144     rtl = targetm.delegitimize_address (rtl);
10145
10146   /* If we don't look past the constant pool, we risk emitting a
10147      reference to a constant pool entry that isn't referenced from
10148      code, and thus is not emitted.  */
10149   if (rtl)
10150     rtl = avoid_constant_pool_reference (rtl);
10151
10152   return rtl;
10153 }
10154
10155 /* We need to figure out what section we should use as the base for the
10156    address ranges where a given location is valid.
10157    1. If this particular DECL has a section associated with it, use that.
10158    2. If this function has a section associated with it, use that.
10159    3. Otherwise, use the text section.
10160    XXX: If you split a variable across multiple sections, we won't notice.  */
10161
10162 static const char *
10163 secname_for_decl (tree decl)
10164 {
10165   const char *secname;
10166
10167   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10168     {
10169       tree sectree = DECL_SECTION_NAME (decl);
10170       secname = TREE_STRING_POINTER (sectree);
10171     }
10172   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10173     {
10174       tree sectree = DECL_SECTION_NAME (current_function_decl);
10175       secname = TREE_STRING_POINTER (sectree);
10176     }
10177   else if (cfun && in_cold_section_p)
10178     secname = cfun->cold_section_label;
10179   else
10180     secname = text_section_label;
10181
10182   return secname;
10183 }
10184
10185 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10186    data attribute for a variable or a parameter.  We generate the
10187    DW_AT_const_value attribute only in those cases where the given variable
10188    or parameter does not have a true "location" either in memory or in a
10189    register.  This can happen (for example) when a constant is passed as an
10190    actual argument in a call to an inline function.  (It's possible that
10191    these things can crop up in other ways also.)  Note that one type of
10192    constant value which can be passed into an inlined function is a constant
10193    pointer.  This can happen for example if an actual argument in an inlined
10194    function call evaluates to a compile-time constant address.  */
10195
10196 static void
10197 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10198                                        enum dwarf_attribute attr)
10199 {
10200   rtx rtl;
10201   dw_loc_descr_ref descr;
10202   var_loc_list *loc_list;
10203   struct var_loc_node *node;
10204   if (TREE_CODE (decl) == ERROR_MARK)
10205     return;
10206
10207   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10208               || TREE_CODE (decl) == RESULT_DECL);
10209
10210   /* See if we possibly have multiple locations for this variable.  */
10211   loc_list = lookup_decl_loc (decl);
10212
10213   /* If it truly has multiple locations, the first and last node will
10214      differ.  */
10215   if (loc_list && loc_list->first != loc_list->last)
10216     {
10217       const char *endname, *secname;
10218       dw_loc_list_ref list;
10219       rtx varloc;
10220
10221       /* Now that we know what section we are using for a base,
10222          actually construct the list of locations.
10223          The first location information is what is passed to the
10224          function that creates the location list, and the remaining
10225          locations just get added on to that list.
10226          Note that we only know the start address for a location
10227          (IE location changes), so to build the range, we use
10228          the range [current location start, next location start].
10229          This means we have to special case the last node, and generate
10230          a range of [last location start, end of function label].  */
10231
10232       node = loc_list->first;
10233       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10234       secname = secname_for_decl (decl);
10235
10236       list = new_loc_list (loc_descriptor (varloc),
10237                            node->label, node->next->label, secname, 1);
10238       node = node->next;
10239
10240       for (; node->next; node = node->next)
10241         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10242           {
10243             /* The variable has a location between NODE->LABEL and
10244                NODE->NEXT->LABEL.  */
10245             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10246             add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10247                                        node->label, node->next->label, secname);
10248           }
10249
10250       /* If the variable has a location at the last label
10251          it keeps its location until the end of function.  */
10252       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10253         {
10254           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10255
10256           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10257           if (!current_function_decl)
10258             endname = text_end_label;
10259           else
10260             {
10261               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10262                                            current_function_funcdef_no);
10263               endname = ggc_strdup (label_id);
10264             }
10265           add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10266                                      node->label, endname, secname);
10267         }
10268
10269       /* Finally, add the location list to the DIE, and we are done.  */
10270       add_AT_loc_list (die, attr, list);
10271       return;
10272     }
10273
10274   /* Try to get some constant RTL for this decl, and use that as the value of
10275      the location.  */
10276
10277   rtl = rtl_for_decl_location (decl);
10278   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10279     {
10280       add_const_value_attribute (die, rtl);
10281       return;
10282     }
10283
10284   /* If we have tried to generate the location otherwise, and it
10285      didn't work out (we wouldn't be here if we did), and we have a one entry
10286      location list, try generating a location from that.  */
10287   if (loc_list && loc_list->first)
10288     {
10289       node = loc_list->first;
10290       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10291       if (descr)
10292         {
10293           add_AT_location_description (die, attr, descr);
10294           return;
10295         }
10296     }
10297
10298   /* We couldn't get any rtl, so try directly generating the location
10299      description from the tree.  */
10300   descr = loc_descriptor_from_tree (decl);
10301   if (descr)
10302     {
10303       add_AT_location_description (die, attr, descr);
10304       return;
10305     }
10306 }
10307
10308 /* If we don't have a copy of this variable in memory for some reason (such
10309    as a C++ member constant that doesn't have an out-of-line definition),
10310    we should tell the debugger about the constant value.  */
10311
10312 static void
10313 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10314 {
10315   tree init = DECL_INITIAL (decl);
10316   tree type = TREE_TYPE (decl);
10317   rtx rtl;
10318
10319   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10320     /* OK */;
10321   else
10322     return;
10323
10324   rtl = rtl_for_decl_init (init, type);
10325   if (rtl)
10326     add_const_value_attribute (var_die, rtl);
10327 }
10328
10329 #ifdef DWARF2_UNWIND_INFO
10330 /* Convert the CFI instructions for the current function into a location
10331    list.  This is used for DW_AT_frame_base when we targeting a dwarf2
10332    consumer that does not support the dwarf3 DW_OP_call_frame_cfa.  */
10333
10334 static dw_loc_list_ref
10335 convert_cfa_to_loc_list (void)
10336 {
10337   dw_fde_ref fde;
10338   dw_loc_list_ref list, *list_tail;
10339   dw_cfi_ref cfi;
10340   dw_cfa_location last_cfa, next_cfa;
10341   const char *start_label, *last_label, *section;
10342
10343   fde = &fde_table[fde_table_in_use - 1];
10344
10345   section = secname_for_decl (current_function_decl);
10346   list_tail = &list;
10347   list = NULL;
10348
10349   next_cfa.reg = INVALID_REGNUM;
10350   next_cfa.offset = 0;
10351   next_cfa.indirect = 0;
10352   next_cfa.base_offset = 0;
10353
10354   start_label = fde->dw_fde_begin;
10355
10356   /* ??? Bald assumption that the CIE opcode list does not contain
10357      advance opcodes.  */
10358   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10359     lookup_cfa_1 (cfi, &next_cfa);
10360
10361   last_cfa = next_cfa;
10362   last_label = start_label;
10363
10364   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10365     switch (cfi->dw_cfi_opc)
10366       {
10367       case DW_CFA_advance_loc1:
10368       case DW_CFA_advance_loc2:
10369       case DW_CFA_advance_loc4:
10370         if (!cfa_equal_p (&last_cfa, &next_cfa))
10371           {
10372             *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10373                                        last_label, section, list == NULL);
10374
10375             list_tail = &(*list_tail)->dw_loc_next;
10376             last_cfa = next_cfa;
10377             start_label = last_label;
10378           }
10379         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10380         break;
10381
10382       case DW_CFA_advance_loc:
10383         /* The encoding is complex enough that we should never emit this.  */
10384       case DW_CFA_remember_state:
10385       case DW_CFA_restore_state:
10386         /* We don't handle these two in this function.  It would be possible
10387            if it were to be required.  */
10388         gcc_unreachable ();
10389
10390       default:
10391         lookup_cfa_1 (cfi, &next_cfa);
10392         break;
10393       }
10394
10395   if (!cfa_equal_p (&last_cfa, &next_cfa))
10396     {
10397       *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10398                                  last_label, section, list == NULL);
10399       list_tail = &(*list_tail)->dw_loc_next;
10400       start_label = last_label;
10401     }
10402   *list_tail = new_loc_list (build_cfa_loc (&next_cfa), start_label,
10403                              fde->dw_fde_end, section, list == NULL);
10404
10405   return list;
10406 }
10407
10408 /* Compute a displacement from the "steady-state frame pointer" to
10409    the CFA, and store it in frame_pointer_cfa_offset.  */
10410
10411 static void
10412 compute_frame_pointer_to_cfa_displacement (void)
10413 {
10414   HOST_WIDE_INT offset;
10415   rtx reg, elim;
10416
10417 #ifdef FRAME_POINTER_CFA_OFFSET
10418   reg = frame_pointer_rtx;
10419   offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10420 #else
10421   reg = arg_pointer_rtx;
10422   offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10423 #endif
10424
10425   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10426   if (GET_CODE (elim) == PLUS)
10427     {
10428       offset += INTVAL (XEXP (elim, 1));
10429       elim = XEXP (elim, 0);
10430     }
10431   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10432                        : stack_pointer_rtx));
10433
10434   frame_pointer_cfa_offset = -offset;
10435 }
10436 #endif
10437
10438 /* Generate a DW_AT_name attribute given some string value to be included as
10439    the value of the attribute.  */
10440
10441 static void
10442 add_name_attribute (dw_die_ref die, const char *name_string)
10443 {
10444   if (name_string != NULL && *name_string != 0)
10445     {
10446       if (demangle_name_func)
10447         name_string = (*demangle_name_func) (name_string);
10448
10449       add_AT_string (die, DW_AT_name, name_string);
10450     }
10451 }
10452
10453 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10454
10455 static void
10456 add_comp_dir_attribute (dw_die_ref die)
10457 {
10458   const char *wd = get_src_pwd ();
10459   if (wd != NULL)
10460     add_AT_string (die, DW_AT_comp_dir, wd);
10461 }
10462
10463 /* Given a tree node describing an array bound (either lower or upper) output
10464    a representation for that bound.  */
10465
10466 static void
10467 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10468 {
10469   switch (TREE_CODE (bound))
10470     {
10471     case ERROR_MARK:
10472       return;
10473
10474     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10475     case INTEGER_CST:
10476       if (! host_integerp (bound, 0)
10477           || (bound_attr == DW_AT_lower_bound
10478               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10479                   || (is_fortran () && integer_onep (bound)))))
10480         /* Use the default.  */
10481         ;
10482       else
10483         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10484       break;
10485
10486     case CONVERT_EXPR:
10487     case NOP_EXPR:
10488     case NON_LVALUE_EXPR:
10489     case VIEW_CONVERT_EXPR:
10490       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10491       break;
10492
10493     case SAVE_EXPR:
10494       break;
10495
10496     case VAR_DECL:
10497     case PARM_DECL:
10498     case RESULT_DECL:
10499       {
10500         dw_die_ref decl_die = lookup_decl_die (bound);
10501
10502         /* ??? Can this happen, or should the variable have been bound
10503            first?  Probably it can, since I imagine that we try to create
10504            the types of parameters in the order in which they exist in
10505            the list, and won't have created a forward reference to a
10506            later parameter.  */
10507         if (decl_die != NULL)
10508           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10509         break;
10510       }
10511
10512     default:
10513       {
10514         /* Otherwise try to create a stack operation procedure to
10515            evaluate the value of the array bound.  */
10516
10517         dw_die_ref ctx, decl_die;
10518         dw_loc_descr_ref loc;
10519
10520         loc = loc_descriptor_from_tree (bound);
10521         if (loc == NULL)
10522           break;
10523
10524         if (current_function_decl == 0)
10525           ctx = comp_unit_die;
10526         else
10527           ctx = lookup_decl_die (current_function_decl);
10528
10529         decl_die = new_die (DW_TAG_variable, ctx, bound);
10530         add_AT_flag (decl_die, DW_AT_artificial, 1);
10531         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10532         add_AT_loc (decl_die, DW_AT_location, loc);
10533
10534         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10535         break;
10536       }
10537     }
10538 }
10539
10540 /* Note that the block of subscript information for an array type also
10541    includes information about the element type of type given array type.  */
10542
10543 static void
10544 add_subscript_info (dw_die_ref type_die, tree type)
10545 {
10546 #ifndef MIPS_DEBUGGING_INFO
10547   unsigned dimension_number;
10548 #endif
10549   tree lower, upper;
10550   dw_die_ref subrange_die;
10551
10552   /* The GNU compilers represent multidimensional array types as sequences of
10553      one dimensional array types whose element types are themselves array
10554      types.  Here we squish that down, so that each multidimensional array
10555      type gets only one array_type DIE in the Dwarf debugging info. The draft
10556      Dwarf specification say that we are allowed to do this kind of
10557      compression in C (because there is no difference between an array or
10558      arrays and a multidimensional array in C) but for other source languages
10559      (e.g. Ada) we probably shouldn't do this.  */
10560
10561   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10562      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10563      We work around this by disabling this feature.  See also
10564      gen_array_type_die.  */
10565 #ifndef MIPS_DEBUGGING_INFO
10566   for (dimension_number = 0;
10567        TREE_CODE (type) == ARRAY_TYPE;
10568        type = TREE_TYPE (type), dimension_number++)
10569 #endif
10570     {
10571       tree domain = TYPE_DOMAIN (type);
10572
10573       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10574          and (in GNU C only) variable bounds.  Handle all three forms
10575          here.  */
10576       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10577       if (domain)
10578         {
10579           /* We have an array type with specified bounds.  */
10580           lower = TYPE_MIN_VALUE (domain);
10581           upper = TYPE_MAX_VALUE (domain);
10582
10583           /* Define the index type.  */
10584           if (TREE_TYPE (domain))
10585             {
10586               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10587                  TREE_TYPE field.  We can't emit debug info for this
10588                  because it is an unnamed integral type.  */
10589               if (TREE_CODE (domain) == INTEGER_TYPE
10590                   && TYPE_NAME (domain) == NULL_TREE
10591                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10592                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10593                 ;
10594               else
10595                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10596                                     type_die);
10597             }
10598
10599           /* ??? If upper is NULL, the array has unspecified length,
10600              but it does have a lower bound.  This happens with Fortran
10601                dimension arr(N:*)
10602              Since the debugger is definitely going to need to know N
10603              to produce useful results, go ahead and output the lower
10604              bound solo, and hope the debugger can cope.  */
10605
10606           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10607           if (upper)
10608             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10609         }
10610
10611       /* Otherwise we have an array type with an unspecified length.  The
10612          DWARF-2 spec does not say how to handle this; let's just leave out the
10613          bounds.  */
10614     }
10615 }
10616
10617 static void
10618 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10619 {
10620   unsigned size;
10621
10622   switch (TREE_CODE (tree_node))
10623     {
10624     case ERROR_MARK:
10625       size = 0;
10626       break;
10627     case ENUMERAL_TYPE:
10628     case RECORD_TYPE:
10629     case UNION_TYPE:
10630     case QUAL_UNION_TYPE:
10631       size = int_size_in_bytes (tree_node);
10632       break;
10633     case FIELD_DECL:
10634       /* For a data member of a struct or union, the DW_AT_byte_size is
10635          generally given as the number of bytes normally allocated for an
10636          object of the *declared* type of the member itself.  This is true
10637          even for bit-fields.  */
10638       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10639       break;
10640     default:
10641       gcc_unreachable ();
10642     }
10643
10644   /* Note that `size' might be -1 when we get to this point.  If it is, that
10645      indicates that the byte size of the entity in question is variable.  We
10646      have no good way of expressing this fact in Dwarf at the present time,
10647      so just let the -1 pass on through.  */
10648   add_AT_unsigned (die, DW_AT_byte_size, size);
10649 }
10650
10651 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10652    which specifies the distance in bits from the highest order bit of the
10653    "containing object" for the bit-field to the highest order bit of the
10654    bit-field itself.
10655
10656    For any given bit-field, the "containing object" is a hypothetical object
10657    (of some integral or enum type) within which the given bit-field lives.  The
10658    type of this hypothetical "containing object" is always the same as the
10659    declared type of the individual bit-field itself.  The determination of the
10660    exact location of the "containing object" for a bit-field is rather
10661    complicated.  It's handled by the `field_byte_offset' function (above).
10662
10663    Note that it is the size (in bytes) of the hypothetical "containing object"
10664    which will be given in the DW_AT_byte_size attribute for this bit-field.
10665    (See `byte_size_attribute' above).  */
10666
10667 static inline void
10668 add_bit_offset_attribute (dw_die_ref die, tree decl)
10669 {
10670   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10671   tree type = DECL_BIT_FIELD_TYPE (decl);
10672   HOST_WIDE_INT bitpos_int;
10673   HOST_WIDE_INT highest_order_object_bit_offset;
10674   HOST_WIDE_INT highest_order_field_bit_offset;
10675   HOST_WIDE_INT unsigned bit_offset;
10676
10677   /* Must be a field and a bit field.  */
10678   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10679
10680   /* We can't yet handle bit-fields whose offsets are variable, so if we
10681      encounter such things, just return without generating any attribute
10682      whatsoever.  Likewise for variable or too large size.  */
10683   if (! host_integerp (bit_position (decl), 0)
10684       || ! host_integerp (DECL_SIZE (decl), 1))
10685     return;
10686
10687   bitpos_int = int_bit_position (decl);
10688
10689   /* Note that the bit offset is always the distance (in bits) from the
10690      highest-order bit of the "containing object" to the highest-order bit of
10691      the bit-field itself.  Since the "high-order end" of any object or field
10692      is different on big-endian and little-endian machines, the computation
10693      below must take account of these differences.  */
10694   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10695   highest_order_field_bit_offset = bitpos_int;
10696
10697   if (! BYTES_BIG_ENDIAN)
10698     {
10699       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10700       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10701     }
10702
10703   bit_offset
10704     = (! BYTES_BIG_ENDIAN
10705        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10706        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10707
10708   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10709 }
10710
10711 /* For a FIELD_DECL node which represents a bit field, output an attribute
10712    which specifies the length in bits of the given field.  */
10713
10714 static inline void
10715 add_bit_size_attribute (dw_die_ref die, tree decl)
10716 {
10717   /* Must be a field and a bit field.  */
10718   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10719               && DECL_BIT_FIELD_TYPE (decl));
10720
10721   if (host_integerp (DECL_SIZE (decl), 1))
10722     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10723 }
10724
10725 /* If the compiled language is ANSI C, then add a 'prototyped'
10726    attribute, if arg types are given for the parameters of a function.  */
10727
10728 static inline void
10729 add_prototyped_attribute (dw_die_ref die, tree func_type)
10730 {
10731   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10732       && TYPE_ARG_TYPES (func_type) != NULL)
10733     add_AT_flag (die, DW_AT_prototyped, 1);
10734 }
10735
10736 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10737    by looking in either the type declaration or object declaration
10738    equate table.  */
10739
10740 static inline void
10741 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10742 {
10743   dw_die_ref origin_die = NULL;
10744
10745   if (TREE_CODE (origin) != FUNCTION_DECL)
10746     {
10747       /* We may have gotten separated from the block for the inlined
10748          function, if we're in an exception handler or some such; make
10749          sure that the abstract function has been written out.
10750
10751          Doing this for nested functions is wrong, however; functions are
10752          distinct units, and our context might not even be inline.  */
10753       tree fn = origin;
10754
10755       if (TYPE_P (fn))
10756         fn = TYPE_STUB_DECL (fn);
10757
10758       fn = decl_function_context (fn);
10759       if (fn)
10760         dwarf2out_abstract_function (fn);
10761     }
10762
10763   if (DECL_P (origin))
10764     origin_die = lookup_decl_die (origin);
10765   else if (TYPE_P (origin))
10766     origin_die = lookup_type_die (origin);
10767
10768   /* XXX: Functions that are never lowered don't always have correct block
10769      trees (in the case of java, they simply have no block tree, in some other
10770      languages).  For these functions, there is nothing we can really do to
10771      output correct debug info for inlined functions in all cases.  Rather
10772      than die, we'll just produce deficient debug info now, in that we will
10773      have variables without a proper abstract origin.  In the future, when all
10774      functions are lowered, we should re-add a gcc_assert (origin_die)
10775      here.  */
10776
10777   if (origin_die)
10778       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10779 }
10780
10781 /* We do not currently support the pure_virtual attribute.  */
10782
10783 static inline void
10784 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10785 {
10786   if (DECL_VINDEX (func_decl))
10787     {
10788       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10789
10790       if (host_integerp (DECL_VINDEX (func_decl), 0))
10791         add_AT_loc (die, DW_AT_vtable_elem_location,
10792                     new_loc_descr (DW_OP_constu,
10793                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10794                                    0));
10795
10796       /* GNU extension: Record what type this method came from originally.  */
10797       if (debug_info_level > DINFO_LEVEL_TERSE)
10798         add_AT_die_ref (die, DW_AT_containing_type,
10799                         lookup_type_die (DECL_CONTEXT (func_decl)));
10800     }
10801 }
10802 \f
10803 /* Add source coordinate attributes for the given decl.  */
10804
10805 static void
10806 add_src_coords_attributes (dw_die_ref die, tree decl)
10807 {
10808   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10809   unsigned file_index = lookup_filename (s.file);
10810
10811   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10812   add_AT_unsigned (die, DW_AT_decl_line, s.line);
10813 }
10814
10815 /* Add a DW_AT_name attribute and source coordinate attribute for the
10816    given decl, but only if it actually has a name.  */
10817
10818 static void
10819 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10820 {
10821   tree decl_name;
10822
10823   decl_name = DECL_NAME (decl);
10824   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10825     {
10826       add_name_attribute (die, dwarf2_name (decl, 0));
10827       if (! DECL_ARTIFICIAL (decl))
10828         add_src_coords_attributes (die, decl);
10829
10830       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10831           && TREE_PUBLIC (decl)
10832           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10833           && !DECL_ABSTRACT (decl)
10834           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10835         add_AT_string (die, DW_AT_MIPS_linkage_name,
10836                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10837     }
10838
10839 #ifdef VMS_DEBUGGING_INFO
10840   /* Get the function's name, as described by its RTL.  This may be different
10841      from the DECL_NAME name used in the source file.  */
10842   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10843     {
10844       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10845                    XEXP (DECL_RTL (decl), 0));
10846       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10847     }
10848 #endif
10849 }
10850
10851 /* Push a new declaration scope.  */
10852
10853 static void
10854 push_decl_scope (tree scope)
10855 {
10856   VEC_safe_push (tree, gc, decl_scope_table, scope);
10857 }
10858
10859 /* Pop a declaration scope.  */
10860
10861 static inline void
10862 pop_decl_scope (void)
10863 {
10864   VEC_pop (tree, decl_scope_table);
10865 }
10866
10867 /* Return the DIE for the scope that immediately contains this type.
10868    Non-named types get global scope.  Named types nested in other
10869    types get their containing scope if it's open, or global scope
10870    otherwise.  All other types (i.e. function-local named types) get
10871    the current active scope.  */
10872
10873 static dw_die_ref
10874 scope_die_for (tree t, dw_die_ref context_die)
10875 {
10876   dw_die_ref scope_die = NULL;
10877   tree containing_scope;
10878   int i;
10879
10880   /* Non-types always go in the current scope.  */
10881   gcc_assert (TYPE_P (t));
10882
10883   containing_scope = TYPE_CONTEXT (t);
10884
10885   /* Use the containing namespace if it was passed in (for a declaration).  */
10886   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10887     {
10888       if (context_die == lookup_decl_die (containing_scope))
10889         /* OK */;
10890       else
10891         containing_scope = NULL_TREE;
10892     }
10893
10894   /* Ignore function type "scopes" from the C frontend.  They mean that
10895      a tagged type is local to a parmlist of a function declarator, but
10896      that isn't useful to DWARF.  */
10897   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10898     containing_scope = NULL_TREE;
10899
10900   if (containing_scope == NULL_TREE)
10901     scope_die = comp_unit_die;
10902   else if (TYPE_P (containing_scope))
10903     {
10904       /* For types, we can just look up the appropriate DIE.  But
10905          first we check to see if we're in the middle of emitting it
10906          so we know where the new DIE should go.  */
10907       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
10908         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
10909           break;
10910
10911       if (i < 0)
10912         {
10913           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10914                       || TREE_ASM_WRITTEN (containing_scope));
10915
10916           /* If none of the current dies are suitable, we get file scope.  */
10917           scope_die = comp_unit_die;
10918         }
10919       else
10920         scope_die = lookup_type_die (containing_scope);
10921     }
10922   else
10923     scope_die = context_die;
10924
10925   return scope_die;
10926 }
10927
10928 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10929
10930 static inline int
10931 local_scope_p (dw_die_ref context_die)
10932 {
10933   for (; context_die; context_die = context_die->die_parent)
10934     if (context_die->die_tag == DW_TAG_inlined_subroutine
10935         || context_die->die_tag == DW_TAG_subprogram)
10936       return 1;
10937
10938   return 0;
10939 }
10940
10941 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10942    whether or not to treat a DIE in this context as a declaration.  */
10943
10944 static inline int
10945 class_or_namespace_scope_p (dw_die_ref context_die)
10946 {
10947   return (context_die
10948           && (context_die->die_tag == DW_TAG_structure_type
10949               || context_die->die_tag == DW_TAG_union_type
10950               || context_die->die_tag == DW_TAG_namespace));
10951 }
10952
10953 /* Many forms of DIEs require a "type description" attribute.  This
10954    routine locates the proper "type descriptor" die for the type given
10955    by 'type', and adds a DW_AT_type attribute below the given die.  */
10956
10957 static void
10958 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10959                     int decl_volatile, dw_die_ref context_die)
10960 {
10961   enum tree_code code  = TREE_CODE (type);
10962   dw_die_ref type_die  = NULL;
10963
10964   /* ??? If this type is an unnamed subrange type of an integral or
10965      floating-point type, use the inner type.  This is because we have no
10966      support for unnamed types in base_type_die.  This can happen if this is
10967      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10968   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10969       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10970     type = TREE_TYPE (type), code = TREE_CODE (type);
10971
10972   if (code == ERROR_MARK
10973       /* Handle a special case.  For functions whose return type is void, we
10974          generate *no* type attribute.  (Note that no object may have type
10975          `void', so this only applies to function return types).  */
10976       || code == VOID_TYPE)
10977     return;
10978
10979   type_die = modified_type_die (type,
10980                                 decl_const || TYPE_READONLY (type),
10981                                 decl_volatile || TYPE_VOLATILE (type),
10982                                 context_die);
10983
10984   if (type_die != NULL)
10985     add_AT_die_ref (object_die, DW_AT_type, type_die);
10986 }
10987
10988 /* Given an object die, add the calling convention attribute for the
10989    function call type.  */
10990 static void
10991 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
10992 {
10993   enum dwarf_calling_convention value = DW_CC_normal;
10994
10995   value = targetm.dwarf_calling_convention (type);
10996
10997   /* Only add the attribute if the backend requests it, and
10998      is not DW_CC_normal.  */
10999   if (value && (value != DW_CC_normal))
11000     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11001 }
11002
11003 /* Given a tree pointer to a struct, class, union, or enum type node, return
11004    a pointer to the (string) tag name for the given type, or zero if the type
11005    was declared without a tag.  */
11006
11007 static const char *
11008 type_tag (tree type)
11009 {
11010   const char *name = 0;
11011
11012   if (TYPE_NAME (type) != 0)
11013     {
11014       tree t = 0;
11015
11016       /* Find the IDENTIFIER_NODE for the type name.  */
11017       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11018         t = TYPE_NAME (type);
11019
11020       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11021          a TYPE_DECL node, regardless of whether or not a `typedef' was
11022          involved.  */
11023       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11024                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11025         t = DECL_NAME (TYPE_NAME (type));
11026
11027       /* Now get the name as a string, or invent one.  */
11028       if (t != 0)
11029         name = IDENTIFIER_POINTER (t);
11030     }
11031
11032   return (name == 0 || *name == '\0') ? 0 : name;
11033 }
11034
11035 /* Return the type associated with a data member, make a special check
11036    for bit field types.  */
11037
11038 static inline tree
11039 member_declared_type (tree member)
11040 {
11041   return (DECL_BIT_FIELD_TYPE (member)
11042           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11043 }
11044
11045 /* Get the decl's label, as described by its RTL. This may be different
11046    from the DECL_NAME name used in the source file.  */
11047
11048 #if 0
11049 static const char *
11050 decl_start_label (tree decl)
11051 {
11052   rtx x;
11053   const char *fnname;
11054
11055   x = DECL_RTL (decl);
11056   gcc_assert (MEM_P (x));
11057
11058   x = XEXP (x, 0);
11059   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11060
11061   fnname = XSTR (x, 0);
11062   return fnname;
11063 }
11064 #endif
11065 \f
11066 /* These routines generate the internal representation of the DIE's for
11067    the compilation unit.  Debugging information is collected by walking
11068    the declaration trees passed in from dwarf2out_decl().  */
11069
11070 static void
11071 gen_array_type_die (tree type, dw_die_ref context_die)
11072 {
11073   dw_die_ref scope_die = scope_die_for (type, context_die);
11074   dw_die_ref array_die;
11075   tree element_type;
11076
11077   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11078      the inner array type comes before the outer array type.  Thus we must
11079      call gen_type_die before we call new_die.  See below also.  */
11080 #ifdef MIPS_DEBUGGING_INFO
11081   gen_type_die (TREE_TYPE (type), context_die);
11082 #endif
11083
11084   array_die = new_die (DW_TAG_array_type, scope_die, type);
11085   add_name_attribute (array_die, type_tag (type));
11086   equate_type_number_to_die (type, array_die);
11087
11088   if (TREE_CODE (type) == VECTOR_TYPE)
11089     {
11090       /* The frontend feeds us a representation for the vector as a struct
11091          containing an array.  Pull out the array type.  */
11092       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11093       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11094     }
11095
11096 #if 0
11097   /* We default the array ordering.  SDB will probably do
11098      the right things even if DW_AT_ordering is not present.  It's not even
11099      an issue until we start to get into multidimensional arrays anyway.  If
11100      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11101      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11102      and when we find out that we need to put these in, we will only do so
11103      for multidimensional arrays.  */
11104   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11105 #endif
11106
11107 #ifdef MIPS_DEBUGGING_INFO
11108   /* The SGI compilers handle arrays of unknown bound by setting
11109      AT_declaration and not emitting any subrange DIEs.  */
11110   if (! TYPE_DOMAIN (type))
11111     add_AT_flag (array_die, DW_AT_declaration, 1);
11112   else
11113 #endif
11114     add_subscript_info (array_die, type);
11115
11116   /* Add representation of the type of the elements of this array type.  */
11117   element_type = TREE_TYPE (type);
11118
11119   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11120      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11121      We work around this by disabling this feature.  See also
11122      add_subscript_info.  */
11123 #ifndef MIPS_DEBUGGING_INFO
11124   while (TREE_CODE (element_type) == ARRAY_TYPE)
11125     element_type = TREE_TYPE (element_type);
11126
11127   gen_type_die (element_type, context_die);
11128 #endif
11129
11130   add_type_attribute (array_die, element_type, 0, 0, context_die);
11131 }
11132
11133 #if 0
11134 static void
11135 gen_entry_point_die (tree decl, dw_die_ref context_die)
11136 {
11137   tree origin = decl_ultimate_origin (decl);
11138   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11139
11140   if (origin != NULL)
11141     add_abstract_origin_attribute (decl_die, origin);
11142   else
11143     {
11144       add_name_and_src_coords_attributes (decl_die, decl);
11145       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11146                           0, 0, context_die);
11147     }
11148
11149   if (DECL_ABSTRACT (decl))
11150     equate_decl_number_to_die (decl, decl_die);
11151   else
11152     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11153 }
11154 #endif
11155
11156 /* Walk through the list of incomplete types again, trying once more to
11157    emit full debugging info for them.  */
11158
11159 static void
11160 retry_incomplete_types (void)
11161 {
11162   int i;
11163
11164   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11165     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11166 }
11167
11168 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11169
11170 static void
11171 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11172 {
11173   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11174
11175   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11176      be incomplete and such types are not marked.  */
11177   add_abstract_origin_attribute (type_die, type);
11178 }
11179
11180 /* Generate a DIE to represent an inlined instance of a structure type.  */
11181
11182 static void
11183 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11184 {
11185   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11186
11187   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11188      be incomplete and such types are not marked.  */
11189   add_abstract_origin_attribute (type_die, type);
11190 }
11191
11192 /* Generate a DIE to represent an inlined instance of a union type.  */
11193
11194 static void
11195 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11196 {
11197   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11198
11199   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11200      be incomplete and such types are not marked.  */
11201   add_abstract_origin_attribute (type_die, type);
11202 }
11203
11204 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11205    include all of the information about the enumeration values also. Each
11206    enumerated type name/value is listed as a child of the enumerated type
11207    DIE.  */
11208
11209 static dw_die_ref
11210 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11211 {
11212   dw_die_ref type_die = lookup_type_die (type);
11213
11214   if (type_die == NULL)
11215     {
11216       type_die = new_die (DW_TAG_enumeration_type,
11217                           scope_die_for (type, context_die), type);
11218       equate_type_number_to_die (type, type_die);
11219       add_name_attribute (type_die, type_tag (type));
11220     }
11221   else if (! TYPE_SIZE (type))
11222     return type_die;
11223   else
11224     remove_AT (type_die, DW_AT_declaration);
11225
11226   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11227      given enum type is incomplete, do not generate the DW_AT_byte_size
11228      attribute or the DW_AT_element_list attribute.  */
11229   if (TYPE_SIZE (type))
11230     {
11231       tree link;
11232
11233       TREE_ASM_WRITTEN (type) = 1;
11234       add_byte_size_attribute (type_die, type);
11235       if (TYPE_STUB_DECL (type) != NULL_TREE)
11236         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11237
11238       /* If the first reference to this type was as the return type of an
11239          inline function, then it may not have a parent.  Fix this now.  */
11240       if (type_die->die_parent == NULL)
11241         add_child_die (scope_die_for (type, context_die), type_die);
11242
11243       for (link = TYPE_VALUES (type);
11244            link != NULL; link = TREE_CHAIN (link))
11245         {
11246           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11247           tree value = TREE_VALUE (link);
11248
11249           add_name_attribute (enum_die,
11250                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11251
11252           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11253             /* DWARF2 does not provide a way of indicating whether or
11254                not enumeration constants are signed or unsigned.  GDB
11255                always assumes the values are signed, so we output all
11256                values as if they were signed.  That means that
11257                enumeration constants with very large unsigned values
11258                will appear to have negative values in the debugger.  */
11259             add_AT_int (enum_die, DW_AT_const_value,
11260                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11261         }
11262     }
11263   else
11264     add_AT_flag (type_die, DW_AT_declaration, 1);
11265
11266   return type_die;
11267 }
11268
11269 /* Generate a DIE to represent either a real live formal parameter decl or to
11270    represent just the type of some formal parameter position in some function
11271    type.
11272
11273    Note that this routine is a bit unusual because its argument may be a
11274    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11275    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11276    node.  If it's the former then this function is being called to output a
11277    DIE to represent a formal parameter object (or some inlining thereof).  If
11278    it's the latter, then this function is only being called to output a
11279    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11280    argument type of some subprogram type.  */
11281
11282 static dw_die_ref
11283 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11284 {
11285   dw_die_ref parm_die
11286     = new_die (DW_TAG_formal_parameter, context_die, node);
11287   tree origin;
11288
11289   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11290     {
11291     case tcc_declaration:
11292       origin = decl_ultimate_origin (node);
11293       if (origin != NULL)
11294         add_abstract_origin_attribute (parm_die, origin);
11295       else
11296         {
11297           add_name_and_src_coords_attributes (parm_die, node);
11298           add_type_attribute (parm_die, TREE_TYPE (node),
11299                               TREE_READONLY (node),
11300                               TREE_THIS_VOLATILE (node),
11301                               context_die);
11302           if (DECL_ARTIFICIAL (node))
11303             add_AT_flag (parm_die, DW_AT_artificial, 1);
11304         }
11305
11306       equate_decl_number_to_die (node, parm_die);
11307       if (! DECL_ABSTRACT (node))
11308         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11309
11310       break;
11311
11312     case tcc_type:
11313       /* We were called with some kind of a ..._TYPE node.  */
11314       add_type_attribute (parm_die, node, 0, 0, context_die);
11315       break;
11316
11317     default:
11318       gcc_unreachable ();
11319     }
11320
11321   return parm_die;
11322 }
11323
11324 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11325    at the end of an (ANSI prototyped) formal parameters list.  */
11326
11327 static void
11328 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11329 {
11330   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11331 }
11332
11333 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11334    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11335    parameters as specified in some function type specification (except for
11336    those which appear as part of a function *definition*).  */
11337
11338 static void
11339 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11340 {
11341   tree link;
11342   tree formal_type = NULL;
11343   tree first_parm_type;
11344   tree arg;
11345
11346   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11347     {
11348       arg = DECL_ARGUMENTS (function_or_method_type);
11349       function_or_method_type = TREE_TYPE (function_or_method_type);
11350     }
11351   else
11352     arg = NULL_TREE;
11353
11354   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11355
11356   /* Make our first pass over the list of formal parameter types and output a
11357      DW_TAG_formal_parameter DIE for each one.  */
11358   for (link = first_parm_type; link; )
11359     {
11360       dw_die_ref parm_die;
11361
11362       formal_type = TREE_VALUE (link);
11363       if (formal_type == void_type_node)
11364         break;
11365
11366       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11367       parm_die = gen_formal_parameter_die (formal_type, context_die);
11368       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11369            && link == first_parm_type)
11370           || (arg && DECL_ARTIFICIAL (arg)))
11371         add_AT_flag (parm_die, DW_AT_artificial, 1);
11372
11373       link = TREE_CHAIN (link);
11374       if (arg)
11375         arg = TREE_CHAIN (arg);
11376     }
11377
11378   /* If this function type has an ellipsis, add a
11379      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11380   if (formal_type != void_type_node)
11381     gen_unspecified_parameters_die (function_or_method_type, context_die);
11382
11383   /* Make our second (and final) pass over the list of formal parameter types
11384      and output DIEs to represent those types (as necessary).  */
11385   for (link = TYPE_ARG_TYPES (function_or_method_type);
11386        link && TREE_VALUE (link);
11387        link = TREE_CHAIN (link))
11388     gen_type_die (TREE_VALUE (link), context_die);
11389 }
11390
11391 /* We want to generate the DIE for TYPE so that we can generate the
11392    die for MEMBER, which has been defined; we will need to refer back
11393    to the member declaration nested within TYPE.  If we're trying to
11394    generate minimal debug info for TYPE, processing TYPE won't do the
11395    trick; we need to attach the member declaration by hand.  */
11396
11397 static void
11398 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11399 {
11400   gen_type_die (type, context_die);
11401
11402   /* If we're trying to avoid duplicate debug info, we may not have
11403      emitted the member decl for this function.  Emit it now.  */
11404   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11405       && ! lookup_decl_die (member))
11406     {
11407       dw_die_ref type_die;
11408       gcc_assert (!decl_ultimate_origin (member));
11409
11410       push_decl_scope (type);
11411       type_die = lookup_type_die (type);
11412       if (TREE_CODE (member) == FUNCTION_DECL)
11413         gen_subprogram_die (member, type_die);
11414       else if (TREE_CODE (member) == FIELD_DECL)
11415         {
11416           /* Ignore the nameless fields that are used to skip bits but handle
11417              C++ anonymous unions and structs.  */
11418           if (DECL_NAME (member) != NULL_TREE
11419               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11420               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11421             {
11422               gen_type_die (member_declared_type (member), type_die);
11423               gen_field_die (member, type_die);
11424             }
11425         }
11426       else
11427         gen_variable_die (member, type_die);
11428
11429       pop_decl_scope ();
11430     }
11431 }
11432
11433 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11434    may later generate inlined and/or out-of-line instances of.  */
11435
11436 static void
11437 dwarf2out_abstract_function (tree decl)
11438 {
11439   dw_die_ref old_die;
11440   tree save_fn;
11441   tree context;
11442   int was_abstract = DECL_ABSTRACT (decl);
11443
11444   /* Make sure we have the actual abstract inline, not a clone.  */
11445   decl = DECL_ORIGIN (decl);
11446
11447   old_die = lookup_decl_die (decl);
11448   if (old_die && get_AT (old_die, DW_AT_inline))
11449     /* We've already generated the abstract instance.  */
11450     return;
11451
11452   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11453      we don't get confused by DECL_ABSTRACT.  */
11454   if (debug_info_level > DINFO_LEVEL_TERSE)
11455     {
11456       context = decl_class_context (decl);
11457       if (context)
11458         gen_type_die_for_member
11459           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11460     }
11461
11462   /* Pretend we've just finished compiling this function.  */
11463   save_fn = current_function_decl;
11464   current_function_decl = decl;
11465
11466   set_decl_abstract_flags (decl, 1);
11467   dwarf2out_decl (decl);
11468   if (! was_abstract)
11469     set_decl_abstract_flags (decl, 0);
11470
11471   current_function_decl = save_fn;
11472 }
11473
11474 /* Generate a DIE to represent a declared function (either file-scope or
11475    block-local).  */
11476
11477 static void
11478 gen_subprogram_die (tree decl, dw_die_ref context_die)
11479 {
11480   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11481   tree origin = decl_ultimate_origin (decl);
11482   dw_die_ref subr_die;
11483   tree fn_arg_types;
11484   tree outer_scope;
11485   dw_die_ref old_die = lookup_decl_die (decl);
11486   int declaration = (current_function_decl != decl
11487                      || class_or_namespace_scope_p (context_die));
11488
11489   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11490      started to generate the abstract instance of an inline, decided to output
11491      its containing class, and proceeded to emit the declaration of the inline
11492      from the member list for the class.  If so, DECLARATION takes priority;
11493      we'll get back to the abstract instance when done with the class.  */
11494
11495   /* The class-scope declaration DIE must be the primary DIE.  */
11496   if (origin && declaration && class_or_namespace_scope_p (context_die))
11497     {
11498       origin = NULL;
11499       gcc_assert (!old_die);
11500     }
11501
11502   /* Now that the C++ front end lazily declares artificial member fns, we
11503      might need to retrofit the declaration into its class.  */
11504   if (!declaration && !origin && !old_die
11505       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11506       && !class_or_namespace_scope_p (context_die)
11507       && debug_info_level > DINFO_LEVEL_TERSE)
11508     old_die = force_decl_die (decl);
11509
11510   if (origin != NULL)
11511     {
11512       gcc_assert (!declaration || local_scope_p (context_die));
11513
11514       /* Fixup die_parent for the abstract instance of a nested
11515          inline function.  */
11516       if (old_die && old_die->die_parent == NULL)
11517         add_child_die (context_die, old_die);
11518
11519       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11520       add_abstract_origin_attribute (subr_die, origin);
11521     }
11522   else if (old_die)
11523     {
11524       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11525       unsigned file_index = lookup_filename (s.file);
11526
11527       if (!get_AT_flag (old_die, DW_AT_declaration)
11528           /* We can have a normal definition following an inline one in the
11529              case of redefinition of GNU C extern inlines.
11530              It seems reasonable to use AT_specification in this case.  */
11531           && !get_AT (old_die, DW_AT_inline))
11532         {
11533           /* Detect and ignore this case, where we are trying to output
11534              something we have already output.  */
11535           return;
11536         }
11537
11538       /* If the definition comes from the same place as the declaration,
11539          maybe use the old DIE.  We always want the DIE for this function
11540          that has the *_pc attributes to be under comp_unit_die so the
11541          debugger can find it.  We also need to do this for abstract
11542          instances of inlines, since the spec requires the out-of-line copy
11543          to have the same parent.  For local class methods, this doesn't
11544          apply; we just use the old DIE.  */
11545       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11546           && (DECL_ARTIFICIAL (decl)
11547               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11548                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11549                       == (unsigned) s.line))))
11550         {
11551           subr_die = old_die;
11552
11553           /* Clear out the declaration attribute and the formal parameters.
11554              Do not remove all children, because it is possible that this
11555              declaration die was forced using force_decl_die(). In such
11556              cases die that forced declaration die (e.g. TAG_imported_module)
11557              is one of the children that we do not want to remove.  */
11558           remove_AT (subr_die, DW_AT_declaration);
11559           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11560         }
11561       else
11562         {
11563           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11564           add_AT_specification (subr_die, old_die);
11565           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11566             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11567           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11568               != (unsigned) s.line)
11569             add_AT_unsigned
11570               (subr_die, DW_AT_decl_line, s.line);
11571         }
11572     }
11573   else
11574     {
11575       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11576
11577       if (TREE_PUBLIC (decl))
11578         add_AT_flag (subr_die, DW_AT_external, 1);
11579
11580       add_name_and_src_coords_attributes (subr_die, decl);
11581       if (debug_info_level > DINFO_LEVEL_TERSE)
11582         {
11583           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11584           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11585                               0, 0, context_die);
11586         }
11587
11588       add_pure_or_virtual_attribute (subr_die, decl);
11589       if (DECL_ARTIFICIAL (decl))
11590         add_AT_flag (subr_die, DW_AT_artificial, 1);
11591
11592       if (TREE_PROTECTED (decl))
11593         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11594       else if (TREE_PRIVATE (decl))
11595         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11596     }
11597
11598   if (declaration)
11599     {
11600       if (!old_die || !get_AT (old_die, DW_AT_inline))
11601         {
11602           add_AT_flag (subr_die, DW_AT_declaration, 1);
11603
11604           /* The first time we see a member function, it is in the context of
11605              the class to which it belongs.  We make sure of this by emitting
11606              the class first.  The next time is the definition, which is
11607              handled above.  The two may come from the same source text.
11608
11609              Note that force_decl_die() forces function declaration die. It is
11610              later reused to represent definition.  */
11611           equate_decl_number_to_die (decl, subr_die);
11612         }
11613     }
11614   else if (DECL_ABSTRACT (decl))
11615     {
11616       if (DECL_DECLARED_INLINE_P (decl))
11617         {
11618           if (cgraph_function_possibly_inlined_p (decl))
11619             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11620           else
11621             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11622         }
11623       else
11624         {
11625           if (cgraph_function_possibly_inlined_p (decl))
11626             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11627           else
11628             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11629         }
11630
11631       equate_decl_number_to_die (decl, subr_die);
11632     }
11633   else if (!DECL_EXTERNAL (decl))
11634     {
11635       if (!old_die || !get_AT (old_die, DW_AT_inline))
11636         equate_decl_number_to_die (decl, subr_die);
11637
11638       if (!flag_reorder_blocks_and_partition)
11639         {
11640           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11641                                        current_function_funcdef_no);
11642           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11643           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11644                                        current_function_funcdef_no);
11645           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11646
11647           add_pubname (decl, subr_die);
11648           add_arange (decl, subr_die);
11649         }
11650       else
11651         {  /* Do nothing for now; maybe need to duplicate die, one for
11652               hot section and ond for cold section, then use the hot/cold
11653               section begin/end labels to generate the aranges...  */
11654           /*
11655             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11656             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11657             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11658             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11659
11660             add_pubname (decl, subr_die);
11661             add_arange (decl, subr_die);
11662             add_arange (decl, subr_die);
11663            */
11664         }
11665
11666 #ifdef MIPS_DEBUGGING_INFO
11667       /* Add a reference to the FDE for this routine.  */
11668       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11669 #endif
11670
11671 #ifdef DWARF2_UNWIND_INFO
11672       /* We define the "frame base" as the function's CFA.  This is more
11673          convenient for several reasons: (1) It's stable across the prologue
11674          and epilogue, which makes it better than just a frame pointer,
11675          (2) With dwarf3, there exists a one-byte encoding that allows us
11676          to reference the .debug_frame data by proxy, but failing that,
11677          (3) We can at least reuse the code inspection and interpretation
11678          code that determines the CFA position at various points in the
11679          function.  */
11680       /* ??? Use some command-line or configury switch to enable the use
11681          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
11682          consumers that understand it; fall back to "pure" dwarf2 and
11683          convert the CFA data into a location list.  */
11684       {
11685         dw_loc_list_ref list = convert_cfa_to_loc_list ();
11686         if (list->dw_loc_next)
11687           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11688         else
11689           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11690       }
11691
11692       /* Compute a displacement from the "steady-state frame pointer" to
11693          the CFA.  The former is what all stack slots and argument slots
11694          will reference in the rtl; the later is what we've told the
11695          debugger about.  We'll need to adjust all frame_base references
11696          by this displacement.  */
11697       compute_frame_pointer_to_cfa_displacement ();
11698 #else
11699       /* For targets which support DWARF2, but not DWARF2 call-frame info,
11700          we just use the stack pointer or frame pointer.  */
11701       /* ??? Should investigate getting better info via callbacks, or else
11702          by interpreting the IA-64 unwind info.  */
11703       {
11704         rtx fp_reg
11705           = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
11706         add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
11707       }
11708 #endif
11709
11710       if (cfun->static_chain_decl)
11711         add_AT_location_description (subr_die, DW_AT_static_link,
11712                  loc_descriptor_from_tree (cfun->static_chain_decl));
11713     }
11714
11715   /* Now output descriptions of the arguments for this function. This gets
11716      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11717      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11718      `...' at the end of the formal parameter list.  In order to find out if
11719      there was a trailing ellipsis or not, we must instead look at the type
11720      associated with the FUNCTION_DECL.  This will be a node of type
11721      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11722      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11723      an ellipsis at the end.  */
11724
11725   /* In the case where we are describing a mere function declaration, all we
11726      need to do here (and all we *can* do here) is to describe the *types* of
11727      its formal parameters.  */
11728   if (debug_info_level <= DINFO_LEVEL_TERSE)
11729     ;
11730   else if (declaration)
11731     gen_formal_types_die (decl, subr_die);
11732   else
11733     {
11734       /* Generate DIEs to represent all known formal parameters.  */
11735       tree arg_decls = DECL_ARGUMENTS (decl);
11736       tree parm;
11737
11738       /* When generating DIEs, generate the unspecified_parameters DIE
11739          instead if we come across the arg "__builtin_va_alist" */
11740       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11741         if (TREE_CODE (parm) == PARM_DECL)
11742           {
11743             if (DECL_NAME (parm)
11744                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11745                             "__builtin_va_alist"))
11746               gen_unspecified_parameters_die (parm, subr_die);
11747             else
11748               gen_decl_die (parm, subr_die);
11749           }
11750
11751       /* Decide whether we need an unspecified_parameters DIE at the end.
11752          There are 2 more cases to do this for: 1) the ansi ... declaration -
11753          this is detectable when the end of the arg list is not a
11754          void_type_node 2) an unprototyped function declaration (not a
11755          definition).  This just means that we have no info about the
11756          parameters at all.  */
11757       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11758       if (fn_arg_types != NULL)
11759         {
11760           /* This is the prototyped case, check for....  */
11761           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11762             gen_unspecified_parameters_die (decl, subr_die);
11763         }
11764       else if (DECL_INITIAL (decl) == NULL_TREE)
11765         gen_unspecified_parameters_die (decl, subr_die);
11766     }
11767
11768   /* Output Dwarf info for all of the stuff within the body of the function
11769      (if it has one - it may be just a declaration).  */
11770   outer_scope = DECL_INITIAL (decl);
11771
11772   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11773      a function.  This BLOCK actually represents the outermost binding contour
11774      for the function, i.e. the contour in which the function's formal
11775      parameters and labels get declared. Curiously, it appears that the front
11776      end doesn't actually put the PARM_DECL nodes for the current function onto
11777      the BLOCK_VARS list for this outer scope, but are strung off of the
11778      DECL_ARGUMENTS list for the function instead.
11779
11780      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11781      the LABEL_DECL nodes for the function however, and we output DWARF info
11782      for those in decls_for_scope.  Just within the `outer_scope' there will be
11783      a BLOCK node representing the function's outermost pair of curly braces,
11784      and any blocks used for the base and member initializers of a C++
11785      constructor function.  */
11786   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11787     {
11788       /* Emit a DW_TAG_variable DIE for a named return value.  */
11789       if (DECL_NAME (DECL_RESULT (decl)))
11790         gen_decl_die (DECL_RESULT (decl), subr_die);
11791
11792       current_function_has_inlines = 0;
11793       decls_for_scope (outer_scope, subr_die, 0);
11794
11795 #if 0 && defined (MIPS_DEBUGGING_INFO)
11796       if (current_function_has_inlines)
11797         {
11798           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11799           if (! comp_unit_has_inlines)
11800             {
11801               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11802               comp_unit_has_inlines = 1;
11803             }
11804         }
11805 #endif
11806     }
11807   /* Add the calling convention attribute if requested.  */
11808   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11809
11810 }
11811
11812 /* Generate a DIE to represent a declared data object.  */
11813
11814 static void
11815 gen_variable_die (tree decl, dw_die_ref context_die)
11816 {
11817   tree origin = decl_ultimate_origin (decl);
11818   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11819
11820   dw_die_ref old_die = lookup_decl_die (decl);
11821   int declaration = (DECL_EXTERNAL (decl)
11822                      /* If DECL is COMDAT and has not actually been
11823                         emitted, we cannot take its address; there
11824                         might end up being no definition anywhere in
11825                         the program.  For example, consider the C++
11826                         test case:
11827
11828                           template <class T>
11829                           struct S { static const int i = 7; };
11830
11831                           template <class T>
11832                           const int S<T>::i;
11833
11834                           int f() { return S<int>::i; }
11835
11836                         Here, S<int>::i is not DECL_EXTERNAL, but no
11837                         definition is required, so the compiler will
11838                         not emit a definition.  */
11839                      || (TREE_CODE (decl) == VAR_DECL
11840                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11841                      || class_or_namespace_scope_p (context_die));
11842
11843   if (origin != NULL)
11844     add_abstract_origin_attribute (var_die, origin);
11845
11846   /* Loop unrolling can create multiple blocks that refer to the same
11847      static variable, so we must test for the DW_AT_declaration flag.
11848
11849      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11850      copy decls and set the DECL_ABSTRACT flag on them instead of
11851      sharing them.
11852
11853      ??? Duplicated blocks have been rewritten to use .debug_ranges.
11854
11855      ??? The declare_in_namespace support causes us to get two DIEs for one
11856      variable, both of which are declarations.  We want to avoid considering
11857      one to be a specification, so we must test that this DIE is not a
11858      declaration.  */
11859   else if (old_die && TREE_STATIC (decl) && ! declaration
11860            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11861     {
11862       /* This is a definition of a C++ class level static.  */
11863       add_AT_specification (var_die, old_die);
11864       if (DECL_NAME (decl))
11865         {
11866           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11867           unsigned file_index = lookup_filename (s.file);
11868
11869           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11870             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11871
11872           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11873               != (unsigned) s.line)
11874
11875             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11876         }
11877     }
11878   else
11879     {
11880       add_name_and_src_coords_attributes (var_die, decl);
11881       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11882                           TREE_THIS_VOLATILE (decl), context_die);
11883
11884       if (TREE_PUBLIC (decl))
11885         add_AT_flag (var_die, DW_AT_external, 1);
11886
11887       if (DECL_ARTIFICIAL (decl))
11888         add_AT_flag (var_die, DW_AT_artificial, 1);
11889
11890       if (TREE_PROTECTED (decl))
11891         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11892       else if (TREE_PRIVATE (decl))
11893         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11894     }
11895
11896   if (declaration)
11897     add_AT_flag (var_die, DW_AT_declaration, 1);
11898
11899   if (DECL_ABSTRACT (decl) || declaration)
11900     equate_decl_number_to_die (decl, var_die);
11901
11902   if (! declaration && ! DECL_ABSTRACT (decl))
11903     {
11904       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11905       add_pubname (decl, var_die);
11906     }
11907   else
11908     tree_add_const_value_attribute (var_die, decl);
11909 }
11910
11911 /* Generate a DIE to represent a label identifier.  */
11912
11913 static void
11914 gen_label_die (tree decl, dw_die_ref context_die)
11915 {
11916   tree origin = decl_ultimate_origin (decl);
11917   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11918   rtx insn;
11919   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11920
11921   if (origin != NULL)
11922     add_abstract_origin_attribute (lbl_die, origin);
11923   else
11924     add_name_and_src_coords_attributes (lbl_die, decl);
11925
11926   if (DECL_ABSTRACT (decl))
11927     equate_decl_number_to_die (decl, lbl_die);
11928   else
11929     {
11930       insn = DECL_RTL_IF_SET (decl);
11931
11932       /* Deleted labels are programmer specified labels which have been
11933          eliminated because of various optimizations.  We still emit them
11934          here so that it is possible to put breakpoints on them.  */
11935       if (insn
11936           && (LABEL_P (insn)
11937               || ((NOTE_P (insn)
11938                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11939         {
11940           /* When optimization is enabled (via -O) some parts of the compiler
11941              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11942              represent source-level labels which were explicitly declared by
11943              the user.  This really shouldn't be happening though, so catch
11944              it if it ever does happen.  */
11945           gcc_assert (!INSN_DELETED_P (insn));
11946
11947           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11948           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11949         }
11950     }
11951 }
11952
11953 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
11954    attributes to the DIE for a block STMT, to describe where the inlined
11955    function was called from.  This is similar to add_src_coords_attributes.  */
11956
11957 static inline void
11958 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
11959 {
11960   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
11961   unsigned file_index = lookup_filename (s.file);
11962
11963   add_AT_unsigned (die, DW_AT_call_file, file_index);
11964   add_AT_unsigned (die, DW_AT_call_line, s.line);
11965 }
11966
11967 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
11968    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
11969
11970 static inline void
11971 add_high_low_attributes (tree stmt, dw_die_ref die)
11972 {
11973   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11974
11975   if (BLOCK_FRAGMENT_CHAIN (stmt))
11976     {
11977       tree chain;
11978
11979       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
11980
11981       chain = BLOCK_FRAGMENT_CHAIN (stmt);
11982       do
11983         {
11984           add_ranges (chain);
11985           chain = BLOCK_FRAGMENT_CHAIN (chain);
11986         }
11987       while (chain);
11988       add_ranges (NULL);
11989     }
11990   else
11991     {
11992       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11993                                    BLOCK_NUMBER (stmt));
11994       add_AT_lbl_id (die, DW_AT_low_pc, label);
11995       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11996                                    BLOCK_NUMBER (stmt));
11997       add_AT_lbl_id (die, DW_AT_high_pc, label);
11998     }
11999 }
12000
12001 /* Generate a DIE for a lexical block.  */
12002
12003 static void
12004 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12005 {
12006   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12007
12008   if (! BLOCK_ABSTRACT (stmt))
12009     add_high_low_attributes (stmt, stmt_die);
12010
12011   decls_for_scope (stmt, stmt_die, depth);
12012 }
12013
12014 /* Generate a DIE for an inlined subprogram.  */
12015
12016 static void
12017 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12018 {
12019   tree decl = block_ultimate_origin (stmt);
12020
12021   /* Emit info for the abstract instance first, if we haven't yet.  We
12022      must emit this even if the block is abstract, otherwise when we
12023      emit the block below (or elsewhere), we may end up trying to emit
12024      a die whose origin die hasn't been emitted, and crashing.  */
12025   dwarf2out_abstract_function (decl);
12026
12027   if (! BLOCK_ABSTRACT (stmt))
12028     {
12029       dw_die_ref subr_die
12030         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12031
12032       add_abstract_origin_attribute (subr_die, decl);
12033       add_high_low_attributes (stmt, subr_die);
12034       add_call_src_coords_attributes (stmt, subr_die);
12035
12036       decls_for_scope (stmt, subr_die, depth);
12037       current_function_has_inlines = 1;
12038     }
12039   else
12040     /* We may get here if we're the outer block of function A that was
12041        inlined into function B that was inlined into function C.  When
12042        generating debugging info for C, dwarf2out_abstract_function(B)
12043        would mark all inlined blocks as abstract, including this one.
12044        So, we wouldn't (and shouldn't) expect labels to be generated
12045        for this one.  Instead, just emit debugging info for
12046        declarations within the block.  This is particularly important
12047        in the case of initializers of arguments passed from B to us:
12048        if they're statement expressions containing declarations, we
12049        wouldn't generate dies for their abstract variables, and then,
12050        when generating dies for the real variables, we'd die (pun
12051        intended :-)  */
12052     gen_lexical_block_die (stmt, context_die, depth);
12053 }
12054
12055 /* Generate a DIE for a field in a record, or structure.  */
12056
12057 static void
12058 gen_field_die (tree decl, dw_die_ref context_die)
12059 {
12060   dw_die_ref decl_die;
12061
12062   if (TREE_TYPE (decl) == error_mark_node)
12063     return;
12064
12065   decl_die = new_die (DW_TAG_member, context_die, decl);
12066   add_name_and_src_coords_attributes (decl_die, decl);
12067   add_type_attribute (decl_die, member_declared_type (decl),
12068                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12069                       context_die);
12070
12071   if (DECL_BIT_FIELD_TYPE (decl))
12072     {
12073       add_byte_size_attribute (decl_die, decl);
12074       add_bit_size_attribute (decl_die, decl);
12075       add_bit_offset_attribute (decl_die, decl);
12076     }
12077
12078   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12079     add_data_member_location_attribute (decl_die, decl);
12080
12081   if (DECL_ARTIFICIAL (decl))
12082     add_AT_flag (decl_die, DW_AT_artificial, 1);
12083
12084   if (TREE_PROTECTED (decl))
12085     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12086   else if (TREE_PRIVATE (decl))
12087     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12088
12089   /* Equate decl number to die, so that we can look up this decl later on.  */
12090   equate_decl_number_to_die (decl, decl_die);
12091 }
12092
12093 #if 0
12094 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12095    Use modified_type_die instead.
12096    We keep this code here just in case these types of DIEs may be needed to
12097    represent certain things in other languages (e.g. Pascal) someday.  */
12098
12099 static void
12100 gen_pointer_type_die (tree type, dw_die_ref context_die)
12101 {
12102   dw_die_ref ptr_die
12103     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12104
12105   equate_type_number_to_die (type, ptr_die);
12106   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12107   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12108 }
12109
12110 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12111    Use modified_type_die instead.
12112    We keep this code here just in case these types of DIEs may be needed to
12113    represent certain things in other languages (e.g. Pascal) someday.  */
12114
12115 static void
12116 gen_reference_type_die (tree type, dw_die_ref context_die)
12117 {
12118   dw_die_ref ref_die
12119     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12120
12121   equate_type_number_to_die (type, ref_die);
12122   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12123   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12124 }
12125 #endif
12126
12127 /* Generate a DIE for a pointer to a member type.  */
12128
12129 static void
12130 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12131 {
12132   dw_die_ref ptr_die
12133     = new_die (DW_TAG_ptr_to_member_type,
12134                scope_die_for (type, context_die), type);
12135
12136   equate_type_number_to_die (type, ptr_die);
12137   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12138                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12139   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12140 }
12141
12142 /* Generate the DIE for the compilation unit.  */
12143
12144 static dw_die_ref
12145 gen_compile_unit_die (const char *filename)
12146 {
12147   dw_die_ref die;
12148   char producer[250];
12149   const char *language_string = lang_hooks.name;
12150   int language;
12151
12152   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12153
12154   if (filename)
12155     {
12156       add_name_attribute (die, filename);
12157       /* Don't add cwd for <built-in>.  */
12158       if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12159         add_comp_dir_attribute (die);
12160     }
12161
12162   sprintf (producer, "%s %s", language_string, version_string);
12163
12164 #ifdef MIPS_DEBUGGING_INFO
12165   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12166      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12167      not appear in the producer string, the debugger reaches the conclusion
12168      that the object file is stripped and has no debugging information.
12169      To get the MIPS/SGI debugger to believe that there is debugging
12170      information in the object file, we add a -g to the producer string.  */
12171   if (debug_info_level > DINFO_LEVEL_TERSE)
12172     strcat (producer, " -g");
12173 #endif
12174
12175   add_AT_string (die, DW_AT_producer, producer);
12176
12177   if (strcmp (language_string, "GNU C++") == 0)
12178     language = DW_LANG_C_plus_plus;
12179   else if (strcmp (language_string, "GNU Ada") == 0)
12180     language = DW_LANG_Ada95;
12181   else if (strcmp (language_string, "GNU F77") == 0)
12182     language = DW_LANG_Fortran77;
12183   else if (strcmp (language_string, "GNU F95") == 0)
12184     language = DW_LANG_Fortran95;
12185   else if (strcmp (language_string, "GNU Pascal") == 0)
12186     language = DW_LANG_Pascal83;
12187   else if (strcmp (language_string, "GNU Java") == 0)
12188     language = DW_LANG_Java;
12189   else
12190     language = DW_LANG_C89;
12191
12192   add_AT_unsigned (die, DW_AT_language, language);
12193   return die;
12194 }
12195
12196 /* Generate a DIE for a string type.  */
12197
12198 static void
12199 gen_string_type_die (tree type, dw_die_ref context_die)
12200 {
12201   dw_die_ref type_die
12202     = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
12203
12204   equate_type_number_to_die (type, type_die);
12205
12206   /* ??? Fudge the string length attribute for now.
12207      TODO: add string length info.  */
12208 #if 0
12209   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
12210   bound_representation (upper_bound, 0, 'u');
12211 #endif
12212 }
12213
12214 /* Generate the DIE for a base class.  */
12215
12216 static void
12217 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12218 {
12219   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12220
12221   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12222   add_data_member_location_attribute (die, binfo);
12223
12224   if (BINFO_VIRTUAL_P (binfo))
12225     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12226
12227   if (access == access_public_node)
12228     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12229   else if (access == access_protected_node)
12230     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12231 }
12232
12233 /* Generate a DIE for a class member.  */
12234
12235 static void
12236 gen_member_die (tree type, dw_die_ref context_die)
12237 {
12238   tree member;
12239   tree binfo = TYPE_BINFO (type);
12240   dw_die_ref child;
12241
12242   /* If this is not an incomplete type, output descriptions of each of its
12243      members. Note that as we output the DIEs necessary to represent the
12244      members of this record or union type, we will also be trying to output
12245      DIEs to represent the *types* of those members. However the `type'
12246      function (above) will specifically avoid generating type DIEs for member
12247      types *within* the list of member DIEs for this (containing) type except
12248      for those types (of members) which are explicitly marked as also being
12249      members of this (containing) type themselves.  The g++ front- end can
12250      force any given type to be treated as a member of some other (containing)
12251      type by setting the TYPE_CONTEXT of the given (member) type to point to
12252      the TREE node representing the appropriate (containing) type.  */
12253
12254   /* First output info about the base classes.  */
12255   if (binfo)
12256     {
12257       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12258       int i;
12259       tree base;
12260
12261       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12262         gen_inheritance_die (base,
12263                              (accesses ? VEC_index (tree, accesses, i)
12264                               : access_public_node), context_die);
12265     }
12266
12267   /* Now output info about the data members and type members.  */
12268   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12269     {
12270       /* If we thought we were generating minimal debug info for TYPE
12271          and then changed our minds, some of the member declarations
12272          may have already been defined.  Don't define them again, but
12273          do put them in the right order.  */
12274
12275       child = lookup_decl_die (member);
12276       if (child)
12277         splice_child_die (context_die, child);
12278       else
12279         gen_decl_die (member, context_die);
12280     }
12281
12282   /* Now output info about the function members (if any).  */
12283   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12284     {
12285       /* Don't include clones in the member list.  */
12286       if (DECL_ABSTRACT_ORIGIN (member))
12287         continue;
12288
12289       child = lookup_decl_die (member);
12290       if (child)
12291         splice_child_die (context_die, child);
12292       else
12293         gen_decl_die (member, context_die);
12294     }
12295 }
12296
12297 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12298    is set, we pretend that the type was never defined, so we only get the
12299    member DIEs needed by later specification DIEs.  */
12300
12301 static void
12302 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12303 {
12304   dw_die_ref type_die = lookup_type_die (type);
12305   dw_die_ref scope_die = 0;
12306   int nested = 0;
12307   int complete = (TYPE_SIZE (type)
12308                   && (! TYPE_STUB_DECL (type)
12309                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12310   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12311
12312   if (type_die && ! complete)
12313     return;
12314
12315   if (TYPE_CONTEXT (type) != NULL_TREE
12316       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12317           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12318     nested = 1;
12319
12320   scope_die = scope_die_for (type, context_die);
12321
12322   if (! type_die || (nested && scope_die == comp_unit_die))
12323     /* First occurrence of type or toplevel definition of nested class.  */
12324     {
12325       dw_die_ref old_die = type_die;
12326
12327       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12328                           ? DW_TAG_structure_type : DW_TAG_union_type,
12329                           scope_die, type);
12330       equate_type_number_to_die (type, type_die);
12331       if (old_die)
12332         add_AT_specification (type_die, old_die);
12333       else
12334         add_name_attribute (type_die, type_tag (type));
12335     }
12336   else
12337     remove_AT (type_die, DW_AT_declaration);
12338
12339   /* If this type has been completed, then give it a byte_size attribute and
12340      then give a list of members.  */
12341   if (complete && !ns_decl)
12342     {
12343       /* Prevent infinite recursion in cases where the type of some member of
12344          this type is expressed in terms of this type itself.  */
12345       TREE_ASM_WRITTEN (type) = 1;
12346       add_byte_size_attribute (type_die, type);
12347       if (TYPE_STUB_DECL (type) != NULL_TREE)
12348         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12349
12350       /* If the first reference to this type was as the return type of an
12351          inline function, then it may not have a parent.  Fix this now.  */
12352       if (type_die->die_parent == NULL)
12353         add_child_die (scope_die, type_die);
12354
12355       push_decl_scope (type);
12356       gen_member_die (type, type_die);
12357       pop_decl_scope ();
12358
12359       /* GNU extension: Record what type our vtable lives in.  */
12360       if (TYPE_VFIELD (type))
12361         {
12362           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12363
12364           gen_type_die (vtype, context_die);
12365           add_AT_die_ref (type_die, DW_AT_containing_type,
12366                           lookup_type_die (vtype));
12367         }
12368     }
12369   else
12370     {
12371       add_AT_flag (type_die, DW_AT_declaration, 1);
12372
12373       /* We don't need to do this for function-local types.  */
12374       if (TYPE_STUB_DECL (type)
12375           && ! decl_function_context (TYPE_STUB_DECL (type)))
12376         VEC_safe_push (tree, gc, incomplete_types, type);
12377     }
12378 }
12379
12380 /* Generate a DIE for a subroutine _type_.  */
12381
12382 static void
12383 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12384 {
12385   tree return_type = TREE_TYPE (type);
12386   dw_die_ref subr_die
12387     = new_die (DW_TAG_subroutine_type,
12388                scope_die_for (type, context_die), type);
12389
12390   equate_type_number_to_die (type, subr_die);
12391   add_prototyped_attribute (subr_die, type);
12392   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12393   gen_formal_types_die (type, subr_die);
12394 }
12395
12396 /* Generate a DIE for a type definition.  */
12397
12398 static void
12399 gen_typedef_die (tree decl, dw_die_ref context_die)
12400 {
12401   dw_die_ref type_die;
12402   tree origin;
12403
12404   if (TREE_ASM_WRITTEN (decl))
12405     return;
12406
12407   TREE_ASM_WRITTEN (decl) = 1;
12408   type_die = new_die (DW_TAG_typedef, context_die, decl);
12409   origin = decl_ultimate_origin (decl);
12410   if (origin != NULL)
12411     add_abstract_origin_attribute (type_die, origin);
12412   else
12413     {
12414       tree type;
12415
12416       add_name_and_src_coords_attributes (type_die, decl);
12417       if (DECL_ORIGINAL_TYPE (decl))
12418         {
12419           type = DECL_ORIGINAL_TYPE (decl);
12420
12421           gcc_assert (type != TREE_TYPE (decl));
12422           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12423         }
12424       else
12425         type = TREE_TYPE (decl);
12426
12427       add_type_attribute (type_die, type, TREE_READONLY (decl),
12428                           TREE_THIS_VOLATILE (decl), context_die);
12429     }
12430
12431   if (DECL_ABSTRACT (decl))
12432     equate_decl_number_to_die (decl, type_die);
12433 }
12434
12435 /* Generate a type description DIE.  */
12436
12437 static void
12438 gen_type_die (tree type, dw_die_ref context_die)
12439 {
12440   int need_pop;
12441
12442   if (type == NULL_TREE || type == error_mark_node)
12443     return;
12444
12445   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12446       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12447     {
12448       if (TREE_ASM_WRITTEN (type))
12449         return;
12450
12451       /* Prevent broken recursion; we can't hand off to the same type.  */
12452       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12453
12454       TREE_ASM_WRITTEN (type) = 1;
12455       gen_decl_die (TYPE_NAME (type), context_die);
12456       return;
12457     }
12458
12459   /* We are going to output a DIE to represent the unqualified version
12460      of this type (i.e. without any const or volatile qualifiers) so
12461      get the main variant (i.e. the unqualified version) of this type
12462      now.  (Vectors are special because the debugging info is in the
12463      cloned type itself).  */
12464   if (TREE_CODE (type) != VECTOR_TYPE)
12465     type = type_main_variant (type);
12466
12467   if (TREE_ASM_WRITTEN (type))
12468     return;
12469
12470   switch (TREE_CODE (type))
12471     {
12472     case ERROR_MARK:
12473       break;
12474
12475     case POINTER_TYPE:
12476     case REFERENCE_TYPE:
12477       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12478          ensures that the gen_type_die recursion will terminate even if the
12479          type is recursive.  Recursive types are possible in Ada.  */
12480       /* ??? We could perhaps do this for all types before the switch
12481          statement.  */
12482       TREE_ASM_WRITTEN (type) = 1;
12483
12484       /* For these types, all that is required is that we output a DIE (or a
12485          set of DIEs) to represent the "basis" type.  */
12486       gen_type_die (TREE_TYPE (type), context_die);
12487       break;
12488
12489     case OFFSET_TYPE:
12490       /* This code is used for C++ pointer-to-data-member types.
12491          Output a description of the relevant class type.  */
12492       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12493
12494       /* Output a description of the type of the object pointed to.  */
12495       gen_type_die (TREE_TYPE (type), context_die);
12496
12497       /* Now output a DIE to represent this pointer-to-data-member type
12498          itself.  */
12499       gen_ptr_to_mbr_type_die (type, context_die);
12500       break;
12501
12502     case FUNCTION_TYPE:
12503       /* Force out return type (in case it wasn't forced out already).  */
12504       gen_type_die (TREE_TYPE (type), context_die);
12505       gen_subroutine_type_die (type, context_die);
12506       break;
12507
12508     case METHOD_TYPE:
12509       /* Force out return type (in case it wasn't forced out already).  */
12510       gen_type_die (TREE_TYPE (type), context_die);
12511       gen_subroutine_type_die (type, context_die);
12512       break;
12513
12514     case ARRAY_TYPE:
12515       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
12516         {
12517           gen_type_die (TREE_TYPE (type), context_die);
12518           gen_string_type_die (type, context_die);
12519         }
12520       else
12521         gen_array_type_die (type, context_die);
12522       break;
12523
12524     case VECTOR_TYPE:
12525       gen_array_type_die (type, context_die);
12526       break;
12527
12528     case ENUMERAL_TYPE:
12529     case RECORD_TYPE:
12530     case UNION_TYPE:
12531     case QUAL_UNION_TYPE:
12532       /* If this is a nested type whose containing class hasn't been written
12533          out yet, writing it out will cover this one, too.  This does not apply
12534          to instantiations of member class templates; they need to be added to
12535          the containing class as they are generated.  FIXME: This hurts the
12536          idea of combining type decls from multiple TUs, since we can't predict
12537          what set of template instantiations we'll get.  */
12538       if (TYPE_CONTEXT (type)
12539           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12540           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12541         {
12542           gen_type_die (TYPE_CONTEXT (type), context_die);
12543
12544           if (TREE_ASM_WRITTEN (type))
12545             return;
12546
12547           /* If that failed, attach ourselves to the stub.  */
12548           push_decl_scope (TYPE_CONTEXT (type));
12549           context_die = lookup_type_die (TYPE_CONTEXT (type));
12550           need_pop = 1;
12551         }
12552       else
12553         {
12554           declare_in_namespace (type, context_die);
12555           need_pop = 0;
12556         }
12557
12558       if (TREE_CODE (type) == ENUMERAL_TYPE)
12559         gen_enumeration_type_die (type, context_die);
12560       else
12561         gen_struct_or_union_type_die (type, context_die);
12562
12563       if (need_pop)
12564         pop_decl_scope ();
12565
12566       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12567          it up if it is ever completed.  gen_*_type_die will set it for us
12568          when appropriate.  */
12569       return;
12570
12571     case VOID_TYPE:
12572     case INTEGER_TYPE:
12573     case REAL_TYPE:
12574     case COMPLEX_TYPE:
12575     case BOOLEAN_TYPE:
12576     case CHAR_TYPE:
12577       /* No DIEs needed for fundamental types.  */
12578       break;
12579
12580     case LANG_TYPE:
12581       /* No Dwarf representation currently defined.  */
12582       break;
12583
12584     default:
12585       gcc_unreachable ();
12586     }
12587
12588   TREE_ASM_WRITTEN (type) = 1;
12589 }
12590
12591 /* Generate a DIE for a tagged type instantiation.  */
12592
12593 static void
12594 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12595 {
12596   if (type == NULL_TREE || type == error_mark_node)
12597     return;
12598
12599   /* We are going to output a DIE to represent the unqualified version of
12600      this type (i.e. without any const or volatile qualifiers) so make sure
12601      that we have the main variant (i.e. the unqualified version) of this
12602      type now.  */
12603   gcc_assert (type == type_main_variant (type));
12604
12605   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12606      an instance of an unresolved type.  */
12607
12608   switch (TREE_CODE (type))
12609     {
12610     case ERROR_MARK:
12611       break;
12612
12613     case ENUMERAL_TYPE:
12614       gen_inlined_enumeration_type_die (type, context_die);
12615       break;
12616
12617     case RECORD_TYPE:
12618       gen_inlined_structure_type_die (type, context_die);
12619       break;
12620
12621     case UNION_TYPE:
12622     case QUAL_UNION_TYPE:
12623       gen_inlined_union_type_die (type, context_die);
12624       break;
12625
12626     default:
12627       gcc_unreachable ();
12628     }
12629 }
12630
12631 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12632    things which are local to the given block.  */
12633
12634 static void
12635 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12636 {
12637   int must_output_die = 0;
12638   tree origin;
12639   tree decl;
12640   enum tree_code origin_code;
12641
12642   /* Ignore blocks that are NULL.  */
12643   if (stmt == NULL_TREE)
12644     return;
12645
12646   /* If the block is one fragment of a non-contiguous block, do not
12647      process the variables, since they will have been done by the
12648      origin block.  Do process subblocks.  */
12649   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12650     {
12651       tree sub;
12652
12653       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12654         gen_block_die (sub, context_die, depth + 1);
12655
12656       return;
12657     }
12658
12659   /* Determine the "ultimate origin" of this block.  This block may be an
12660      inlined instance of an inlined instance of inline function, so we have
12661      to trace all of the way back through the origin chain to find out what
12662      sort of node actually served as the original seed for the creation of
12663      the current block.  */
12664   origin = block_ultimate_origin (stmt);
12665   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12666
12667   /* Determine if we need to output any Dwarf DIEs at all to represent this
12668      block.  */
12669   if (origin_code == FUNCTION_DECL)
12670     /* The outer scopes for inlinings *must* always be represented.  We
12671        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12672     must_output_die = 1;
12673   else
12674     {
12675       /* In the case where the current block represents an inlining of the
12676          "body block" of an inline function, we must *NOT* output any DIE for
12677          this block because we have already output a DIE to represent the whole
12678          inlined function scope and the "body block" of any function doesn't
12679          really represent a different scope according to ANSI C rules.  So we
12680          check here to make sure that this block does not represent a "body
12681          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12682       if (! is_body_block (origin ? origin : stmt))
12683         {
12684           /* Determine if this block directly contains any "significant"
12685              local declarations which we will need to output DIEs for.  */
12686           if (debug_info_level > DINFO_LEVEL_TERSE)
12687             /* We are not in terse mode so *any* local declaration counts
12688                as being a "significant" one.  */
12689             must_output_die = (BLOCK_VARS (stmt) != NULL
12690                                && (TREE_USED (stmt)
12691                                    || TREE_ASM_WRITTEN (stmt)
12692                                    || BLOCK_ABSTRACT (stmt)));
12693           else
12694             /* We are in terse mode, so only local (nested) function
12695                definitions count as "significant" local declarations.  */
12696             for (decl = BLOCK_VARS (stmt);
12697                  decl != NULL; decl = TREE_CHAIN (decl))
12698               if (TREE_CODE (decl) == FUNCTION_DECL
12699                   && DECL_INITIAL (decl))
12700                 {
12701                   must_output_die = 1;
12702                   break;
12703                 }
12704         }
12705     }
12706
12707   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12708      DIE for any block which contains no significant local declarations at
12709      all.  Rather, in such cases we just call `decls_for_scope' so that any
12710      needed Dwarf info for any sub-blocks will get properly generated. Note
12711      that in terse mode, our definition of what constitutes a "significant"
12712      local declaration gets restricted to include only inlined function
12713      instances and local (nested) function definitions.  */
12714   if (must_output_die)
12715     {
12716       if (origin_code == FUNCTION_DECL)
12717         gen_inlined_subroutine_die (stmt, context_die, depth);
12718       else
12719         gen_lexical_block_die (stmt, context_die, depth);
12720     }
12721   else
12722     decls_for_scope (stmt, context_die, depth);
12723 }
12724
12725 /* Generate all of the decls declared within a given scope and (recursively)
12726    all of its sub-blocks.  */
12727
12728 static void
12729 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12730 {
12731   tree decl;
12732   tree subblocks;
12733
12734   /* Ignore NULL blocks.  */
12735   if (stmt == NULL_TREE)
12736     return;
12737
12738   if (TREE_USED (stmt))
12739     {
12740       /* Output the DIEs to represent all of the data objects and typedefs
12741          declared directly within this block but not within any nested
12742          sub-blocks.  Also, nested function and tag DIEs have been
12743          generated with a parent of NULL; fix that up now.  */
12744       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12745         {
12746           dw_die_ref die;
12747
12748           if (TREE_CODE (decl) == FUNCTION_DECL)
12749             die = lookup_decl_die (decl);
12750           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12751             die = lookup_type_die (TREE_TYPE (decl));
12752           else
12753             die = NULL;
12754
12755           if (die != NULL && die->die_parent == NULL)
12756             add_child_die (context_die, die);
12757           /* Do not produce debug information for static variables since
12758              these might be optimized out.  We are called for these later
12759              in cgraph_varpool_analyze_pending_decls. */
12760           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12761             ;
12762           else
12763             gen_decl_die (decl, context_die);
12764         }
12765     }
12766
12767   /* If we're at -g1, we're not interested in subblocks.  */
12768   if (debug_info_level <= DINFO_LEVEL_TERSE)
12769     return;
12770
12771   /* Output the DIEs to represent all sub-blocks (and the items declared
12772      therein) of this block.  */
12773   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12774        subblocks != NULL;
12775        subblocks = BLOCK_CHAIN (subblocks))
12776     gen_block_die (subblocks, context_die, depth + 1);
12777 }
12778
12779 /* Is this a typedef we can avoid emitting?  */
12780
12781 static inline int
12782 is_redundant_typedef (tree decl)
12783 {
12784   if (TYPE_DECL_IS_STUB (decl))
12785     return 1;
12786
12787   if (DECL_ARTIFICIAL (decl)
12788       && DECL_CONTEXT (decl)
12789       && is_tagged_type (DECL_CONTEXT (decl))
12790       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12791       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12792     /* Also ignore the artificial member typedef for the class name.  */
12793     return 1;
12794
12795   return 0;
12796 }
12797
12798 /* Returns the DIE for decl.  A DIE will always be returned.  */
12799
12800 static dw_die_ref
12801 force_decl_die (tree decl)
12802 {
12803   dw_die_ref decl_die;
12804   unsigned saved_external_flag;
12805   tree save_fn = NULL_TREE;
12806   decl_die = lookup_decl_die (decl);
12807   if (!decl_die)
12808     {
12809       dw_die_ref context_die;
12810       tree decl_context = DECL_CONTEXT (decl);
12811       if (decl_context)
12812         {
12813           /* Find die that represents this context.  */
12814           if (TYPE_P (decl_context))
12815             context_die = force_type_die (decl_context);
12816           else
12817             context_die = force_decl_die (decl_context);
12818         }
12819       else
12820         context_die = comp_unit_die;
12821
12822       decl_die = lookup_decl_die (decl);
12823       if (decl_die)
12824         return decl_die;
12825
12826       switch (TREE_CODE (decl))
12827         {
12828         case FUNCTION_DECL:
12829           /* Clear current_function_decl, so that gen_subprogram_die thinks
12830              that this is a declaration. At this point, we just want to force
12831              declaration die.  */
12832           save_fn = current_function_decl;
12833           current_function_decl = NULL_TREE;
12834           gen_subprogram_die (decl, context_die);
12835           current_function_decl = save_fn;
12836           break;
12837
12838         case VAR_DECL:
12839           /* Set external flag to force declaration die. Restore it after
12840            gen_decl_die() call.  */
12841           saved_external_flag = DECL_EXTERNAL (decl);
12842           DECL_EXTERNAL (decl) = 1;
12843           gen_decl_die (decl, context_die);
12844           DECL_EXTERNAL (decl) = saved_external_flag;
12845           break;
12846
12847         case NAMESPACE_DECL:
12848           dwarf2out_decl (decl);
12849           break;
12850
12851         default:
12852           gcc_unreachable ();
12853         }
12854
12855       /* We should be able to find the DIE now.  */
12856       if (!decl_die)
12857         decl_die = lookup_decl_die (decl);
12858       gcc_assert (decl_die);
12859     }
12860
12861   return decl_die;
12862 }
12863
12864 /* Returns the DIE for TYPE.  A DIE is always returned.  */
12865
12866 static dw_die_ref
12867 force_type_die (tree type)
12868 {
12869   dw_die_ref type_die;
12870
12871   type_die = lookup_type_die (type);
12872   if (!type_die)
12873     {
12874       dw_die_ref context_die;
12875       if (TYPE_CONTEXT (type))
12876         {
12877           if (TYPE_P (TYPE_CONTEXT (type)))
12878             context_die = force_type_die (TYPE_CONTEXT (type));
12879           else
12880             context_die = force_decl_die (TYPE_CONTEXT (type));
12881         }
12882       else
12883         context_die = comp_unit_die;
12884
12885       type_die = lookup_type_die (type);
12886       if (type_die)
12887         return type_die;
12888       gen_type_die (type, context_die);
12889       type_die = lookup_type_die (type);
12890       gcc_assert (type_die);
12891     }
12892   return type_die;
12893 }
12894
12895 /* Force out any required namespaces to be able to output DECL,
12896    and return the new context_die for it, if it's changed.  */
12897
12898 static dw_die_ref
12899 setup_namespace_context (tree thing, dw_die_ref context_die)
12900 {
12901   tree context = (DECL_P (thing)
12902                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12903   if (context && TREE_CODE (context) == NAMESPACE_DECL)
12904     /* Force out the namespace.  */
12905     context_die = force_decl_die (context);
12906
12907   return context_die;
12908 }
12909
12910 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12911    type) within its namespace, if appropriate.
12912
12913    For compatibility with older debuggers, namespace DIEs only contain
12914    declarations; all definitions are emitted at CU scope.  */
12915
12916 static void
12917 declare_in_namespace (tree thing, dw_die_ref context_die)
12918 {
12919   dw_die_ref ns_context;
12920
12921   if (debug_info_level <= DINFO_LEVEL_TERSE)
12922     return;
12923
12924   /* If this decl is from an inlined function, then don't try to emit it in its
12925      namespace, as we will get confused.  It would have already been emitted
12926      when the abstract instance of the inline function was emitted anyways.  */
12927   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12928     return;
12929
12930   ns_context = setup_namespace_context (thing, context_die);
12931
12932   if (ns_context != context_die)
12933     {
12934       if (DECL_P (thing))
12935         gen_decl_die (thing, ns_context);
12936       else
12937         gen_type_die (thing, ns_context);
12938     }
12939 }
12940
12941 /* Generate a DIE for a namespace or namespace alias.  */
12942
12943 static void
12944 gen_namespace_die (tree decl)
12945 {
12946   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12947
12948   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12949      they are an alias of.  */
12950   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12951     {
12952       /* Output a real namespace.  */
12953       dw_die_ref namespace_die
12954         = new_die (DW_TAG_namespace, context_die, decl);
12955       add_name_and_src_coords_attributes (namespace_die, decl);
12956       equate_decl_number_to_die (decl, namespace_die);
12957     }
12958   else
12959     {
12960       /* Output a namespace alias.  */
12961
12962       /* Force out the namespace we are an alias of, if necessary.  */
12963       dw_die_ref origin_die
12964         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12965
12966       /* Now create the namespace alias DIE.  */
12967       dw_die_ref namespace_die
12968         = new_die (DW_TAG_imported_declaration, context_die, decl);
12969       add_name_and_src_coords_attributes (namespace_die, decl);
12970       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12971       equate_decl_number_to_die (decl, namespace_die);
12972     }
12973 }
12974
12975 /* Generate Dwarf debug information for a decl described by DECL.  */
12976
12977 static void
12978 gen_decl_die (tree decl, dw_die_ref context_die)
12979 {
12980   tree origin;
12981
12982   if (DECL_P (decl) && DECL_IGNORED_P (decl))
12983     return;
12984
12985   switch (TREE_CODE (decl))
12986     {
12987     case ERROR_MARK:
12988       break;
12989
12990     case CONST_DECL:
12991       /* The individual enumerators of an enum type get output when we output
12992          the Dwarf representation of the relevant enum type itself.  */
12993       break;
12994
12995     case FUNCTION_DECL:
12996       /* Don't output any DIEs to represent mere function declarations,
12997          unless they are class members or explicit block externs.  */
12998       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12999           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13000         break;
13001
13002 #if 0
13003       /* FIXME */
13004       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13005          on local redeclarations of global functions.  That seems broken.  */
13006       if (current_function_decl != decl)
13007         /* This is only a declaration.  */;
13008 #endif
13009
13010       /* If we're emitting a clone, emit info for the abstract instance.  */
13011       if (DECL_ORIGIN (decl) != decl)
13012         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13013
13014       /* If we're emitting an out-of-line copy of an inline function,
13015          emit info for the abstract instance and set up to refer to it.  */
13016       else if (cgraph_function_possibly_inlined_p (decl)
13017                && ! DECL_ABSTRACT (decl)
13018                && ! class_or_namespace_scope_p (context_die)
13019                /* dwarf2out_abstract_function won't emit a die if this is just
13020                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
13021                   that case, because that works only if we have a die.  */
13022                && DECL_INITIAL (decl) != NULL_TREE)
13023         {
13024           dwarf2out_abstract_function (decl);
13025           set_decl_origin_self (decl);
13026         }
13027
13028       /* Otherwise we're emitting the primary DIE for this decl.  */
13029       else if (debug_info_level > DINFO_LEVEL_TERSE)
13030         {
13031           /* Before we describe the FUNCTION_DECL itself, make sure that we
13032              have described its return type.  */
13033           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13034
13035           /* And its virtual context.  */
13036           if (DECL_VINDEX (decl) != NULL_TREE)
13037             gen_type_die (DECL_CONTEXT (decl), context_die);
13038
13039           /* And its containing type.  */
13040           origin = decl_class_context (decl);
13041           if (origin != NULL_TREE)
13042             gen_type_die_for_member (origin, decl, context_die);
13043
13044           /* And its containing namespace.  */
13045           declare_in_namespace (decl, context_die);
13046         }
13047
13048       /* Now output a DIE to represent the function itself.  */
13049       gen_subprogram_die (decl, context_die);
13050       break;
13051
13052     case TYPE_DECL:
13053       /* If we are in terse mode, don't generate any DIEs to represent any
13054          actual typedefs.  */
13055       if (debug_info_level <= DINFO_LEVEL_TERSE)
13056         break;
13057
13058       /* In the special case of a TYPE_DECL node representing the declaration
13059          of some type tag, if the given TYPE_DECL is marked as having been
13060          instantiated from some other (original) TYPE_DECL node (e.g. one which
13061          was generated within the original definition of an inline function) we
13062          have to generate a special (abbreviated) DW_TAG_structure_type,
13063          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13064       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13065         {
13066           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13067           break;
13068         }
13069
13070       if (is_redundant_typedef (decl))
13071         gen_type_die (TREE_TYPE (decl), context_die);
13072       else
13073         /* Output a DIE to represent the typedef itself.  */
13074         gen_typedef_die (decl, context_die);
13075       break;
13076
13077     case LABEL_DECL:
13078       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13079         gen_label_die (decl, context_die);
13080       break;
13081
13082     case VAR_DECL:
13083     case RESULT_DECL:
13084       /* If we are in terse mode, don't generate any DIEs to represent any
13085          variable declarations or definitions.  */
13086       if (debug_info_level <= DINFO_LEVEL_TERSE)
13087         break;
13088
13089       /* Output any DIEs that are needed to specify the type of this data
13090          object.  */
13091       gen_type_die (TREE_TYPE (decl), context_die);
13092
13093       /* And its containing type.  */
13094       origin = decl_class_context (decl);
13095       if (origin != NULL_TREE)
13096         gen_type_die_for_member (origin, decl, context_die);
13097
13098       /* And its containing namespace.  */
13099       declare_in_namespace (decl, context_die);
13100
13101       /* Now output the DIE to represent the data object itself.  This gets
13102          complicated because of the possibility that the VAR_DECL really
13103          represents an inlined instance of a formal parameter for an inline
13104          function.  */
13105       origin = decl_ultimate_origin (decl);
13106       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13107         gen_formal_parameter_die (decl, context_die);
13108       else
13109         gen_variable_die (decl, context_die);
13110       break;
13111
13112     case FIELD_DECL:
13113       /* Ignore the nameless fields that are used to skip bits but handle C++
13114          anonymous unions and structs.  */
13115       if (DECL_NAME (decl) != NULL_TREE
13116           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13117           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13118         {
13119           gen_type_die (member_declared_type (decl), context_die);
13120           gen_field_die (decl, context_die);
13121         }
13122       break;
13123
13124     case PARM_DECL:
13125       gen_type_die (TREE_TYPE (decl), context_die);
13126       gen_formal_parameter_die (decl, context_die);
13127       break;
13128
13129     case NAMESPACE_DECL:
13130       gen_namespace_die (decl);
13131       break;
13132
13133     default:
13134       /* Probably some frontend-internal decl.  Assume we don't care.  */
13135       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13136       break;
13137     }
13138 }
13139 \f
13140 /* Add Ada "use" clause information for SGI Workshop debugger.  */
13141
13142 void
13143 dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
13144 {
13145   unsigned int file_index;
13146
13147   if (filename != NULL)
13148     {
13149       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
13150       tree context_list_decl
13151         = build_decl (LABEL_DECL, get_identifier (context_list),
13152                       void_type_node);
13153
13154       TREE_PUBLIC (context_list_decl) = TRUE;
13155       add_name_attribute (unit_die, context_list);
13156       file_index = lookup_filename (filename);
13157       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
13158       add_pubname (context_list_decl, unit_die);
13159     }
13160 }
13161
13162 /* Output debug information for global decl DECL.  Called from toplev.c after
13163    compilation proper has finished.  */
13164
13165 static void
13166 dwarf2out_global_decl (tree decl)
13167 {
13168   /* Output DWARF2 information for file-scope tentative data object
13169      declarations, file-scope (extern) function declarations (which had no
13170      corresponding body) and file-scope tagged type declarations and
13171      definitions which have not yet been forced out.  */
13172   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13173     dwarf2out_decl (decl);
13174 }
13175
13176 /* Output debug information for type decl DECL.  Called from toplev.c
13177    and from language front ends (to record built-in types).  */
13178 static void
13179 dwarf2out_type_decl (tree decl, int local)
13180 {
13181   if (!local)
13182     dwarf2out_decl (decl);
13183 }
13184
13185 /* Output debug information for imported module or decl.  */
13186
13187 static void
13188 dwarf2out_imported_module_or_decl (tree decl, tree context)
13189 {
13190   dw_die_ref imported_die, at_import_die;
13191   dw_die_ref scope_die;
13192   unsigned file_index;
13193   expanded_location xloc;
13194
13195   if (debug_info_level <= DINFO_LEVEL_TERSE)
13196     return;
13197
13198   gcc_assert (decl);
13199
13200   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13201      We need decl DIE for reference and scope die. First, get DIE for the decl
13202      itself.  */
13203
13204   /* Get the scope die for decl context. Use comp_unit_die for global module
13205      or decl. If die is not found for non globals, force new die.  */
13206   if (!context)
13207     scope_die = comp_unit_die;
13208   else if (TYPE_P (context))
13209     scope_die = force_type_die (context);
13210   else
13211     scope_die = force_decl_die (context);
13212
13213   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13214   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13215     at_import_die = force_type_die (TREE_TYPE (decl));
13216   else
13217     {
13218       at_import_die = lookup_decl_die (decl);
13219       if (!at_import_die)
13220         {
13221           /* If we're trying to avoid duplicate debug info, we may not have
13222              emitted the member decl for this field.  Emit it now.  */
13223           if (TREE_CODE (decl) == FIELD_DECL)
13224             {
13225               tree type = DECL_CONTEXT (decl);
13226               dw_die_ref type_context_die;
13227
13228               if (TYPE_CONTEXT (type))
13229                 if (TYPE_P (TYPE_CONTEXT (type)))
13230                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13231               else
13232                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13233               else
13234                 type_context_die = comp_unit_die;
13235               gen_type_die_for_member (type, decl, type_context_die);
13236             }
13237           at_import_die = force_decl_die (decl);
13238         }
13239     }
13240
13241   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13242   if (TREE_CODE (decl) == NAMESPACE_DECL)
13243     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13244   else
13245     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13246
13247   xloc = expand_location (input_location);
13248   file_index = lookup_filename (xloc.file);
13249   add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
13250   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13251   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13252 }
13253
13254 /* Write the debugging output for DECL.  */
13255
13256 void
13257 dwarf2out_decl (tree decl)
13258 {
13259   dw_die_ref context_die = comp_unit_die;
13260
13261   switch (TREE_CODE (decl))
13262     {
13263     case ERROR_MARK:
13264       return;
13265
13266     case FUNCTION_DECL:
13267       /* What we would really like to do here is to filter out all mere
13268          file-scope declarations of file-scope functions which are never
13269          referenced later within this translation unit (and keep all of ones
13270          that *are* referenced later on) but we aren't clairvoyant, so we have
13271          no idea which functions will be referenced in the future (i.e. later
13272          on within the current translation unit). So here we just ignore all
13273          file-scope function declarations which are not also definitions.  If
13274          and when the debugger needs to know something about these functions,
13275          it will have to hunt around and find the DWARF information associated
13276          with the definition of the function.
13277
13278          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13279          nodes represent definitions and which ones represent mere
13280          declarations.  We have to check DECL_INITIAL instead. That's because
13281          the C front-end supports some weird semantics for "extern inline"
13282          function definitions.  These can get inlined within the current
13283          translation unit (and thus, we need to generate Dwarf info for their
13284          abstract instances so that the Dwarf info for the concrete inlined
13285          instances can have something to refer to) but the compiler never
13286          generates any out-of-lines instances of such things (despite the fact
13287          that they *are* definitions).
13288
13289          The important point is that the C front-end marks these "extern
13290          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13291          them anyway. Note that the C++ front-end also plays some similar games
13292          for inline function definitions appearing within include files which
13293          also contain `#pragma interface' pragmas.  */
13294       if (DECL_INITIAL (decl) == NULL_TREE)
13295         return;
13296
13297       /* If we're a nested function, initially use a parent of NULL; if we're
13298          a plain function, this will be fixed up in decls_for_scope.  If
13299          we're a method, it will be ignored, since we already have a DIE.  */
13300       if (decl_function_context (decl)
13301           /* But if we're in terse mode, we don't care about scope.  */
13302           && debug_info_level > DINFO_LEVEL_TERSE)
13303         context_die = NULL;
13304       break;
13305
13306     case VAR_DECL:
13307       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13308          declaration and if the declaration was never even referenced from
13309          within this entire compilation unit.  We suppress these DIEs in
13310          order to save space in the .debug section (by eliminating entries
13311          which are probably useless).  Note that we must not suppress
13312          block-local extern declarations (whether used or not) because that
13313          would screw-up the debugger's name lookup mechanism and cause it to
13314          miss things which really ought to be in scope at a given point.  */
13315       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13316         return;
13317
13318       /* For local statics lookup proper context die.  */
13319       if (TREE_STATIC (decl) && decl_function_context (decl))
13320         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13321
13322       /* If we are in terse mode, don't generate any DIEs to represent any
13323          variable declarations or definitions.  */
13324       if (debug_info_level <= DINFO_LEVEL_TERSE)
13325         return;
13326       break;
13327
13328     case NAMESPACE_DECL:
13329       if (debug_info_level <= DINFO_LEVEL_TERSE)
13330         return;
13331       if (lookup_decl_die (decl) != NULL)
13332         return;
13333       break;
13334
13335     case TYPE_DECL:
13336       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13337       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13338         return;
13339
13340       /* Don't bother trying to generate any DIEs to represent any of the
13341          normal built-in types for the language we are compiling.  */
13342       if (DECL_IS_BUILTIN (decl))
13343         {
13344           /* OK, we need to generate one for `bool' so GDB knows what type
13345              comparisons have.  */
13346           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
13347                == DW_LANG_C_plus_plus)
13348               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13349               && ! DECL_IGNORED_P (decl))
13350             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13351
13352           return;
13353         }
13354
13355       /* If we are in terse mode, don't generate any DIEs for types.  */
13356       if (debug_info_level <= DINFO_LEVEL_TERSE)
13357         return;
13358
13359       /* If we're a function-scope tag, initially use a parent of NULL;
13360          this will be fixed up in decls_for_scope.  */
13361       if (decl_function_context (decl))
13362         context_die = NULL;
13363
13364       break;
13365
13366     default:
13367       return;
13368     }
13369
13370   gen_decl_die (decl, context_die);
13371 }
13372
13373 /* Output a marker (i.e. a label) for the beginning of the generated code for
13374    a lexical block.  */
13375
13376 static void
13377 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13378                        unsigned int blocknum)
13379 {
13380   switch_to_section (current_function_section ());
13381   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13382 }
13383
13384 /* Output a marker (i.e. a label) for the end of the generated code for a
13385    lexical block.  */
13386
13387 static void
13388 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13389 {
13390   switch_to_section (current_function_section ());
13391   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13392 }
13393
13394 /* Returns nonzero if it is appropriate not to emit any debugging
13395    information for BLOCK, because it doesn't contain any instructions.
13396
13397    Don't allow this for blocks with nested functions or local classes
13398    as we would end up with orphans, and in the presence of scheduling
13399    we may end up calling them anyway.  */
13400
13401 static bool
13402 dwarf2out_ignore_block (tree block)
13403 {
13404   tree decl;
13405
13406   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13407     if (TREE_CODE (decl) == FUNCTION_DECL
13408         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13409       return 0;
13410
13411   return 1;
13412 }
13413
13414 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13415    dwarf2out.c) and return its "index".  The index of each (known) filename is
13416    just a unique number which is associated with only that one filename.  We
13417    need such numbers for the sake of generating labels (in the .debug_sfnames
13418    section) and references to those files numbers (in the .debug_srcinfo
13419    and.debug_macinfo sections).  If the filename given as an argument is not
13420    found in our current list, add it to the list and assign it the next
13421    available unique index number.  In order to speed up searches, we remember
13422    the index of the filename was looked up last.  This handles the majority of
13423    all searches.  */
13424
13425 static unsigned
13426 lookup_filename (const char *file_name)
13427 {
13428   size_t i, n;
13429   char *save_file_name;
13430
13431   /* Check to see if the file name that was searched on the previous
13432      call matches this file name.  If so, return the index.  */
13433   if (file_table_last_lookup_index != 0)
13434     {
13435       const char *last
13436         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13437       if (strcmp (file_name, last) == 0)
13438         return file_table_last_lookup_index;
13439     }
13440
13441   /* Didn't match the previous lookup, search the table.  */
13442   n = VARRAY_ACTIVE_SIZE (file_table);
13443   for (i = 1; i < n; i++)
13444     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13445       {
13446         file_table_last_lookup_index = i;
13447         return i;
13448       }
13449
13450   /* Add the new entry to the end of the filename table.  */
13451   file_table_last_lookup_index = n;
13452   save_file_name = (char *) ggc_strdup (file_name);
13453   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13454   VARRAY_PUSH_UINT (file_table_emitted, 0);
13455
13456   /* If the assembler is emitting the file table, and we aren't eliminating
13457      unused debug types, then we must emit .file here.  If we are eliminating
13458      unused debug types, then this will be done by the maybe_emit_file call in
13459      prune_unused_types_walk_attribs.  */
13460
13461   if (DWARF2_ASM_LINE_DEBUG_INFO && ! flag_eliminate_unused_debug_types)
13462     return maybe_emit_file (i);
13463
13464   return i;
13465 }
13466
13467 /* If the assembler will construct the file table, then translate the compiler
13468    internal file table number into the assembler file table number, and emit
13469    a .file directive if we haven't already emitted one yet.  The file table
13470    numbers are different because we prune debug info for unused variables and
13471    types, which may include filenames.  */
13472
13473 static int
13474 maybe_emit_file (int fileno)
13475 {
13476   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13477     {
13478       if (!VARRAY_UINT (file_table_emitted, fileno))
13479         {
13480           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13481           fprintf (asm_out_file, "\t.file %u ",
13482                    VARRAY_UINT (file_table_emitted, fileno));
13483           output_quoted_string (asm_out_file,
13484                                 VARRAY_CHAR_PTR (file_table, fileno));
13485           fputc ('\n', asm_out_file);
13486         }
13487       return VARRAY_UINT (file_table_emitted, fileno);
13488     }
13489   else
13490     return fileno;
13491 }
13492
13493 /* Initialize the compiler internal file table.  */
13494
13495 static void
13496 init_file_table (void)
13497 {
13498   /* Allocate the initial hunk of the file_table.  */
13499   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13500   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13501
13502   /* Skip the first entry - file numbers begin at 1.  */
13503   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13504   VARRAY_PUSH_UINT (file_table_emitted, 0);
13505   file_table_last_lookup_index = 0;
13506 }
13507
13508 /* Called by the final INSN scan whenever we see a var location.  We
13509    use it to drop labels in the right places, and throw the location in
13510    our lookup table.  */
13511
13512 static void
13513 dwarf2out_var_location (rtx loc_note)
13514 {
13515   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13516   struct var_loc_node *newloc;
13517   rtx prev_insn;
13518   static rtx last_insn;
13519   static const char *last_label;
13520   tree decl;
13521
13522   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13523     return;
13524   prev_insn = PREV_INSN (loc_note);
13525
13526   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13527   /* If the insn we processed last time is the previous insn
13528      and it is also a var location note, use the label we emitted
13529      last time.  */
13530   if (last_insn != NULL_RTX
13531       && last_insn == prev_insn
13532       && NOTE_P (prev_insn)
13533       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13534     {
13535       newloc->label = last_label;
13536     }
13537   else
13538     {
13539       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13540       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13541       loclabel_num++;
13542       newloc->label = ggc_strdup (loclabel);
13543     }
13544   newloc->var_loc_note = loc_note;
13545   newloc->next = NULL;
13546
13547   if (cfun && in_cold_section_p)
13548     newloc->section_label = cfun->cold_section_label;
13549   else
13550     newloc->section_label = text_section_label;
13551
13552   last_insn = loc_note;
13553   last_label = newloc->label;
13554   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13555   if (DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
13556       && DECL_P (DECL_DEBUG_EXPR (decl)))
13557     decl = DECL_DEBUG_EXPR (decl);
13558   add_var_loc_to_decl (decl, newloc);
13559 }
13560
13561 /* We need to reset the locations at the beginning of each
13562    function. We can't do this in the end_function hook, because the
13563    declarations that use the locations won't have been output when
13564    that hook is called.  Also compute have_multiple_function_sections here.  */
13565
13566 static void
13567 dwarf2out_begin_function (tree fun)
13568 {
13569   htab_empty (decl_loc_table);
13570
13571   if (function_section (fun) != text_section)
13572     have_multiple_function_sections = true;
13573 }
13574
13575 /* Output a label to mark the beginning of a source code line entry
13576    and record information relating to this source line, in
13577    'line_info_table' for later output of the .debug_line section.  */
13578
13579 static void
13580 dwarf2out_source_line (unsigned int line, const char *filename)
13581 {
13582   if (debug_info_level >= DINFO_LEVEL_NORMAL
13583       && line != 0)
13584     {
13585       switch_to_section (current_function_section ());
13586
13587       /* If requested, emit something human-readable.  */
13588       if (flag_debug_asm)
13589         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13590                  filename, line);
13591
13592       if (DWARF2_ASM_LINE_DEBUG_INFO)
13593         {
13594           unsigned file_num = lookup_filename (filename);
13595
13596           file_num = maybe_emit_file (file_num);
13597
13598           /* Emit the .loc directive understood by GNU as.  */
13599           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13600
13601           /* Indicate that line number info exists.  */
13602           line_info_table_in_use++;
13603         }
13604       else if (function_section (current_function_decl) != text_section)
13605         {
13606           dw_separate_line_info_ref line_info;
13607           targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13608                                      separate_line_info_table_in_use);
13609
13610           /* Expand the line info table if necessary.  */
13611           if (separate_line_info_table_in_use
13612               == separate_line_info_table_allocated)
13613             {
13614               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13615               separate_line_info_table
13616                 = ggc_realloc (separate_line_info_table,
13617                                separate_line_info_table_allocated
13618                                * sizeof (dw_separate_line_info_entry));
13619               memset (separate_line_info_table
13620                        + separate_line_info_table_in_use,
13621                       0,
13622                       (LINE_INFO_TABLE_INCREMENT
13623                        * sizeof (dw_separate_line_info_entry)));
13624             }
13625
13626           /* Add the new entry at the end of the line_info_table.  */
13627           line_info
13628             = &separate_line_info_table[separate_line_info_table_in_use++];
13629           line_info->dw_file_num = lookup_filename (filename);
13630           line_info->dw_line_num = line;
13631           line_info->function = current_function_funcdef_no;
13632         }
13633       else
13634         {
13635           dw_line_info_ref line_info;
13636
13637           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13638                                      line_info_table_in_use);
13639
13640           /* Expand the line info table if necessary.  */
13641           if (line_info_table_in_use == line_info_table_allocated)
13642             {
13643               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13644               line_info_table
13645                 = ggc_realloc (line_info_table,
13646                                (line_info_table_allocated
13647                                 * sizeof (dw_line_info_entry)));
13648               memset (line_info_table + line_info_table_in_use, 0,
13649                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13650             }
13651
13652           /* Add the new entry at the end of the line_info_table.  */
13653           line_info = &line_info_table[line_info_table_in_use++];
13654           line_info->dw_file_num = lookup_filename (filename);
13655           line_info->dw_line_num = line;
13656         }
13657     }
13658 }
13659
13660 /* Record the beginning of a new source file.  */
13661
13662 static void
13663 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13664 {
13665   if (flag_eliminate_dwarf2_dups)
13666     {
13667       /* Record the beginning of the file for break_out_includes.  */
13668       dw_die_ref bincl_die;
13669
13670       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13671       add_AT_string (bincl_die, DW_AT_name, filename);
13672     }
13673
13674   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13675     {
13676       int fileno;
13677
13678       switch_to_section (debug_macinfo_section);
13679       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13680       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13681                                    lineno);
13682
13683       fileno = maybe_emit_file (lookup_filename (filename));
13684       dw2_asm_output_data_uleb128 (fileno, "Filename we just started");
13685     }
13686 }
13687
13688 /* Record the end of a source file.  */
13689
13690 static void
13691 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13692 {
13693   if (flag_eliminate_dwarf2_dups)
13694     /* Record the end of the file for break_out_includes.  */
13695     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13696
13697   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13698     {
13699       switch_to_section (debug_macinfo_section);
13700       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13701     }
13702 }
13703
13704 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13705    the tail part of the directive line, i.e. the part which is past the
13706    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13707
13708 static void
13709 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13710                   const char *buffer ATTRIBUTE_UNUSED)
13711 {
13712   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13713     {
13714       switch_to_section (debug_macinfo_section);
13715       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13716       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13717       dw2_asm_output_nstring (buffer, -1, "The macro");
13718     }
13719 }
13720
13721 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13722    the tail part of the directive line, i.e. the part which is past the
13723    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13724
13725 static void
13726 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13727                  const char *buffer ATTRIBUTE_UNUSED)
13728 {
13729   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13730     {
13731       switch_to_section (debug_macinfo_section);
13732       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13733       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13734       dw2_asm_output_nstring (buffer, -1, "The macro");
13735     }
13736 }
13737
13738 /* Set up for Dwarf output at the start of compilation.  */
13739
13740 static void
13741 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13742 {
13743   init_file_table ();
13744
13745   /* Allocate the decl_die_table.  */
13746   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13747                                     decl_die_table_eq, NULL);
13748
13749   /* Allocate the decl_loc_table.  */
13750   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13751                                     decl_loc_table_eq, NULL);
13752
13753   /* Allocate the initial hunk of the decl_scope_table.  */
13754   decl_scope_table = VEC_alloc (tree, gc, 256);
13755
13756   /* Allocate the initial hunk of the abbrev_die_table.  */
13757   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13758                                         * sizeof (dw_die_ref));
13759   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13760   /* Zero-th entry is allocated, but unused.  */
13761   abbrev_die_table_in_use = 1;
13762
13763   /* Allocate the initial hunk of the line_info_table.  */
13764   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13765                                        * sizeof (dw_line_info_entry));
13766   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13767
13768   /* Zero-th entry is allocated, but unused.  */
13769   line_info_table_in_use = 1;
13770
13771   /* Generate the initial DIE for the .debug section.  Note that the (string)
13772      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13773      will (typically) be a relative pathname and that this pathname should be
13774      taken as being relative to the directory from which the compiler was
13775      invoked when the given (base) source file was compiled.  We will fill
13776      in this value in dwarf2out_finish.  */
13777   comp_unit_die = gen_compile_unit_die (NULL);
13778
13779   incomplete_types = VEC_alloc (tree, gc, 64);
13780
13781   used_rtx_array = VEC_alloc (rtx, gc, 32);
13782
13783   debug_info_section = get_section (DEBUG_INFO_SECTION,
13784                                     SECTION_DEBUG, NULL);
13785   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13786                                       SECTION_DEBUG, NULL);
13787   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13788                                        SECTION_DEBUG, NULL);
13789   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13790                                        SECTION_DEBUG, NULL);
13791   debug_line_section = get_section (DEBUG_LINE_SECTION,
13792                                     SECTION_DEBUG, NULL);
13793   debug_loc_section = get_section (DEBUG_LOC_SECTION,
13794                                    SECTION_DEBUG, NULL);
13795   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13796                                         SECTION_DEBUG, NULL);
13797   debug_str_section = get_section (DEBUG_STR_SECTION,
13798                                    DEBUG_STR_SECTION_FLAGS, NULL);
13799   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13800                                       SECTION_DEBUG, NULL);
13801
13802   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13803   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13804                                DEBUG_ABBREV_SECTION_LABEL, 0);
13805   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13806   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13807                                COLD_TEXT_SECTION_LABEL, 0);
13808   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13809
13810   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13811                                DEBUG_INFO_SECTION_LABEL, 0);
13812   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13813                                DEBUG_LINE_SECTION_LABEL, 0);
13814   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13815                                DEBUG_RANGES_SECTION_LABEL, 0);
13816   switch_to_section (debug_abbrev_section);
13817   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13818   switch_to_section (debug_info_section);
13819   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13820   switch_to_section (debug_line_section);
13821   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13822
13823   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13824     {
13825       switch_to_section (debug_macinfo_section);
13826       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13827                                    DEBUG_MACINFO_SECTION_LABEL, 0);
13828       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13829     }
13830
13831   switch_to_section (text_section);
13832   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13833   if (flag_reorder_blocks_and_partition)
13834     {
13835       switch_to_section (unlikely_text_section ());
13836       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13837     }
13838 }
13839
13840 /* A helper function for dwarf2out_finish called through
13841    ht_forall.  Emit one queued .debug_str string.  */
13842
13843 static int
13844 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13845 {
13846   struct indirect_string_node *node = (struct indirect_string_node *) *h;
13847
13848   if (node->form == DW_FORM_strp)
13849     {
13850       switch_to_section (debug_str_section);
13851       ASM_OUTPUT_LABEL (asm_out_file, node->label);
13852       assemble_string (node->str, strlen (node->str) + 1);
13853     }
13854
13855   return 1;
13856 }
13857
13858
13859
13860 /* Clear the marks for a die and its children.
13861    Be cool if the mark isn't set.  */
13862
13863 static void
13864 prune_unmark_dies (dw_die_ref die)
13865 {
13866   dw_die_ref c;
13867   die->die_mark = 0;
13868   for (c = die->die_child; c; c = c->die_sib)
13869     prune_unmark_dies (c);
13870 }
13871
13872
13873 /* Given DIE that we're marking as used, find any other dies
13874    it references as attributes and mark them as used.  */
13875
13876 static void
13877 prune_unused_types_walk_attribs (dw_die_ref die)
13878 {
13879   dw_attr_ref a;
13880
13881   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13882     {
13883       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13884         {
13885           /* A reference to another DIE.
13886              Make sure that it will get emitted.  */
13887           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13888         }
13889       else if (a->dw_attr == DW_AT_decl_file || a->dw_attr == DW_AT_call_file)
13890         {
13891           /* A reference to a file.  Make sure the file name is emitted.  */
13892           a->dw_attr_val.v.val_unsigned =
13893             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13894         }
13895     }
13896 }
13897
13898
13899 /* Mark DIE as being used.  If DOKIDS is true, then walk down
13900    to DIE's children.  */
13901
13902 static void
13903 prune_unused_types_mark (dw_die_ref die, int dokids)
13904 {
13905   dw_die_ref c;
13906
13907   if (die->die_mark == 0)
13908     {
13909       /* We haven't done this node yet.  Mark it as used.  */
13910       die->die_mark = 1;
13911
13912       /* We also have to mark its parents as used.
13913          (But we don't want to mark our parents' kids due to this.)  */
13914       if (die->die_parent)
13915         prune_unused_types_mark (die->die_parent, 0);
13916
13917       /* Mark any referenced nodes.  */
13918       prune_unused_types_walk_attribs (die);
13919
13920       /* If this node is a specification,
13921          also mark the definition, if it exists.  */
13922       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13923         prune_unused_types_mark (die->die_definition, 1);
13924     }
13925
13926   if (dokids && die->die_mark != 2)
13927     {
13928       /* We need to walk the children, but haven't done so yet.
13929          Remember that we've walked the kids.  */
13930       die->die_mark = 2;
13931
13932       /* Walk them.  */
13933       for (c = die->die_child; c; c = c->die_sib)
13934         {
13935           /* If this is an array type, we need to make sure our
13936              kids get marked, even if they're types.  */
13937           if (die->die_tag == DW_TAG_array_type)
13938             prune_unused_types_mark (c, 1);
13939           else
13940             prune_unused_types_walk (c);
13941         }
13942     }
13943 }
13944
13945
13946 /* Walk the tree DIE and mark types that we actually use.  */
13947
13948 static void
13949 prune_unused_types_walk (dw_die_ref die)
13950 {
13951   dw_die_ref c;
13952
13953   /* Don't do anything if this node is already marked.  */
13954   if (die->die_mark)
13955     return;
13956
13957   switch (die->die_tag) {
13958   case DW_TAG_const_type:
13959   case DW_TAG_packed_type:
13960   case DW_TAG_pointer_type:
13961   case DW_TAG_reference_type:
13962   case DW_TAG_volatile_type:
13963   case DW_TAG_typedef:
13964   case DW_TAG_array_type:
13965   case DW_TAG_structure_type:
13966   case DW_TAG_union_type:
13967   case DW_TAG_class_type:
13968   case DW_TAG_friend:
13969   case DW_TAG_variant_part:
13970   case DW_TAG_enumeration_type:
13971   case DW_TAG_subroutine_type:
13972   case DW_TAG_string_type:
13973   case DW_TAG_set_type:
13974   case DW_TAG_subrange_type:
13975   case DW_TAG_ptr_to_member_type:
13976   case DW_TAG_file_type:
13977     /* It's a type node --- don't mark it.  */
13978     return;
13979
13980   default:
13981     /* Mark everything else.  */
13982     break;
13983   }
13984
13985   die->die_mark = 1;
13986
13987   /* Now, mark any dies referenced from here.  */
13988   prune_unused_types_walk_attribs (die);
13989
13990   /* Mark children.  */
13991   for (c = die->die_child; c; c = c->die_sib)
13992     prune_unused_types_walk (c);
13993 }
13994
13995
13996 /* Remove from the tree DIE any dies that aren't marked.  */
13997
13998 static void
13999 prune_unused_types_prune (dw_die_ref die)
14000 {
14001   dw_die_ref c, p, n;
14002
14003   gcc_assert (die->die_mark);
14004
14005   p = NULL;
14006   for (c = die->die_child; c; c = n)
14007     {
14008       n = c->die_sib;
14009       if (c->die_mark)
14010         {
14011           prune_unused_types_prune (c);
14012           p = c;
14013         }
14014       else
14015         {
14016           if (p)
14017             p->die_sib = n;
14018           else
14019             die->die_child = n;
14020           free_die (c);
14021         }
14022     }
14023 }
14024
14025
14026 /* Remove dies representing declarations that we never use.  */
14027
14028 static void
14029 prune_unused_types (void)
14030 {
14031   unsigned int i;
14032   limbo_die_node *node;
14033
14034   /* Clear all the marks.  */
14035   prune_unmark_dies (comp_unit_die);
14036   for (node = limbo_die_list; node; node = node->next)
14037     prune_unmark_dies (node->die);
14038
14039   /* Set the mark on nodes that are actually used.  */
14040   prune_unused_types_walk (comp_unit_die);
14041   for (node = limbo_die_list; node; node = node->next)
14042     prune_unused_types_walk (node->die);
14043
14044   /* Also set the mark on nodes referenced from the
14045      pubname_table or arange_table.  */
14046   for (i = 0; i < pubname_table_in_use; i++)
14047     prune_unused_types_mark (pubname_table[i].die, 1);
14048   for (i = 0; i < arange_table_in_use; i++)
14049     prune_unused_types_mark (arange_table[i], 1);
14050
14051   /* Get rid of nodes that aren't marked.  */
14052   prune_unused_types_prune (comp_unit_die);
14053   for (node = limbo_die_list; node; node = node->next)
14054     prune_unused_types_prune (node->die);
14055
14056   /* Leave the marks clear.  */
14057   prune_unmark_dies (comp_unit_die);
14058   for (node = limbo_die_list; node; node = node->next)
14059     prune_unmark_dies (node->die);
14060 }
14061
14062 /* Output stuff that dwarf requires at the end of every file,
14063    and generate the DWARF-2 debugging info.  */
14064
14065 static void
14066 dwarf2out_finish (const char *filename)
14067 {
14068   limbo_die_node *node, *next_node;
14069   dw_die_ref die = 0;
14070
14071   /* Add the name for the main input file now.  We delayed this from
14072      dwarf2out_init to avoid complications with PCH.  */
14073   add_name_attribute (comp_unit_die, filename);
14074   if (filename[0] != DIR_SEPARATOR)
14075     add_comp_dir_attribute (comp_unit_die);
14076   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14077     {
14078       size_t i;
14079       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
14080         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
14081             /* Don't add cwd for <built-in>.  */
14082             && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
14083           {
14084             add_comp_dir_attribute (comp_unit_die);
14085             break;
14086           }
14087     }
14088
14089   /* Traverse the limbo die list, and add parent/child links.  The only
14090      dies without parents that should be here are concrete instances of
14091      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14092      For concrete instances, we can get the parent die from the abstract
14093      instance.  */
14094   for (node = limbo_die_list; node; node = next_node)
14095     {
14096       next_node = node->next;
14097       die = node->die;
14098
14099       if (die->die_parent == NULL)
14100         {
14101           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14102
14103           if (origin)
14104             add_child_die (origin->die_parent, die);
14105           else if (die == comp_unit_die)
14106             ;
14107           else if (errorcount > 0 || sorrycount > 0)
14108             /* It's OK to be confused by errors in the input.  */
14109             add_child_die (comp_unit_die, die);
14110           else
14111             {
14112               /* In certain situations, the lexical block containing a
14113                  nested function can be optimized away, which results
14114                  in the nested function die being orphaned.  Likewise
14115                  with the return type of that nested function.  Force
14116                  this to be a child of the containing function.
14117
14118                  It may happen that even the containing function got fully
14119                  inlined and optimized out.  In that case we are lost and
14120                  assign the empty child.  This should not be big issue as
14121                  the function is likely unreachable too.  */
14122               tree context = NULL_TREE;
14123
14124               gcc_assert (node->created_for);
14125
14126               if (DECL_P (node->created_for))
14127                 context = DECL_CONTEXT (node->created_for);
14128               else if (TYPE_P (node->created_for))
14129                 context = TYPE_CONTEXT (node->created_for);
14130
14131               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14132
14133               origin = lookup_decl_die (context);
14134               if (origin)
14135                 add_child_die (origin, die);
14136               else
14137                 add_child_die (comp_unit_die, die);
14138             }
14139         }
14140     }
14141
14142   limbo_die_list = NULL;
14143
14144   /* Walk through the list of incomplete types again, trying once more to
14145      emit full debugging info for them.  */
14146   retry_incomplete_types ();
14147
14148   /* We need to reverse all the dies before break_out_includes, or
14149      we'll see the end of an include file before the beginning.  */
14150   reverse_all_dies (comp_unit_die);
14151
14152   if (flag_eliminate_unused_debug_types)
14153     prune_unused_types ();
14154
14155   /* Generate separate CUs for each of the include files we've seen.
14156      They will go into limbo_die_list.  */
14157   if (flag_eliminate_dwarf2_dups)
14158     break_out_includes (comp_unit_die);
14159
14160   /* Traverse the DIE's and add add sibling attributes to those DIE's
14161      that have children.  */
14162   add_sibling_attributes (comp_unit_die);
14163   for (node = limbo_die_list; node; node = node->next)
14164     add_sibling_attributes (node->die);
14165
14166   /* Output a terminator label for the .text section.  */
14167   switch_to_section (text_section);
14168   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14169   if (flag_reorder_blocks_and_partition)
14170     {
14171       switch_to_section (unlikely_text_section ());
14172       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14173     }
14174
14175   /* Output the source line correspondence table.  We must do this
14176      even if there is no line information.  Otherwise, on an empty
14177      translation unit, we will generate a present, but empty,
14178      .debug_info section.  IRIX 6.5 `nm' will then complain when
14179      examining the file.  */
14180   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14181     {
14182       switch_to_section (debug_line_section);
14183       output_line_info ();
14184     }
14185
14186   /* We can only use the low/high_pc attributes if all of the code was
14187      in .text.  */
14188   if (!have_multiple_function_sections)
14189     {
14190       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14191       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14192     }
14193
14194   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14195      "base address".  Use zero so that these addresses become absolute.  */
14196   else if (have_location_lists || ranges_table_in_use)
14197     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14198
14199   /* Output location list section if necessary.  */
14200   if (have_location_lists)
14201     {
14202       /* Output the location lists info.  */
14203       switch_to_section (debug_loc_section);
14204       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14205                                    DEBUG_LOC_SECTION_LABEL, 0);
14206       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14207       output_location_lists (die);
14208     }
14209
14210   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14211     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
14212                        debug_line_section_label);
14213
14214   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14215     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14216
14217   /* Output all of the compilation units.  We put the main one last so that
14218      the offsets are available to output_pubnames.  */
14219   for (node = limbo_die_list; node; node = node->next)
14220     output_comp_unit (node->die, 0);
14221
14222   output_comp_unit (comp_unit_die, 0);
14223
14224   /* Output the abbreviation table.  */
14225   switch_to_section (debug_abbrev_section);
14226   output_abbrev_section ();
14227
14228   /* Output public names table if necessary.  */
14229   if (pubname_table_in_use)
14230     {
14231       switch_to_section (debug_pubnames_section);
14232       output_pubnames ();
14233     }
14234
14235   /* Output the address range information.  We only put functions in the arange
14236      table, so don't write it out if we don't have any.  */
14237   if (fde_table_in_use)
14238     {
14239       switch_to_section (debug_aranges_section);
14240       output_aranges ();
14241     }
14242
14243   /* Output ranges section if necessary.  */
14244   if (ranges_table_in_use)
14245     {
14246       switch_to_section (debug_ranges_section);
14247       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14248       output_ranges ();
14249     }
14250
14251   /* Have to end the macro section.  */
14252   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14253     {
14254       switch_to_section (debug_macinfo_section);
14255       dw2_asm_output_data (1, 0, "End compilation unit");
14256     }
14257
14258   /* If we emitted any DW_FORM_strp form attribute, output the string
14259      table too.  */
14260   if (debug_str_hash)
14261     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14262 }
14263 #else
14264
14265 /* This should never be used, but its address is needed for comparisons.  */
14266 const struct gcc_debug_hooks dwarf2_debug_hooks;
14267
14268 #endif /* DWARF2_DEBUGGING_INFO */
14269
14270 #include "gt-dwarf2out.h"