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