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   long 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   long offset;
 233   long 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, long);
 354 static void initial_return_save (rtx);
 355 static long 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, long);
 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 long args_size;
 709
 710 /* The last args_size we actually output.  */
 711 static long 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, long 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, long 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         long 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, long 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, long 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, long 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 long
 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   long 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, long 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 0x%lx",
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       long unsigned 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       long int GTY ((default (""))) val_int;
2372       long unsigned 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 long, unsigned long);
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, long unsigned int oprnd1,
2746                long unsigned 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, long);
3590 static inline long int AT_int (dw_attr_ref);
3591 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned long);
3592 static inline unsigned long 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, unsigned long);
3616 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3617                                unsigned long);
3618 static inline const char *AT_lbl (dw_attr_ref);
3619 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3620 static const char *get_AT_low_pc (dw_die_ref);
3621 static const char *get_AT_hi_pc (dw_die_ref);
3622 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3623 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3624 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3625 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3626 static bool is_c_family (void);
3627 static bool is_cxx (void);
3628 static bool is_java (void);
3629 static bool is_fortran (void);
3630 static bool is_ada (void);
3631 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3632 static inline void free_die (dw_die_ref);
3633 static void remove_children (dw_die_ref);
3634 static void add_child_die (dw_die_ref, dw_die_ref);
3635 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3636 static dw_die_ref lookup_type_die (tree);
3637 static void equate_type_number_to_die (tree, dw_die_ref);
3638 static dw_die_ref lookup_decl_die (tree);
3639 static void equate_decl_number_to_die (tree, dw_die_ref);
3640 static void print_spaces (FILE *);
3641 static void print_die (dw_die_ref, FILE *);
3642 static void print_dwarf_line_table (FILE *);
3643 static void reverse_die_lists (dw_die_ref);
3644 static void reverse_all_dies (dw_die_ref);
3645 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3646 static dw_die_ref pop_compile_unit (dw_die_ref);
3647 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3648 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3649 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3650 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3651 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
3652 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3653 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3654 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3655 static void compute_section_prefix (dw_die_ref);
3656 static int is_type_die (dw_die_ref);
3657 static int is_comdat_die (dw_die_ref);
3658 static int is_symbol_die (dw_die_ref);
3659 static void assign_symbol_names (dw_die_ref);
3660 static void break_out_includes (dw_die_ref);
3661 static hashval_t htab_cu_hash (const void *);
3662 static int htab_cu_eq (const void *, const void *);
3663 static void htab_cu_del (void *);
3664 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3665 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3666 static void add_sibling_attributes (dw_die_ref);
3667 static void build_abbrev_table (dw_die_ref);
3668 static void output_location_lists (dw_die_ref);
3669 static int constant_size (long unsigned);
3670 static unsigned long size_of_die (dw_die_ref);
3671 static void calc_die_sizes (dw_die_ref);
3672 static void mark_dies (dw_die_ref);
3673 static void unmark_dies (dw_die_ref);
3674 static void unmark_all_dies (dw_die_ref);
3675 static unsigned long size_of_pubnames (void);
3676 static unsigned long size_of_aranges (void);
3677 static enum dwarf_form value_format (dw_attr_ref);
3678 static void output_value_format (dw_attr_ref);
3679 static void output_abbrev_section (void);
3680 static void output_die_symbol (dw_die_ref);
3681 static void output_die (dw_die_ref);
3682 static void output_compilation_unit_header (void);
3683 static void output_comp_unit (dw_die_ref, int);
3684 static const char *dwarf2_name (tree, int);
3685 static void add_pubname (tree, dw_die_ref);
3686 static void output_pubnames (void);
3687 static void add_arange (tree, dw_die_ref);
3688 static void output_aranges (void);
3689 static unsigned int add_ranges (tree);
3690 static void output_ranges (void);
3691 static void output_line_info (void);
3692 static void output_file_names (void);
3693 static dw_die_ref base_type_die (tree);
3694 static tree root_type (tree);
3695 static int is_base_type (tree);
3696 static bool is_ada_subrange_type (tree);
3697 static dw_die_ref subrange_type_die (tree);
3698 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3699 static int type_is_enum (tree);
3700 static unsigned int reg_number (rtx);
3701 static dw_loc_descr_ref reg_loc_descriptor (rtx);
3702 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
3703 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
3704 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3705 static dw_loc_descr_ref based_loc_descr (unsigned, long);
3706 static int is_based_loc (rtx);
3707 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
3708 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
3709 static dw_loc_descr_ref loc_descriptor (rtx);
3710 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
3711 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3712 static tree field_type (tree);
3713 static unsigned int simple_type_align_in_bits (tree);
3714 static unsigned int simple_decl_align_in_bits (tree);
3715 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
3716 static HOST_WIDE_INT field_byte_offset (tree);
3717 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3718                                          dw_loc_descr_ref);
3719 static void add_data_member_location_attribute (dw_die_ref, tree);
3720 static void add_const_value_attribute (dw_die_ref, rtx);
3721 static rtx rtl_for_decl_location (tree);
3722 static void add_location_or_const_value_attribute (dw_die_ref, tree);
3723 static void tree_add_const_value_attribute (dw_die_ref, tree);
3724 static void add_name_attribute (dw_die_ref, const char *);
3725 static void add_comp_dir_attribute (dw_die_ref);
3726 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
3727 static void add_subscript_info (dw_die_ref, tree);
3728 static void add_byte_size_attribute (dw_die_ref, tree);
3729 static void add_bit_offset_attribute (dw_die_ref, tree);
3730 static void add_bit_size_attribute (dw_die_ref, tree);
3731 static void add_prototyped_attribute (dw_die_ref, tree);
3732 static void add_abstract_origin_attribute (dw_die_ref, tree);
3733 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3734 static void add_src_coords_attributes (dw_die_ref, tree);
3735 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3736 static void push_decl_scope (tree);
3737 static void pop_decl_scope (void);
3738 static dw_die_ref scope_die_for (tree, dw_die_ref);
3739 static inline int local_scope_p (dw_die_ref);
3740 static inline int class_scope_p (dw_die_ref);
3741 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
3742 static const char *type_tag (tree);
3743 static tree member_declared_type (tree);
3744 #if 0
3745 static const char *decl_start_label (tree);
3746 #endif
3747 static void gen_array_type_die (tree, dw_die_ref);
3748 static void gen_set_type_die (tree, dw_die_ref);
3749 #if 0
3750 static void gen_entry_point_die (tree, dw_die_ref);
3751 #endif
3752 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
3753 static void gen_inlined_structure_type_die (tree, dw_die_ref);
3754 static void gen_inlined_union_type_die (tree, dw_die_ref);
3755 static void gen_enumeration_type_die (tree, dw_die_ref);
3756 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
3757 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3758 static void gen_formal_types_die (tree, dw_die_ref);
3759 static void gen_subprogram_die (tree, dw_die_ref);
3760 static void gen_variable_die (tree, dw_die_ref);
3761 static void gen_label_die (tree, dw_die_ref);
3762 static void gen_lexical_block_die (tree, dw_die_ref, int);
3763 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
3764 static void gen_field_die (tree, dw_die_ref);
3765 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3766 static dw_die_ref gen_compile_unit_die (const char *);
3767 static void gen_string_type_die (tree, dw_die_ref);
3768 static void gen_inheritance_die (tree, tree, dw_die_ref);
3769 static void gen_member_die (tree, dw_die_ref);
3770 static void gen_struct_or_union_type_die (tree, dw_die_ref);
3771 static void gen_subroutine_type_die (tree, dw_die_ref);
3772 static void gen_typedef_die (tree, dw_die_ref);
3773 static void gen_type_die (tree, dw_die_ref);
3774 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
3775 static void gen_block_die (tree, dw_die_ref, int);
3776 static void decls_for_scope (tree, dw_die_ref, int);
3777 static int is_redundant_typedef (tree);
3778 static void gen_decl_die (tree, dw_die_ref);
3779 static unsigned lookup_filename (const char *);
3780 static void init_file_table (void);
3781 static void retry_incomplete_types (void);
3782 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3783 static void splice_child_die (dw_die_ref, dw_die_ref);
3784 static int file_info_cmp (const void *, const void *);
3785 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3786                                      const char *, const char *, unsigned);
3787 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
3788                                        const char *, const char *,
3789                                        const char *);
3790 static void output_loc_list (dw_loc_list_ref);
3791 static char *gen_internal_sym (const char *);
3792
3793 static void prune_unmark_dies (dw_die_ref);
3794 static void prune_unused_types_mark (dw_die_ref, int);
3795 static void prune_unused_types_walk (dw_die_ref);
3796 static void prune_unused_types_walk_attribs (dw_die_ref);
3797 static void prune_unused_types_prune (dw_die_ref);
3798 static void prune_unused_types (void);
3799 static int maybe_emit_file (int);
3800
3801 /* Section names used to hold DWARF debugging information.  */
3802 #ifndef DEBUG_INFO_SECTION
3803 #define DEBUG_INFO_SECTION      ".debug_info"
3804 #endif
3805 #ifndef DEBUG_ABBREV_SECTION
3806 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3807 #endif
3808 #ifndef DEBUG_ARANGES_SECTION
3809 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3810 #endif
3811 #ifndef DEBUG_MACINFO_SECTION
3812 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3813 #endif
3814 #ifndef DEBUG_LINE_SECTION
3815 #define DEBUG_LINE_SECTION      ".debug_line"
3816 #endif
3817 #ifndef DEBUG_LOC_SECTION
3818 #define DEBUG_LOC_SECTION       ".debug_loc"
3819 #endif
3820 #ifndef DEBUG_PUBNAMES_SECTION
3821 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3822 #endif
3823 #ifndef DEBUG_STR_SECTION
3824 #define DEBUG_STR_SECTION       ".debug_str"
3825 #endif
3826 #ifndef DEBUG_RANGES_SECTION
3827 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3828 #endif
3829
3830 /* Standard ELF section names for compiled code and data.  */
3831 #ifndef TEXT_SECTION_NAME
3832 #define TEXT_SECTION_NAME       ".text"
3833 #endif
3834
3835 /* Section flags for .debug_str section.  */
3836 #define DEBUG_STR_SECTION_FLAGS \
3837   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
3838    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
3839    : SECTION_DEBUG)
3840
3841 /* Labels we insert at beginning sections we can reference instead of
3842    the section names themselves.  */
3843
3844 #ifndef TEXT_SECTION_LABEL
3845 #define TEXT_SECTION_LABEL              "Ltext"
3846 #endif
3847 #ifndef DEBUG_LINE_SECTION_LABEL
3848 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
3849 #endif
3850 #ifndef DEBUG_INFO_SECTION_LABEL
3851 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
3852 #endif
3853 #ifndef DEBUG_ABBREV_SECTION_LABEL
3854 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
3855 #endif
3856 #ifndef DEBUG_LOC_SECTION_LABEL
3857 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
3858 #endif
3859 #ifndef DEBUG_RANGES_SECTION_LABEL
3860 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
3861 #endif
3862 #ifndef DEBUG_MACINFO_SECTION_LABEL
3863 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
3864 #endif
3865
3866 /* Definitions of defaults for formats and names of various special
3867    (artificial) labels which may be generated within this file (when the -g
3868    options is used and DWARF_DEBUGGING_INFO is in effect.
3869    If necessary, these may be overridden from within the tm.h file, but
3870    typically, overriding these defaults is unnecessary.  */
3871
3872 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3873 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3874 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3875 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3876 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3877 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3878 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3879 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3880
3881 #ifndef TEXT_END_LABEL
3882 #define TEXT_END_LABEL          "Letext"
3883 #endif
3884 #ifndef BLOCK_BEGIN_LABEL
3885 #define BLOCK_BEGIN_LABEL       "LBB"
3886 #endif
3887 #ifndef BLOCK_END_LABEL
3888 #define BLOCK_END_LABEL         "LBE"
3889 #endif
3890 #ifndef LINE_CODE_LABEL
3891 #define LINE_CODE_LABEL         "LM"
3892 #endif
3893 #ifndef SEPARATE_LINE_CODE_LABEL
3894 #define SEPARATE_LINE_CODE_LABEL        "LSM"
3895 #endif
3896 \f
3897 /* We allow a language front-end to designate a function that is to be
3898    called to "demangle" any name before it it put into a DIE.  */
3899
3900 static const char *(*demangle_name_func) (const char *);
3901
3902 void
3903 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3904 {
3905   demangle_name_func = func;
3906 }
3907
3908 /* Test if rtl node points to a pseudo register.  */
3909
3910 static inline int
3911 is_pseudo_reg (rtx rtl)
3912 {
3913   return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3914           || (GET_CODE (rtl) == SUBREG
3915               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3916 }
3917
3918 /* Return a reference to a type, with its const and volatile qualifiers
3919    removed.  */
3920
3921 static inline tree
3922 type_main_variant (tree type)
3923 {
3924   type = TYPE_MAIN_VARIANT (type);
3925
3926   /* ??? There really should be only one main variant among any group of
3927      variants of a given type (and all of the MAIN_VARIANT values for all
3928      members of the group should point to that one type) but sometimes the C
3929      front-end messes this up for array types, so we work around that bug
3930      here.  */
3931   if (TREE_CODE (type) == ARRAY_TYPE)
3932     while (type != TYPE_MAIN_VARIANT (type))
3933       type = TYPE_MAIN_VARIANT (type);
3934
3935   return type;
3936 }
3937
3938 /* Return nonzero if the given type node represents a tagged type.  */
3939
3940 static inline int
3941 is_tagged_type (tree type)
3942 {
3943   enum tree_code code = TREE_CODE (type);
3944
3945   return (code == RECORD_TYPE || code == UNION_TYPE
3946           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3947 }
3948
3949 /* Convert a DIE tag into its string name.  */
3950
3951 static const char *
3952 dwarf_tag_name (unsigned int tag)
3953 {
3954   switch (tag)
3955     {
3956     case DW_TAG_padding:
3957       return "DW_TAG_padding";
3958     case DW_TAG_array_type:
3959       return "DW_TAG_array_type";
3960     case DW_TAG_class_type:
3961       return "DW_TAG_class_type";
3962     case DW_TAG_entry_point:
3963       return "DW_TAG_entry_point";
3964     case DW_TAG_enumeration_type:
3965       return "DW_TAG_enumeration_type";
3966     case DW_TAG_formal_parameter:
3967       return "DW_TAG_formal_parameter";
3968     case DW_TAG_imported_declaration:
3969       return "DW_TAG_imported_declaration";
3970     case DW_TAG_label:
3971       return "DW_TAG_label";
3972     case DW_TAG_lexical_block:
3973       return "DW_TAG_lexical_block";
3974     case DW_TAG_member:
3975       return "DW_TAG_member";
3976     case DW_TAG_pointer_type:
3977       return "DW_TAG_pointer_type";
3978     case DW_TAG_reference_type:
3979       return "DW_TAG_reference_type";
3980     case DW_TAG_compile_unit:
3981       return "DW_TAG_compile_unit";
3982     case DW_TAG_string_type:
3983       return "DW_TAG_string_type";
3984     case DW_TAG_structure_type:
3985       return "DW_TAG_structure_type";
3986     case DW_TAG_subroutine_type:
3987       return "DW_TAG_subroutine_type";
3988     case DW_TAG_typedef:
3989       return "DW_TAG_typedef";
3990     case DW_TAG_union_type:
3991       return "DW_TAG_union_type";
3992     case DW_TAG_unspecified_parameters:
3993       return "DW_TAG_unspecified_parameters";
3994     case DW_TAG_variant:
3995       return "DW_TAG_variant";
3996     case DW_TAG_common_block:
3997       return "DW_TAG_common_block";
3998     case DW_TAG_common_inclusion:
3999       return "DW_TAG_common_inclusion";
4000     case DW_TAG_inheritance:
4001       return "DW_TAG_inheritance";
4002     case DW_TAG_inlined_subroutine:
4003       return "DW_TAG_inlined_subroutine";
4004     case DW_TAG_module:
4005       return "DW_TAG_module";
4006     case DW_TAG_ptr_to_member_type:
4007       return "DW_TAG_ptr_to_member_type";
4008     case DW_TAG_set_type:
4009       return "DW_TAG_set_type";
4010     case DW_TAG_subrange_type:
4011       return "DW_TAG_subrange_type";
4012     case DW_TAG_with_stmt:
4013       return "DW_TAG_with_stmt";
4014     case DW_TAG_access_declaration:
4015       return "DW_TAG_access_declaration";
4016     case DW_TAG_base_type:
4017       return "DW_TAG_base_type";
4018     case DW_TAG_catch_block:
4019       return "DW_TAG_catch_block";
4020     case DW_TAG_const_type:
4021       return "DW_TAG_const_type";
4022     case DW_TAG_constant:
4023       return "DW_TAG_constant";
4024     case DW_TAG_enumerator:
4025       return "DW_TAG_enumerator";
4026     case DW_TAG_file_type:
4027       return "DW_TAG_file_type";
4028     case DW_TAG_friend:
4029       return "DW_TAG_friend";
4030     case DW_TAG_namelist:
4031       return "DW_TAG_namelist";
4032     case DW_TAG_namelist_item:
4033       return "DW_TAG_namelist_item";
4034     case DW_TAG_packed_type:
4035       return "DW_TAG_packed_type";
4036     case DW_TAG_subprogram:
4037       return "DW_TAG_subprogram";
4038     case DW_TAG_template_type_param:
4039       return "DW_TAG_template_type_param";
4040     case DW_TAG_template_value_param:
4041       return "DW_TAG_template_value_param";
4042     case DW_TAG_thrown_type:
4043       return "DW_TAG_thrown_type";
4044     case DW_TAG_try_block:
4045       return "DW_TAG_try_block";
4046     case DW_TAG_variant_part:
4047       return "DW_TAG_variant_part";
4048     case DW_TAG_variable:
4049       return "DW_TAG_variable";
4050     case DW_TAG_volatile_type:
4051       return "DW_TAG_volatile_type";
4052     case DW_TAG_MIPS_loop:
4053       return "DW_TAG_MIPS_loop";
4054     case DW_TAG_format_label:
4055       return "DW_TAG_format_label";
4056     case DW_TAG_function_template:
4057       return "DW_TAG_function_template";
4058     case DW_TAG_class_template:
4059       return "DW_TAG_class_template";
4060     case DW_TAG_GNU_BINCL:
4061       return "DW_TAG_GNU_BINCL";
4062     case DW_TAG_GNU_EINCL:
4063       return "DW_TAG_GNU_EINCL";
4064     default:
4065       return "DW_TAG_<unknown>";
4066     }
4067 }
4068
4069 /* Convert a DWARF attribute code into its string name.  */
4070
4071 static const char *
4072 dwarf_attr_name (unsigned int attr)
4073 {
4074   switch (attr)
4075     {
4076     case DW_AT_sibling:
4077       return "DW_AT_sibling";
4078     case DW_AT_location:
4079       return "DW_AT_location";
4080     case DW_AT_name:
4081       return "DW_AT_name";
4082     case DW_AT_ordering:
4083       return "DW_AT_ordering";
4084     case DW_AT_subscr_data:
4085       return "DW_AT_subscr_data";
4086     case DW_AT_byte_size:
4087       return "DW_AT_byte_size";
4088     case DW_AT_bit_offset:
4089       return "DW_AT_bit_offset";
4090     case DW_AT_bit_size:
4091       return "DW_AT_bit_size";
4092     case DW_AT_element_list:
4093       return "DW_AT_element_list";
4094     case DW_AT_stmt_list:
4095       return "DW_AT_stmt_list";
4096     case DW_AT_low_pc:
4097       return "DW_AT_low_pc";
4098     case DW_AT_high_pc:
4099       return "DW_AT_high_pc";
4100     case DW_AT_language:
4101       return "DW_AT_language";
4102     case DW_AT_member:
4103       return "DW_AT_member";
4104     case DW_AT_discr:
4105       return "DW_AT_discr";
4106     case DW_AT_discr_value:
4107       return "DW_AT_discr_value";
4108     case DW_AT_visibility:
4109       return "DW_AT_visibility";
4110     case DW_AT_import:
4111       return "DW_AT_import";
4112     case DW_AT_string_length:
4113       return "DW_AT_string_length";
4114     case DW_AT_common_reference:
4115       return "DW_AT_common_reference";
4116     case DW_AT_comp_dir:
4117       return "DW_AT_comp_dir";
4118     case DW_AT_const_value:
4119       return "DW_AT_const_value";
4120     case DW_AT_containing_type:
4121       return "DW_AT_containing_type";
4122     case DW_AT_default_value:
4123       return "DW_AT_default_value";
4124     case DW_AT_inline:
4125       return "DW_AT_inline";
4126     case DW_AT_is_optional:
4127       return "DW_AT_is_optional";
4128     case DW_AT_lower_bound:
4129       return "DW_AT_lower_bound";
4130     case DW_AT_producer:
4131       return "DW_AT_producer";
4132     case DW_AT_prototyped:
4133       return "DW_AT_prototyped";
4134     case DW_AT_return_addr:
4135       return "DW_AT_return_addr";
4136     case DW_AT_start_scope:
4137       return "DW_AT_start_scope";
4138     case DW_AT_stride_size:
4139       return "DW_AT_stride_size";
4140     case DW_AT_upper_bound:
4141       return "DW_AT_upper_bound";
4142     case DW_AT_abstract_origin:
4143       return "DW_AT_abstract_origin";
4144     case DW_AT_accessibility:
4145       return "DW_AT_accessibility";
4146     case DW_AT_address_class:
4147       return "DW_AT_address_class";
4148     case DW_AT_artificial:
4149       return "DW_AT_artificial";
4150     case DW_AT_base_types:
4151       return "DW_AT_base_types";
4152     case DW_AT_calling_convention:
4153       return "DW_AT_calling_convention";
4154     case DW_AT_count:
4155       return "DW_AT_count";
4156     case DW_AT_data_member_location:
4157       return "DW_AT_data_member_location";
4158     case DW_AT_decl_column:
4159       return "DW_AT_decl_column";
4160     case DW_AT_decl_file:
4161       return "DW_AT_decl_file";
4162     case DW_AT_decl_line:
4163       return "DW_AT_decl_line";
4164     case DW_AT_declaration:
4165       return "DW_AT_declaration";
4166     case DW_AT_discr_list:
4167       return "DW_AT_discr_list";
4168     case DW_AT_encoding:
4169       return "DW_AT_encoding";
4170     case DW_AT_external:
4171       return "DW_AT_external";
4172     case DW_AT_frame_base:
4173       return "DW_AT_frame_base";
4174     case DW_AT_friend:
4175       return "DW_AT_friend";
4176     case DW_AT_identifier_case:
4177       return "DW_AT_identifier_case";
4178     case DW_AT_macro_info:
4179       return "DW_AT_macro_info";
4180     case DW_AT_namelist_items:
4181       return "DW_AT_namelist_items";
4182     case DW_AT_priority:
4183       return "DW_AT_priority";
4184     case DW_AT_segment:
4185       return "DW_AT_segment";
4186     case DW_AT_specification:
4187       return "DW_AT_specification";
4188     case DW_AT_static_link:
4189       return "DW_AT_static_link";
4190     case DW_AT_type:
4191       return "DW_AT_type";
4192     case DW_AT_use_location:
4193       return "DW_AT_use_location";
4194     case DW_AT_variable_parameter:
4195       return "DW_AT_variable_parameter";
4196     case DW_AT_virtuality:
4197       return "DW_AT_virtuality";
4198     case DW_AT_vtable_elem_location:
4199       return "DW_AT_vtable_elem_location";
4200
4201     case DW_AT_allocated:
4202       return "DW_AT_allocated";
4203     case DW_AT_associated:
4204       return "DW_AT_associated";
4205     case DW_AT_data_location:
4206       return "DW_AT_data_location";
4207     case DW_AT_stride:
4208       return "DW_AT_stride";
4209     case DW_AT_entry_pc:
4210       return "DW_AT_entry_pc";
4211     case DW_AT_use_UTF8:
4212       return "DW_AT_use_UTF8";
4213     case DW_AT_extension:
4214       return "DW_AT_extension";
4215     case DW_AT_ranges:
4216       return "DW_AT_ranges";
4217     case DW_AT_trampoline:
4218       return "DW_AT_trampoline";
4219     case DW_AT_call_column:
4220       return "DW_AT_call_column";
4221     case DW_AT_call_file:
4222       return "DW_AT_call_file";
4223     case DW_AT_call_line:
4224       return "DW_AT_call_line";
4225
4226     case DW_AT_MIPS_fde:
4227       return "DW_AT_MIPS_fde";
4228     case DW_AT_MIPS_loop_begin:
4229       return "DW_AT_MIPS_loop_begin";
4230     case DW_AT_MIPS_tail_loop_begin:
4231       return "DW_AT_MIPS_tail_loop_begin";
4232     case DW_AT_MIPS_epilog_begin:
4233       return "DW_AT_MIPS_epilog_begin";
4234     case DW_AT_MIPS_loop_unroll_factor:
4235       return "DW_AT_MIPS_loop_unroll_factor";
4236     case DW_AT_MIPS_software_pipeline_depth:
4237       return "DW_AT_MIPS_software_pipeline_depth";
4238     case DW_AT_MIPS_linkage_name:
4239       return "DW_AT_MIPS_linkage_name";
4240     case DW_AT_MIPS_stride:
4241       return "DW_AT_MIPS_stride";
4242     case DW_AT_MIPS_abstract_name:
4243       return "DW_AT_MIPS_abstract_name";
4244     case DW_AT_MIPS_clone_origin:
4245       return "DW_AT_MIPS_clone_origin";
4246     case DW_AT_MIPS_has_inlines:
4247       return "DW_AT_MIPS_has_inlines";
4248
4249     case DW_AT_sf_names:
4250       return "DW_AT_sf_names";
4251     case DW_AT_src_info:
4252       return "DW_AT_src_info";
4253     case DW_AT_mac_info:
4254       return "DW_AT_mac_info";
4255     case DW_AT_src_coords:
4256       return "DW_AT_src_coords";
4257     case DW_AT_body_begin:
4258       return "DW_AT_body_begin";
4259     case DW_AT_body_end:
4260       return "DW_AT_body_end";
4261     case DW_AT_GNU_vector:
4262       return "DW_AT_GNU_vector";
4263
4264     case DW_AT_VMS_rtnbeg_pd_address:
4265       return "DW_AT_VMS_rtnbeg_pd_address";
4266
4267     default:
4268       return "DW_AT_<unknown>";
4269     }
4270 }
4271
4272 /* Convert a DWARF value form code into its string name.  */
4273
4274 static const char *
4275 dwarf_form_name (unsigned int form)
4276 {
4277   switch (form)
4278     {
4279     case DW_FORM_addr:
4280       return "DW_FORM_addr";
4281     case DW_FORM_block2:
4282       return "DW_FORM_block2";
4283     case DW_FORM_block4:
4284       return "DW_FORM_block4";
4285     case DW_FORM_data2:
4286       return "DW_FORM_data2";
4287     case DW_FORM_data4:
4288       return "DW_FORM_data4";
4289     case DW_FORM_data8:
4290       return "DW_FORM_data8";
4291     case DW_FORM_string:
4292       return "DW_FORM_string";
4293     case DW_FORM_block:
4294       return "DW_FORM_block";
4295     case DW_FORM_block1:
4296       return "DW_FORM_block1";
4297     case DW_FORM_data1:
4298       return "DW_FORM_data1";
4299     case DW_FORM_flag:
4300       return "DW_FORM_flag";
4301     case DW_FORM_sdata:
4302       return "DW_FORM_sdata";
4303     case DW_FORM_strp:
4304       return "DW_FORM_strp";
4305     case DW_FORM_udata:
4306       return "DW_FORM_udata";
4307     case DW_FORM_ref_addr:
4308       return "DW_FORM_ref_addr";
4309     case DW_FORM_ref1:
4310       return "DW_FORM_ref1";
4311     case DW_FORM_ref2:
4312       return "DW_FORM_ref2";
4313     case DW_FORM_ref4:
4314       return "DW_FORM_ref4";
4315     case DW_FORM_ref8:
4316       return "DW_FORM_ref8";
4317     case DW_FORM_ref_udata:
4318       return "DW_FORM_ref_udata";
4319     case DW_FORM_indirect:
4320       return "DW_FORM_indirect";
4321     default:
4322       return "DW_FORM_<unknown>";
4323     }
4324 }
4325
4326 /* Convert a DWARF type code into its string name.  */
4327
4328 #if 0
4329 static const char *
4330 dwarf_type_encoding_name (unsigned enc)
4331 {
4332   switch (enc)
4333     {
4334     case DW_ATE_address:
4335       return "DW_ATE_address";
4336     case DW_ATE_boolean:
4337       return "DW_ATE_boolean";
4338     case DW_ATE_complex_float:
4339       return "DW_ATE_complex_float";
4340     case DW_ATE_float:
4341       return "DW_ATE_float";
4342     case DW_ATE_signed:
4343       return "DW_ATE_signed";
4344     case DW_ATE_signed_char:
4345       return "DW_ATE_signed_char";
4346     case DW_ATE_unsigned:
4347       return "DW_ATE_unsigned";
4348     case DW_ATE_unsigned_char:
4349       return "DW_ATE_unsigned_char";
4350     default:
4351       return "DW_ATE_<unknown>";
4352     }
4353 }
4354 #endif
4355 \f
4356 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4357    instance of an inlined instance of a decl which is local to an inline
4358    function, so we have to trace all of the way back through the origin chain
4359    to find out what sort of node actually served as the original seed for the
4360    given block.  */
4361
4362 static tree
4363 decl_ultimate_origin (tree decl)
4364 {
4365   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4366      nodes in the function to point to themselves; ignore that if
4367      we're trying to output the abstract instance of this function.  */
4368   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4369     return NULL_TREE;
4370
4371 #ifdef ENABLE_CHECKING
4372   if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
4373     /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4374        most distant ancestor, this should never happen.  */
4375     abort ();
4376 #endif
4377
4378   return DECL_ABSTRACT_ORIGIN (decl);
4379 }
4380
4381 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4382    instance of an inlined instance of a block which is local to an inline
4383    function, so we have to trace all of the way back through the origin chain
4384    to find out what sort of node actually served as the original seed for the
4385    given block.  */
4386
4387 static tree
4388 block_ultimate_origin (tree block)
4389 {
4390   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4391
4392   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4393      nodes in the function to point to themselves; ignore that if
4394      we're trying to output the abstract instance of this function.  */
4395   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4396     return NULL_TREE;
4397
4398   if (immediate_origin == NULL_TREE)
4399     return NULL_TREE;
4400   else
4401     {
4402       tree ret_val;
4403       tree lookahead = immediate_origin;
4404
4405       do
4406         {
4407           ret_val = lookahead;
4408           lookahead = (TREE_CODE (ret_val) == BLOCK
4409                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4410         }
4411       while (lookahead != NULL && lookahead != ret_val);
4412
4413       return ret_val;
4414     }
4415 }
4416
4417 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4418    of a virtual function may refer to a base class, so we check the 'this'
4419    parameter.  */
4420
4421 static tree
4422 decl_class_context (tree decl)
4423 {
4424   tree context = NULL_TREE;
4425
4426   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4427     context = DECL_CONTEXT (decl);
4428   else
4429     context = TYPE_MAIN_VARIANT
4430       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4431
4432   if (context && !TYPE_P (context))
4433     context = NULL_TREE;
4434
4435   return context;
4436 }
4437 \f
4438 /* Add an attribute/value pair to a DIE.  We build the lists up in reverse
4439    addition order, and correct that in reverse_all_dies.  */
4440
4441 static inline void
4442 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4443 {
4444   if (die != NULL && attr != NULL)
4445     {
4446       attr->dw_attr_next = die->die_attr;
4447       die->die_attr = attr;
4448     }
4449 }
4450
4451 static inline enum dw_val_class
4452 AT_class (dw_attr_ref a)
4453 {
4454   return a->dw_attr_val.val_class;
4455 }
4456
4457 /* Add a flag value attribute to a DIE.  */
4458
4459 static inline void
4460 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4461 {
4462   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4463
4464   attr->dw_attr_next = NULL;
4465   attr->dw_attr = attr_kind;
4466   attr->dw_attr_val.val_class = dw_val_class_flag;
4467   attr->dw_attr_val.v.val_flag = flag;
4468   add_dwarf_attr (die, attr);
4469 }
4470
4471 static inline unsigned
4472 AT_flag (dw_attr_ref a)
4473 {
4474   if (a && AT_class (a) == dw_val_class_flag)
4475     return a->dw_attr_val.v.val_flag;
4476
4477   abort ();
4478 }
4479
4480 /* Add a signed integer attribute value to a DIE.  */
4481
4482 static inline void
4483 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, long int int_val)
4484 {
4485   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4486
4487   attr->dw_attr_next = NULL;
4488   attr->dw_attr = attr_kind;
4489   attr->dw_attr_val.val_class = dw_val_class_const;
4490   attr->dw_attr_val.v.val_int = int_val;
4491   add_dwarf_attr (die, attr);
4492 }
4493
4494 static inline long int
4495 AT_int (dw_attr_ref a)
4496 {
4497   if (a && AT_class (a) == dw_val_class_const)
4498     return a->dw_attr_val.v.val_int;
4499
4500   abort ();
4501 }
4502
4503 /* Add an unsigned integer attribute value to a DIE.  */
4504
4505 static inline void
4506 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4507                  long unsigned int unsigned_val)
4508 {
4509   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4510
4511   attr->dw_attr_next = NULL;
4512   attr->dw_attr = attr_kind;
4513   attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4514   attr->dw_attr_val.v.val_unsigned = unsigned_val;
4515   add_dwarf_attr (die, attr);
4516 }
4517
4518 static inline unsigned long
4519 AT_unsigned (dw_attr_ref a)
4520 {
4521   if (a && AT_class (a) == dw_val_class_unsigned_const)
4522     return a->dw_attr_val.v.val_unsigned;
4523
4524   abort ();
4525 }
4526
4527 /* Add an unsigned double integer attribute value to a DIE.  */
4528
4529 static inline void
4530 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4531                   long unsigned int val_hi, long unsigned int val_low)
4532 {
4533   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4534
4535   attr->dw_attr_next = NULL;
4536   attr->dw_attr = attr_kind;
4537   attr->dw_attr_val.val_class = dw_val_class_long_long;
4538   attr->dw_attr_val.v.val_long_long.hi = val_hi;
4539   attr->dw_attr_val.v.val_long_long.low = val_low;
4540   add_dwarf_attr (die, attr);
4541 }
4542
4543 /* Add a floating point attribute value to a DIE and return it.  */
4544
4545 static inline void
4546 add_AT_float (dw_die_ref die, enum dwarf_attribute attr_kind,
4547               unsigned int length, long int *array)
4548 {
4549   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4550
4551   attr->dw_attr_next = NULL;
4552   attr->dw_attr = attr_kind;
4553   attr->dw_attr_val.val_class = dw_val_class_float;
4554   attr->dw_attr_val.v.val_float.length = length;
4555   attr->dw_attr_val.v.val_float.array = array;
4556   add_dwarf_attr (die, attr);
4557 }
4558
4559 /* Hash and equality functions for debug_str_hash.  */
4560
4561 static hashval_t
4562 debug_str_do_hash (const void *x)
4563 {
4564   return htab_hash_string (((const struct indirect_string_node *)x)->str);
4565 }
4566
4567 static int
4568 debug_str_eq (const void *x1, const void *x2)
4569 {
4570   return strcmp ((((const struct indirect_string_node *)x1)->str),
4571                  (const char *)x2) == 0;
4572 }
4573
4574 /* Add a string attribute value to a DIE.  */
4575
4576 static inline void
4577 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4578 {
4579   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4580   struct indirect_string_node *node;
4581   void **slot;
4582
4583   if (! debug_str_hash)
4584     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4585                                       debug_str_eq, NULL);
4586
4587   slot = htab_find_slot_with_hash (debug_str_hash, str,
4588                                    htab_hash_string (str), INSERT);
4589   if (*slot == NULL)
4590     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4591   node = (struct indirect_string_node *) *slot;
4592   node->str = ggc_strdup (str);
4593   node->refcount++;
4594
4595   attr->dw_attr_next = NULL;
4596   attr->dw_attr = attr_kind;
4597   attr->dw_attr_val.val_class = dw_val_class_str;
4598   attr->dw_attr_val.v.val_str = node;
4599   add_dwarf_attr (die, attr);
4600 }
4601
4602 static inline const char *
4603 AT_string (dw_attr_ref a)
4604 {
4605   if (a && AT_class (a) == dw_val_class_str)
4606     return a->dw_attr_val.v.val_str->str;
4607
4608   abort ();
4609 }
4610
4611 /* Find out whether a string should be output inline in DIE
4612    or out-of-line in .debug_str section.  */
4613
4614 static int
4615 AT_string_form (dw_attr_ref a)
4616 {
4617   if (a && AT_class (a) == dw_val_class_str)
4618     {
4619       struct indirect_string_node *node;
4620       unsigned int len;
4621       char label[32];
4622
4623       node = a->dw_attr_val.v.val_str;
4624       if (node->form)
4625         return node->form;
4626
4627       len = strlen (node->str) + 1;
4628
4629       /* If the string is shorter or equal to the size of the reference, it is
4630          always better to put it inline.  */
4631       if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4632         return node->form = DW_FORM_string;
4633
4634       /* If we cannot expect the linker to merge strings in .debug_str
4635          section, only put it into .debug_str if it is worth even in this
4636          single module.  */
4637       if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
4638           && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
4639         return node->form = DW_FORM_string;
4640
4641       ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4642       ++dw2_string_counter;
4643       node->label = xstrdup (label);
4644
4645       return node->form = DW_FORM_strp;
4646     }
4647
4648   abort ();
4649 }
4650
4651 /* Add a DIE reference attribute value to a DIE.  */
4652
4653 static inline void
4654 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4655 {
4656   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4657
4658   attr->dw_attr_next = NULL;
4659   attr->dw_attr = attr_kind;
4660   attr->dw_attr_val.val_class = dw_val_class_die_ref;
4661   attr->dw_attr_val.v.val_die_ref.die = targ_die;
4662   attr->dw_attr_val.v.val_die_ref.external = 0;
4663   add_dwarf_attr (die, attr);
4664 }
4665
4666 static inline dw_die_ref
4667 AT_ref (dw_attr_ref a)
4668 {
4669   if (a && AT_class (a) == dw_val_class_die_ref)
4670     return a->dw_attr_val.v.val_die_ref.die;
4671
4672   abort ();
4673 }
4674
4675 static inline int
4676 AT_ref_external (dw_attr_ref a)
4677 {
4678   if (a && AT_class (a) == dw_val_class_die_ref)
4679     return a->dw_attr_val.v.val_die_ref.external;
4680
4681   return 0;
4682 }
4683
4684 static inline void
4685 set_AT_ref_external (dw_attr_ref a, int i)
4686 {
4687   if (a && AT_class (a) == dw_val_class_die_ref)
4688     a->dw_attr_val.v.val_die_ref.external = i;
4689   else
4690     abort ();
4691 }
4692
4693 /* Add an FDE reference attribute value to a DIE.  */
4694
4695 static inline void
4696 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4697 {
4698   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4699
4700   attr->dw_attr_next = NULL;
4701   attr->dw_attr = attr_kind;
4702   attr->dw_attr_val.val_class = dw_val_class_fde_ref;
4703   attr->dw_attr_val.v.val_fde_index = targ_fde;
4704   add_dwarf_attr (die, attr);
4705 }
4706
4707 /* Add a location description attribute value to a DIE.  */
4708
4709 static inline void
4710 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4711 {
4712   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4713
4714   attr->dw_attr_next = NULL;
4715   attr->dw_attr = attr_kind;
4716   attr->dw_attr_val.val_class = dw_val_class_loc;
4717   attr->dw_attr_val.v.val_loc = loc;
4718   add_dwarf_attr (die, attr);
4719 }
4720
4721 static inline dw_loc_descr_ref
4722 AT_loc (dw_attr_ref a)
4723 {
4724   if (a && AT_class (a) == dw_val_class_loc)
4725     return a->dw_attr_val.v.val_loc;
4726
4727   abort ();
4728 }
4729
4730 static inline void
4731 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4732 {
4733   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4734
4735   attr->dw_attr_next = NULL;
4736   attr->dw_attr = attr_kind;
4737   attr->dw_attr_val.val_class = dw_val_class_loc_list;
4738   attr->dw_attr_val.v.val_loc_list = loc_list;
4739   add_dwarf_attr (die, attr);
4740   have_location_lists = 1;
4741 }
4742
4743 static inline dw_loc_list_ref
4744 AT_loc_list (dw_attr_ref a)
4745 {
4746   if (a && AT_class (a) == dw_val_class_loc_list)
4747     return a->dw_attr_val.v.val_loc_list;
4748
4749   abort ();
4750 }
4751
4752 /* Add an address constant attribute value to a DIE.  */
4753
4754 static inline void
4755 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
4756 {
4757   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4758
4759   attr->dw_attr_next = NULL;
4760   attr->dw_attr = attr_kind;
4761   attr->dw_attr_val.val_class = dw_val_class_addr;
4762   attr->dw_attr_val.v.val_addr = addr;
4763   add_dwarf_attr (die, attr);
4764 }
4765
4766 static inline rtx
4767 AT_addr (dw_attr_ref a)
4768 {
4769   if (a && AT_class (a) == dw_val_class_addr)
4770     return a->dw_attr_val.v.val_addr;
4771
4772   abort ();
4773 }
4774
4775 /* Add a label identifier attribute value to a DIE.  */
4776
4777 static inline void
4778 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
4779 {
4780   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4781
4782   attr->dw_attr_next = NULL;
4783   attr->dw_attr = attr_kind;
4784   attr->dw_attr_val.val_class = dw_val_class_lbl_id;
4785   attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4786   add_dwarf_attr (die, attr);
4787 }
4788
4789 /* Add a section offset attribute value to a DIE.  */
4790
4791 static inline void
4792 add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
4793 {
4794   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4795
4796   attr->dw_attr_next = NULL;
4797   attr->dw_attr = attr_kind;
4798   attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
4799   attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
4800   add_dwarf_attr (die, attr);
4801 }
4802
4803 /* Add an offset attribute value to a DIE.  */
4804
4805 static inline void
4806 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, long unsigned int offset)
4807 {
4808   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4809
4810   attr->dw_attr_next = NULL;
4811   attr->dw_attr = attr_kind;
4812   attr->dw_attr_val.val_class = dw_val_class_offset;
4813   attr->dw_attr_val.v.val_offset = offset;
4814   add_dwarf_attr (die, attr);
4815 }
4816
4817 /* Add an range_list attribute value to a DIE.  */
4818
4819 static void
4820 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
4821                    long unsigned int offset)
4822 {
4823   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4824
4825   attr->dw_attr_next = NULL;
4826   attr->dw_attr = attr_kind;
4827   attr->dw_attr_val.val_class = dw_val_class_range_list;
4828   attr->dw_attr_val.v.val_offset = offset;
4829   add_dwarf_attr (die, attr);
4830 }
4831
4832 static inline const char *
4833 AT_lbl (dw_attr_ref a)
4834 {
4835   if (a && (AT_class (a) == dw_val_class_lbl_id
4836             || AT_class (a) == dw_val_class_lbl_offset))
4837     return a->dw_attr_val.v.val_lbl_id;
4838
4839   abort ();
4840 }
4841
4842 /* Get the attribute of type attr_kind.  */
4843
4844 static inline dw_attr_ref
4845 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4846 {
4847   dw_attr_ref a;
4848   dw_die_ref spec = NULL;
4849
4850   if (die != NULL)
4851     {
4852       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4853         if (a->dw_attr == attr_kind)
4854           return a;
4855         else if (a->dw_attr == DW_AT_specification
4856                  || a->dw_attr == DW_AT_abstract_origin)
4857           spec = AT_ref (a);
4858
4859       if (spec)
4860         return get_AT (spec, attr_kind);
4861     }
4862
4863   return NULL;
4864 }
4865
4866 /* Return the "low pc" attribute value, typically associated with a subprogram
4867    DIE.  Return null if the "low pc" attribute is either not present, or if it
4868    cannot be represented as an assembler label identifier.  */
4869
4870 static inline const char *
4871 get_AT_low_pc (dw_die_ref die)
4872 {
4873   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
4874
4875   return a ? AT_lbl (a) : NULL;
4876 }
4877
4878 /* Return the "high pc" attribute value, typically associated with a subprogram
4879    DIE.  Return null if the "high pc" attribute is either not present, or if it
4880    cannot be represented as an assembler label identifier.  */
4881
4882 static inline const char *
4883 get_AT_hi_pc (dw_die_ref die)
4884 {
4885   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4886
4887   return a ? AT_lbl (a) : NULL;
4888 }
4889
4890 /* Return the value of the string attribute designated by ATTR_KIND, or
4891    NULL if it is not present.  */
4892
4893 static inline const char *
4894 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
4895 {
4896   dw_attr_ref a = get_AT (die, attr_kind);
4897
4898   return a ? AT_string (a) : NULL;
4899 }
4900
4901 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4902    if it is not present.  */
4903
4904 static inline int
4905 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
4906 {
4907   dw_attr_ref a = get_AT (die, attr_kind);
4908
4909   return a ? AT_flag (a) : 0;
4910 }
4911
4912 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4913    if it is not present.  */
4914
4915 static inline unsigned
4916 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
4917 {
4918   dw_attr_ref a = get_AT (die, attr_kind);
4919
4920   return a ? AT_unsigned (a) : 0;
4921 }
4922
4923 static inline dw_die_ref
4924 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
4925 {
4926   dw_attr_ref a = get_AT (die, attr_kind);
4927
4928   return a ? AT_ref (a) : NULL;
4929 }
4930
4931 /* Return TRUE if the language is C or C++.  */
4932
4933 static inline bool
4934 is_c_family (void)
4935 {
4936   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4937
4938   return (lang == DW_LANG_C || lang == DW_LANG_C89
4939           || lang == DW_LANG_C_plus_plus);
4940 }
4941
4942 /* Return TRUE if the language is C++.  */
4943
4944 static inline bool
4945 is_cxx (void)
4946 {
4947   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
4948           == DW_LANG_C_plus_plus);
4949 }
4950
4951 /* Return TRUE if the language is Fortran.  */
4952
4953 static inline bool
4954 is_fortran (void)
4955 {
4956   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4957
4958   return lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90;
4959 }
4960
4961 /* Return TRUE if the language is Java.  */
4962
4963 static inline bool
4964 is_java (void)
4965 {
4966   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4967
4968   return lang == DW_LANG_Java;
4969 }
4970
4971 /* Return TRUE if the language is Ada.  */
4972
4973 static inline bool
4974 is_ada (void)
4975 {
4976   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4977
4978   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
4979 }
4980
4981 /* Free up the memory used by A.  */
4982
4983 static inline void free_AT (dw_attr_ref);
4984 static inline void
4985 free_AT (dw_attr_ref a)
4986 {
4987   if (AT_class (a) == dw_val_class_str)
4988     if (a->dw_attr_val.v.val_str->refcount)
4989       a->dw_attr_val.v.val_str->refcount--;
4990 }
4991
4992 /* Remove the specified attribute if present.  */
4993
4994 static void
4995 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4996 {
4997   dw_attr_ref *p;
4998   dw_attr_ref removed = NULL;
4999
5000   if (die != NULL)
5001     {
5002       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5003         if ((*p)->dw_attr == attr_kind)
5004           {
5005             removed = *p;
5006             *p = (*p)->dw_attr_next;
5007             break;
5008           }
5009
5010       if (removed != 0)
5011         free_AT (removed);
5012     }
5013 }
5014
5015 /* Free up the memory used by DIE.  */
5016
5017 static inline void
5018 free_die (dw_die_ref die)
5019 {
5020   remove_children (die);
5021 }
5022
5023 /* Discard the children of this DIE.  */
5024
5025 static void
5026 remove_children (dw_die_ref die)
5027 {
5028   dw_die_ref child_die = die->die_child;
5029
5030   die->die_child = NULL;
5031
5032   while (child_die != NULL)
5033     {
5034       dw_die_ref tmp_die = child_die;
5035       dw_attr_ref a;
5036
5037       child_die = child_die->die_sib;
5038
5039       for (a = tmp_die->die_attr; a != NULL;)
5040         {
5041           dw_attr_ref tmp_a = a;
5042
5043           a = a->dw_attr_next;
5044           free_AT (tmp_a);
5045         }
5046
5047       free_die (tmp_die);
5048     }
5049 }
5050
5051 /* Add a child DIE below its parent.  We build the lists up in reverse
5052    addition order, and correct that in reverse_all_dies.  */
5053
5054 static inline void
5055 add_child_die (dw_die_ref die, dw_die_ref child_die)
5056 {
5057   if (die != NULL && child_die != NULL)
5058     {
5059       if (die == child_die)
5060         abort ();
5061
5062       child_die->die_parent = die;
5063       child_die->die_sib = die->die_child;
5064       die->die_child = child_die;
5065     }
5066 }
5067
5068 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5069    is the specification, to the front of PARENT's list of children.  */
5070
5071 static void
5072 splice_child_die (dw_die_ref parent, dw_die_ref child)
5073 {
5074   dw_die_ref *p;
5075
5076   /* We want the declaration DIE from inside the class, not the
5077      specification DIE at toplevel.  */
5078   if (child->die_parent != parent)
5079     {
5080       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5081
5082       if (tmp)
5083         child = tmp;
5084     }
5085
5086   if (child->die_parent != parent
5087       && child->die_parent != get_AT_ref (parent, DW_AT_specification))
5088     abort ();
5089
5090   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5091     if (*p == child)
5092       {
5093         *p = child->die_sib;
5094         break;
5095       }
5096
5097   child->die_parent = parent;
5098   child->die_sib = parent->die_child;
5099   parent->die_child = child;
5100 }
5101
5102 /* Return a pointer to a newly created DIE node.  */
5103
5104 static inline dw_die_ref
5105 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5106 {
5107   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5108
5109   die->die_tag = tag_value;
5110
5111   if (parent_die != NULL)
5112     add_child_die (parent_die, die);
5113   else
5114     {
5115       limbo_die_node *limbo_node;
5116
5117       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5118       limbo_node->die = die;
5119       limbo_node->created_for = t;
5120       limbo_node->next = limbo_die_list;
5121       limbo_die_list = limbo_node;
5122     }
5123
5124   return die;
5125 }
5126
5127 /* Return the DIE associated with the given type specifier.  */
5128
5129 static inline dw_die_ref
5130 lookup_type_die (tree type)
5131 {
5132   return TYPE_SYMTAB_DIE (type);
5133 }
5134
5135 /* Equate a DIE to a given type specifier.  */
5136
5137 static inline void
5138 equate_type_number_to_die (tree type, dw_die_ref type_die)
5139 {
5140   TYPE_SYMTAB_DIE (type) = type_die;
5141 }
5142
5143 /* Return the DIE associated with a given declaration.  */
5144
5145 static inline dw_die_ref
5146 lookup_decl_die (tree decl)
5147 {
5148   unsigned decl_id = DECL_UID (decl);
5149
5150   return (decl_id < decl_die_table_in_use ? decl_die_table[decl_id] : NULL);
5151 }
5152
5153 /* Equate a DIE to a particular declaration.  */
5154
5155 static void
5156 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5157 {
5158   unsigned int decl_id = DECL_UID (decl);
5159   unsigned int num_allocated;
5160
5161   if (decl_id >= decl_die_table_allocated)
5162     {
5163       num_allocated
5164         = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
5165            / DECL_DIE_TABLE_INCREMENT)
5166           * DECL_DIE_TABLE_INCREMENT;
5167
5168       decl_die_table = ggc_realloc (decl_die_table,
5169                                     sizeof (dw_die_ref) * num_allocated);
5170
5171       memset (&decl_die_table[decl_die_table_allocated], 0,
5172              (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
5173       decl_die_table_allocated = num_allocated;
5174     }
5175
5176   if (decl_id >= decl_die_table_in_use)
5177     decl_die_table_in_use = (decl_id + 1);
5178
5179   decl_die_table[decl_id] = decl_die;
5180 }
5181 \f
5182 /* Keep track of the number of spaces used to indent the
5183    output of the debugging routines that print the structure of
5184    the DIE internal representation.  */
5185 static int print_indent;
5186
5187 /* Indent the line the number of spaces given by print_indent.  */
5188
5189 static inline void
5190 print_spaces (FILE *outfile)
5191 {
5192   fprintf (outfile, "%*s", print_indent, "");
5193 }
5194
5195 /* Print the information associated with a given DIE, and its children.
5196    This routine is a debugging aid only.  */
5197
5198 static void
5199 print_die (dw_die_ref die, FILE *outfile)
5200 {
5201   dw_attr_ref a;
5202   dw_die_ref c;
5203
5204   print_spaces (outfile);
5205   fprintf (outfile, "DIE %4lu: %s\n",
5206            die->die_offset, dwarf_tag_name (die->die_tag));
5207   print_spaces (outfile);
5208   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5209   fprintf (outfile, " offset: %lu\n", die->die_offset);
5210
5211   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5212     {
5213       print_spaces (outfile);
5214       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5215
5216       switch (AT_class (a))
5217         {
5218         case dw_val_class_addr:
5219           fprintf (outfile, "address");
5220           break;
5221         case dw_val_class_offset:
5222           fprintf (outfile, "offset");
5223           break;
5224         case dw_val_class_loc:
5225           fprintf (outfile, "location descriptor");
5226           break;
5227         case dw_val_class_loc_list:
5228           fprintf (outfile, "location list -> label:%s",
5229                    AT_loc_list (a)->ll_symbol);
5230           break;
5231         case dw_val_class_range_list:
5232           fprintf (outfile, "range list");
5233           break;
5234         case dw_val_class_const:
5235           fprintf (outfile, "%ld", AT_int (a));
5236           break;
5237         case dw_val_class_unsigned_const:
5238           fprintf (outfile, "%lu", AT_unsigned (a));
5239           break;
5240         case dw_val_class_long_long:
5241           fprintf (outfile, "constant (%lu,%lu)",
5242                    a->dw_attr_val.v.val_long_long.hi,
5243                    a->dw_attr_val.v.val_long_long.low);
5244           break;
5245         case dw_val_class_float:
5246           fprintf (outfile, "floating-point constant");
5247           break;
5248         case dw_val_class_flag:
5249           fprintf (outfile, "%u", AT_flag (a));
5250           break;
5251         case dw_val_class_die_ref:
5252           if (AT_ref (a) != NULL)
5253             {
5254               if (AT_ref (a)->die_symbol)
5255                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5256               else
5257                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5258             }
5259           else
5260             fprintf (outfile, "die -> <null>");
5261           break;
5262         case dw_val_class_lbl_id:
5263         case dw_val_class_lbl_offset:
5264           fprintf (outfile, "label: %s", AT_lbl (a));
5265           break;
5266         case dw_val_class_str:
5267           if (AT_string (a) != NULL)
5268             fprintf (outfile, "\"%s\"", AT_string (a));
5269           else
5270             fprintf (outfile, "<null>");
5271           break;
5272         default:
5273           break;
5274         }
5275
5276       fprintf (outfile, "\n");
5277     }
5278
5279   if (die->die_child != NULL)
5280     {
5281       print_indent += 4;
5282       for (c = die->die_child; c != NULL; c = c->die_sib)
5283         print_die (c, outfile);
5284
5285       print_indent -= 4;
5286     }
5287   if (print_indent == 0)
5288     fprintf (outfile, "\n");
5289 }
5290
5291 /* Print the contents of the source code line number correspondence table.
5292    This routine is a debugging aid only.  */
5293
5294 static void
5295 print_dwarf_line_table (FILE *outfile)
5296 {
5297   unsigned i;
5298   dw_line_info_ref line_info;
5299
5300   fprintf (outfile, "\n\nDWARF source line information\n");
5301   for (i = 1; i < line_info_table_in_use; i++)
5302     {
5303       line_info = &line_info_table[i];
5304       fprintf (outfile, "%5d: ", i);
5305       fprintf (outfile, "%-20s",
5306                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5307       fprintf (outfile, "%6ld", line_info->dw_line_num);
5308       fprintf (outfile, "\n");
5309     }
5310
5311   fprintf (outfile, "\n\n");
5312 }
5313
5314 /* Print the information collected for a given DIE.  */
5315
5316 void
5317 debug_dwarf_die (dw_die_ref die)
5318 {
5319   print_die (die, stderr);
5320 }
5321
5322 /* Print all DWARF information collected for the compilation unit.
5323    This routine is a debugging aid only.  */
5324
5325 void
5326 debug_dwarf (void)
5327 {
5328   print_indent = 0;
5329   print_die (comp_unit_die, stderr);
5330   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5331     print_dwarf_line_table (stderr);
5332 }
5333 \f
5334 /* We build up the lists of children and attributes by pushing new ones
5335    onto the beginning of the list.  Reverse the lists for DIE so that
5336    they are in order of addition.  */
5337
5338 static void
5339 reverse_die_lists (dw_die_ref die)
5340 {
5341   dw_die_ref c, cp, cn;
5342   dw_attr_ref a, ap, an;
5343
5344   for (a = die->die_attr, ap = 0; a; a = an)
5345     {
5346       an = a->dw_attr_next;
5347       a->dw_attr_next = ap;
5348       ap = a;
5349     }
5350
5351   die->die_attr = ap;
5352
5353   for (c = die->die_child, cp = 0; c; c = cn)
5354     {
5355       cn = c->die_sib;
5356       c->die_sib = cp;
5357       cp = c;
5358     }
5359
5360   die->die_child = cp;
5361 }
5362
5363 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5364    reverse all dies in add_sibling_attributes, which runs through all the dies,
5365    it would reverse all the dies.  Now, however, since we don't call
5366    reverse_die_lists in add_sibling_attributes, we need a routine to
5367    recursively reverse all the dies. This is that routine.  */
5368
5369 static void
5370 reverse_all_dies (dw_die_ref die)
5371 {
5372   dw_die_ref c;
5373
5374   reverse_die_lists (die);
5375
5376   for (c = die->die_child; c; c = c->die_sib)
5377     reverse_all_dies (c);
5378 }
5379
5380 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5381    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5382    DIE that marks the start of the DIEs for this include file.  */
5383
5384 static dw_die_ref
5385 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5386 {
5387   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5388   dw_die_ref new_unit = gen_compile_unit_die (filename);
5389
5390   new_unit->die_sib = old_unit;
5391   return new_unit;
5392 }
5393
5394 /* Close an include-file CU and reopen the enclosing one.  */
5395
5396 static dw_die_ref
5397 pop_compile_unit (dw_die_ref old_unit)
5398 {
5399   dw_die_ref new_unit = old_unit->die_sib;
5400
5401   old_unit->die_sib = NULL;
5402   return new_unit;
5403 }
5404
5405 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5406 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5407
5408 /* Calculate the checksum of a location expression.  */
5409
5410 static inline void
5411 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5412 {
5413   CHECKSUM (loc->dw_loc_opc);
5414   CHECKSUM (loc->dw_loc_oprnd1);
5415   CHECKSUM (loc->dw_loc_oprnd2);
5416 }
5417
5418 /* Calculate the checksum of an attribute.  */
5419
5420 static void
5421 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5422 {
5423   dw_loc_descr_ref loc;
5424   rtx r;
5425
5426   CHECKSUM (at->dw_attr);
5427
5428   /* We don't care about differences in file numbering.  */
5429   if (at->dw_attr == DW_AT_decl_file
5430       /* Or that this was compiled with a different compiler snapshot; if
5431          the output is the same, that's what matters.  */
5432       || at->dw_attr == DW_AT_producer)
5433     return;
5434
5435   switch (AT_class (at))
5436     {
5437     case dw_val_class_const:
5438       CHECKSUM (at->dw_attr_val.v.val_int);
5439       break;
5440     case dw_val_class_unsigned_const:
5441       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5442       break;
5443     case dw_val_class_long_long:
5444       CHECKSUM (at->dw_attr_val.v.val_long_long);
5445       break;
5446     case dw_val_class_float:
5447       CHECKSUM (at->dw_attr_val.v.val_float);
5448       break;
5449     case dw_val_class_flag:
5450       CHECKSUM (at->dw_attr_val.v.val_flag);
5451       break;
5452     case dw_val_class_str:
5453       CHECKSUM_STRING (AT_string (at));
5454       break;
5455
5456     case dw_val_class_addr:
5457       r = AT_addr (at);
5458       switch (GET_CODE (r))
5459         {
5460         case SYMBOL_REF:
5461           CHECKSUM_STRING (XSTR (r, 0));
5462           break;
5463
5464         default:
5465           abort ();
5466         }
5467       break;
5468
5469     case dw_val_class_offset:
5470       CHECKSUM (at->dw_attr_val.v.val_offset);
5471       break;
5472
5473     case dw_val_class_loc:
5474       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5475         loc_checksum (loc, ctx);
5476       break;
5477
5478     case dw_val_class_die_ref:
5479       die_checksum (AT_ref (at), ctx, mark);
5480       break;
5481
5482     case dw_val_class_fde_ref:
5483     case dw_val_class_lbl_id:
5484     case dw_val_class_lbl_offset:
5485       break;
5486
5487     default:
5488       break;
5489     }
5490 }
5491
5492 /* Calculate the checksum of a DIE.  */
5493
5494 static void
5495 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5496 {
5497   dw_die_ref c;
5498   dw_attr_ref a;
5499
5500   /* To avoid infinite recursion.  */
5501   if (die->die_mark)
5502     {
5503       CHECKSUM (die->die_mark);
5504       return;
5505     }
5506   die->die_mark = ++(*mark);
5507
5508   CHECKSUM (die->die_tag);
5509
5510   for (a = die->die_attr; a; a = a->dw_attr_next)
5511     attr_checksum (a, ctx, mark);
5512
5513   for (c = die->die_child; c; c = c->die_sib)
5514     die_checksum (c, ctx, mark);
5515 }
5516
5517 #undef CHECKSUM
5518 #undef CHECKSUM_STRING
5519
5520 /* Do the location expressions look same?  */
5521 static inline int
5522 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
5523 {
5524   return loc1->dw_loc_opc == loc2->dw_loc_opc
5525          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5526          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5527 }
5528
5529 /* Do the values look the same?  */
5530 static int
5531 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
5532 {
5533   dw_loc_descr_ref loc1, loc2;
5534   rtx r1, r2;
5535   unsigned i;
5536
5537   if (v1->val_class != v2->val_class)
5538     return 0;
5539
5540   switch (v1->val_class)
5541     {
5542     case dw_val_class_const:
5543       return v1->v.val_int == v2->v.val_int;
5544     case dw_val_class_unsigned_const:
5545       return v1->v.val_unsigned == v2->v.val_unsigned;
5546     case dw_val_class_long_long:
5547       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5548              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5549     case dw_val_class_float:
5550       if (v1->v.val_float.length != v2->v.val_float.length)
5551         return 0;
5552       for (i = 0; i < v1->v.val_float.length; i++)
5553         if (v1->v.val_float.array[i] != v2->v.val_float.array[i])
5554           return 0;
5555       return 1;
5556     case dw_val_class_flag:
5557       return v1->v.val_flag == v2->v.val_flag;
5558     case dw_val_class_str:
5559       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
5560
5561     case dw_val_class_addr:
5562       r1 = v1->v.val_addr;
5563       r2 = v2->v.val_addr;
5564       if (GET_CODE (r1) != GET_CODE (r2))
5565         return 0;
5566       switch (GET_CODE (r1))
5567         {
5568         case SYMBOL_REF:
5569           return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
5570
5571         default:
5572           abort ();
5573         }
5574
5575     case dw_val_class_offset:
5576       return v1->v.val_offset == v2->v.val_offset;
5577
5578     case dw_val_class_loc:
5579       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
5580            loc1 && loc2;
5581            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
5582         if (!same_loc_p (loc1, loc2, mark))
5583           return 0;
5584       return !loc1 && !loc2;
5585
5586     case dw_val_class_die_ref:
5587       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
5588
5589     case dw_val_class_fde_ref:
5590     case dw_val_class_lbl_id:
5591     case dw_val_class_lbl_offset:
5592       return 1;
5593
5594     default:
5595       return 1;
5596     }
5597 }
5598
5599 /* Do the attributes look the same?  */
5600
5601 static int
5602 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
5603 {
5604   if (at1->dw_attr != at2->dw_attr)
5605     return 0;
5606
5607   /* We don't care about differences in file numbering.  */
5608   if (at1->dw_attr == DW_AT_decl_file
5609       /* Or that this was compiled with a different compiler snapshot; if
5610          the output is the same, that's what matters.  */
5611       || at1->dw_attr == DW_AT_producer)
5612     return 1;
5613
5614   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
5615 }
5616
5617 /* Do the dies look the same?  */
5618
5619 static int
5620 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
5621 {
5622   dw_die_ref c1, c2;
5623   dw_attr_ref a1, a2;
5624
5625   /* To avoid infinite recursion.  */
5626   if (die1->die_mark)
5627     return die1->die_mark == die2->die_mark;
5628   die1->die_mark = die2->die_mark = ++(*mark);
5629
5630   if (die1->die_tag != die2->die_tag)
5631     return 0;
5632
5633   for (a1 = die1->die_attr, a2 = die2->die_attr;
5634        a1 && a2;
5635        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
5636     if (!same_attr_p (a1, a2, mark))
5637       return 0;
5638   if (a1 || a2)
5639     return 0;
5640
5641   for (c1 = die1->die_child, c2 = die2->die_child;
5642        c1 && c2;
5643        c1 = c1->die_sib, c2 = c2->die_sib)
5644     if (!same_die_p (c1, c2, mark))
5645       return 0;
5646   if (c1 || c2)
5647     return 0;
5648
5649   return 1;
5650 }
5651
5652 /* Do the dies look the same?  Wrapper around same_die_p.  */
5653
5654 static int
5655 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
5656 {
5657   int mark = 0;
5658   int ret = same_die_p (die1, die2, &mark);
5659
5660   unmark_all_dies (die1);
5661   unmark_all_dies (die2);
5662
5663   return ret;
5664 }
5665
5666 /* The prefix to attach to symbols on DIEs in the current comdat debug
5667    info section.  */
5668 static char *comdat_symbol_id;
5669
5670 /* The index of the current symbol within the current comdat CU.  */
5671 static unsigned int comdat_symbol_number;
5672
5673 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5674    children, and set comdat_symbol_id accordingly.  */
5675
5676 static void
5677 compute_section_prefix (dw_die_ref unit_die)
5678 {
5679   const char *die_name = get_AT_string (unit_die, DW_AT_name);
5680   const char *base = die_name ? lbasename (die_name) : "anonymous";
5681   char *name = alloca (strlen (base) + 64);
5682   char *p;
5683   int i, mark;
5684   unsigned char checksum[16];
5685   struct md5_ctx ctx;
5686
5687   /* Compute the checksum of the DIE, then append part of it as hex digits to
5688      the name filename of the unit.  */
5689
5690   md5_init_ctx (&ctx);
5691   mark = 0;
5692   die_checksum (unit_die, &ctx, &mark);
5693   unmark_all_dies (unit_die);
5694   md5_finish_ctx (&ctx, checksum);
5695
5696   sprintf (name, "%s.", base);
5697   clean_symbol_name (name);
5698
5699   p = name + strlen (name);
5700   for (i = 0; i < 4; i++)
5701     {
5702       sprintf (p, "%.2x", checksum[i]);
5703       p += 2;
5704     }
5705
5706   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
5707   comdat_symbol_number = 0;
5708 }
5709
5710 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
5711
5712 static int
5713 is_type_die (dw_die_ref die)
5714 {
5715   switch (die->die_tag)
5716     {
5717     case DW_TAG_array_type:
5718     case DW_TAG_class_type:
5719     case DW_TAG_enumeration_type:
5720     case DW_TAG_pointer_type:
5721     case DW_TAG_reference_type:
5722     case DW_TAG_string_type:
5723     case DW_TAG_structure_type:
5724     case DW_TAG_subroutine_type:
5725     case DW_TAG_union_type:
5726     case DW_TAG_ptr_to_member_type:
5727     case DW_TAG_set_type:
5728     case DW_TAG_subrange_type:
5729     case DW_TAG_base_type:
5730     case DW_TAG_const_type:
5731     case DW_TAG_file_type:
5732     case DW_TAG_packed_type:
5733     case DW_TAG_volatile_type:
5734     case DW_TAG_typedef:
5735       return 1;
5736     default:
5737       return 0;
5738     }
5739 }
5740
5741 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
5742    Basically, we want to choose the bits that are likely to be shared between
5743    compilations (types) and leave out the bits that are specific to individual
5744    compilations (functions).  */
5745
5746 static int
5747 is_comdat_die (dw_die_ref c)
5748 {
5749   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
5750      we do for stabs.  The advantage is a greater likelihood of sharing between
5751      objects that don't include headers in the same order (and therefore would
5752      put the base types in a different comdat).  jason 8/28/00 */
5753
5754   if (c->die_tag == DW_TAG_base_type)
5755     return 0;
5756
5757   if (c->die_tag == DW_TAG_pointer_type
5758       || c->die_tag == DW_TAG_reference_type
5759       || c->die_tag == DW_TAG_const_type
5760       || c->die_tag == DW_TAG_volatile_type)
5761     {
5762       dw_die_ref t = get_AT_ref (c, DW_AT_type);
5763
5764       return t ? is_comdat_die (t) : 0;
5765     }
5766
5767   return is_type_die (c);
5768 }
5769
5770 /* Returns 1 iff C is the sort of DIE that might be referred to from another
5771    compilation unit.  */
5772
5773 static int
5774 is_symbol_die (dw_die_ref c)
5775 {
5776   return (is_type_die (c)
5777           || (get_AT (c, DW_AT_declaration)
5778               && !get_AT (c, DW_AT_specification)));
5779 }
5780
5781 static char *
5782 gen_internal_sym (const char *prefix)
5783 {
5784   char buf[256];
5785
5786   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
5787   return xstrdup (buf);
5788 }
5789
5790 /* Assign symbols to all worthy DIEs under DIE.  */
5791
5792 static void
5793 assign_symbol_names (dw_die_ref die)
5794 {
5795   dw_die_ref c;
5796
5797   if (is_symbol_die (die))
5798     {
5799       if (comdat_symbol_id)
5800         {
5801           char *p = alloca (strlen (comdat_symbol_id) + 64);
5802
5803           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
5804                    comdat_symbol_id, comdat_symbol_number++);
5805           die->die_symbol = xstrdup (p);
5806         }
5807       else
5808         die->die_symbol = gen_internal_sym ("LDIE");
5809     }
5810
5811   for (c = die->die_child; c != NULL; c = c->die_sib)
5812     assign_symbol_names (c);
5813 }
5814
5815 struct cu_hash_table_entry
5816 {
5817   dw_die_ref cu;
5818   unsigned min_comdat_num, max_comdat_num;
5819   struct cu_hash_table_entry *next;
5820 };
5821
5822 /* Routines to manipulate hash table of CUs.  */
5823 static hashval_t
5824 htab_cu_hash (const void *of)
5825 {
5826   const struct cu_hash_table_entry *entry = of;
5827
5828   return htab_hash_string (entry->cu->die_symbol);
5829 }
5830
5831 static int
5832 htab_cu_eq (const void *of1, const void *of2)
5833 {
5834   const struct cu_hash_table_entry *entry1 = of1;
5835   const struct die_struct *entry2 = of2;
5836
5837   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
5838 }
5839
5840 static void
5841 htab_cu_del (void *what)
5842 {
5843   struct cu_hash_table_entry *next, *entry = what;
5844
5845   while (entry)
5846     {
5847       next = entry->next;
5848       free (entry);
5849       entry = next;
5850     }
5851 }
5852
5853 /* Check whether we have already seen this CU and set up SYM_NUM
5854    accordingly.  */
5855 static int
5856 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
5857 {
5858   struct cu_hash_table_entry dummy;
5859   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
5860
5861   dummy.max_comdat_num = 0;
5862
5863   slot = (struct cu_hash_table_entry **)
5864     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
5865         INSERT);
5866   entry = *slot;
5867
5868   for (; entry; last = entry, entry = entry->next)
5869     {
5870       if (same_die_p_wrap (cu, entry->cu))
5871         break;
5872     }
5873
5874   if (entry)
5875     {
5876       *sym_num = entry->min_comdat_num;
5877       return 1;
5878     }
5879
5880   entry = xcalloc (1, sizeof (struct cu_hash_table_entry));
5881   entry->cu = cu;
5882   entry->min_comdat_num = *sym_num = last->max_comdat_num;
5883   entry->next = *slot;
5884   *slot = entry;
5885
5886   return 0;
5887 }
5888
5889 /* Record SYM_NUM to record of CU in HTABLE.  */
5890 static void
5891 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
5892 {
5893   struct cu_hash_table_entry **slot, *entry;
5894
5895   slot = (struct cu_hash_table_entry **)
5896     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
5897         NO_INSERT);
5898   entry = *slot;
5899
5900   entry->max_comdat_num = sym_num;
5901 }
5902
5903 /* Traverse the DIE (which is always comp_unit_die), and set up
5904    additional compilation units for each of the include files we see
5905    bracketed by BINCL/EINCL.  */
5906
5907 static void
5908 break_out_includes (dw_die_ref die)
5909 {
5910   dw_die_ref *ptr;
5911   dw_die_ref unit = NULL;
5912   limbo_die_node *node, **pnode;
5913   htab_t cu_hash_table;
5914
5915   for (ptr = &(die->die_child); *ptr;)
5916     {
5917       dw_die_ref c = *ptr;
5918
5919       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
5920           || (unit && is_comdat_die (c)))
5921         {
5922           /* This DIE is for a secondary CU; remove it from the main one.  */
5923           *ptr = c->die_sib;
5924
5925           if (c->die_tag == DW_TAG_GNU_BINCL)
5926             {
5927               unit = push_new_compile_unit (unit, c);
5928               free_die (c);
5929             }
5930           else if (c->die_tag == DW_TAG_GNU_EINCL)
5931             {
5932               unit = pop_compile_unit (unit);
5933               free_die (c);
5934             }
5935           else
5936             add_child_die (unit, c);
5937         }
5938       else
5939         {
5940           /* Leave this DIE in the main CU.  */
5941           ptr = &(c->die_sib);
5942           continue;
5943         }
5944     }
5945
5946 #if 0
5947   /* We can only use this in debugging, since the frontend doesn't check
5948      to make sure that we leave every include file we enter.  */
5949   if (unit != NULL)
5950     abort ();
5951 #endif
5952
5953   assign_symbol_names (die);
5954   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
5955   for (node = limbo_die_list, pnode = &limbo_die_list;
5956        node;
5957        node = node->next)
5958     {
5959       int is_dupl;
5960
5961       compute_section_prefix (node->die);
5962       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
5963                         &comdat_symbol_number);
5964       assign_symbol_names (node->die);
5965       if (is_dupl)
5966         *pnode = node->next;
5967       else
5968         {
5969           pnode = &node->next;
5970           record_comdat_symbol_number (node->die, cu_hash_table,
5971                 comdat_symbol_number);
5972         }
5973     }
5974   htab_delete (cu_hash_table);
5975 }
5976
5977 /* Traverse the DIE and add a sibling attribute if it may have the
5978    effect of speeding up access to siblings.  To save some space,
5979    avoid generating sibling attributes for DIE's without children.  */
5980
5981 static void
5982 add_sibling_attributes (dw_die_ref die)
5983 {
5984   dw_die_ref c;
5985
5986   if (die->die_tag != DW_TAG_compile_unit
5987       && die->die_sib && die->die_child != NULL)
5988     /* Add the sibling link to the front of the attribute list.  */
5989     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
5990
5991   for (c = die->die_child; c != NULL; c = c->die_sib)
5992     add_sibling_attributes (c);
5993 }
5994
5995 /* Output all location lists for the DIE and its children.  */
5996
5997 static void
5998 output_location_lists (dw_die_ref die)
5999 {
6000   dw_die_ref c;
6001   dw_attr_ref d_attr;
6002
6003   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6004     if (AT_class (d_attr) == dw_val_class_loc_list)
6005       output_loc_list (AT_loc_list (d_attr));
6006
6007   for (c = die->die_child; c != NULL; c = c->die_sib)
6008     output_location_lists (c);
6009
6010 }
6011
6012 /* The format of each DIE (and its attribute value pairs) is encoded in an
6013    abbreviation table.  This routine builds the abbreviation table and assigns
6014    a unique abbreviation id for each abbreviation entry.  The children of each
6015    die are visited recursively.  */
6016
6017 static void
6018 build_abbrev_table (dw_die_ref die)
6019 {
6020   unsigned long abbrev_id;
6021   unsigned int n_alloc;
6022   dw_die_ref c;
6023   dw_attr_ref d_attr, a_attr;
6024
6025   /* Scan the DIE references, and mark as external any that refer to
6026      DIEs from other CUs (i.e. those which are not marked).  */
6027   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6028     if (AT_class (d_attr) == dw_val_class_die_ref
6029         && AT_ref (d_attr)->die_mark == 0)
6030       {
6031         if (AT_ref (d_attr)->die_symbol == 0)
6032           abort ();
6033
6034         set_AT_ref_external (d_attr, 1);
6035       }
6036
6037   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6038     {
6039       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6040
6041       if (abbrev->die_tag == die->die_tag)
6042         {
6043           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6044             {
6045               a_attr = abbrev->die_attr;
6046               d_attr = die->die_attr;
6047
6048               while (a_attr != NULL && d_attr != NULL)
6049                 {
6050                   if ((a_attr->dw_attr != d_attr->dw_attr)
6051                       || (value_format (a_attr) != value_format (d_attr)))
6052                     break;
6053
6054                   a_attr = a_attr->dw_attr_next;
6055                   d_attr = d_attr->dw_attr_next;
6056                 }
6057
6058               if (a_attr == NULL && d_attr == NULL)
6059                 break;
6060             }
6061         }
6062     }
6063
6064   if (abbrev_id >= abbrev_die_table_in_use)
6065     {
6066       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6067         {
6068           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6069           abbrev_die_table = ggc_realloc (abbrev_die_table,
6070                                           sizeof (dw_die_ref) * n_alloc);
6071
6072           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6073                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6074           abbrev_die_table_allocated = n_alloc;
6075         }
6076
6077       ++abbrev_die_table_in_use;
6078       abbrev_die_table[abbrev_id] = die;
6079     }
6080
6081   die->die_abbrev = abbrev_id;
6082   for (c = die->die_child; c != NULL; c = c->die_sib)
6083     build_abbrev_table (c);
6084 }
6085 \f
6086 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6087
6088 static int
6089 constant_size (long unsigned int value)
6090 {
6091   int log;
6092
6093   if (value == 0)
6094     log = 0;
6095   else
6096     log = floor_log2 (value);
6097
6098   log = log / 8;
6099   log = 1 << (floor_log2 (log) + 1);
6100
6101   return log;
6102 }
6103
6104 /* Return the size of a DIE as it is represented in the
6105    .debug_info section.  */
6106
6107 static unsigned long
6108 size_of_die (dw_die_ref die)
6109 {
6110   unsigned long size = 0;
6111   dw_attr_ref a;
6112
6113   size += size_of_uleb128 (die->die_abbrev);
6114   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6115     {
6116       switch (AT_class (a))
6117         {
6118         case dw_val_class_addr:
6119           size += DWARF2_ADDR_SIZE;
6120           break;
6121         case dw_val_class_offset:
6122           size += DWARF_OFFSET_SIZE;
6123           break;
6124         case dw_val_class_loc:
6125           {
6126             unsigned long lsize = size_of_locs (AT_loc (a));
6127
6128             /* Block length.  */
6129             size += constant_size (lsize);
6130             size += lsize;
6131           }
6132           break;
6133         case dw_val_class_loc_list:
6134           size += DWARF_OFFSET_SIZE;
6135           break;
6136         case dw_val_class_range_list:
6137           size += DWARF_OFFSET_SIZE;
6138           break;
6139         case dw_val_class_const:
6140           size += size_of_sleb128 (AT_int (a));
6141           break;
6142         case dw_val_class_unsigned_const:
6143           size += constant_size (AT_unsigned (a));
6144           break;
6145         case dw_val_class_long_long:
6146           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6147           break;
6148         case dw_val_class_float:
6149           size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
6150           break;
6151         case dw_val_class_flag:
6152           size += 1;
6153           break;
6154         case dw_val_class_die_ref:
6155           if (AT_ref_external (a))
6156             size += DWARF2_ADDR_SIZE;
6157           else
6158             size += DWARF_OFFSET_SIZE;
6159           break;
6160         case dw_val_class_fde_ref:
6161           size += DWARF_OFFSET_SIZE;
6162           break;
6163         case dw_val_class_lbl_id:
6164           size += DWARF2_ADDR_SIZE;
6165           break;
6166         case dw_val_class_lbl_offset:
6167           size += DWARF_OFFSET_SIZE;
6168           break;
6169         case dw_val_class_str:
6170           if (AT_string_form (a) == DW_FORM_strp)
6171             size += DWARF_OFFSET_SIZE;
6172           else
6173             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6174           break;
6175         default:
6176           abort ();
6177         }
6178     }
6179
6180   return size;
6181 }
6182
6183 /* Size the debugging information associated with a given DIE.  Visits the
6184    DIE's children recursively.  Updates the global variable next_die_offset, on
6185    each time through.  Uses the current value of next_die_offset to update the
6186    die_offset field in each DIE.  */
6187
6188 static void
6189 calc_die_sizes (dw_die_ref die)
6190 {
6191   dw_die_ref c;
6192
6193   die->die_offset = next_die_offset;
6194   next_die_offset += size_of_die (die);
6195
6196   for (c = die->die_child; c != NULL; c = c->die_sib)
6197     calc_die_sizes (c);
6198
6199   if (die->die_child != NULL)
6200     /* Count the null byte used to terminate sibling lists.  */
6201     next_die_offset += 1;
6202 }
6203
6204 /* Set the marks for a die and its children.  We do this so
6205    that we know whether or not a reference needs to use FORM_ref_addr; only
6206    DIEs in the same CU will be marked.  We used to clear out the offset
6207    and use that as the flag, but ran into ordering problems.  */
6208
6209 static void
6210 mark_dies (dw_die_ref die)
6211 {
6212   dw_die_ref c;
6213
6214   if (die->die_mark)
6215     abort ();
6216
6217   die->die_mark = 1;
6218   for (c = die->die_child; c; c = c->die_sib)
6219     mark_dies (c);
6220 }
6221
6222 /* Clear the marks for a die and its children.  */
6223
6224 static void
6225 unmark_dies (dw_die_ref die)
6226 {
6227   dw_die_ref c;
6228
6229   if (!die->die_mark)
6230     abort ();
6231
6232   die->die_mark = 0;
6233   for (c = die->die_child; c; c = c->die_sib)
6234     unmark_dies (c);
6235 }
6236
6237 /* Clear the marks for a die, its children and referred dies.  */
6238
6239 static void
6240 unmark_all_dies (dw_die_ref die)
6241 {
6242   dw_die_ref c;
6243   dw_attr_ref a;
6244
6245   if (!die->die_mark)
6246     return;
6247   die->die_mark = 0;
6248
6249   for (c = die->die_child; c; c = c->die_sib)
6250     unmark_all_dies (c);
6251
6252   for (a = die->die_attr; a; a = a->dw_attr_next)
6253     if (AT_class (a) == dw_val_class_die_ref)
6254       unmark_all_dies (AT_ref (a));
6255 }
6256
6257 /* Return the size of the .debug_pubnames table  generated for the
6258    compilation unit.  */
6259
6260 static unsigned long
6261 size_of_pubnames (void)
6262 {
6263   unsigned long size;
6264   unsigned i;
6265
6266   size = DWARF_PUBNAMES_HEADER_SIZE;
6267   for (i = 0; i < pubname_table_in_use; i++)
6268     {
6269       pubname_ref p = &pubname_table[i];
6270       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6271     }
6272
6273   size += DWARF_OFFSET_SIZE;
6274   return size;
6275 }
6276
6277 /* Return the size of the information in the .debug_aranges section.  */
6278
6279 static unsigned long
6280 size_of_aranges (void)
6281 {
6282   unsigned long size;
6283
6284   size = DWARF_ARANGES_HEADER_SIZE;
6285
6286   /* Count the address/length pair for this compilation unit.  */
6287   size += 2 * DWARF2_ADDR_SIZE;
6288   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6289
6290   /* Count the two zero words used to terminated the address range table.  */
6291   size += 2 * DWARF2_ADDR_SIZE;
6292   return size;
6293 }
6294 \f
6295 /* Select the encoding of an attribute value.  */
6296
6297 static enum dwarf_form
6298 value_format (dw_attr_ref a)
6299 {
6300   switch (a->dw_attr_val.val_class)
6301     {
6302     case dw_val_class_addr:
6303       return DW_FORM_addr;
6304     case dw_val_class_range_list:
6305     case dw_val_class_offset:
6306       if (DWARF_OFFSET_SIZE == 4)
6307         return DW_FORM_data4;
6308       if (DWARF_OFFSET_SIZE == 8)
6309         return DW_FORM_data8;
6310       abort ();
6311     case dw_val_class_loc_list:
6312       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6313          .debug_loc section */
6314       return DW_FORM_data4;
6315     case dw_val_class_loc:
6316       switch (constant_size (size_of_locs (AT_loc (a))))
6317         {
6318         case 1:
6319           return DW_FORM_block1;
6320         case 2:
6321           return DW_FORM_block2;
6322         default:
6323           abort ();
6324         }
6325     case dw_val_class_const:
6326       return DW_FORM_sdata;
6327     case dw_val_class_unsigned_const:
6328       switch (constant_size (AT_unsigned (a)))
6329         {
6330         case 1:
6331           return DW_FORM_data1;
6332         case 2:
6333           return DW_FORM_data2;
6334         case 4:
6335           return DW_FORM_data4;
6336         case 8:
6337           return DW_FORM_data8;
6338         default:
6339           abort ();
6340         }
6341     case dw_val_class_long_long:
6342       return DW_FORM_block1;
6343     case dw_val_class_float:
6344       return DW_FORM_block1;
6345     case dw_val_class_flag:
6346       return DW_FORM_flag;
6347     case dw_val_class_die_ref:
6348       if (AT_ref_external (a))
6349         return DW_FORM_ref_addr;
6350       else
6351         return DW_FORM_ref;
6352     case dw_val_class_fde_ref:
6353       return DW_FORM_data;
6354     case dw_val_class_lbl_id:
6355       return DW_FORM_addr;
6356     case dw_val_class_lbl_offset:
6357       return DW_FORM_data;
6358     case dw_val_class_str:
6359       return AT_string_form (a);
6360
6361     default:
6362       abort ();
6363     }
6364 }
6365
6366 /* Output the encoding of an attribute value.  */
6367
6368 static void
6369 output_value_format (dw_attr_ref a)
6370 {
6371   enum dwarf_form form = value_format (a);
6372
6373   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6374 }
6375
6376 /* Output the .debug_abbrev section which defines the DIE abbreviation
6377    table.  */
6378
6379 static void
6380 output_abbrev_section (void)
6381 {
6382   unsigned long abbrev_id;
6383
6384   dw_attr_ref a_attr;
6385
6386   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6387     {
6388       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6389
6390       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6391       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6392                                    dwarf_tag_name (abbrev->die_tag));
6393
6394       if (abbrev->die_child != NULL)
6395         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6396       else
6397         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6398
6399       for (a_attr = abbrev->die_attr; a_attr != NULL;
6400            a_attr = a_attr->dw_attr_next)
6401         {
6402           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6403                                        dwarf_attr_name (a_attr->dw_attr));
6404           output_value_format (a_attr);
6405         }
6406
6407       dw2_asm_output_data (1, 0, NULL);
6408       dw2_asm_output_data (1, 0, NULL);
6409     }
6410
6411   /* Terminate the table.  */
6412   dw2_asm_output_data (1, 0, NULL);
6413 }
6414
6415 /* Output a symbol we can use to refer to this DIE from another CU.  */
6416
6417 static inline void
6418 output_die_symbol (dw_die_ref die)
6419 {
6420   char *sym = die->die_symbol;
6421
6422   if (sym == 0)
6423     return;
6424
6425   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6426     /* We make these global, not weak; if the target doesn't support
6427        .linkonce, it doesn't support combining the sections, so debugging
6428        will break.  */
6429     (*targetm.asm_out.globalize_label) (asm_out_file, sym);
6430
6431   ASM_OUTPUT_LABEL (asm_out_file, sym);
6432 }
6433
6434 /* Return a new location list, given the begin and end range, and the
6435    expression. gensym tells us whether to generate a new internal symbol for
6436    this location list node, which is done for the head of the list only.  */
6437
6438 static inline dw_loc_list_ref
6439 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6440               const char *section, unsigned int gensym)
6441 {
6442   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6443
6444   retlist->begin = begin;
6445   retlist->end = end;
6446   retlist->expr = expr;
6447   retlist->section = section;
6448   if (gensym)
6449     retlist->ll_symbol = gen_internal_sym ("LLST");
6450
6451   return retlist;
6452 }
6453
6454 /* Add a location description expression to a location list.  */
6455
6456 static inline void
6457 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6458                            const char *begin, const char *end,
6459                            const char *section)
6460 {
6461   dw_loc_list_ref *d;
6462
6463   /* Find the end of the chain.  */
6464   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6465     ;
6466
6467   /* Add a new location list node to the list.  */
6468   *d = new_loc_list (descr, begin, end, section, 0);
6469 }
6470
6471 /* Output the location list given to us.  */
6472
6473 static void
6474 output_loc_list (dw_loc_list_ref list_head)
6475 {
6476   dw_loc_list_ref curr = list_head;
6477
6478   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6479
6480   /* ??? This shouldn't be needed now that we've forced the
6481      compilation unit base address to zero when there is code
6482      in more than one section.  */
6483   if (strcmp (curr->section, ".text") == 0)
6484     {
6485       /* dw2_asm_output_data will mask off any extra bits in the ~0.  */
6486       dw2_asm_output_data (DWARF2_ADDR_SIZE, ~(unsigned HOST_WIDE_INT) 0,
6487                            "Location list base address specifier fake entry");
6488       dw2_asm_output_offset (DWARF2_ADDR_SIZE, curr->section,
6489                              "Location list base address specifier base");
6490     }
6491
6492   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6493     {
6494       unsigned long size;
6495
6496       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6497                             "Location list begin address (%s)",
6498                             list_head->ll_symbol);
6499       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6500                             "Location list end address (%s)",
6501                             list_head->ll_symbol);
6502       size = size_of_locs (curr->expr);
6503
6504       /* Output the block length for this list of location operations.  */
6505       if (size > 0xffff)
6506         abort ();
6507       dw2_asm_output_data (2, size, "%s", "Location expression size");
6508
6509       output_loc_sequence (curr->expr);
6510     }
6511
6512   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6513                        "Location list terminator begin (%s)",
6514                        list_head->ll_symbol);
6515   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6516                        "Location list terminator end (%s)",
6517                        list_head->ll_symbol);
6518 }
6519
6520 /* Output the DIE and its attributes.  Called recursively to generate
6521    the definitions of each child DIE.  */
6522
6523 static void
6524 output_die (dw_die_ref die)
6525 {
6526   dw_attr_ref a;
6527   dw_die_ref c;
6528   unsigned long size;
6529
6530   /* If someone in another CU might refer to us, set up a symbol for
6531      them to point to.  */
6532   if (die->die_symbol)
6533     output_die_symbol (die);
6534
6535   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6536                                die->die_offset, dwarf_tag_name (die->die_tag));
6537
6538   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6539     {
6540       const char *name = dwarf_attr_name (a->dw_attr);
6541
6542       switch (AT_class (a))
6543         {
6544         case dw_val_class_addr:
6545           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
6546           break;
6547
6548         case dw_val_class_offset:
6549           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
6550                                "%s", name);
6551           break;
6552
6553         case dw_val_class_range_list:
6554           {
6555             char *p = strchr (ranges_section_label, '\0');
6556
6557             sprintf (p, "+0x%lx", a->dw_attr_val.v.val_offset);
6558             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
6559                                    "%s", name);
6560             *p = '\0';
6561           }
6562           break;
6563
6564         case dw_val_class_loc:
6565           size = size_of_locs (AT_loc (a));
6566
6567           /* Output the block length for this list of location operations.  */
6568           dw2_asm_output_data (constant_size (size), size, "%s", name);
6569
6570           output_loc_sequence (AT_loc (a));
6571           break;
6572
6573         case dw_val_class_const:
6574           /* ??? It would be slightly more efficient to use a scheme like is
6575              used for unsigned constants below, but gdb 4.x does not sign
6576              extend.  Gdb 5.x does sign extend.  */
6577           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
6578           break;
6579
6580         case dw_val_class_unsigned_const:
6581           dw2_asm_output_data (constant_size (AT_unsigned (a)),
6582                                AT_unsigned (a), "%s", name);
6583           break;
6584
6585         case dw_val_class_long_long:
6586           {
6587             unsigned HOST_WIDE_INT first, second;
6588
6589             dw2_asm_output_data (1,
6590                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6591                                  "%s", name);
6592
6593             if (WORDS_BIG_ENDIAN)
6594               {
6595                 first = a->dw_attr_val.v.val_long_long.hi;
6596                 second = a->dw_attr_val.v.val_long_long.low;
6597               }
6598             else
6599               {
6600                 first = a->dw_attr_val.v.val_long_long.low;
6601                 second = a->dw_attr_val.v.val_long_long.hi;
6602               }
6603
6604             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6605                                  first, "long long constant");
6606             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6607                                  second, NULL);
6608           }
6609           break;
6610
6611         case dw_val_class_float:
6612           {
6613             unsigned int i;
6614
6615             dw2_asm_output_data (1, a->dw_attr_val.v.val_float.length * 4,
6616                                  "%s", name);
6617
6618             for (i = 0; i < a->dw_attr_val.v.val_float.length; i++)
6619               dw2_asm_output_data (4, a->dw_attr_val.v.val_float.array[i],
6620                                    "fp constant word %u", i);
6621             break;
6622           }
6623
6624         case dw_val_class_flag:
6625           dw2_asm_output_data (1, AT_flag (a), "%s", name);
6626           break;
6627
6628         case dw_val_class_loc_list:
6629           {
6630             char *sym = AT_loc_list (a)->ll_symbol;
6631
6632             if (sym == 0)
6633               abort ();
6634             dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym,
6635                                   loc_section_label, "%s", name);
6636           }
6637           break;
6638
6639         case dw_val_class_die_ref:
6640           if (AT_ref_external (a))
6641             {
6642               char *sym = AT_ref (a)->die_symbol;
6643
6644               if (sym == 0)
6645                 abort ();
6646               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
6647             }
6648           else if (AT_ref (a)->die_offset == 0)
6649             abort ();
6650           else
6651             dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
6652                                  "%s", name);
6653           break;
6654
6655         case dw_val_class_fde_ref:
6656           {
6657             char l1[20];
6658
6659             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
6660                                          a->dw_attr_val.v.val_fde_index * 2);
6661             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
6662           }
6663           break;
6664
6665         case dw_val_class_lbl_id:
6666           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
6667           break;
6668
6669         case dw_val_class_lbl_offset:
6670           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
6671           break;
6672
6673         case dw_val_class_str:
6674           if (AT_string_form (a) == DW_FORM_strp)
6675             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
6676                                    a->dw_attr_val.v.val_str->label,
6677                                    "%s: \"%s\"", name, AT_string (a));
6678           else
6679             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
6680           break;
6681
6682         default:
6683           abort ();
6684         }
6685     }
6686
6687   for (c = die->die_child; c != NULL; c = c->die_sib)
6688     output_die (c);
6689
6690   /* Add null byte to terminate sibling list.  */
6691   if (die->die_child != NULL)
6692     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6693                          die->die_offset);
6694 }
6695
6696 /* Output the compilation unit that appears at the beginning of the
6697    .debug_info section, and precedes the DIE descriptions.  */
6698
6699 static void
6700 output_compilation_unit_header (void)
6701 {
6702   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
6703     dw2_asm_output_data (4, 0xffffffff,
6704       "Initial length escape value indicating 64-bit DWARF extension");
6705   dw2_asm_output_data (DWARF_OFFSET_SIZE,
6706                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
6707                        "Length of Compilation Unit Info");
6708   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
6709   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
6710                          "Offset Into Abbrev. Section");
6711   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
6712 }
6713
6714 /* Output the compilation unit DIE and its children.  */
6715
6716 static void
6717 output_comp_unit (dw_die_ref die, int output_if_empty)
6718 {
6719   const char *secname;
6720   char *oldsym, *tmp;
6721
6722   /* Unless we are outputting main CU, we may throw away empty ones.  */
6723   if (!output_if_empty && die->die_child == NULL)
6724     return;
6725
6726   /* Even if there are no children of this DIE, we must output the information
6727      about the compilation unit.  Otherwise, on an empty translation unit, we
6728      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
6729      will then complain when examining the file.  First mark all the DIEs in
6730      this CU so we know which get local refs.  */
6731   mark_dies (die);
6732
6733   build_abbrev_table (die);
6734
6735   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
6736   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
6737   calc_die_sizes (die);
6738
6739   oldsym = die->die_symbol;
6740   if (oldsym)
6741     {
6742       tmp = alloca (strlen (oldsym) + 24);
6743
6744       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
6745       secname = tmp;
6746       die->die_symbol = NULL;
6747     }
6748   else
6749     secname = (const char *) DEBUG_INFO_SECTION;
6750
6751   /* Output debugging information.  */
6752   named_section_flags (secname, SECTION_DEBUG);
6753   output_compilation_unit_header ();
6754   output_die (die);
6755
6756   /* Leave the marks on the main CU, so we can check them in
6757      output_pubnames.  */
6758   if (oldsym)
6759     {
6760       unmark_dies (die);
6761       die->die_symbol = oldsym;
6762     }
6763 }
6764
6765 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
6766    output of lang_hooks.decl_printable_name for C++ looks like
6767    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
6768
6769 static const char *
6770 dwarf2_name (tree decl, int scope)
6771 {
6772   return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0);
6773 }
6774
6775 /* Add a new entry to .debug_pubnames if appropriate.  */
6776
6777 static void
6778 add_pubname (tree decl, dw_die_ref die)
6779 {
6780   pubname_ref p;
6781
6782   if (! TREE_PUBLIC (decl))
6783     return;
6784
6785   if (pubname_table_in_use == pubname_table_allocated)
6786     {
6787       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
6788       pubname_table
6789         = ggc_realloc (pubname_table,
6790                        (pubname_table_allocated * sizeof (pubname_entry)));
6791       memset (pubname_table + pubname_table_in_use, 0,
6792               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
6793     }
6794
6795   p = &pubname_table[pubname_table_in_use++];
6796   p->die = die;
6797   p->name = xstrdup (dwarf2_name (decl, 1));
6798 }
6799
6800 /* Output the public names table used to speed up access to externally
6801    visible names.  For now, only generate entries for externally
6802    visible procedures.  */
6803
6804 static void
6805 output_pubnames (void)
6806 {
6807   unsigned i;
6808   unsigned long pubnames_length = size_of_pubnames ();
6809
6810   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
6811     dw2_asm_output_data (4, 0xffffffff,
6812       "Initial length escape value indicating 64-bit DWARF extension");
6813   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
6814                        "Length of Public Names Info");
6815   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
6816   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
6817                          "Offset of Compilation Unit Info");
6818   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
6819                        "Compilation Unit Length");
6820
6821   for (i = 0; i < pubname_table_in_use; i++)
6822     {
6823       pubname_ref pub = &pubname_table[i];
6824
6825       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
6826       if (pub->die->die_mark == 0)
6827         abort ();
6828
6829       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
6830                            "DIE offset");
6831
6832       dw2_asm_output_nstring (pub->name, -1, "external name");
6833     }
6834
6835   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
6836 }
6837
6838 /* Add a new entry to .debug_aranges if appropriate.  */
6839
6840 static void
6841 add_arange (tree decl, dw_die_ref die)
6842 {
6843   if (! DECL_SECTION_NAME (decl))
6844     return;
6845
6846   if (arange_table_in_use == arange_table_allocated)
6847     {
6848       arange_table_allocated += ARANGE_TABLE_INCREMENT;
6849       arange_table = ggc_realloc (arange_table,
6850                                   (arange_table_allocated
6851                                    * sizeof (dw_die_ref)));
6852       memset (arange_table + arange_table_in_use, 0,
6853               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
6854     }
6855
6856   arange_table[arange_table_in_use++] = die;
6857 }
6858
6859 /* Output the information that goes into the .debug_aranges table.
6860    Namely, define the beginning and ending address range of the
6861    text section generated for this compilation unit.  */
6862
6863 static void
6864 output_aranges (void)
6865 {
6866   unsigned i;
6867   unsigned long aranges_length = size_of_aranges ();
6868
6869   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
6870     dw2_asm_output_data (4, 0xffffffff,
6871       "Initial length escape value indicating 64-bit DWARF extension");
6872   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
6873                        "Length of Address Ranges Info");
6874   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
6875   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
6876                          "Offset of Compilation Unit Info");
6877   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
6878   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
6879
6880   /* We need to align to twice the pointer size here.  */
6881   if (DWARF_ARANGES_PAD_SIZE)
6882     {
6883       /* Pad using a 2 byte words so that padding is correct for any
6884          pointer size.  */
6885       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
6886                            2 * DWARF2_ADDR_SIZE);
6887       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
6888         dw2_asm_output_data (2, 0, NULL);
6889     }
6890
6891   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
6892   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
6893                         text_section_label, "Length");
6894
6895   for (i = 0; i < arange_table_in_use; i++)
6896     {
6897       dw_die_ref die = arange_table[i];
6898
6899       /* We shouldn't see aranges for DIEs outside of the main CU.  */
6900       if (die->die_mark == 0)
6901         abort ();
6902
6903       if (die->die_tag == DW_TAG_subprogram)
6904         {
6905           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
6906                                "Address");
6907           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
6908                                 get_AT_low_pc (die), "Length");
6909         }
6910       else
6911         {
6912           /* A static variable; extract the symbol from DW_AT_location.
6913              Note that this code isn't currently hit, as we only emit
6914              aranges for functions (jason 9/23/99).  */
6915           dw_attr_ref a = get_AT (die, DW_AT_location);
6916           dw_loc_descr_ref loc;
6917
6918           if (! a || AT_class (a) != dw_val_class_loc)
6919             abort ();
6920
6921           loc = AT_loc (a);
6922           if (loc->dw_loc_opc != DW_OP_addr)
6923             abort ();
6924
6925           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
6926                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
6927           dw2_asm_output_data (DWARF2_ADDR_SIZE,
6928                                get_AT_unsigned (die, DW_AT_byte_size),
6929                                "Length");
6930         }
6931     }
6932
6933   /* Output the terminator words.  */
6934   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
6935   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
6936 }
6937
6938 /* Add a new entry to .debug_ranges.  Return the offset at which it
6939    was placed.  */
6940
6941 static unsigned int
6942 add_ranges (tree block)
6943 {
6944   unsigned int in_use = ranges_table_in_use;
6945
6946   if (in_use == ranges_table_allocated)
6947     {
6948       ranges_table_allocated += RANGES_TABLE_INCREMENT;
6949       ranges_table
6950         = ggc_realloc (ranges_table, (ranges_table_allocated
6951                                       * sizeof (struct dw_ranges_struct)));
6952       memset (ranges_table + ranges_table_in_use, 0,
6953               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
6954     }
6955
6956   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
6957   ranges_table_in_use = in_use + 1;
6958
6959   return in_use * 2 * DWARF2_ADDR_SIZE;
6960 }
6961
6962 static void
6963 output_ranges (void)
6964 {
6965   unsigned i;
6966   static const char *const start_fmt = "Offset 0x%x";
6967   const char *fmt = start_fmt;
6968
6969   for (i = 0; i < ranges_table_in_use; i++)
6970     {
6971       int block_num = ranges_table[i].block_num;
6972
6973       if (block_num)
6974         {
6975           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
6976           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
6977
6978           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
6979           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
6980
6981           /* If all code is in the text section, then the compilation
6982              unit base address defaults to DW_AT_low_pc, which is the
6983              base of the text section.  */
6984           if (separate_line_info_table_in_use == 0)
6985             {
6986               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
6987                                     text_section_label,
6988                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
6989               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
6990                                     text_section_label, NULL);
6991             }
6992
6993           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
6994              compilation unit base address to zero, which allows us to
6995              use absolute addresses, and not worry about whether the
6996              target supports cross-section arithmetic.  */
6997           else
6998             {
6999               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7000                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7001               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7002             }
7003
7004           fmt = NULL;
7005         }
7006       else
7007         {
7008           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7009           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7010           fmt = start_fmt;
7011         }
7012     }
7013 }
7014
7015 /* Data structure containing information about input files.  */
7016 struct file_info
7017 {
7018   char *path;           /* Complete file name.  */
7019   char *fname;          /* File name part.  */
7020   int length;           /* Length of entire string.  */
7021   int file_idx;         /* Index in input file table.  */
7022   int dir_idx;          /* Index in directory table.  */
7023 };
7024
7025 /* Data structure containing information about directories with source
7026    files.  */
7027 struct dir_info
7028 {
7029   char *path;           /* Path including directory name.  */
7030   int length;           /* Path length.  */
7031   int prefix;           /* Index of directory entry which is a prefix.  */
7032   int count;            /* Number of files in this directory.  */
7033   int dir_idx;          /* Index of directory used as base.  */
7034   int used;             /* Used in the end?  */
7035 };
7036
7037 /* Callback function for file_info comparison.  We sort by looking at
7038    the directories in the path.  */
7039
7040 static int
7041 file_info_cmp (const void *p1, const void *p2)
7042 {
7043   const struct file_info *s1 = p1;
7044   const struct file_info *s2 = p2;
7045   unsigned char *cp1;
7046   unsigned char *cp2;
7047
7048   /* Take care of file names without directories.  We need to make sure that
7049      we return consistent values to qsort since some will get confused if
7050      we return the same value when identical operands are passed in opposite
7051      orders.  So if neither has a directory, return 0 and otherwise return
7052      1 or -1 depending on which one has the directory.  */
7053   if ((s1->path == s1->fname || s2->path == s2->fname))
7054     return (s2->path == s2->fname) - (s1->path == s1->fname);
7055
7056   cp1 = (unsigned char *) s1->path;
7057   cp2 = (unsigned char *) s2->path;
7058
7059   while (1)
7060     {
7061       ++cp1;
7062       ++cp2;
7063       /* Reached the end of the first path?  If so, handle like above.  */
7064       if ((cp1 == (unsigned char *) s1->fname)
7065           || (cp2 == (unsigned char *) s2->fname))
7066         return ((cp2 == (unsigned char *) s2->fname)
7067                 - (cp1 == (unsigned char *) s1->fname));
7068
7069       /* Character of current path component the same?  */
7070       else if (*cp1 != *cp2)
7071         return *cp1 - *cp2;
7072     }
7073 }
7074
7075 /* Output the directory table and the file name table.  We try to minimize
7076    the total amount of memory needed.  A heuristic is used to avoid large
7077    slowdowns with many input files.  */
7078
7079 static void
7080 output_file_names (void)
7081 {
7082   struct file_info *files;
7083   struct dir_info *dirs;
7084   int *saved;
7085   int *savehere;
7086   int *backmap;
7087   size_t ndirs;
7088   int idx_offset;
7089   size_t i;
7090   int idx;
7091
7092   /* Handle the case where file_table is empty.  */
7093   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7094     {
7095       dw2_asm_output_data (1, 0, "End directory table");
7096       dw2_asm_output_data (1, 0, "End file name table");
7097       return;
7098     }
7099
7100   /* Allocate the various arrays we need.  */
7101   files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7102   dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7103
7104   /* Sort the file names.  */
7105   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7106     {
7107       char *f;
7108
7109       /* Skip all leading "./".  */
7110       f = VARRAY_CHAR_PTR (file_table, i);
7111       while (f[0] == '.' && f[1] == '/')
7112         f += 2;
7113
7114       /* Create a new array entry.  */
7115       files[i].path = f;
7116       files[i].length = strlen (f);
7117       files[i].file_idx = i;
7118
7119       /* Search for the file name part.  */
7120       f = strrchr (f, '/');
7121       files[i].fname = f == NULL ? files[i].path : f + 1;
7122     }
7123
7124   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7125          sizeof (files[0]), file_info_cmp);
7126
7127   /* Find all the different directories used.  */
7128   dirs[0].path = files[1].path;
7129   dirs[0].length = files[1].fname - files[1].path;
7130   dirs[0].prefix = -1;
7131   dirs[0].count = 1;
7132   dirs[0].dir_idx = 0;
7133   dirs[0].used = 0;
7134   files[1].dir_idx = 0;
7135   ndirs = 1;
7136
7137   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7138     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7139         && memcmp (dirs[ndirs - 1].path, files[i].path,
7140                    dirs[ndirs - 1].length) == 0)
7141       {
7142         /* Same directory as last entry.  */
7143         files[i].dir_idx = ndirs - 1;
7144         ++dirs[ndirs - 1].count;
7145       }
7146     else
7147       {
7148         size_t j;
7149
7150         /* This is a new directory.  */
7151         dirs[ndirs].path = files[i].path;
7152         dirs[ndirs].length = files[i].fname - files[i].path;
7153         dirs[ndirs].count = 1;
7154         dirs[ndirs].dir_idx = ndirs;
7155         dirs[ndirs].used = 0;
7156         files[i].dir_idx = ndirs;
7157
7158         /* Search for a prefix.  */
7159         dirs[ndirs].prefix = -1;
7160         for (j = 0; j < ndirs; j++)
7161           if (dirs[j].length < dirs[ndirs].length
7162               && dirs[j].length > 1
7163               && (dirs[ndirs].prefix == -1
7164                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7165               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7166             dirs[ndirs].prefix = j;
7167
7168         ++ndirs;
7169       }
7170
7171   /* Now to the actual work.  We have to find a subset of the directories which
7172      allow expressing the file name using references to the directory table
7173      with the least amount of characters.  We do not do an exhaustive search
7174      where we would have to check out every combination of every single
7175      possible prefix.  Instead we use a heuristic which provides nearly optimal
7176      results in most cases and never is much off.  */
7177   saved = alloca (ndirs * sizeof (int));
7178   savehere = alloca (ndirs * sizeof (int));
7179
7180   memset (saved, '\0', ndirs * sizeof (saved[0]));
7181   for (i = 0; i < ndirs; i++)
7182     {
7183       size_t j;
7184       int total;
7185
7186       /* We can always save some space for the current directory.  But this
7187          does not mean it will be enough to justify adding the directory.  */
7188       savehere[i] = dirs[i].length;
7189       total = (savehere[i] - saved[i]) * dirs[i].count;
7190
7191       for (j = i + 1; j < ndirs; j++)
7192         {
7193           savehere[j] = 0;
7194           if (saved[j] < dirs[i].length)
7195             {
7196               /* Determine whether the dirs[i] path is a prefix of the
7197                  dirs[j] path.  */
7198               int k;
7199
7200               k = dirs[j].prefix;
7201               while (k != -1 && k != (int) i)
7202                 k = dirs[k].prefix;
7203
7204               if (k == (int) i)
7205                 {
7206                   /* Yes it is.  We can possibly safe some memory but
7207                      writing the filenames in dirs[j] relative to
7208                      dirs[i].  */
7209                   savehere[j] = dirs[i].length;
7210                   total += (savehere[j] - saved[j]) * dirs[j].count;
7211                 }
7212             }
7213         }
7214
7215       /* Check whether we can safe enough to justify adding the dirs[i]
7216          directory.  */
7217       if (total > dirs[i].length + 1)
7218         {
7219           /* It's worthwhile adding.  */
7220           for (j = i; j < ndirs; j++)
7221             if (savehere[j] > 0)
7222               {
7223                 /* Remember how much we saved for this directory so far.  */
7224                 saved[j] = savehere[j];
7225
7226                 /* Remember the prefix directory.  */
7227                 dirs[j].dir_idx = i;
7228               }
7229         }
7230     }
7231
7232   /* We have to emit them in the order they appear in the file_table array
7233      since the index is used in the debug info generation.  To do this
7234      efficiently we generate a back-mapping of the indices first.  */
7235   backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7236   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7237     {
7238       backmap[files[i].file_idx] = i;
7239
7240       /* Mark this directory as used.  */
7241       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7242     }
7243
7244   /* That was it.  We are ready to emit the information.  First emit the
7245      directory name table.  We have to make sure the first actually emitted
7246      directory name has index one; zero is reserved for the current working
7247      directory.  Make sure we do not confuse these indices with the one for the
7248      constructed table (even though most of the time they are identical).  */
7249   idx = 1;
7250   idx_offset = dirs[0].length > 0 ? 1 : 0;
7251   for (i = 1 - idx_offset; i < ndirs; i++)
7252     if (dirs[i].used != 0)
7253       {
7254         dirs[i].used = idx++;
7255         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7256                                 "Directory Entry: 0x%x", dirs[i].used);
7257       }
7258
7259   dw2_asm_output_data (1, 0, "End directory table");
7260
7261   /* Correct the index for the current working directory entry if it
7262      exists.  */
7263   if (idx_offset == 0)
7264     dirs[0].used = 0;
7265
7266   /* Now write all the file names.  */
7267   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7268     {
7269       int file_idx = backmap[i];
7270       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7271
7272       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7273                               "File Entry: 0x%lx", (unsigned long) i);
7274
7275       /* Include directory index.  */
7276       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7277
7278       /* Modification time.  */
7279       dw2_asm_output_data_uleb128 (0, NULL);
7280
7281       /* File length in bytes.  */
7282       dw2_asm_output_data_uleb128 (0, NULL);
7283     }
7284
7285   dw2_asm_output_data (1, 0, "End file name table");
7286 }
7287
7288
7289 /* Output the source line number correspondence information.  This
7290    information goes into the .debug_line section.  */
7291
7292 static void
7293 output_line_info (void)
7294 {
7295   char l1[20], l2[20], p1[20], p2[20];
7296   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7297   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7298   unsigned opc;
7299   unsigned n_op_args;
7300   unsigned long lt_index;
7301   unsigned long current_line;
7302   long line_offset;
7303   long line_delta;
7304   unsigned long current_file;
7305   unsigned long function;
7306
7307   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7308   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7309   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7310   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7311
7312   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7313     dw2_asm_output_data (4, 0xffffffff,
7314       "Initial length escape value indicating 64-bit DWARF extension");
7315   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7316                         "Length of Source Line Info");
7317   ASM_OUTPUT_LABEL (asm_out_file, l1);
7318
7319   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7320   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7321   ASM_OUTPUT_LABEL (asm_out_file, p1);
7322
7323   /* Define the architecture-dependent minimum instruction length (in
7324    bytes).  In this implementation of DWARF, this field is used for
7325    information purposes only.  Since GCC generates assembly language,
7326    we have no a priori knowledge of how many instruction bytes are
7327    generated for each source line, and therefore can use only the
7328    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7329    commands.  Accordingly, we fix this as `1', which is "correct
7330    enough" for all architectures, and don't let the target override.  */
7331   dw2_asm_output_data (1, 1,
7332                        "Minimum Instruction Length");
7333
7334   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7335                        "Default is_stmt_start flag");
7336   dw2_asm_output_data (1, DWARF_LINE_BASE,
7337                        "Line Base Value (Special Opcodes)");
7338   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7339                        "Line Range Value (Special Opcodes)");
7340   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7341                        "Special Opcode Base");
7342
7343   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7344     {
7345       switch (opc)
7346         {
7347         case DW_LNS_advance_pc:
7348         case DW_LNS_advance_line:
7349         case DW_LNS_set_file:
7350         case DW_LNS_set_column:
7351         case DW_LNS_fixed_advance_pc:
7352           n_op_args = 1;
7353           break;
7354         default:
7355           n_op_args = 0;
7356           break;
7357         }
7358
7359       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7360                            opc, n_op_args);
7361     }
7362
7363   /* Write out the information about the files we use.  */
7364   output_file_names ();
7365   ASM_OUTPUT_LABEL (asm_out_file, p2);
7366
7367   /* We used to set the address register to the first location in the text
7368      section here, but that didn't accomplish anything since we already
7369      have a line note for the opening brace of the first function.  */
7370
7371   /* Generate the line number to PC correspondence table, encoded as
7372      a series of state machine operations.  */
7373   current_file = 1;
7374   current_line = 1;
7375   strcpy (prev_line_label, text_section_label);
7376   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7377     {
7378       dw_line_info_ref line_info = &line_info_table[lt_index];
7379
7380 #if 0
7381       /* Disable this optimization for now; GDB wants to see two line notes
7382          at the beginning of a function so it can find the end of the
7383          prologue.  */
7384
7385       /* Don't emit anything for redundant notes.  Just updating the
7386          address doesn't accomplish anything, because we already assume
7387          that anything after the last address is this line.  */
7388       if (line_info->dw_line_num == current_line
7389           && line_info->dw_file_num == current_file)
7390         continue;
7391 #endif
7392
7393       /* Emit debug info for the address of the current line.
7394
7395          Unfortunately, we have little choice here currently, and must always
7396          use the most general form.  GCC does not know the address delta
7397          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7398          attributes which will give an upper bound on the address range.  We
7399          could perhaps use length attributes to determine when it is safe to
7400          use DW_LNS_fixed_advance_pc.  */
7401
7402       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7403       if (0)
7404         {
7405           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7406           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7407                                "DW_LNS_fixed_advance_pc");
7408           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7409         }
7410       else
7411         {
7412           /* This can handle any delta.  This takes
7413              4+DWARF2_ADDR_SIZE bytes.  */
7414           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7415           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7416           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7417           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7418         }
7419
7420       strcpy (prev_line_label, line_label);
7421
7422       /* Emit debug info for the source file of the current line, if
7423          different from the previous line.  */
7424       if (line_info->dw_file_num != current_file)
7425         {
7426           current_file = line_info->dw_file_num;
7427           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7428           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7429                                        VARRAY_CHAR_PTR (file_table,
7430                                                         current_file));
7431         }
7432
7433       /* Emit debug info for the current line number, choosing the encoding
7434          that uses the least amount of space.  */
7435       if (line_info->dw_line_num != current_line)
7436         {
7437           line_offset = line_info->dw_line_num - current_line;
7438           line_delta = line_offset - DWARF_LINE_BASE;
7439           current_line = line_info->dw_line_num;
7440           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7441             /* This can handle deltas from -10 to 234, using the current
7442                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7443                takes 1 byte.  */
7444             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7445                                  "line %lu", current_line);
7446           else
7447             {
7448               /* This can handle any delta.  This takes at least 4 bytes,
7449                  depending on the value being encoded.  */
7450               dw2_asm_output_data (1, DW_LNS_advance_line,
7451                                    "advance to line %lu", current_line);
7452               dw2_asm_output_data_sleb128 (line_offset, NULL);
7453               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7454             }
7455         }
7456       else
7457         /* We still need to start a new row, so output a copy insn.  */
7458         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7459     }
7460
7461   /* Emit debug info for the address of the end of the function.  */
7462   if (0)
7463     {
7464       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7465                            "DW_LNS_fixed_advance_pc");
7466       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7467     }
7468   else
7469     {
7470       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7471       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7472       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7473       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7474     }
7475
7476   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7477   dw2_asm_output_data_uleb128 (1, NULL);
7478   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7479
7480   function = 0;
7481   current_file = 1;
7482   current_line = 1;
7483   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7484     {
7485       dw_separate_line_info_ref line_info
7486         = &separate_line_info_table[lt_index];
7487
7488 #if 0
7489       /* Don't emit anything for redundant notes.  */
7490       if (line_info->dw_line_num == current_line
7491           && line_info->dw_file_num == current_file
7492           && line_info->function == function)
7493         goto cont;
7494 #endif
7495
7496       /* Emit debug info for the address of the current line.  If this is
7497          a new function, or the first line of a function, then we need
7498          to handle it differently.  */
7499       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7500                                    lt_index);
7501       if (function != line_info->function)
7502         {
7503           function = line_info->function;
7504
7505           /* Set the address register to the first line in the function.  */
7506           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7507           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7508           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7509           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7510         }
7511       else
7512         {
7513           /* ??? See the DW_LNS_advance_pc comment above.  */
7514           if (0)
7515             {
7516               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7517                                    "DW_LNS_fixed_advance_pc");
7518               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7519             }
7520           else
7521             {
7522               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7523               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7524               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7525               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7526             }
7527         }
7528
7529       strcpy (prev_line_label, line_label);
7530
7531       /* Emit debug info for the source file of the current line, if
7532          different from the previous line.  */
7533       if (line_info->dw_file_num != current_file)
7534         {
7535           current_file = line_info->dw_file_num;
7536           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7537           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7538                                        VARRAY_CHAR_PTR (file_table,
7539                                                         current_file));
7540         }
7541
7542       /* Emit debug info for the current line number, choosing the encoding
7543          that uses the least amount of space.  */
7544       if (line_info->dw_line_num != current_line)
7545         {
7546           line_offset = line_info->dw_line_num - current_line;
7547           line_delta = line_offset - DWARF_LINE_BASE;
7548           current_line = line_info->dw_line_num;
7549           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7550             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7551                                  "line %lu", current_line);
7552           else
7553             {
7554               dw2_asm_output_data (1, DW_LNS_advance_line,
7555                                    "advance to line %lu", current_line);
7556               dw2_asm_output_data_sleb128 (line_offset, NULL);
7557               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7558             }
7559         }
7560       else
7561         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7562
7563 #if 0
7564     cont:
7565 #endif
7566
7567       lt_index++;
7568
7569       /* If we're done with a function, end its sequence.  */
7570       if (lt_index == separate_line_info_table_in_use
7571           || separate_line_info_table[lt_index].function != function)
7572         {
7573           current_file = 1;
7574           current_line = 1;
7575
7576           /* Emit debug info for the address of the end of the function.  */
7577           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
7578           if (0)
7579             {
7580               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7581                                    "DW_LNS_fixed_advance_pc");
7582               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7583             }
7584           else
7585             {
7586               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7587               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7588               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7589               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7590             }
7591
7592           /* Output the marker for the end of this sequence.  */
7593           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7594           dw2_asm_output_data_uleb128 (1, NULL);
7595           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7596         }
7597     }
7598
7599   /* Output the marker for the end of the line number info.  */
7600   ASM_OUTPUT_LABEL (asm_out_file, l2);
7601 }
7602 \f
7603 /* Given a pointer to a tree node for some base type, return a pointer to
7604    a DIE that describes the given type.
7605
7606    This routine must only be called for GCC type nodes that correspond to
7607    Dwarf base (fundamental) types.  */
7608
7609 static dw_die_ref
7610 base_type_die (tree type)
7611 {
7612   dw_die_ref base_type_result;
7613   const char *type_name;
7614   enum dwarf_type encoding;
7615   tree name = TYPE_NAME (type);
7616
7617   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
7618     return 0;
7619
7620   if (name)
7621     {
7622       if (TREE_CODE (name) == TYPE_DECL)
7623         name = DECL_NAME (name);
7624
7625       type_name = IDENTIFIER_POINTER (name);
7626     }
7627   else
7628     type_name = "__unknown__";
7629
7630   switch (TREE_CODE (type))
7631     {
7632     case INTEGER_TYPE:
7633       /* Carefully distinguish the C character types, without messing
7634          up if the language is not C. Note that we check only for the names
7635          that contain spaces; other names might occur by coincidence in other
7636          languages.  */
7637       if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
7638              && (type == char_type_node
7639                  || ! strcmp (type_name, "signed char")
7640                  || ! strcmp (type_name, "unsigned char"))))
7641         {
7642           if (TREE_UNSIGNED (type))
7643             encoding = DW_ATE_unsigned;
7644           else
7645             encoding = DW_ATE_signed;
7646           break;
7647         }
7648       /* else fall through.  */
7649
7650     case CHAR_TYPE:
7651       /* GNU Pascal/Ada CHAR type.  Not used in C.  */
7652       if (TREE_UNSIGNED (type))
7653         encoding = DW_ATE_unsigned_char;
7654       else
7655         encoding = DW_ATE_signed_char;
7656       break;
7657
7658     case REAL_TYPE:
7659       encoding = DW_ATE_float;
7660       break;
7661
7662       /* Dwarf2 doesn't know anything about complex ints, so use
7663          a user defined type for it.  */
7664     case COMPLEX_TYPE:
7665       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
7666         encoding = DW_ATE_complex_float;
7667       else
7668         encoding = DW_ATE_lo_user;
7669       break;
7670
7671     case BOOLEAN_TYPE:
7672       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
7673       encoding = DW_ATE_boolean;
7674       break;
7675
7676     default:
7677       /* No other TREE_CODEs are Dwarf fundamental types.  */
7678       abort ();
7679     }
7680
7681   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
7682   if (demangle_name_func)
7683     type_name = (*demangle_name_func) (type_name);
7684
7685   add_AT_string (base_type_result, DW_AT_name, type_name);
7686   add_AT_unsigned (base_type_result, DW_AT_byte_size,
7687                    int_size_in_bytes (type));
7688   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
7689
7690   return base_type_result;
7691 }
7692
7693 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7694    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
7695    a given type is generally the same as the given type, except that if the
7696    given type is a pointer or reference type, then the root type of the given
7697    type is the root type of the "basis" type for the pointer or reference
7698    type.  (This definition of the "root" type is recursive.) Also, the root
7699    type of a `const' qualified type or a `volatile' qualified type is the
7700    root type of the given type without the qualifiers.  */
7701
7702 static tree
7703 root_type (tree type)
7704 {
7705   if (TREE_CODE (type) == ERROR_MARK)
7706     return error_mark_node;
7707
7708   switch (TREE_CODE (type))
7709     {
7710     case ERROR_MARK:
7711       return error_mark_node;
7712
7713     case POINTER_TYPE:
7714     case REFERENCE_TYPE:
7715       return type_main_variant (root_type (TREE_TYPE (type)));
7716
7717     default:
7718       return type_main_variant (type);
7719     }
7720 }
7721
7722 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7723    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
7724
7725 static inline int
7726 is_base_type (tree type)
7727 {
7728   switch (TREE_CODE (type))
7729     {
7730     case ERROR_MARK:
7731     case VOID_TYPE:
7732     case INTEGER_TYPE:
7733     case REAL_TYPE:
7734     case COMPLEX_TYPE:
7735     case BOOLEAN_TYPE:
7736     case CHAR_TYPE:
7737       return 1;
7738
7739     case SET_TYPE:
7740     case ARRAY_TYPE:
7741     case RECORD_TYPE:
7742     case UNION_TYPE:
7743     case QUAL_UNION_TYPE:
7744     case ENUMERAL_TYPE:
7745     case FUNCTION_TYPE:
7746     case METHOD_TYPE:
7747     case POINTER_TYPE:
7748     case REFERENCE_TYPE:
7749     case FILE_TYPE:
7750     case OFFSET_TYPE:
7751     case LANG_TYPE:
7752     case VECTOR_TYPE:
7753       return 0;
7754
7755     default:
7756       abort ();
7757     }
7758
7759   return 0;
7760 }
7761
7762 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
7763    node, return the size in bits for the type if it is a constant, or else
7764    return the alignment for the type if the type's size is not constant, or
7765    else return BITS_PER_WORD if the type actually turns out to be an
7766    ERROR_MARK node.  */
7767
7768 static inline unsigned HOST_WIDE_INT
7769 simple_type_size_in_bits (tree type)
7770 {
7771   if (TREE_CODE (type) == ERROR_MARK)
7772     return BITS_PER_WORD;
7773   else if (TYPE_SIZE (type) == NULL_TREE)
7774     return 0;
7775   else if (host_integerp (TYPE_SIZE (type), 1))
7776     return tree_low_cst (TYPE_SIZE (type), 1);
7777   else
7778     return TYPE_ALIGN (type);
7779 }
7780
7781 /* Return true if the debug information for the given type should be
7782    emitted as a subrange type.  */
7783
7784 static inline bool
7785 is_ada_subrange_type (tree type)
7786 {
7787   /* We do this for INTEGER_TYPEs that have names, parent types, and when
7788      we are compiling Ada code.  */
7789   return (TREE_CODE (type) == INTEGER_TYPE
7790           && TYPE_NAME (type) != 0 && TREE_TYPE (type) != 0
7791           && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
7792           && TREE_UNSIGNED (TREE_TYPE (type)) && is_ada ());
7793 }
7794
7795 /*  Given a pointer to a tree node for a subrange type, return a pointer
7796     to a DIE that describes the given type.  */
7797
7798 static dw_die_ref
7799 subrange_type_die (tree type)
7800 {
7801   dw_die_ref subtype_die;
7802   dw_die_ref subrange_die;
7803   tree name = TYPE_NAME (type);
7804
7805   subtype_die = base_type_die (TREE_TYPE (type));
7806
7807   if (TREE_CODE (name) == TYPE_DECL)
7808     name = DECL_NAME (name);
7809
7810   subrange_die = new_die (DW_TAG_subrange_type, comp_unit_die, type);
7811   add_name_attribute (subrange_die, IDENTIFIER_POINTER (name));
7812   if (TYPE_MIN_VALUE (type) != NULL)
7813     add_bound_info (subrange_die, DW_AT_lower_bound,
7814                     TYPE_MIN_VALUE (type));
7815   if (TYPE_MAX_VALUE (type) != NULL)
7816     add_bound_info (subrange_die, DW_AT_upper_bound,
7817                     TYPE_MAX_VALUE (type));
7818   add_AT_die_ref (subrange_die, DW_AT_type, subtype_die);
7819
7820   return subrange_die;
7821 }
7822
7823 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
7824    entry that chains various modifiers in front of the given type.  */
7825
7826 static dw_die_ref
7827 modified_type_die (tree type, int is_const_type, int is_volatile_type,
7828                    dw_die_ref context_die)
7829 {
7830   enum tree_code code = TREE_CODE (type);
7831   dw_die_ref mod_type_die = NULL;
7832   dw_die_ref sub_die = NULL;
7833   tree item_type = NULL;
7834
7835   if (code != ERROR_MARK)
7836     {
7837       tree qualified_type;
7838
7839       /* See if we already have the appropriately qualified variant of
7840          this type.  */
7841       qualified_type
7842         = get_qualified_type (type,
7843                               ((is_const_type ? TYPE_QUAL_CONST : 0)
7844                                | (is_volatile_type
7845                                   ? TYPE_QUAL_VOLATILE : 0)));
7846
7847       /* If we do, then we can just use its DIE, if it exists.  */
7848       if (qualified_type)
7849         {
7850           mod_type_die = lookup_type_die (qualified_type);
7851           if (mod_type_die)
7852             return mod_type_die;
7853         }
7854
7855       /* Handle C typedef types.  */
7856       if (qualified_type && TYPE_NAME (qualified_type)
7857           && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
7858           && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
7859         {
7860           tree type_name = TYPE_NAME (qualified_type);
7861           tree dtype = TREE_TYPE (type_name);
7862
7863           if (qualified_type == dtype)
7864             {
7865               /* For a named type, use the typedef.  */
7866               gen_type_die (qualified_type, context_die);
7867               mod_type_die = lookup_type_die (qualified_type);
7868             }
7869           else if (is_const_type < TYPE_READONLY (dtype)
7870                    || is_volatile_type < TYPE_VOLATILE (dtype))
7871             /* cv-unqualified version of named type.  Just use the unnamed
7872                type to which it refers.  */
7873             mod_type_die
7874               = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
7875                                    is_const_type, is_volatile_type,
7876                                    context_die);
7877
7878           /* Else cv-qualified version of named type; fall through.  */
7879         }
7880
7881       if (mod_type_die)
7882         /* OK.  */
7883         ;
7884       else if (is_const_type)
7885         {
7886           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
7887           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
7888         }
7889       else if (is_volatile_type)
7890         {
7891           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
7892           sub_die = modified_type_die (type, 0, 0, context_die);
7893         }
7894       else if (code == POINTER_TYPE)
7895         {
7896           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
7897           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
7898                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
7899 #if 0
7900           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
7901 #endif
7902           item_type = TREE_TYPE (type);
7903         }
7904       else if (code == REFERENCE_TYPE)
7905         {
7906           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
7907           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
7908                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
7909 #if 0
7910           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
7911 #endif
7912           item_type = TREE_TYPE (type);
7913         }
7914       else if (is_ada_subrange_type (type))
7915         mod_type_die = subrange_type_die (type);
7916       else if (is_base_type (type))
7917         mod_type_die = base_type_die (type);
7918       else
7919         {
7920           gen_type_die (type, context_die);
7921
7922           /* We have to get the type_main_variant here (and pass that to the
7923              `lookup_type_die' routine) because the ..._TYPE node we have
7924              might simply be a *copy* of some original type node (where the
7925              copy was created to help us keep track of typedef names) and
7926              that copy might have a different TYPE_UID from the original
7927              ..._TYPE node.  */
7928           if (TREE_CODE (type) != VECTOR_TYPE)
7929             mod_type_die = lookup_type_die (type_main_variant (type));
7930           else
7931             /* Vectors have the debugging information in the type,
7932                not the main variant.  */
7933             mod_type_die = lookup_type_die (type);
7934           if (mod_type_die == NULL)
7935             abort ();
7936         }
7937
7938       /* We want to equate the qualified type to the die below.  */
7939       type = qualified_type;
7940     }
7941
7942   if (type)
7943     equate_type_number_to_die (type, mod_type_die);
7944   if (item_type)
7945     /* We must do this after the equate_type_number_to_die call, in case
7946        this is a recursive type.  This ensures that the modified_type_die
7947        recursion will terminate even if the type is recursive.  Recursive
7948        types are possible in Ada.  */
7949     sub_die = modified_type_die (item_type,
7950                                  TYPE_READONLY (item_type),
7951                                  TYPE_VOLATILE (item_type),
7952                                  context_die);
7953
7954   if (sub_die != NULL)
7955     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
7956
7957   return mod_type_die;
7958 }
7959
7960 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
7961    an enumerated type.  */
7962
7963 static inline int
7964 type_is_enum (tree type)
7965 {
7966   return TREE_CODE (type) == ENUMERAL_TYPE;
7967 }
7968
7969 /* Return the register number described by a given RTL node.  */
7970
7971 static unsigned int
7972 reg_number (rtx rtl)
7973 {
7974   unsigned regno = REGNO (rtl);
7975
7976   if (regno >= FIRST_PSEUDO_REGISTER)
7977     abort ();
7978
7979   return DBX_REGISTER_NUMBER (regno);
7980 }
7981
7982 /* Return a location descriptor that designates a machine register or
7983    zero if there is none.  */
7984
7985 static dw_loc_descr_ref
7986 reg_loc_descriptor (rtx rtl)
7987 {
7988   unsigned reg;
7989   rtx regs;
7990
7991   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
7992     return 0;
7993
7994   reg = reg_number (rtl);
7995   regs = (*targetm.dwarf_register_span) (rtl);
7996
7997   if (HARD_REGNO_NREGS (reg, GET_MODE (rtl)) > 1
7998       || regs)
7999     return multiple_reg_loc_descriptor (rtl, regs);
8000   else
8001     return one_reg_loc_descriptor (reg);
8002 }
8003
8004 /* Return a location descriptor that designates a machine register for
8005    a given hard register number.  */
8006
8007 static dw_loc_descr_ref
8008 one_reg_loc_descriptor (unsigned int regno)
8009 {
8010   if (regno <= 31)
8011     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8012   else
8013     return new_loc_descr (DW_OP_regx, regno, 0);
8014 }
8015
8016 /* Given an RTL of a register, return a location descriptor that
8017    designates a value that spans more than one register.  */
8018
8019 static dw_loc_descr_ref
8020 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8021 {
8022   int nregs, size, i;
8023   unsigned reg;
8024   dw_loc_descr_ref loc_result = NULL;
8025
8026   reg = reg_number (rtl);
8027   nregs = HARD_REGNO_NREGS (reg, GET_MODE (rtl));
8028
8029   /* Simple, contiguous registers.  */
8030   if (regs == NULL_RTX)
8031     {
8032       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8033
8034       loc_result = NULL;
8035       while (nregs--)
8036         {
8037           dw_loc_descr_ref t;
8038
8039           t = one_reg_loc_descriptor (reg);
8040           add_loc_descr (&loc_result, t);
8041           add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8042           ++reg;
8043         }
8044       return loc_result;
8045     }
8046
8047   /* Now onto stupid register sets in non contiguous locations.  */
8048
8049   if (GET_CODE (regs) != PARALLEL)
8050     abort ();
8051
8052   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8053   loc_result = NULL;
8054
8055   for (i = 0; i < XVECLEN (regs, 0); ++i)
8056     {
8057       dw_loc_descr_ref t;
8058
8059       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8060       add_loc_descr (&loc_result, t);
8061       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8062       add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8063     }
8064   return loc_result;
8065 }
8066
8067 /* Return a location descriptor that designates a constant.  */
8068
8069 static dw_loc_descr_ref
8070 int_loc_descriptor (HOST_WIDE_INT i)
8071 {
8072   enum dwarf_location_atom op;
8073
8074   /* Pick the smallest representation of a constant, rather than just
8075      defaulting to the LEB encoding.  */
8076   if (i >= 0)
8077     {
8078       if (i <= 31)
8079         op = DW_OP_lit0 + i;
8080       else if (i <= 0xff)
8081         op = DW_OP_const1u;
8082       else if (i <= 0xffff)
8083         op = DW_OP_const2u;
8084       else if (HOST_BITS_PER_WIDE_INT == 32
8085                || i <= 0xffffffff)
8086         op = DW_OP_const4u;
8087       else
8088         op = DW_OP_constu;
8089     }
8090   else
8091     {
8092       if (i >= -0x80)
8093         op = DW_OP_const1s;
8094       else if (i >= -0x8000)
8095         op = DW_OP_const2s;
8096       else if (HOST_BITS_PER_WIDE_INT == 32
8097                || i >= -0x80000000)
8098         op = DW_OP_const4s;
8099       else
8100         op = DW_OP_consts;
8101     }
8102
8103   return new_loc_descr (op, i, 0);
8104 }
8105
8106 /* Return a location descriptor that designates a base+offset location.  */
8107
8108 static dw_loc_descr_ref
8109 based_loc_descr (unsigned int reg, long int offset)
8110 {
8111   dw_loc_descr_ref loc_result;
8112   /* For the "frame base", we use the frame pointer or stack pointer
8113      registers, since the RTL for local variables is relative to one of
8114      them.  */
8115   unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
8116                                          ? HARD_FRAME_POINTER_REGNUM
8117                                          : STACK_POINTER_REGNUM);
8118
8119   if (reg == fp_reg)
8120     loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
8121   else if (reg <= 31)
8122     loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
8123   else
8124     loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
8125
8126   return loc_result;
8127 }
8128
8129 /* Return true if this RTL expression describes a base+offset calculation.  */
8130
8131 static inline int
8132 is_based_loc (rtx rtl)
8133 {
8134   return (GET_CODE (rtl) == PLUS
8135           && ((GET_CODE (XEXP (rtl, 0)) == REG
8136                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8137                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8138 }
8139
8140 /* The following routine converts the RTL for a variable or parameter
8141    (resident in memory) into an equivalent Dwarf representation of a
8142    mechanism for getting the address of that same variable onto the top of a
8143    hypothetical "address evaluation" stack.
8144
8145    When creating memory location descriptors, we are effectively transforming
8146    the RTL for a memory-resident object into its Dwarf postfix expression
8147    equivalent.  This routine recursively descends an RTL tree, turning
8148    it into Dwarf postfix code as it goes.
8149
8150    MODE is the mode of the memory reference, needed to handle some
8151    autoincrement addressing modes.
8152
8153    Return 0 if we can't represent the location.  */
8154
8155 static dw_loc_descr_ref
8156 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8157 {
8158   dw_loc_descr_ref mem_loc_result = NULL;
8159
8160   /* Note that for a dynamically sized array, the location we will generate a
8161      description of here will be the lowest numbered location which is
8162      actually within the array.  That's *not* necessarily the same as the
8163      zeroth element of the array.  */
8164
8165   rtl = (*targetm.delegitimize_address) (rtl);
8166
8167   switch (GET_CODE (rtl))
8168     {
8169     case POST_INC:
8170     case POST_DEC:
8171     case POST_MODIFY:
8172       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8173          just fall into the SUBREG code.  */
8174
8175       /* ... fall through ...  */
8176
8177     case SUBREG:
8178       /* The case of a subreg may arise when we have a local (register)
8179          variable or a formal (register) parameter which doesn't quite fill
8180          up an entire register.  For now, just assume that it is
8181          legitimate to make the Dwarf info refer to the whole register which
8182          contains the given subreg.  */
8183       rtl = SUBREG_REG (rtl);
8184
8185       /* ... fall through ...  */
8186
8187     case REG:
8188       /* Whenever a register number forms a part of the description of the
8189          method for calculating the (dynamic) address of a memory resident
8190          object, DWARF rules require the register number be referred to as
8191          a "base register".  This distinction is not based in any way upon
8192          what category of register the hardware believes the given register
8193          belongs to.  This is strictly DWARF terminology we're dealing with
8194          here. Note that in cases where the location of a memory-resident
8195          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8196          OP_CONST (0)) the actual DWARF location descriptor that we generate
8197          may just be OP_BASEREG (basereg).  This may look deceptively like
8198          the object in question was allocated to a register (rather than in
8199          memory) so DWARF consumers need to be aware of the subtle
8200          distinction between OP_REG and OP_BASEREG.  */
8201       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8202         mem_loc_result = based_loc_descr (reg_number (rtl), 0);
8203       break;
8204
8205     case MEM:
8206       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8207       if (mem_loc_result != 0)
8208         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8209       break;
8210
8211     case LO_SUM:
8212          rtl = XEXP (rtl, 1);
8213
8214       /* ... fall through ...  */
8215
8216     case LABEL_REF:
8217       /* Some ports can transform a symbol ref into a label ref, because
8218          the symbol ref is too far away and has to be dumped into a constant
8219          pool.  */
8220     case CONST:
8221     case SYMBOL_REF:
8222       /* Alternatively, the symbol in the constant pool might be referenced
8223          by a different symbol.  */
8224       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8225         {
8226           bool marked;
8227           rtx tmp = get_pool_constant_mark (rtl, &marked);
8228
8229           if (GET_CODE (tmp) == SYMBOL_REF)
8230             {
8231               rtl = tmp;
8232               if (CONSTANT_POOL_ADDRESS_P (tmp))
8233                 get_pool_constant_mark (tmp, &marked);
8234               else
8235                 marked = true;
8236             }
8237
8238           /* If all references to this pool constant were optimized away,
8239              it was not output and thus we can't represent it.
8240              FIXME: might try to use DW_OP_const_value here, though
8241              DW_OP_piece complicates it.  */
8242           if (!marked)
8243             return 0;
8244         }
8245
8246       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8247       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8248       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8249       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
8250       break;
8251
8252     case PRE_MODIFY:
8253       /* Extract the PLUS expression nested inside and fall into
8254          PLUS code below.  */
8255       rtl = XEXP (rtl, 1);
8256       goto plus;
8257
8258     case PRE_INC:
8259     case PRE_DEC:
8260       /* Turn these into a PLUS expression and fall into the PLUS code
8261          below.  */
8262       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8263                           GEN_INT (GET_CODE (rtl) == PRE_INC
8264                                    ? GET_MODE_UNIT_SIZE (mode)
8265                                    : -GET_MODE_UNIT_SIZE (mode)));
8266
8267       /* ... fall through ...  */
8268
8269     case PLUS:
8270     plus:
8271       if (is_based_loc (rtl))
8272         mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
8273                                           INTVAL (XEXP (rtl, 1)));
8274       else
8275         {
8276           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8277           if (mem_loc_result == 0)
8278             break;
8279
8280           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8281               && INTVAL (XEXP (rtl, 1)) >= 0)
8282             add_loc_descr (&mem_loc_result,
8283                            new_loc_descr (DW_OP_plus_uconst,
8284                                           INTVAL (XEXP (rtl, 1)), 0));
8285           else
8286             {
8287               add_loc_descr (&mem_loc_result,
8288                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8289               add_loc_descr (&mem_loc_result,
8290                              new_loc_descr (DW_OP_plus, 0, 0));
8291             }
8292         }
8293       break;
8294
8295     case MULT:
8296       {
8297         /* If a pseudo-reg is optimized away, it is possible for it to
8298            be replaced with a MEM containing a multiply.  */
8299         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8300         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8301
8302         if (op0 == 0 || op1 == 0)
8303           break;
8304
8305         mem_loc_result = op0;
8306         add_loc_descr (&mem_loc_result, op1);
8307         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
8308         break;
8309       }
8310
8311     case CONST_INT:
8312       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8313       break;
8314
8315     case ADDRESSOF:
8316       /* If this is a MEM, return its address.  Otherwise, we can't
8317          represent this.  */
8318       if (GET_CODE (XEXP (rtl, 0)) == MEM)
8319         return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode);
8320       else
8321         return 0;
8322
8323     default:
8324       abort ();
8325     }
8326
8327   return mem_loc_result;
8328 }
8329
8330 /* Return a descriptor that describes the concatenation of two locations.
8331    This is typically a complex variable.  */
8332
8333 static dw_loc_descr_ref
8334 concat_loc_descriptor (rtx x0, rtx x1)
8335 {
8336   dw_loc_descr_ref cc_loc_result = NULL;
8337   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8338   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8339
8340   if (x0_ref == 0 || x1_ref == 0)
8341     return 0;
8342
8343   cc_loc_result = x0_ref;
8344   add_loc_descr (&cc_loc_result,
8345                  new_loc_descr (DW_OP_piece,
8346                                 GET_MODE_SIZE (GET_MODE (x0)), 0));
8347
8348   add_loc_descr (&cc_loc_result, x1_ref);
8349   add_loc_descr (&cc_loc_result,
8350                  new_loc_descr (DW_OP_piece,
8351                                 GET_MODE_SIZE (GET_MODE (x1)), 0));
8352
8353   return cc_loc_result;
8354 }
8355
8356 /* Output a proper Dwarf location descriptor for a variable or parameter
8357    which is either allocated in a register or in a memory location.  For a
8358    register, we just generate an OP_REG and the register number.  For a
8359    memory location we provide a Dwarf postfix expression describing how to
8360    generate the (dynamic) address of the object onto the address stack.
8361
8362    If we don't know how to describe it, return 0.  */
8363
8364 static dw_loc_descr_ref
8365 loc_descriptor (rtx rtl)
8366 {
8367   dw_loc_descr_ref loc_result = NULL;
8368
8369   switch (GET_CODE (rtl))
8370     {
8371     case SUBREG:
8372       /* The case of a subreg may arise when we have a local (register)
8373          variable or a formal (register) parameter which doesn't quite fill
8374          up an entire register.  For now, just assume that it is
8375          legitimate to make the Dwarf info refer to the whole register which
8376          contains the given subreg.  */
8377       rtl = SUBREG_REG (rtl);
8378
8379       /* ... fall through ...  */
8380
8381     case REG:
8382       loc_result = reg_loc_descriptor (rtl);
8383       break;
8384
8385     case MEM:
8386       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8387       break;
8388
8389     case CONCAT:
8390       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8391       break;
8392
8393     default:
8394       abort ();
8395     }
8396
8397   return loc_result;
8398 }
8399
8400 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8401    up particularly with variable length arrays.  If ADDRESSP is nonzero, we are
8402    looking for an address.  Otherwise, we return a value.  If we can't make a
8403    descriptor, return 0.  */
8404
8405 static dw_loc_descr_ref
8406 loc_descriptor_from_tree (tree loc, int addressp)
8407 {
8408   dw_loc_descr_ref ret, ret1;
8409   int indirect_p = 0;
8410   int unsignedp = TREE_UNSIGNED (TREE_TYPE (loc));
8411   enum dwarf_location_atom op;
8412
8413   /* ??? Most of the time we do not take proper care for sign/zero
8414      extending the values properly.  Hopefully this won't be a real
8415      problem...  */
8416
8417   switch (TREE_CODE (loc))
8418     {
8419     case ERROR_MARK:
8420       return 0;
8421
8422     case WITH_RECORD_EXPR:
8423     case PLACEHOLDER_EXPR:
8424       /* This case involves extracting fields from an object to determine the
8425          position of other fields.  We don't try to encode this here.  The
8426          only user of this is Ada, which encodes the needed information using
8427          the names of types.  */
8428       return 0;
8429
8430     case CALL_EXPR:
8431       return 0;
8432
8433     case ADDR_EXPR:
8434       /* We can support this only if we can look through conversions and
8435          find an INDIRECT_EXPR.  */
8436       for (loc = TREE_OPERAND (loc, 0);
8437            TREE_CODE (loc) == CONVERT_EXPR || TREE_CODE (loc) == NOP_EXPR
8438            || TREE_CODE (loc) == NON_LVALUE_EXPR
8439            || TREE_CODE (loc) == VIEW_CONVERT_EXPR
8440            || TREE_CODE (loc) == SAVE_EXPR;
8441            loc = TREE_OPERAND (loc, 0))
8442         ;
8443
8444        return (TREE_CODE (loc) == INDIRECT_REF
8445                ? loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp)
8446                : 0);
8447
8448     case VAR_DECL:
8449       if (DECL_THREAD_LOCAL (loc))
8450         {
8451           rtx rtl;
8452
8453 #ifndef ASM_OUTPUT_DWARF_DTPREL
8454           /* If this is not defined, we have no way to emit the data.  */
8455           return 0;
8456 #endif
8457
8458           /* The way DW_OP_GNU_push_tls_address is specified, we can only
8459              look up addresses of objects in the current module.  */
8460           if (DECL_EXTERNAL (loc))
8461             return 0;
8462
8463           rtl = rtl_for_decl_location (loc);
8464           if (rtl == NULL_RTX)
8465             return 0;
8466
8467           if (GET_CODE (rtl) != MEM)
8468             return 0;
8469           rtl = XEXP (rtl, 0);
8470           if (! CONSTANT_P (rtl))
8471             return 0;
8472
8473           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
8474           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8475           ret->dw_loc_oprnd1.v.val_addr = rtl;
8476
8477           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
8478           add_loc_descr (&ret, ret1);
8479
8480           indirect_p = 1;
8481           break;
8482         }
8483       /* FALLTHRU */
8484
8485     case PARM_DECL:
8486       {
8487         rtx rtl = rtl_for_decl_location (loc);
8488
8489         if (rtl == NULL_RTX)
8490           return 0;
8491         else if (CONSTANT_P (rtl))
8492           {
8493             ret = new_loc_descr (DW_OP_addr, 0, 0);
8494             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8495             ret->dw_loc_oprnd1.v.val_addr = rtl;
8496             indirect_p = 1;
8497           }
8498         else
8499           {
8500             enum machine_mode mode = GET_MODE (rtl);
8501
8502             if (GET_CODE (rtl) == MEM)
8503               {
8504                 indirect_p = 1;
8505                 rtl = XEXP (rtl, 0);
8506               }
8507
8508             ret = mem_loc_descriptor (rtl, mode);
8509           }
8510       }
8511       break;
8512
8513     case INDIRECT_REF:
8514       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8515       indirect_p = 1;
8516       break;
8517
8518     case COMPOUND_EXPR:
8519       return loc_descriptor_from_tree (TREE_OPERAND (loc, 1), addressp);
8520
8521     case NOP_EXPR:
8522     case CONVERT_EXPR:
8523     case NON_LVALUE_EXPR:
8524     case VIEW_CONVERT_EXPR:
8525     case SAVE_EXPR:
8526     case MODIFY_EXPR:
8527       return loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp);
8528
8529     case COMPONENT_REF:
8530     case BIT_FIELD_REF:
8531     case ARRAY_REF:
8532     case ARRAY_RANGE_REF:
8533       {
8534         tree obj, offset;
8535         HOST_WIDE_INT bitsize, bitpos, bytepos;
8536         enum machine_mode mode;
8537         int volatilep;
8538
8539         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
8540                                    &unsignedp, &volatilep);
8541
8542         if (obj == loc)
8543           return 0;
8544
8545         ret = loc_descriptor_from_tree (obj, 1);
8546         if (ret == 0
8547             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
8548           return 0;
8549
8550         if (offset != NULL_TREE)
8551           {
8552             /* Variable offset.  */
8553             add_loc_descr (&ret, loc_descriptor_from_tree (offset, 0));
8554             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8555           }
8556
8557         if (!addressp)
8558           indirect_p = 1;
8559
8560         bytepos = bitpos / BITS_PER_UNIT;
8561         if (bytepos > 0)
8562           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
8563         else if (bytepos < 0)
8564           {
8565             add_loc_descr (&ret, int_loc_descriptor (bytepos));
8566             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8567           }
8568         break;
8569       }
8570
8571     case INTEGER_CST:
8572       if (host_integerp (loc, 0))
8573         ret = int_loc_descriptor (tree_low_cst (loc, 0));
8574       else
8575         return 0;
8576       break;
8577
8578     case CONSTRUCTOR:
8579       {
8580         /* Get an RTL for this, if something has been emitted.  */
8581         rtx rtl = lookup_constant_def (loc);
8582         enum machine_mode mode;
8583
8584         if (GET_CODE (rtl) != MEM)
8585           return 0;
8586         mode = GET_MODE (rtl);
8587         rtl = XEXP (rtl, 0);
8588
8589         rtl = (*targetm.delegitimize_address) (rtl);
8590
8591         indirect_p = 1;
8592         ret = mem_loc_descriptor (rtl, mode);
8593         break;
8594       }
8595
8596     case TRUTH_AND_EXPR:
8597     case TRUTH_ANDIF_EXPR:
8598     case BIT_AND_EXPR:
8599       op = DW_OP_and;
8600       goto do_binop;
8601
8602     case TRUTH_XOR_EXPR:
8603     case BIT_XOR_EXPR:
8604       op = DW_OP_xor;
8605       goto do_binop;
8606
8607     case TRUTH_OR_EXPR:
8608     case TRUTH_ORIF_EXPR:
8609     case BIT_IOR_EXPR:
8610       op = DW_OP_or;
8611       goto do_binop;
8612
8613     case FLOOR_DIV_EXPR:
8614     case CEIL_DIV_EXPR:
8615     case ROUND_DIV_EXPR:
8616     case TRUNC_DIV_EXPR:
8617       op = DW_OP_div;
8618       goto do_binop;
8619
8620     case MINUS_EXPR:
8621       op = DW_OP_minus;
8622       goto do_binop;
8623
8624     case FLOOR_MOD_EXPR:
8625     case CEIL_MOD_EXPR:
8626     case ROUND_MOD_EXPR:
8627     case TRUNC_MOD_EXPR:
8628       op = DW_OP_mod;
8629       goto do_binop;
8630
8631     case MULT_EXPR:
8632       op = DW_OP_mul;
8633       goto do_binop;
8634
8635     case LSHIFT_EXPR:
8636       op = DW_OP_shl;
8637       goto do_binop;
8638
8639     case RSHIFT_EXPR:
8640       op = (unsignedp ? DW_OP_shr : DW_OP_shra);
8641       goto do_binop;
8642
8643     case PLUS_EXPR:
8644       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
8645           && host_integerp (TREE_OPERAND (loc, 1), 0))
8646         {
8647           ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8648           if (ret == 0)
8649             return 0;
8650
8651           add_loc_descr (&ret,
8652                          new_loc_descr (DW_OP_plus_uconst,
8653                                         tree_low_cst (TREE_OPERAND (loc, 1),
8654                                                       0),
8655                                         0));
8656           break;
8657         }
8658
8659       op = DW_OP_plus;
8660       goto do_binop;
8661
8662     case LE_EXPR:
8663       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8664         return 0;
8665
8666       op = DW_OP_le;
8667       goto do_binop;
8668
8669     case GE_EXPR:
8670       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8671         return 0;
8672
8673       op = DW_OP_ge;
8674       goto do_binop;
8675
8676     case LT_EXPR:
8677       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8678         return 0;
8679
8680       op = DW_OP_lt;
8681       goto do_binop;
8682
8683     case GT_EXPR:
8684       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8685         return 0;
8686
8687       op = DW_OP_gt;
8688       goto do_binop;
8689
8690     case EQ_EXPR:
8691       op = DW_OP_eq;
8692       goto do_binop;
8693
8694     case NE_EXPR:
8695       op = DW_OP_ne;
8696       goto do_binop;
8697
8698     do_binop:
8699       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8700       ret1 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8701       if (ret == 0 || ret1 == 0)
8702         return 0;
8703
8704       add_loc_descr (&ret, ret1);
8705       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8706       break;
8707
8708     case TRUTH_NOT_EXPR:
8709     case BIT_NOT_EXPR:
8710       op = DW_OP_not;
8711       goto do_unop;
8712
8713     case ABS_EXPR:
8714       op = DW_OP_abs;
8715       goto do_unop;
8716
8717     case NEGATE_EXPR:
8718       op = DW_OP_neg;
8719       goto do_unop;
8720
8721     do_unop:
8722       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8723       if (ret == 0)
8724         return 0;
8725
8726       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8727       break;
8728
8729     case MAX_EXPR:
8730       loc = build (COND_EXPR, TREE_TYPE (loc),
8731                    build (LT_EXPR, integer_type_node,
8732                           TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
8733                    TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
8734
8735       /* ... fall through ...  */
8736
8737     case COND_EXPR:
8738       {
8739         dw_loc_descr_ref lhs
8740           = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8741         dw_loc_descr_ref rhs
8742           = loc_descriptor_from_tree (TREE_OPERAND (loc, 2), 0);
8743         dw_loc_descr_ref bra_node, jump_node, tmp;
8744
8745         ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8746         if (ret == 0 || lhs == 0 || rhs == 0)
8747           return 0;
8748
8749         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
8750         add_loc_descr (&ret, bra_node);
8751
8752         add_loc_descr (&ret, rhs);
8753         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
8754         add_loc_descr (&ret, jump_node);
8755
8756         add_loc_descr (&ret, lhs);
8757         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8758         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
8759
8760         /* ??? Need a node to point the skip at.  Use a nop.  */
8761         tmp = new_loc_descr (DW_OP_nop, 0, 0);
8762         add_loc_descr (&ret, tmp);
8763         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8764         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
8765       }
8766       break;
8767
8768     default:
8769       /* Leave front-end specific codes as simply unknown.  This comes
8770          up, for instance, with the C STMT_EXPR.  */
8771       if ((unsigned int) TREE_CODE (loc)
8772           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
8773         return 0;
8774
8775       /* Otherwise this is a generic code; we should just lists all of
8776          these explicitly.  Aborting means we forgot one.  */
8777       abort ();
8778     }
8779
8780   /* Show if we can't fill the request for an address.  */
8781   if (addressp && indirect_p == 0)
8782     return 0;
8783
8784   /* If we've got an address and don't want one, dereference.  */
8785   if (!addressp && indirect_p > 0)
8786     {
8787       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
8788
8789       if (size > DWARF2_ADDR_SIZE || size == -1)
8790         return 0;
8791       else if (size == DWARF2_ADDR_SIZE)
8792         op = DW_OP_deref;
8793       else
8794         op = DW_OP_deref_size;
8795
8796       add_loc_descr (&ret, new_loc_descr (op, size, 0));
8797     }
8798
8799   return ret;
8800 }
8801
8802 /* Given a value, round it up to the lowest multiple of `boundary'
8803    which is not less than the value itself.  */
8804
8805 static inline HOST_WIDE_INT
8806 ceiling (HOST_WIDE_INT value, unsigned int boundary)
8807 {
8808   return (((value + boundary - 1) / boundary) * boundary);
8809 }
8810
8811 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
8812    pointer to the declared type for the relevant field variable, or return
8813    `integer_type_node' if the given node turns out to be an
8814    ERROR_MARK node.  */
8815
8816 static inline tree
8817 field_type (tree decl)
8818 {
8819   tree type;
8820
8821   if (TREE_CODE (decl) == ERROR_MARK)
8822     return integer_type_node;
8823
8824   type = DECL_BIT_FIELD_TYPE (decl);
8825   if (type == NULL_TREE)
8826     type = TREE_TYPE (decl);
8827
8828   return type;
8829 }
8830
8831 /* Given a pointer to a tree node, return the alignment in bits for
8832    it, or else return BITS_PER_WORD if the node actually turns out to
8833    be an ERROR_MARK node.  */
8834
8835 static inline unsigned
8836 simple_type_align_in_bits (tree type)
8837 {
8838   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
8839 }
8840
8841 static inline unsigned
8842 simple_decl_align_in_bits (tree decl)
8843 {
8844   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
8845 }
8846
8847 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
8848    lowest addressed byte of the "containing object" for the given FIELD_DECL,
8849    or return 0 if we are unable to determine what that offset is, either
8850    because the argument turns out to be a pointer to an ERROR_MARK node, or
8851    because the offset is actually variable.  (We can't handle the latter case
8852    just yet).  */
8853
8854 static HOST_WIDE_INT
8855 field_byte_offset (tree decl)
8856 {
8857   unsigned int type_align_in_bits;
8858   unsigned int decl_align_in_bits;
8859   unsigned HOST_WIDE_INT type_size_in_bits;
8860   HOST_WIDE_INT object_offset_in_bits;
8861   tree type;
8862   tree field_size_tree;
8863   HOST_WIDE_INT bitpos_int;
8864   HOST_WIDE_INT deepest_bitpos;
8865   unsigned HOST_WIDE_INT field_size_in_bits;
8866
8867   if (TREE_CODE (decl) == ERROR_MARK)
8868     return 0;
8869   else if (TREE_CODE (decl) != FIELD_DECL)
8870     abort ();
8871
8872   type = field_type (decl);
8873   field_size_tree = DECL_SIZE (decl);
8874
8875   /* The size could be unspecified if there was an error, or for
8876      a flexible array member.  */
8877   if (! field_size_tree)
8878     field_size_tree = bitsize_zero_node;
8879
8880   /* We cannot yet cope with fields whose positions are variable, so
8881      for now, when we see such things, we simply return 0.  Someday, we may
8882      be able to handle such cases, but it will be damn difficult.  */
8883   if (! host_integerp (bit_position (decl), 0))
8884     return 0;
8885
8886   bitpos_int = int_bit_position (decl);
8887
8888   /* If we don't know the size of the field, pretend it's a full word.  */
8889   if (host_integerp (field_size_tree, 1))
8890     field_size_in_bits = tree_low_cst (field_size_tree, 1);
8891   else
8892     field_size_in_bits = BITS_PER_WORD;
8893
8894   type_size_in_bits = simple_type_size_in_bits (type);
8895   type_align_in_bits = simple_type_align_in_bits (type);
8896   decl_align_in_bits = simple_decl_align_in_bits (decl);
8897
8898   /* The GCC front-end doesn't make any attempt to keep track of the starting
8899      bit offset (relative to the start of the containing structure type) of the
8900      hypothetical "containing object" for a bit-field.  Thus, when computing
8901      the byte offset value for the start of the "containing object" of a
8902      bit-field, we must deduce this information on our own. This can be rather
8903      tricky to do in some cases.  For example, handling the following structure
8904      type definition when compiling for an i386/i486 target (which only aligns
8905      long long's to 32-bit boundaries) can be very tricky:
8906
8907          struct S { int field1; long long field2:31; };
8908
8909      Fortunately, there is a simple rule-of-thumb which can be used in such
8910      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
8911      structure shown above.  It decides to do this based upon one simple rule
8912      for bit-field allocation.  GCC allocates each "containing object" for each
8913      bit-field at the first (i.e. lowest addressed) legitimate alignment
8914      boundary (based upon the required minimum alignment for the declared type
8915      of the field) which it can possibly use, subject to the condition that
8916      there is still enough available space remaining in the containing object
8917      (when allocated at the selected point) to fully accommodate all of the
8918      bits of the bit-field itself.
8919
8920      This simple rule makes it obvious why GCC allocates 8 bytes for each
8921      object of the structure type shown above.  When looking for a place to
8922      allocate the "containing object" for `field2', the compiler simply tries
8923      to allocate a 64-bit "containing object" at each successive 32-bit
8924      boundary (starting at zero) until it finds a place to allocate that 64-
8925      bit field such that at least 31 contiguous (and previously unallocated)
8926      bits remain within that selected 64 bit field.  (As it turns out, for the
8927      example above, the compiler finds it is OK to allocate the "containing
8928      object" 64-bit field at bit-offset zero within the structure type.)
8929
8930      Here we attempt to work backwards from the limited set of facts we're
8931      given, and we try to deduce from those facts, where GCC must have believed
8932      that the containing object started (within the structure type). The value
8933      we deduce is then used (by the callers of this routine) to generate
8934      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
8935      and, in the case of DW_AT_location, regular fields as well).  */
8936
8937   /* Figure out the bit-distance from the start of the structure to the
8938      "deepest" bit of the bit-field.  */
8939   deepest_bitpos = bitpos_int + field_size_in_bits;
8940
8941   /* This is the tricky part.  Use some fancy footwork to deduce where the
8942      lowest addressed bit of the containing object must be.  */
8943   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
8944
8945   /* Round up to type_align by default.  This works best for bitfields.  */
8946   object_offset_in_bits += type_align_in_bits - 1;
8947   object_offset_in_bits /= type_align_in_bits;
8948   object_offset_in_bits *= type_align_in_bits;
8949
8950   if (object_offset_in_bits > bitpos_int)
8951     {
8952       /* Sigh, the decl must be packed.  */
8953       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
8954
8955       /* Round up to decl_align instead.  */
8956       object_offset_in_bits += decl_align_in_bits - 1;
8957       object_offset_in_bits /= decl_align_in_bits;
8958       object_offset_in_bits *= decl_align_in_bits;
8959     }
8960
8961   return object_offset_in_bits / BITS_PER_UNIT;
8962 }
8963 \f
8964 /* The following routines define various Dwarf attributes and any data
8965    associated with them.  */
8966
8967 /* Add a location description attribute value to a DIE.
8968
8969    This emits location attributes suitable for whole variables and
8970    whole parameters.  Note that the location attributes for struct fields are
8971    generated by the routine `data_member_location_attribute' below.  */
8972
8973 static inline void
8974 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
8975                              dw_loc_descr_ref descr)
8976 {
8977   if (descr != 0)
8978     add_AT_loc (die, attr_kind, descr);
8979 }
8980
8981 /* Attach the specialized form of location attribute used for data members of
8982    struct and union types.  In the special case of a FIELD_DECL node which
8983    represents a bit-field, the "offset" part of this special location
8984    descriptor must indicate the distance in bytes from the lowest-addressed
8985    byte of the containing struct or union type to the lowest-addressed byte of
8986    the "containing object" for the bit-field.  (See the `field_byte_offset'
8987    function above).
8988
8989    For any given bit-field, the "containing object" is a hypothetical object
8990    (of some integral or enum type) within which the given bit-field lives.  The
8991    type of this hypothetical "containing object" is always the same as the
8992    declared type of the individual bit-field itself (for GCC anyway... the
8993    DWARF spec doesn't actually mandate this).  Note that it is the size (in
8994    bytes) of the hypothetical "containing object" which will be given in the
8995    DW_AT_byte_size attribute for this bit-field.  (See the
8996    `byte_size_attribute' function below.)  It is also used when calculating the
8997    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
8998    function below.)  */
8999
9000 static void
9001 add_data_member_location_attribute (dw_die_ref die, tree decl)
9002 {
9003   long offset;
9004   dw_loc_descr_ref loc_descr = 0;
9005
9006   if (TREE_CODE (decl) == TREE_VEC)
9007     {
9008       /* We're working on the TAG_inheritance for a base class.  */
9009       if (TREE_VIA_VIRTUAL (decl) && is_cxx ())
9010         {
9011           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9012              aren't at a fixed offset from all (sub)objects of the same
9013              type.  We need to extract the appropriate offset from our
9014              vtable.  The following dwarf expression means
9015
9016                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9017
9018              This is specific to the V3 ABI, of course.  */
9019
9020           dw_loc_descr_ref tmp;
9021
9022           /* Make a copy of the object address.  */
9023           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9024           add_loc_descr (&loc_descr, tmp);
9025
9026           /* Extract the vtable address.  */
9027           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9028           add_loc_descr (&loc_descr, tmp);
9029
9030           /* Calculate the address of the offset.  */
9031           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9032           if (offset >= 0)
9033             abort ();
9034
9035           tmp = int_loc_descriptor (-offset);
9036           add_loc_descr (&loc_descr, tmp);
9037           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9038           add_loc_descr (&loc_descr, tmp);
9039
9040           /* Extract the offset.  */
9041           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9042           add_loc_descr (&loc_descr, tmp);
9043
9044           /* Add it to the object address.  */
9045           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9046           add_loc_descr (&loc_descr, tmp);
9047         }
9048       else
9049         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9050     }
9051   else
9052     offset = field_byte_offset (decl);
9053
9054   if (! loc_descr)
9055     {
9056       enum dwarf_location_atom op;
9057
9058       /* The DWARF2 standard says that we should assume that the structure
9059          address is already on the stack, so we can specify a structure field
9060          address by using DW_OP_plus_uconst.  */
9061
9062 #ifdef MIPS_DEBUGGING_INFO
9063       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9064          operator correctly.  It works only if we leave the offset on the
9065          stack.  */
9066       op = DW_OP_constu;
9067 #else
9068       op = DW_OP_plus_uconst;
9069 #endif
9070
9071       loc_descr = new_loc_descr (op, offset, 0);
9072     }
9073
9074   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9075 }
9076
9077 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9078    does not have a "location" either in memory or in a register.  These
9079    things can arise in GNU C when a constant is passed as an actual parameter
9080    to an inlined function.  They can also arise in C++ where declared
9081    constants do not necessarily get memory "homes".  */
9082
9083 static void
9084 add_const_value_attribute (dw_die_ref die, rtx rtl)
9085 {
9086   switch (GET_CODE (rtl))
9087     {
9088     case CONST_INT:
9089       /* Note that a CONST_INT rtx could represent either an integer
9090          or a floating-point constant.  A CONST_INT is used whenever
9091          the constant will fit into a single word.  In all such
9092          cases, the original mode of the constant value is wiped
9093          out, and the CONST_INT rtx is assigned VOIDmode.  */
9094       {
9095         HOST_WIDE_INT val = INTVAL (rtl);
9096
9097         /* ??? We really should be using HOST_WIDE_INT throughout.  */
9098         if (val < 0 && (long) val == val)
9099           add_AT_int (die, DW_AT_const_value, (long) val);
9100         else if ((unsigned long) val == (unsigned HOST_WIDE_INT) val)
9101           add_AT_unsigned (die, DW_AT_const_value, (unsigned long) val);
9102         else
9103           {
9104 #if HOST_BITS_PER_LONG * 2 == HOST_BITS_PER_WIDE_INT
9105             add_AT_long_long (die, DW_AT_const_value,
9106                               val >> HOST_BITS_PER_LONG, val);
9107 #else
9108             abort ();
9109 #endif
9110           }
9111       }
9112       break;
9113
9114     case CONST_DOUBLE:
9115       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9116          floating-point constant.  A CONST_DOUBLE is used whenever the
9117          constant requires more than one word in order to be adequately
9118          represented.  We output CONST_DOUBLEs as blocks.  */
9119       {
9120         enum machine_mode mode = GET_MODE (rtl);
9121
9122         if (GET_MODE_CLASS (mode) == MODE_FLOAT)
9123           {
9124             unsigned length = GET_MODE_SIZE (mode) / 4;
9125             long *array = ggc_alloc (sizeof (long) * length);
9126             REAL_VALUE_TYPE rv;
9127
9128             REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9129             real_to_target (array, &rv, mode);
9130
9131             add_AT_float (die, DW_AT_const_value, length, array);
9132           }
9133         else
9134           {
9135             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9136             if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT)
9137               abort ();
9138
9139             add_AT_long_long (die, DW_AT_const_value,
9140                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9141           }
9142       }
9143       break;
9144
9145     case CONST_STRING:
9146       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9147       break;
9148
9149     case SYMBOL_REF:
9150     case LABEL_REF:
9151     case CONST:
9152       add_AT_addr (die, DW_AT_const_value, rtl);
9153       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
9154       break;
9155
9156     case PLUS:
9157       /* In cases where an inlined instance of an inline function is passed
9158          the address of an `auto' variable (which is local to the caller) we
9159          can get a situation where the DECL_RTL of the artificial local
9160          variable (for the inlining) which acts as a stand-in for the
9161          corresponding formal parameter (of the inline function) will look
9162          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9163          exactly a compile-time constant expression, but it isn't the address
9164          of the (artificial) local variable either.  Rather, it represents the
9165          *value* which the artificial local variable always has during its
9166          lifetime.  We currently have no way to represent such quasi-constant
9167          values in Dwarf, so for now we just punt and generate nothing.  */
9168       break;
9169
9170     default:
9171       /* No other kinds of rtx should be possible here.  */
9172       abort ();
9173     }
9174
9175 }
9176
9177 static rtx
9178 rtl_for_decl_location (tree decl)
9179 {
9180   rtx rtl;
9181
9182   /* Here we have to decide where we are going to say the parameter "lives"
9183      (as far as the debugger is concerned).  We only have a couple of
9184      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9185
9186      DECL_RTL normally indicates where the parameter lives during most of the
9187      activation of the function.  If optimization is enabled however, this
9188      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9189      that the parameter doesn't really live anywhere (as far as the code
9190      generation parts of GCC are concerned) during most of the function's
9191      activation.  That will happen (for example) if the parameter is never
9192      referenced within the function.
9193
9194      We could just generate a location descriptor here for all non-NULL
9195      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9196      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9197      where DECL_RTL is NULL or is a pseudo-reg.
9198
9199      Note however that we can only get away with using DECL_INCOMING_RTL as
9200      a backup substitute for DECL_RTL in certain limited cases.  In cases
9201      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9202      we can be sure that the parameter was passed using the same type as it is
9203      declared to have within the function, and that its DECL_INCOMING_RTL
9204      points us to a place where a value of that type is passed.
9205
9206      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9207      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9208      because in these cases DECL_INCOMING_RTL points us to a value of some
9209      type which is *different* from the type of the parameter itself.  Thus,
9210      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9211      such cases, the debugger would end up (for example) trying to fetch a
9212      `float' from a place which actually contains the first part of a
9213      `double'.  That would lead to really incorrect and confusing
9214      output at debug-time.
9215
9216      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9217      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9218      are a couple of exceptions however.  On little-endian machines we can
9219      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9220      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9221      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9222      when (on a little-endian machine) a non-prototyped function has a
9223      parameter declared to be of type `short' or `char'.  In such cases,
9224      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9225      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9226      passed `int' value.  If the debugger then uses that address to fetch
9227      a `short' or a `char' (on a little-endian machine) the result will be
9228      the correct data, so we allow for such exceptional cases below.
9229
9230      Note that our goal here is to describe the place where the given formal
9231      parameter lives during most of the function's activation (i.e. between the
9232      end of the prologue and the start of the epilogue).  We'll do that as best
9233      as we can. Note however that if the given formal parameter is modified
9234      sometime during the execution of the function, then a stack backtrace (at
9235      debug-time) will show the function as having been called with the *new*
9236      value rather than the value which was originally passed in.  This happens
9237      rarely enough that it is not a major problem, but it *is* a problem, and
9238      I'd like to fix it.
9239
9240      A future version of dwarf2out.c may generate two additional attributes for
9241      any given DW_TAG_formal_parameter DIE which will describe the "passed
9242      type" and the "passed location" for the given formal parameter in addition
9243      to the attributes we now generate to indicate the "declared type" and the
9244      "active location" for each parameter.  This additional set of attributes
9245      could be used by debuggers for stack backtraces. Separately, note that
9246      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9247      This happens (for example) for inlined-instances of inline function formal
9248      parameters which are never referenced.  This really shouldn't be
9249      happening.  All PARM_DECL nodes should get valid non-NULL
9250      DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these
9251      values for inlined instances of inline function parameters, so when we see
9252      such cases, we are just out-of-luck for the time being (until integrate.c
9253      gets fixed).  */
9254
9255   /* Use DECL_RTL as the "location" unless we find something better.  */
9256   rtl = DECL_RTL_IF_SET (decl);
9257
9258   /* When generating abstract instances, ignore everything except
9259      constants, symbols living in memory, and symbols living in
9260      fixed registers.  */
9261   if (! reload_completed)
9262     {
9263       if (rtl
9264           && (CONSTANT_P (rtl)
9265               || (GET_CODE (rtl) == MEM
9266                   && CONSTANT_P (XEXP (rtl, 0)))
9267               || (GET_CODE (rtl) == REG
9268                   && TREE_CODE (decl) == VAR_DECL
9269                   && TREE_STATIC (decl))))
9270         {
9271           rtl = (*targetm.delegitimize_address) (rtl);
9272           return rtl;
9273         }
9274       rtl = NULL_RTX;
9275     }
9276   else if (TREE_CODE (decl) == PARM_DECL)
9277     {
9278       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
9279         {
9280           tree declared_type = type_main_variant (TREE_TYPE (decl));
9281           tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
9282
9283           /* This decl represents a formal parameter which was optimized out.
9284              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9285              all cases where (rtl == NULL_RTX) just below.  */
9286           if (declared_type == passed_type)
9287             rtl = DECL_INCOMING_RTL (decl);
9288           else if (! BYTES_BIG_ENDIAN
9289                    && TREE_CODE (declared_type) == INTEGER_TYPE
9290                    && (GET_MODE_SIZE (TYPE_MODE (declared_type))
9291                        <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
9292             rtl = DECL_INCOMING_RTL (decl);
9293         }
9294
9295       /* If the parm was passed in registers, but lives on the stack, then
9296          make a big endian correction if the mode of the type of the
9297          parameter is not the same as the mode of the rtl.  */
9298       /* ??? This is the same series of checks that are made in dbxout.c before
9299          we reach the big endian correction code there.  It isn't clear if all
9300          of these checks are necessary here, but keeping them all is the safe
9301          thing to do.  */
9302       else if (GET_CODE (rtl) == MEM
9303                && XEXP (rtl, 0) != const0_rtx
9304                && ! CONSTANT_P (XEXP (rtl, 0))
9305                /* Not passed in memory.  */
9306                && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
9307                /* Not passed by invisible reference.  */
9308                && (GET_CODE (XEXP (rtl, 0)) != REG
9309                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
9310                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
9311 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9312                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
9313 #endif
9314                      )
9315                /* Big endian correction check.  */
9316                && BYTES_BIG_ENDIAN
9317                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
9318                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
9319                    < UNITS_PER_WORD))
9320         {
9321           int offset = (UNITS_PER_WORD
9322                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
9323
9324           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
9325                              plus_constant (XEXP (rtl, 0), offset));
9326         }
9327     }
9328
9329   if (rtl != NULL_RTX)
9330     {
9331       rtl = eliminate_regs (rtl, 0, NULL_RTX);
9332 #ifdef LEAF_REG_REMAP
9333       if (current_function_uses_only_leaf_regs)
9334         leaf_renumber_regs_insn (rtl);
9335 #endif
9336     }
9337
9338   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9339      and will have been substituted directly into all expressions that use it.
9340      C does not have such a concept, but C++ and other languages do.  */
9341   else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
9342     {
9343       /* If a variable is initialized with a string constant without embedded
9344          zeros, build CONST_STRING.  */
9345       if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
9346           && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
9347         {
9348           tree arrtype = TREE_TYPE (decl);
9349           tree enttype = TREE_TYPE (arrtype);
9350           tree domain = TYPE_DOMAIN (arrtype);
9351           tree init = DECL_INITIAL (decl);
9352           enum machine_mode mode = TYPE_MODE (enttype);
9353
9354           if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9355               && domain
9356               && integer_zerop (TYPE_MIN_VALUE (domain))
9357               && compare_tree_int (TYPE_MAX_VALUE (domain),
9358                                    TREE_STRING_LENGTH (init) - 1) == 0
9359               && ((size_t) TREE_STRING_LENGTH (init)
9360                   == strlen (TREE_STRING_POINTER (init)) + 1))
9361             rtl = gen_rtx_CONST_STRING (VOIDmode, TREE_STRING_POINTER (init));
9362         }
9363       /* If the initializer is something that we know will expand into an
9364          immediate RTL constant, expand it now.  Expanding anything else
9365          tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9366       else if (TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST
9367                || TREE_CODE (DECL_INITIAL (decl)) == REAL_CST)
9368         {
9369           rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
9370                              EXPAND_INITIALIZER);
9371           /* If expand_expr returns a MEM, it wasn't immediate.  */
9372           if (rtl && GET_CODE (rtl) == MEM)
9373             abort ();
9374         }
9375     }
9376
9377   if (rtl)
9378     rtl = (*targetm.delegitimize_address) (rtl);
9379
9380   /* If we don't look past the constant pool, we risk emitting a
9381      reference to a constant pool entry that isn't referenced from
9382      code, and thus is not emitted.  */
9383   if (rtl)
9384     rtl = avoid_constant_pool_reference (rtl);
9385
9386   return rtl;
9387 }
9388
9389 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
9390    data attribute for a variable or a parameter.  We generate the
9391    DW_AT_const_value attribute only in those cases where the given variable
9392    or parameter does not have a true "location" either in memory or in a
9393    register.  This can happen (for example) when a constant is passed as an
9394    actual argument in a call to an inline function.  (It's possible that
9395    these things can crop up in other ways also.)  Note that one type of
9396    constant value which can be passed into an inlined function is a constant
9397    pointer.  This can happen for example if an actual argument in an inlined
9398    function call evaluates to a compile-time constant address.  */
9399
9400 static void
9401 add_location_or_const_value_attribute (dw_die_ref die, tree decl)
9402 {
9403   rtx rtl;
9404   dw_loc_descr_ref descr;
9405
9406   if (TREE_CODE (decl) == ERROR_MARK)
9407     return;
9408   else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
9409     abort ();
9410
9411   rtl = rtl_for_decl_location (decl);
9412   if (rtl == NULL_RTX)
9413     return;
9414
9415   switch (GET_CODE (rtl))
9416     {
9417     case ADDRESSOF:
9418       /* The address of a variable that was optimized away;
9419          don't emit anything.  */
9420       break;
9421
9422     case CONST_INT:
9423     case CONST_DOUBLE:
9424     case CONST_STRING:
9425     case SYMBOL_REF:
9426     case LABEL_REF:
9427     case CONST:
9428     case PLUS:
9429       /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
9430       add_const_value_attribute (die, rtl);
9431       break;
9432
9433     case MEM:
9434       if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
9435         {
9436           /* Need loc_descriptor_from_tree since that's where we know
9437              how to handle TLS variables.  Want the object's address
9438              since the top-level DW_AT_location assumes such.  See
9439              the confusion in loc_descriptor for reference.  */
9440           descr = loc_descriptor_from_tree (decl, 1);
9441         }
9442       else
9443         {
9444         case REG:
9445         case SUBREG:
9446         case CONCAT:
9447           descr = loc_descriptor (rtl);
9448         }
9449       add_AT_location_description (die, DW_AT_location, descr);
9450       break;
9451
9452     default:
9453       abort ();
9454     }
9455 }
9456
9457 /* If we don't have a copy of this variable in memory for some reason (such
9458    as a C++ member constant that doesn't have an out-of-line definition),
9459    we should tell the debugger about the constant value.  */
9460
9461 static void
9462 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
9463 {
9464   tree init = DECL_INITIAL (decl);
9465   tree type = TREE_TYPE (decl);
9466
9467   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init
9468       && initializer_constant_valid_p (init, type) == null_pointer_node)
9469     /* OK */;
9470   else
9471     return;
9472
9473   switch (TREE_CODE (type))
9474     {
9475     case INTEGER_TYPE:
9476       if (host_integerp (init, 0))
9477         add_AT_unsigned (var_die, DW_AT_const_value,
9478                          tree_low_cst (init, 0));
9479       else
9480         add_AT_long_long (var_die, DW_AT_const_value,
9481                           TREE_INT_CST_HIGH (init),
9482                           TREE_INT_CST_LOW (init));
9483       break;
9484
9485     default:;
9486     }
9487 }
9488
9489 /* Generate a DW_AT_name attribute given some string value to be included as
9490    the value of the attribute.  */
9491
9492 static void
9493 add_name_attribute (dw_die_ref die, const char *name_string)
9494 {
9495   if (name_string != NULL && *name_string != 0)
9496     {
9497       if (demangle_name_func)
9498         name_string = (*demangle_name_func) (name_string);
9499
9500       add_AT_string (die, DW_AT_name, name_string);
9501     }
9502 }
9503
9504 /* Generate a DW_AT_comp_dir attribute for DIE.  */
9505
9506 static void
9507 add_comp_dir_attribute (dw_die_ref die)
9508 {
9509   const char *wd = get_src_pwd ();
9510   if (wd != NULL)
9511     add_AT_string (die, DW_AT_comp_dir, wd);
9512 }
9513
9514 /* Given a tree node describing an array bound (either lower or upper) output
9515    a representation for that bound.  */
9516
9517 static void
9518 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
9519 {
9520   switch (TREE_CODE (bound))
9521     {
9522     case ERROR_MARK:
9523       return;
9524
9525     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
9526     case INTEGER_CST:
9527       if (! host_integerp (bound, 0)
9528           || (bound_attr == DW_AT_lower_bound
9529               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
9530                   || (is_fortran () && integer_onep (bound)))))
9531         /* use the default */
9532         ;
9533       else
9534         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
9535       break;
9536
9537     case CONVERT_EXPR:
9538     case NOP_EXPR:
9539     case NON_LVALUE_EXPR:
9540     case VIEW_CONVERT_EXPR:
9541       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
9542       break;
9543
9544     case SAVE_EXPR:
9545       /* If optimization is turned on, the SAVE_EXPRs that describe how to
9546          access the upper bound values may be bogus.  If they refer to a
9547          register, they may only describe how to get at these values at the
9548          points in the generated code right after they have just been
9549          computed.  Worse yet, in the typical case, the upper bound values
9550          will not even *be* computed in the optimized code (though the
9551          number of elements will), so these SAVE_EXPRs are entirely
9552          bogus. In order to compensate for this fact, we check here to see
9553          if optimization is enabled, and if so, we don't add an attribute
9554          for the (unknown and unknowable) upper bound.  This should not
9555          cause too much trouble for existing (stupid?)  debuggers because
9556          they have to deal with empty upper bounds location descriptions
9557          anyway in order to be able to deal with incomplete array types.
9558          Of course an intelligent debugger (GDB?)  should be able to
9559          comprehend that a missing upper bound specification in an array
9560          type used for a storage class `auto' local array variable
9561          indicates that the upper bound is both unknown (at compile- time)
9562          and unknowable (at run-time) due to optimization.
9563
9564          We assume that a MEM rtx is safe because gcc wouldn't put the
9565          value there unless it was going to be used repeatedly in the
9566          function, i.e. for cleanups.  */
9567       if (SAVE_EXPR_RTL (bound)
9568           && (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM))
9569         {
9570           dw_die_ref ctx = lookup_decl_die (current_function_decl);
9571           dw_die_ref decl_die = new_die (DW_TAG_variable, ctx, bound);
9572           rtx loc = SAVE_EXPR_RTL (bound);
9573
9574           /* If the RTL for the SAVE_EXPR is memory, handle the case where
9575              it references an outer function's frame.  */
9576           if (GET_CODE (loc) == MEM)
9577             {
9578               rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
9579
9580               if (XEXP (loc, 0) != new_addr)
9581                 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
9582             }
9583
9584           add_AT_flag (decl_die, DW_AT_artificial, 1);
9585           add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9586           add_AT_location_description (decl_die, DW_AT_location,
9587                                        loc_descriptor (loc));
9588           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9589         }
9590
9591       /* Else leave out the attribute.  */
9592       break;
9593
9594     case VAR_DECL:
9595     case PARM_DECL:
9596       {
9597         dw_die_ref decl_die = lookup_decl_die (bound);
9598
9599         /* ??? Can this happen, or should the variable have been bound
9600            first?  Probably it can, since I imagine that we try to create
9601            the types of parameters in the order in which they exist in
9602            the list, and won't have created a forward reference to a
9603            later parameter.  */
9604         if (decl_die != NULL)
9605           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9606         break;
9607       }
9608
9609     default:
9610       {
9611         /* Otherwise try to create a stack operation procedure to
9612            evaluate the value of the array bound.  */
9613
9614         dw_die_ref ctx, decl_die;
9615         dw_loc_descr_ref loc;
9616
9617         loc = loc_descriptor_from_tree (bound, 0);
9618         if (loc == NULL)
9619           break;
9620
9621         if (current_function_decl == 0)
9622           ctx = comp_unit_die;
9623         else
9624           ctx = lookup_decl_die (current_function_decl);
9625
9626         /* If we weren't able to find a context, it's most likely the case
9627            that we are processing the return type of the function.  So
9628            make a SAVE_EXPR to point to it and have the limbo DIE code
9629            find the proper die.  The save_expr function doesn't always
9630            make a SAVE_EXPR, so do it ourselves.  */
9631         if (ctx == 0)
9632           bound = build (SAVE_EXPR, TREE_TYPE (bound), bound,
9633                          current_function_decl, NULL_TREE);
9634
9635         decl_die = new_die (DW_TAG_variable, ctx, bound);
9636         add_AT_flag (decl_die, DW_AT_artificial, 1);
9637         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9638         add_AT_loc (decl_die, DW_AT_location, loc);
9639
9640         add_AT_die_ref (subrange_die, bound_attr, decl_die);
9641         break;
9642       }
9643     }
9644 }
9645
9646 /* Note that the block of subscript information for an array type also
9647    includes information about the element type of type given array type.  */
9648
9649 static void
9650 add_subscript_info (dw_die_ref type_die, tree type)
9651 {
9652 #ifndef MIPS_DEBUGGING_INFO
9653   unsigned dimension_number;
9654 #endif
9655   tree lower, upper;
9656   dw_die_ref subrange_die;
9657
9658   /* The GNU compilers represent multidimensional array types as sequences of
9659      one dimensional array types whose element types are themselves array
9660      types.  Here we squish that down, so that each multidimensional array
9661      type gets only one array_type DIE in the Dwarf debugging info. The draft
9662      Dwarf specification say that we are allowed to do this kind of
9663      compression in C (because there is no difference between an array or
9664      arrays and a multidimensional array in C) but for other source languages
9665      (e.g. Ada) we probably shouldn't do this.  */
9666
9667   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
9668      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
9669      We work around this by disabling this feature.  See also
9670      gen_array_type_die.  */
9671 #ifndef MIPS_DEBUGGING_INFO
9672   for (dimension_number = 0;
9673        TREE_CODE (type) == ARRAY_TYPE;
9674        type = TREE_TYPE (type), dimension_number++)
9675 #endif
9676     {
9677       tree domain = TYPE_DOMAIN (type);
9678
9679       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
9680          and (in GNU C only) variable bounds.  Handle all three forms
9681          here.  */
9682       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
9683       if (domain)
9684         {
9685           /* We have an array type with specified bounds.  */
9686           lower = TYPE_MIN_VALUE (domain);
9687           upper = TYPE_MAX_VALUE (domain);
9688
9689           /* Define the index type.  */
9690           if (TREE_TYPE (domain))
9691             {
9692               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
9693                  TREE_TYPE field.  We can't emit debug info for this
9694                  because it is an unnamed integral type.  */
9695               if (TREE_CODE (domain) == INTEGER_TYPE
9696                   && TYPE_NAME (domain) == NULL_TREE
9697                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
9698                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
9699                 ;
9700               else
9701                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
9702                                     type_die);
9703             }
9704
9705           /* ??? If upper is NULL, the array has unspecified length,
9706              but it does have a lower bound.  This happens with Fortran
9707                dimension arr(N:*)
9708              Since the debugger is definitely going to need to know N
9709              to produce useful results, go ahead and output the lower
9710              bound solo, and hope the debugger can cope.  */
9711
9712           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
9713           if (upper)
9714             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
9715         }
9716
9717       /* Otherwise we have an array type with an unspecified length.  The
9718          DWARF-2 spec does not say how to handle this; let's just leave out the
9719          bounds.  */
9720     }
9721 }
9722
9723 static void
9724 add_byte_size_attribute (dw_die_ref die, tree tree_node)
9725 {
9726   unsigned size;
9727
9728   switch (TREE_CODE (tree_node))
9729     {
9730     case ERROR_MARK:
9731       size = 0;
9732       break;
9733     case ENUMERAL_TYPE:
9734     case RECORD_TYPE:
9735     case UNION_TYPE:
9736     case QUAL_UNION_TYPE:
9737       size = int_size_in_bytes (tree_node);
9738       break;
9739     case FIELD_DECL:
9740       /* For a data member of a struct or union, the DW_AT_byte_size is
9741          generally given as the number of bytes normally allocated for an
9742          object of the *declared* type of the member itself.  This is true
9743          even for bit-fields.  */
9744       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
9745       break;
9746     default:
9747       abort ();
9748     }
9749
9750   /* Note that `size' might be -1 when we get to this point.  If it is, that
9751      indicates that the byte size of the entity in question is variable.  We
9752      have no good way of expressing this fact in Dwarf at the present time,
9753      so just let the -1 pass on through.  */
9754   add_AT_unsigned (die, DW_AT_byte_size, size);
9755 }
9756
9757 /* For a FIELD_DECL node which represents a bit-field, output an attribute
9758    which specifies the distance in bits from the highest order bit of the
9759    "containing object" for the bit-field to the highest order bit of the
9760    bit-field itself.
9761
9762    For any given bit-field, the "containing object" is a hypothetical object
9763    (of some integral or enum type) within which the given bit-field lives.  The
9764    type of this hypothetical "containing object" is always the same as the
9765    declared type of the individual bit-field itself.  The determination of the
9766    exact location of the "containing object" for a bit-field is rather
9767    complicated.  It's handled by the `field_byte_offset' function (above).
9768
9769    Note that it is the size (in bytes) of the hypothetical "containing object"
9770    which will be given in the DW_AT_byte_size attribute for this bit-field.
9771    (See `byte_size_attribute' above).  */
9772
9773 static inline void
9774 add_bit_offset_attribute (dw_die_ref die, tree decl)
9775 {
9776   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
9777   tree type = DECL_BIT_FIELD_TYPE (decl);
9778   HOST_WIDE_INT bitpos_int;
9779   HOST_WIDE_INT highest_order_object_bit_offset;
9780   HOST_WIDE_INT highest_order_field_bit_offset;
9781   HOST_WIDE_INT unsigned bit_offset;
9782
9783   /* Must be a field and a bit field.  */
9784   if (!type
9785       || TREE_CODE (decl) != FIELD_DECL)
9786     abort ();
9787
9788   /* We can't yet handle bit-fields whose offsets are variable, so if we
9789      encounter such things, just return without generating any attribute
9790      whatsoever.  Likewise for variable or too large size.  */
9791   if (! host_integerp (bit_position (decl), 0)
9792       || ! host_integerp (DECL_SIZE (decl), 1))
9793     return;
9794
9795   bitpos_int = int_bit_position (decl);
9796
9797   /* Note that the bit offset is always the distance (in bits) from the
9798      highest-order bit of the "containing object" to the highest-order bit of
9799      the bit-field itself.  Since the "high-order end" of any object or field
9800      is different on big-endian and little-endian machines, the computation
9801      below must take account of these differences.  */
9802   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
9803   highest_order_field_bit_offset = bitpos_int;
9804
9805   if (! BYTES_BIG_ENDIAN)
9806     {
9807       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
9808       highest_order_object_bit_offset += simple_type_size_in_bits (type);
9809     }
9810
9811   bit_offset
9812     = (! BYTES_BIG_ENDIAN
9813        ? highest_order_object_bit_offset - highest_order_field_bit_offset
9814        : highest_order_field_bit_offset - highest_order_object_bit_offset);
9815
9816   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
9817 }
9818
9819 /* For a FIELD_DECL node which represents a bit field, output an attribute
9820    which specifies the length in bits of the given field.  */
9821
9822 static inline void
9823 add_bit_size_attribute (dw_die_ref die, tree decl)
9824 {
9825   /* Must be a field and a bit field.  */
9826   if (TREE_CODE (decl) != FIELD_DECL
9827       || ! DECL_BIT_FIELD_TYPE (decl))
9828     abort ();
9829
9830   if (host_integerp (DECL_SIZE (decl), 1))
9831     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
9832 }
9833
9834 /* If the compiled language is ANSI C, then add a 'prototyped'
9835    attribute, if arg types are given for the parameters of a function.  */
9836
9837 static inline void
9838 add_prototyped_attribute (dw_die_ref die, tree func_type)
9839 {
9840   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
9841       && TYPE_ARG_TYPES (func_type) != NULL)
9842     add_AT_flag (die, DW_AT_prototyped, 1);
9843 }
9844
9845 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
9846    by looking in either the type declaration or object declaration
9847    equate table.  */
9848
9849 static inline void
9850 add_abstract_origin_attribute (dw_die_ref die, tree origin)
9851 {
9852   dw_die_ref origin_die = NULL;
9853
9854   if (TREE_CODE (origin) != FUNCTION_DECL)
9855     {
9856       /* We may have gotten separated from the block for the inlined
9857          function, if we're in an exception handler or some such; make
9858          sure that the abstract function has been written out.
9859
9860          Doing this for nested functions is wrong, however; functions are
9861          distinct units, and our context might not even be inline.  */
9862       tree fn = origin;
9863
9864       if (TYPE_P (fn))
9865         fn = TYPE_STUB_DECL (fn);
9866
9867       fn = decl_function_context (fn);
9868       if (fn)
9869         dwarf2out_abstract_function (fn);
9870     }
9871
9872   if (DECL_P (origin))
9873     origin_die = lookup_decl_die (origin);
9874   else if (TYPE_P (origin))
9875     origin_die = lookup_type_die (origin);
9876
9877   if (origin_die == NULL)
9878     abort ();
9879
9880   add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
9881 }
9882
9883 /* We do not currently support the pure_virtual attribute.  */
9884
9885 static inline void
9886 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
9887 {
9888   if (DECL_VINDEX (func_decl))
9889     {
9890       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
9891
9892       if (host_integerp (DECL_VINDEX (func_decl), 0))
9893         add_AT_loc (die, DW_AT_vtable_elem_location,
9894                     new_loc_descr (DW_OP_constu,
9895                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
9896                                    0));
9897
9898       /* GNU extension: Record what type this method came from originally.  */
9899       if (debug_info_level > DINFO_LEVEL_TERSE)
9900         add_AT_die_ref (die, DW_AT_containing_type,
9901                         lookup_type_die (DECL_CONTEXT (func_decl)));
9902     }
9903 }
9904 \f
9905 /* Add source coordinate attributes for the given decl.  */
9906
9907 static void
9908 add_src_coords_attributes (dw_die_ref die, tree decl)
9909 {
9910   unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
9911
9912   add_AT_unsigned (die, DW_AT_decl_file, file_index);
9913   add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
9914 }
9915
9916 /* Add a DW_AT_name attribute and source coordinate attribute for the
9917    given decl, but only if it actually has a name.  */
9918
9919 static void
9920 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
9921 {
9922   tree decl_name;
9923
9924   decl_name = DECL_NAME (decl);
9925   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
9926     {
9927       add_name_attribute (die, dwarf2_name (decl, 0));
9928       if (! DECL_ARTIFICIAL (decl))
9929         add_src_coords_attributes (die, decl);
9930
9931       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
9932           && TREE_PUBLIC (decl)
9933           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
9934           && !DECL_ABSTRACT (decl))
9935         add_AT_string (die, DW_AT_MIPS_linkage_name,
9936                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
9937     }
9938
9939 #ifdef VMS_DEBUGGING_INFO
9940   /* Get the function's name, as described by its RTL.  This may be different
9941      from the DECL_NAME name used in the source file.  */
9942   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
9943     {
9944       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
9945                    XEXP (DECL_RTL (decl), 0));
9946       VARRAY_PUSH_RTX (used_rtx_varray, XEXP (DECL_RTL (decl), 0));
9947     }
9948 #endif
9949 }
9950
9951 /* Push a new declaration scope.  */
9952
9953 static void
9954 push_decl_scope (tree scope)
9955 {
9956   VARRAY_PUSH_TREE (decl_scope_table, scope);
9957 }
9958
9959 /* Pop a declaration scope.  */
9960
9961 static inline void
9962 pop_decl_scope (void)
9963 {
9964   if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0)
9965     abort ();
9966
9967   VARRAY_POP (decl_scope_table);
9968 }
9969
9970 /* Return the DIE for the scope that immediately contains this type.
9971    Non-named types get global scope.  Named types nested in other
9972    types get their containing scope if it's open, or global scope
9973    otherwise.  All other types (i.e. function-local named types) get
9974    the current active scope.  */
9975
9976 static dw_die_ref
9977 scope_die_for (tree t, dw_die_ref context_die)
9978 {
9979   dw_die_ref scope_die = NULL;
9980   tree containing_scope;
9981   int i;
9982
9983   /* Non-types always go in the current scope.  */
9984   if (! TYPE_P (t))
9985     abort ();
9986
9987   containing_scope = TYPE_CONTEXT (t);
9988
9989   /* Ignore namespaces for the moment.  */
9990   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
9991     containing_scope = NULL_TREE;
9992
9993   /* Ignore function type "scopes" from the C frontend.  They mean that
9994      a tagged type is local to a parmlist of a function declarator, but
9995      that isn't useful to DWARF.  */
9996   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
9997     containing_scope = NULL_TREE;
9998
9999   if (containing_scope == NULL_TREE)
10000     scope_die = comp_unit_die;
10001   else if (TYPE_P (containing_scope))
10002     {
10003       /* For types, we can just look up the appropriate DIE.  But
10004          first we check to see if we're in the middle of emitting it
10005          so we know where the new DIE should go.  */
10006       for (i = VARRAY_ACTIVE_SIZE (decl_scope_table) - 1; i >= 0; --i)
10007         if (VARRAY_TREE (decl_scope_table, i) == containing_scope)
10008           break;
10009
10010       if (i < 0)
10011         {
10012           if (debug_info_level > DINFO_LEVEL_TERSE
10013               && !TREE_ASM_WRITTEN (containing_scope))
10014             abort ();
10015
10016           /* If none of the current dies are suitable, we get file scope.  */
10017           scope_die = comp_unit_die;
10018         }
10019       else
10020         scope_die = lookup_type_die (containing_scope);
10021     }
10022   else
10023     scope_die = context_die;
10024
10025   return scope_die;
10026 }
10027
10028 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10029
10030 static inline int
10031 local_scope_p (dw_die_ref context_die)
10032 {
10033   for (; context_die; context_die = context_die->die_parent)
10034     if (context_die->die_tag == DW_TAG_inlined_subroutine
10035         || context_die->die_tag == DW_TAG_subprogram)
10036       return 1;
10037
10038   return 0;
10039 }
10040
10041 /* Returns nonzero if CONTEXT_DIE is a class.  */
10042
10043 static inline int
10044 class_scope_p (dw_die_ref context_die)
10045 {
10046   return (context_die
10047           && (context_die->die_tag == DW_TAG_structure_type
10048               || context_die->die_tag == DW_TAG_union_type));
10049 }
10050
10051 /* Many forms of DIEs require a "type description" attribute.  This
10052    routine locates the proper "type descriptor" die for the type given
10053    by 'type', and adds a DW_AT_type attribute below the given die.  */
10054
10055 static void
10056 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10057                     int decl_volatile, dw_die_ref context_die)
10058 {
10059   enum tree_code code  = TREE_CODE (type);
10060   dw_die_ref type_die  = NULL;
10061
10062   /* ??? If this type is an unnamed subrange type of an integral or
10063      floating-point type, use the inner type.  This is because we have no
10064      support for unnamed types in base_type_die.  This can happen if this is
10065      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10066   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10067       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10068     type = TREE_TYPE (type), code = TREE_CODE (type);
10069
10070   if (code == ERROR_MARK
10071       /* Handle a special case.  For functions whose return type is void, we
10072          generate *no* type attribute.  (Note that no object may have type
10073          `void', so this only applies to function return types).  */
10074       || code == VOID_TYPE)
10075     return;
10076
10077   type_die = modified_type_die (type,
10078                                 decl_const || TYPE_READONLY (type),
10079                                 decl_volatile || TYPE_VOLATILE (type),
10080                                 context_die);
10081
10082   if (type_die != NULL)
10083     add_AT_die_ref (object_die, DW_AT_type, type_die);
10084 }
10085
10086 /* Given a tree pointer to a struct, class, union, or enum type node, return
10087    a pointer to the (string) tag name for the given type, or zero if the type
10088    was declared without a tag.  */
10089
10090 static const char *
10091 type_tag (tree type)
10092 {
10093   const char *name = 0;
10094
10095   if (TYPE_NAME (type) != 0)
10096     {
10097       tree t = 0;
10098
10099       /* Find the IDENTIFIER_NODE for the type name.  */
10100       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
10101         t = TYPE_NAME (type);
10102
10103       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10104          a TYPE_DECL node, regardless of whether or not a `typedef' was
10105          involved.  */
10106       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10107                && ! DECL_IGNORED_P (TYPE_NAME (type)))
10108         t = DECL_NAME (TYPE_NAME (type));
10109
10110       /* Now get the name as a string, or invent one.  */
10111       if (t != 0)
10112         name = IDENTIFIER_POINTER (t);
10113     }
10114
10115   return (name == 0 || *name == '\0') ? 0 : name;
10116 }
10117
10118 /* Return the type associated with a data member, make a special check
10119    for bit field types.  */
10120
10121 static inline tree
10122 member_declared_type (tree member)
10123 {
10124   return (DECL_BIT_FIELD_TYPE (member)
10125           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
10126 }
10127
10128 /* Get the decl's label, as described by its RTL. This may be different
10129    from the DECL_NAME name used in the source file.  */
10130
10131 #if 0
10132 static const char *
10133 decl_start_label (tree decl)
10134 {
10135   rtx x;
10136   const char *fnname;
10137
10138   x = DECL_RTL (decl);
10139   if (GET_CODE (x) != MEM)
10140     abort ();
10141
10142   x = XEXP (x, 0);
10143   if (GET_CODE (x) != SYMBOL_REF)
10144     abort ();
10145
10146   fnname = XSTR (x, 0);
10147   return fnname;
10148 }
10149 #endif
10150 \f
10151 /* These routines generate the internal representation of the DIE's for
10152    the compilation unit.  Debugging information is collected by walking
10153    the declaration trees passed in from dwarf2out_decl().  */
10154
10155 static void
10156 gen_array_type_die (tree type, dw_die_ref context_die)
10157 {
10158   dw_die_ref scope_die = scope_die_for (type, context_die);
10159   dw_die_ref array_die;
10160   tree element_type;
10161
10162   /* ??? The SGI dwarf reader fails for array of array of enum types unless
10163      the inner array type comes before the outer array type.  Thus we must
10164      call gen_type_die before we call new_die.  See below also.  */
10165 #ifdef MIPS_DEBUGGING_INFO
10166   gen_type_die (TREE_TYPE (type), context_die);
10167 #endif
10168
10169   array_die = new_die (DW_TAG_array_type, scope_die, type);
10170   add_name_attribute (array_die, type_tag (type));
10171   equate_type_number_to_die (type, array_die);
10172
10173   if (TREE_CODE (type) == VECTOR_TYPE)
10174     {
10175       /* The frontend feeds us a representation for the vector as a struct
10176          containing an array.  Pull out the array type.  */
10177       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
10178       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
10179     }
10180
10181 #if 0
10182   /* We default the array ordering.  SDB will probably do
10183      the right things even if DW_AT_ordering is not present.  It's not even
10184      an issue until we start to get into multidimensional arrays anyway.  If
10185      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10186      then we'll have to put the DW_AT_ordering attribute back in.  (But if
10187      and when we find out that we need to put these in, we will only do so
10188      for multidimensional arrays.  */
10189   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
10190 #endif
10191
10192 #ifdef MIPS_DEBUGGING_INFO
10193   /* The SGI compilers handle arrays of unknown bound by setting
10194      AT_declaration and not emitting any subrange DIEs.  */
10195   if (! TYPE_DOMAIN (type))
10196     add_AT_unsigned (array_die, DW_AT_declaration, 1);
10197   else
10198 #endif
10199     add_subscript_info (array_die, type);
10200
10201   /* Add representation of the type of the elements of this array type.  */
10202   element_type = TREE_TYPE (type);
10203
10204   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10205      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10206      We work around this by disabling this feature.  See also
10207      add_subscript_info.  */
10208 #ifndef MIPS_DEBUGGING_INFO
10209   while (TREE_CODE (element_type) == ARRAY_TYPE)
10210     element_type = TREE_TYPE (element_type);
10211
10212   gen_type_die (element_type, context_die);
10213 #endif
10214
10215   add_type_attribute (array_die, element_type, 0, 0, context_die);
10216 }
10217
10218 static void
10219 gen_set_type_die (tree type, dw_die_ref context_die)
10220 {
10221   dw_die_ref type_die
10222     = new_die (DW_TAG_set_type, scope_die_for (type, context_die), type);
10223
10224   equate_type_number_to_die (type, type_die);
10225   add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
10226 }
10227
10228 #if 0
10229 static void
10230 gen_entry_point_die (tree decl, dw_die_ref context_die)
10231 {
10232   tree origin = decl_ultimate_origin (decl);
10233   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
10234
10235   if (origin != NULL)
10236     add_abstract_origin_attribute (decl_die, origin);
10237   else
10238     {
10239       add_name_and_src_coords_attributes (decl_die, decl);
10240       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
10241                           0, 0, context_die);
10242     }
10243
10244   if (DECL_ABSTRACT (decl))
10245     equate_decl_number_to_die (decl, decl_die);
10246   else
10247     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
10248 }
10249 #endif
10250
10251 /* Walk through the list of incomplete types again, trying once more to
10252    emit full debugging info for them.  */
10253
10254 static void
10255 retry_incomplete_types (void)
10256 {
10257   int i;
10258
10259   for (i = VARRAY_ACTIVE_SIZE (incomplete_types) - 1; i >= 0; i--)
10260     gen_type_die (VARRAY_TREE (incomplete_types, i), comp_unit_die);
10261 }
10262
10263 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
10264
10265 static void
10266 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
10267 {
10268   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
10269
10270   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10271      be incomplete and such types are not marked.  */
10272   add_abstract_origin_attribute (type_die, type);
10273 }
10274
10275 /* Generate a DIE to represent an inlined instance of a structure type.  */
10276
10277 static void
10278 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
10279 {
10280   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
10281
10282   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10283      be incomplete and such types are not marked.  */
10284   add_abstract_origin_attribute (type_die, type);
10285 }
10286
10287 /* Generate a DIE to represent an inlined instance of a union type.  */
10288
10289 static void
10290 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
10291 {
10292   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
10293
10294   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10295      be incomplete and such types are not marked.  */
10296   add_abstract_origin_attribute (type_die, type);
10297 }
10298
10299 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
10300    include all of the information about the enumeration values also. Each
10301    enumerated type name/value is listed as a child of the enumerated type
10302    DIE.  */
10303
10304 static void
10305 gen_enumeration_type_die (tree type, dw_die_ref context_die)
10306 {
10307   dw_die_ref type_die = lookup_type_die (type);
10308
10309   if (type_die == NULL)
10310     {
10311       type_die = new_die (DW_TAG_enumeration_type,
10312                           scope_die_for (type, context_die), type);
10313       equate_type_number_to_die (type, type_die);
10314       add_name_attribute (type_die, type_tag (type));
10315     }
10316   else if (! TYPE_SIZE (type))
10317     return;
10318   else
10319     remove_AT (type_die, DW_AT_declaration);
10320
10321   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
10322      given enum type is incomplete, do not generate the DW_AT_byte_size
10323      attribute or the DW_AT_element_list attribute.  */
10324   if (TYPE_SIZE (type))
10325     {
10326       tree link;
10327
10328       TREE_ASM_WRITTEN (type) = 1;
10329       add_byte_size_attribute (type_die, type);
10330       if (TYPE_STUB_DECL (type) != NULL_TREE)
10331         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
10332
10333       /* If the first reference to this type was as the return type of an
10334          inline function, then it may not have a parent.  Fix this now.  */
10335       if (type_die->die_parent == NULL)
10336         add_child_die (scope_die_for (type, context_die), type_die);
10337
10338       for (link = TYPE_FIELDS (type);
10339            link != NULL; link = TREE_CHAIN (link))
10340         {
10341           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
10342
10343           add_name_attribute (enum_die,
10344                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
10345
10346           if (host_integerp (TREE_VALUE (link),
10347                              TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (link)))))
10348             {
10349               if (tree_int_cst_sgn (TREE_VALUE (link)) < 0)
10350                 add_AT_int (enum_die, DW_AT_const_value,
10351                             tree_low_cst (TREE_VALUE (link), 0));
10352               else
10353                 add_AT_unsigned (enum_die, DW_AT_const_value,
10354                                  tree_low_cst (TREE_VALUE (link), 1));
10355             }
10356         }
10357     }
10358   else
10359     add_AT_flag (type_die, DW_AT_declaration, 1);
10360 }
10361
10362 /* Generate a DIE to represent either a real live formal parameter decl or to
10363    represent just the type of some formal parameter position in some function
10364    type.
10365
10366    Note that this routine is a bit unusual because its argument may be a
10367    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10368    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10369    node.  If it's the former then this function is being called to output a
10370    DIE to represent a formal parameter object (or some inlining thereof).  If
10371    it's the latter, then this function is only being called to output a
10372    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10373    argument type of some subprogram type.  */
10374
10375 static dw_die_ref
10376 gen_formal_parameter_die (tree node, dw_die_ref context_die)
10377 {
10378   dw_die_ref parm_die
10379     = new_die (DW_TAG_formal_parameter, context_die, node);
10380   tree origin;
10381
10382   switch (TREE_CODE_CLASS (TREE_CODE (node)))
10383     {
10384     case 'd':
10385       origin = decl_ultimate_origin (node);
10386       if (origin != NULL)
10387         add_abstract_origin_attribute (parm_die, origin);
10388       else
10389         {
10390           add_name_and_src_coords_attributes (parm_die, node);
10391           add_type_attribute (parm_die, TREE_TYPE (node),
10392                               TREE_READONLY (node),
10393                               TREE_THIS_VOLATILE (node),
10394                               context_die);
10395           if (DECL_ARTIFICIAL (node))
10396             add_AT_flag (parm_die, DW_AT_artificial, 1);
10397         }
10398
10399       equate_decl_number_to_die (node, parm_die);
10400       if (! DECL_ABSTRACT (node))
10401         add_location_or_const_value_attribute (parm_die, node);
10402
10403       break;
10404
10405     case 't':
10406       /* We were called with some kind of a ..._TYPE node.  */
10407       add_type_attribute (parm_die, node, 0, 0, context_die);
10408       break;
10409
10410     default:
10411       abort ();
10412     }
10413
10414   return parm_die;
10415 }
10416
10417 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10418    at the end of an (ANSI prototyped) formal parameters list.  */
10419
10420 static void
10421 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
10422 {
10423   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
10424 }
10425
10426 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10427    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10428    parameters as specified in some function type specification (except for
10429    those which appear as part of a function *definition*).  */
10430
10431 static void
10432 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
10433 {
10434   tree link;
10435   tree formal_type = NULL;
10436   tree first_parm_type;
10437   tree arg;
10438
10439   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
10440     {
10441       arg = DECL_ARGUMENTS (function_or_method_type);
10442       function_or_method_type = TREE_TYPE (function_or_method_type);
10443     }
10444   else
10445     arg = NULL_TREE;
10446
10447   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
10448
10449   /* Make our first pass over the list of formal parameter types and output a
10450      DW_TAG_formal_parameter DIE for each one.  */
10451   for (link = first_parm_type; link; )
10452     {
10453       dw_die_ref parm_die;
10454
10455       formal_type = TREE_VALUE (link);
10456       if (formal_type == void_type_node)
10457         break;
10458
10459       /* Output a (nameless) DIE to represent the formal parameter itself.  */
10460       parm_die = gen_formal_parameter_die (formal_type, context_die);
10461       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
10462            && link == first_parm_type)
10463           || (arg && DECL_ARTIFICIAL (arg)))
10464         add_AT_flag (parm_die, DW_AT_artificial, 1);
10465
10466       link = TREE_CHAIN (link);
10467       if (arg)
10468         arg = TREE_CHAIN (arg);
10469     }
10470
10471   /* If this function type has an ellipsis, add a
10472      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
10473   if (formal_type != void_type_node)
10474     gen_unspecified_parameters_die (function_or_method_type, context_die);
10475
10476   /* Make our second (and final) pass over the list of formal parameter types
10477      and output DIEs to represent those types (as necessary).  */
10478   for (link = TYPE_ARG_TYPES (function_or_method_type);
10479        link && TREE_VALUE (link);
10480        link = TREE_CHAIN (link))
10481     gen_type_die (TREE_VALUE (link), context_die);
10482 }
10483
10484 /* We want to generate the DIE for TYPE so that we can generate the
10485    die for MEMBER, which has been defined; we will need to refer back
10486    to the member declaration nested within TYPE.  If we're trying to
10487    generate minimal debug info for TYPE, processing TYPE won't do the
10488    trick; we need to attach the member declaration by hand.  */
10489
10490 static void
10491 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
10492 {
10493   gen_type_die (type, context_die);
10494
10495   /* If we're trying to avoid duplicate debug info, we may not have
10496      emitted the member decl for this function.  Emit it now.  */
10497   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
10498       && ! lookup_decl_die (member))
10499     {
10500       if (decl_ultimate_origin (member))
10501         abort ();
10502
10503       push_decl_scope (type);
10504       if (TREE_CODE (member) == FUNCTION_DECL)
10505         gen_subprogram_die (member, lookup_type_die (type));
10506       else
10507         gen_variable_die (member, lookup_type_die (type));
10508
10509       pop_decl_scope ();
10510     }
10511 }
10512
10513 /* Generate the DWARF2 info for the "abstract" instance of a function which we
10514    may later generate inlined and/or out-of-line instances of.  */
10515
10516 static void
10517 dwarf2out_abstract_function (tree decl)
10518 {
10519   dw_die_ref old_die;
10520   tree save_fn;
10521   tree context;
10522   int was_abstract = DECL_ABSTRACT (decl);
10523
10524   /* Make sure we have the actual abstract inline, not a clone.  */
10525   decl = DECL_ORIGIN (decl);
10526
10527   old_die = lookup_decl_die (decl);
10528   if (old_die && get_AT (old_die, DW_AT_inline))
10529     /* We've already generated the abstract instance.  */
10530     return;
10531
10532   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
10533      we don't get confused by DECL_ABSTRACT.  */
10534   if (debug_info_level > DINFO_LEVEL_TERSE)
10535     {
10536       context = decl_class_context (decl);
10537       if (context)
10538         gen_type_die_for_member
10539           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
10540     }
10541
10542   /* Pretend we've just finished compiling this function.  */
10543   save_fn = current_function_decl;
10544   current_function_decl = decl;
10545
10546   set_decl_abstract_flags (decl, 1);
10547   dwarf2out_decl (decl);
10548   if (! was_abstract)
10549     set_decl_abstract_flags (decl, 0);
10550
10551   current_function_decl = save_fn;
10552 }
10553
10554 /* Generate a DIE to represent a declared function (either file-scope or
10555    block-local).  */
10556
10557 static void
10558 gen_subprogram_die (tree decl, dw_die_ref context_die)
10559 {
10560   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10561   tree origin = decl_ultimate_origin (decl);
10562   dw_die_ref subr_die;
10563   rtx fp_reg;
10564   tree fn_arg_types;
10565   tree outer_scope;
10566   dw_die_ref old_die = lookup_decl_die (decl);
10567   int declaration = (current_function_decl != decl
10568                      || class_scope_p (context_die));
10569
10570   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
10571      started to generate the abstract instance of an inline, decided to output
10572      its containing class, and proceeded to emit the declaration of the inline
10573      from the member list for the class.  If so, DECLARATION takes priority;
10574      we'll get back to the abstract instance when done with the class.  */
10575
10576   /* The class-scope declaration DIE must be the primary DIE.  */
10577   if (origin && declaration && class_scope_p (context_die))
10578     {
10579       origin = NULL;
10580       if (old_die)
10581         abort ();
10582     }
10583
10584   if (origin != NULL)
10585     {
10586       if (declaration && ! local_scope_p (context_die))
10587         abort ();
10588
10589       /* Fixup die_parent for the abstract instance of a nested
10590          inline function.  */
10591       if (old_die && old_die->die_parent == NULL)
10592         add_child_die (context_die, old_die);
10593
10594       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10595       add_abstract_origin_attribute (subr_die, origin);
10596     }
10597   else if (old_die)
10598     {
10599       unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10600
10601       if (!get_AT_flag (old_die, DW_AT_declaration)
10602           /* We can have a normal definition following an inline one in the
10603              case of redefinition of GNU C extern inlines.
10604              It seems reasonable to use AT_specification in this case.  */
10605           && !get_AT (old_die, DW_AT_inline))
10606         {
10607           /* ??? This can happen if there is a bug in the program, for
10608              instance, if it has duplicate function definitions.  Ideally,
10609              we should detect this case and ignore it.  For now, if we have
10610              already reported an error, any error at all, then assume that
10611              we got here because of an input error, not a dwarf2 bug.  */
10612           if (errorcount)
10613             return;
10614           abort ();
10615         }
10616
10617       /* If the definition comes from the same place as the declaration,
10618          maybe use the old DIE.  We always want the DIE for this function
10619          that has the *_pc attributes to be under comp_unit_die so the
10620          debugger can find it.  We also need to do this for abstract
10621          instances of inlines, since the spec requires the out-of-line copy
10622          to have the same parent.  For local class methods, this doesn't
10623          apply; we just use the old DIE.  */
10624       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
10625           && (DECL_ARTIFICIAL (decl)
10626               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
10627                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
10628                       == (unsigned) DECL_SOURCE_LINE (decl)))))
10629         {
10630           subr_die = old_die;
10631
10632           /* Clear out the declaration attribute and the parm types.  */
10633           remove_AT (subr_die, DW_AT_declaration);
10634           remove_children (subr_die);
10635         }
10636       else
10637         {
10638           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10639           add_AT_die_ref (subr_die, DW_AT_specification, old_die);
10640           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
10641             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
10642           if (get_AT_unsigned (old_die, DW_AT_decl_line)
10643               != (unsigned) DECL_SOURCE_LINE (decl))
10644             add_AT_unsigned
10645               (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
10646         }
10647     }
10648   else
10649     {
10650       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10651
10652       if (TREE_PUBLIC (decl))
10653         add_AT_flag (subr_die, DW_AT_external, 1);
10654
10655       add_name_and_src_coords_attributes (subr_die, decl);
10656       if (debug_info_level > DINFO_LEVEL_TERSE)
10657         {
10658           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
10659           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
10660                               0, 0, context_die);
10661         }
10662
10663       add_pure_or_virtual_attribute (subr_die, decl);
10664       if (DECL_ARTIFICIAL (decl))
10665         add_AT_flag (subr_die, DW_AT_artificial, 1);
10666
10667       if (TREE_PROTECTED (decl))
10668         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
10669       else if (TREE_PRIVATE (decl))
10670         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
10671     }
10672
10673   if (declaration)
10674     {
10675       if (!old_die || !get_AT (old_die, DW_AT_inline))
10676         {
10677           add_AT_flag (subr_die, DW_AT_declaration, 1);
10678
10679           /* The first time we see a member function, it is in the context of
10680              the class to which it belongs.  We make sure of this by emitting
10681              the class first.  The next time is the definition, which is
10682              handled above.  The two may come from the same source text.  */
10683           if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
10684             equate_decl_number_to_die (decl, subr_die);
10685         }
10686     }
10687   else if (DECL_ABSTRACT (decl))
10688     {
10689       if (DECL_DECLARED_INLINE_P (decl))
10690         {
10691           if (cgraph_function_possibly_inlined_p (decl))
10692             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
10693           else
10694             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
10695         }
10696       else
10697         {
10698           if (cgraph_function_possibly_inlined_p (decl))
10699             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
10700           else
10701             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
10702         }
10703
10704       equate_decl_number_to_die (decl, subr_die);
10705     }
10706   else if (!DECL_EXTERNAL (decl))
10707     {
10708       if (!old_die || !get_AT (old_die, DW_AT_inline))
10709         equate_decl_number_to_die (decl, subr_die);
10710
10711       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
10712                                    current_function_funcdef_no);
10713       add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
10714       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10715                                    current_function_funcdef_no);
10716       add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
10717
10718       add_pubname (decl, subr_die);
10719       add_arange (decl, subr_die);
10720
10721 #ifdef MIPS_DEBUGGING_INFO
10722       /* Add a reference to the FDE for this routine.  */
10723       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
10724 #endif
10725
10726       /* Define the "frame base" location for this routine.  We use the
10727          frame pointer or stack pointer registers, since the RTL for local
10728          variables is relative to one of them.  */
10729       fp_reg
10730         = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
10731       add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
10732
10733 #if 0
10734       /* ??? This fails for nested inline functions, because context_display
10735          is not part of the state saved/restored for inline functions.  */
10736       if (current_function_needs_context)
10737         add_AT_location_description (subr_die, DW_AT_static_link,
10738                              loc_descriptor (lookup_static_chain (decl)));
10739 #endif
10740     }
10741
10742   /* Now output descriptions of the arguments for this function. This gets
10743      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
10744      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
10745      `...' at the end of the formal parameter list.  In order to find out if
10746      there was a trailing ellipsis or not, we must instead look at the type
10747      associated with the FUNCTION_DECL.  This will be a node of type
10748      FUNCTION_TYPE. If the chain of type nodes hanging off of this
10749      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
10750      an ellipsis at the end.  */
10751
10752   /* In the case where we are describing a mere function declaration, all we
10753      need to do here (and all we *can* do here) is to describe the *types* of
10754      its formal parameters.  */
10755   if (debug_info_level <= DINFO_LEVEL_TERSE)
10756     ;
10757   else if (declaration)
10758     gen_formal_types_die (decl, subr_die);
10759   else
10760     {
10761       /* Generate DIEs to represent all known formal parameters.  */
10762       tree arg_decls = DECL_ARGUMENTS (decl);
10763       tree parm;
10764
10765       /* When generating DIEs, generate the unspecified_parameters DIE
10766          instead if we come across the arg "__builtin_va_alist" */
10767       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
10768         if (TREE_CODE (parm) == PARM_DECL)
10769           {
10770             if (DECL_NAME (parm)
10771                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
10772                             "__builtin_va_alist"))
10773               gen_unspecified_parameters_die (parm, subr_die);
10774             else
10775               gen_decl_die (parm, subr_die);
10776           }
10777
10778       /* Decide whether we need an unspecified_parameters DIE at the end.
10779          There are 2 more cases to do this for: 1) the ansi ... declaration -
10780          this is detectable when the end of the arg list is not a
10781          void_type_node 2) an unprototyped function declaration (not a
10782          definition).  This just means that we have no info about the
10783          parameters at all.  */
10784       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
10785       if (fn_arg_types != NULL)
10786         {
10787           /* This is the prototyped case, check for....  */
10788           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
10789             gen_unspecified_parameters_die (decl, subr_die);
10790         }
10791       else if (DECL_INITIAL (decl) == NULL_TREE)
10792         gen_unspecified_parameters_die (decl, subr_die);
10793     }
10794
10795   /* Output Dwarf info for all of the stuff within the body of the function
10796      (if it has one - it may be just a declaration).  */
10797   outer_scope = DECL_INITIAL (decl);
10798
10799   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
10800      a function.  This BLOCK actually represents the outermost binding contour
10801      for the function, i.e. the contour in which the function's formal
10802      parameters and labels get declared. Curiously, it appears that the front
10803      end doesn't actually put the PARM_DECL nodes for the current function onto
10804      the BLOCK_VARS list for this outer scope, but are strung off of the
10805      DECL_ARGUMENTS list for the function instead.
10806
10807      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
10808      the LABEL_DECL nodes for the function however, and we output DWARF info
10809      for those in decls_for_scope.  Just within the `outer_scope' there will be
10810      a BLOCK node representing the function's outermost pair of curly braces,
10811      and any blocks used for the base and member initializers of a C++
10812      constructor function.  */
10813   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
10814     {
10815       current_function_has_inlines = 0;
10816       decls_for_scope (outer_scope, subr_die, 0);
10817
10818 #if 0 && defined (MIPS_DEBUGGING_INFO)
10819       if (current_function_has_inlines)
10820         {
10821           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
10822           if (! comp_unit_has_inlines)
10823             {
10824               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
10825               comp_unit_has_inlines = 1;
10826             }
10827         }
10828 #endif
10829     }
10830 }
10831
10832 /* Generate a DIE to represent a declared data object.  */
10833
10834 static void
10835 gen_variable_die (tree decl, dw_die_ref context_die)
10836 {
10837   tree origin = decl_ultimate_origin (decl);
10838   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
10839
10840   dw_die_ref old_die = lookup_decl_die (decl);
10841   int declaration = (DECL_EXTERNAL (decl)
10842                      || class_scope_p (context_die));
10843
10844   if (origin != NULL)
10845     add_abstract_origin_attribute (var_die, origin);
10846
10847   /* Loop unrolling can create multiple blocks that refer to the same
10848      static variable, so we must test for the DW_AT_declaration flag.
10849
10850      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
10851      copy decls and set the DECL_ABSTRACT flag on them instead of
10852      sharing them.
10853
10854      ??? Duplicated blocks have been rewritten to use .debug_ranges.  */
10855   else if (old_die && TREE_STATIC (decl)
10856            && get_AT_flag (old_die, DW_AT_declaration) == 1)
10857     {
10858       /* This is a definition of a C++ class level static.  */
10859       add_AT_die_ref (var_die, DW_AT_specification, old_die);
10860       if (DECL_NAME (decl))
10861         {
10862           unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10863
10864           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
10865             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
10866
10867           if (get_AT_unsigned (old_die, DW_AT_decl_line)
10868               != (unsigned) DECL_SOURCE_LINE (decl))
10869
10870             add_AT_unsigned (var_die, DW_AT_decl_line,
10871                              DECL_SOURCE_LINE (decl));
10872         }
10873     }
10874   else
10875     {
10876       add_name_and_src_coords_attributes (var_die, decl);
10877       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
10878                           TREE_THIS_VOLATILE (decl), context_die);
10879
10880       if (TREE_PUBLIC (decl))
10881         add_AT_flag (var_die, DW_AT_external, 1);
10882
10883       if (DECL_ARTIFICIAL (decl))
10884         add_AT_flag (var_die, DW_AT_artificial, 1);
10885
10886       if (TREE_PROTECTED (decl))
10887         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
10888       else if (TREE_PRIVATE (decl))
10889         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
10890     }
10891
10892   if (declaration)
10893     add_AT_flag (var_die, DW_AT_declaration, 1);
10894
10895   if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
10896     equate_decl_number_to_die (decl, var_die);
10897
10898   if (! declaration && ! DECL_ABSTRACT (decl))
10899     {
10900       add_location_or_const_value_attribute (var_die, decl);
10901       add_pubname (decl, var_die);
10902     }
10903   else
10904     tree_add_const_value_attribute (var_die, decl);
10905 }
10906
10907 /* Generate a DIE to represent a label identifier.  */
10908
10909 static void
10910 gen_label_die (tree decl, dw_die_ref context_die)
10911 {
10912   tree origin = decl_ultimate_origin (decl);
10913   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
10914   rtx insn;
10915   char label[MAX_ARTIFICIAL_LABEL_BYTES];
10916
10917   if (origin != NULL)
10918     add_abstract_origin_attribute (lbl_die, origin);
10919   else
10920     add_name_and_src_coords_attributes (lbl_die, decl);
10921
10922   if (DECL_ABSTRACT (decl))
10923     equate_decl_number_to_die (decl, lbl_die);
10924   else
10925     {
10926       insn = DECL_RTL (decl);
10927
10928       /* Deleted labels are programmer specified labels which have been
10929          eliminated because of various optimizations.  We still emit them
10930          here so that it is possible to put breakpoints on them.  */
10931       if (GET_CODE (insn) == CODE_LABEL
10932           || ((GET_CODE (insn) == NOTE
10933                && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
10934         {
10935           /* When optimization is enabled (via -O) some parts of the compiler
10936              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
10937              represent source-level labels which were explicitly declared by
10938              the user.  This really shouldn't be happening though, so catch
10939              it if it ever does happen.  */
10940           if (INSN_DELETED_P (insn))
10941             abort ();
10942
10943           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
10944           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
10945         }
10946     }
10947 }
10948
10949 /* Generate a DIE for a lexical block.  */
10950
10951 static void
10952 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
10953 {
10954   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
10955   char label[MAX_ARTIFICIAL_LABEL_BYTES];
10956
10957   if (! BLOCK_ABSTRACT (stmt))
10958     {
10959       if (BLOCK_FRAGMENT_CHAIN (stmt))
10960         {
10961           tree chain;
10962
10963           add_AT_range_list (stmt_die, DW_AT_ranges, add_ranges (stmt));
10964
10965           chain = BLOCK_FRAGMENT_CHAIN (stmt);
10966           do
10967             {
10968               add_ranges (chain);
10969               chain = BLOCK_FRAGMENT_CHAIN (chain);
10970             }
10971           while (chain);
10972           add_ranges (NULL);
10973         }
10974       else
10975         {
10976           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
10977                                        BLOCK_NUMBER (stmt));
10978           add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
10979           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
10980                                        BLOCK_NUMBER (stmt));
10981           add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
10982         }
10983     }
10984
10985   decls_for_scope (stmt, stmt_die, depth);
10986 }
10987
10988 /* Generate a DIE for an inlined subprogram.  */
10989
10990 static void
10991 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
10992 {
10993   tree decl = block_ultimate_origin (stmt);
10994
10995   /* Emit info for the abstract instance first, if we haven't yet.  We
10996      must emit this even if the block is abstract, otherwise when we
10997      emit the block below (or elsewhere), we may end up trying to emit
10998      a die whose origin die hasn't been emitted, and crashing.  */
10999   dwarf2out_abstract_function (decl);
11000
11001   if (! BLOCK_ABSTRACT (stmt))
11002     {
11003       dw_die_ref subr_die
11004         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
11005       char label[MAX_ARTIFICIAL_LABEL_BYTES];
11006
11007       add_abstract_origin_attribute (subr_die, decl);
11008       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11009                                    BLOCK_NUMBER (stmt));
11010       add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
11011       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11012                                    BLOCK_NUMBER (stmt));
11013       add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
11014       decls_for_scope (stmt, subr_die, depth);
11015       current_function_has_inlines = 1;
11016     }
11017   else
11018     /* We may get here if we're the outer block of function A that was
11019        inlined into function B that was inlined into function C.  When
11020        generating debugging info for C, dwarf2out_abstract_function(B)
11021        would mark all inlined blocks as abstract, including this one.
11022        So, we wouldn't (and shouldn't) expect labels to be generated
11023        for this one.  Instead, just emit debugging info for
11024        declarations within the block.  This is particularly important
11025        in the case of initializers of arguments passed from B to us:
11026        if they're statement expressions containing declarations, we
11027        wouldn't generate dies for their abstract variables, and then,
11028        when generating dies for the real variables, we'd die (pun
11029        intended :-)  */
11030     gen_lexical_block_die (stmt, context_die, depth);
11031 }
11032
11033 /* Generate a DIE for a field in a record, or structure.  */
11034
11035 static void
11036 gen_field_die (tree decl, dw_die_ref context_die)
11037 {
11038   dw_die_ref decl_die;
11039
11040   if (TREE_TYPE (decl) == error_mark_node)
11041     return;
11042
11043   decl_die = new_die (DW_TAG_member, context_die, decl);
11044   add_name_and_src_coords_attributes (decl_die, decl);
11045   add_type_attribute (decl_die, member_declared_type (decl),
11046                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
11047                       context_die);
11048
11049   if (DECL_BIT_FIELD_TYPE (decl))
11050     {
11051       add_byte_size_attribute (decl_die, decl);
11052       add_bit_size_attribute (decl_die, decl);
11053       add_bit_offset_attribute (decl_die, decl);
11054     }
11055
11056   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
11057     add_data_member_location_attribute (decl_die, decl);
11058
11059   if (DECL_ARTIFICIAL (decl))
11060     add_AT_flag (decl_die, DW_AT_artificial, 1);
11061
11062   if (TREE_PROTECTED (decl))
11063     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
11064   else if (TREE_PRIVATE (decl))
11065     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
11066 }
11067
11068 #if 0
11069 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11070    Use modified_type_die instead.
11071    We keep this code here just in case these types of DIEs may be needed to
11072    represent certain things in other languages (e.g. Pascal) someday.  */
11073
11074 static void
11075 gen_pointer_type_die (tree type, dw_die_ref context_die)
11076 {
11077   dw_die_ref ptr_die
11078     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
11079
11080   equate_type_number_to_die (type, ptr_die);
11081   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11082   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11083 }
11084
11085 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11086    Use modified_type_die instead.
11087    We keep this code here just in case these types of DIEs may be needed to
11088    represent certain things in other languages (e.g. Pascal) someday.  */
11089
11090 static void
11091 gen_reference_type_die (tree type, dw_die_ref context_die)
11092 {
11093   dw_die_ref ref_die
11094     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
11095
11096   equate_type_number_to_die (type, ref_die);
11097   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
11098   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11099 }
11100 #endif
11101
11102 /* Generate a DIE for a pointer to a member type.  */
11103
11104 static void
11105 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
11106 {
11107   dw_die_ref ptr_die
11108     = new_die (DW_TAG_ptr_to_member_type,
11109                scope_die_for (type, context_die), type);
11110
11111   equate_type_number_to_die (type, ptr_die);
11112   add_AT_die_ref (ptr_die, DW_AT_containing_type,
11113                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
11114   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11115 }
11116
11117 /* Generate the DIE for the compilation unit.  */
11118
11119 static dw_die_ref
11120 gen_compile_unit_die (const char *filename)
11121 {
11122   dw_die_ref die;
11123   char producer[250];
11124   const char *language_string = lang_hooks.name;
11125   int language;
11126
11127   die = new_die (DW_TAG_compile_unit, NULL, NULL);
11128
11129   if (filename)
11130     {
11131       add_name_attribute (die, filename);
11132       /* Don't add cwd for <built-in>.  */
11133       if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
11134         add_comp_dir_attribute (die);
11135     }
11136
11137   sprintf (producer, "%s %s", language_string, version_string);
11138
11139 #ifdef MIPS_DEBUGGING_INFO
11140   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11141      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11142      not appear in the producer string, the debugger reaches the conclusion
11143      that the object file is stripped and has no debugging information.
11144      To get the MIPS/SGI debugger to believe that there is debugging
11145      information in the object file, we add a -g to the producer string.  */
11146   if (debug_info_level > DINFO_LEVEL_TERSE)
11147     strcat (producer, " -g");
11148 #endif
11149
11150   add_AT_string (die, DW_AT_producer, producer);
11151
11152   if (strcmp (language_string, "GNU C++") == 0)
11153     language = DW_LANG_C_plus_plus;
11154   else if (strcmp (language_string, "GNU Ada") == 0)
11155     language = DW_LANG_Ada95;
11156   else if (strcmp (language_string, "GNU F77") == 0)
11157     language = DW_LANG_Fortran77;
11158   else if (strcmp (language_string, "GNU Pascal") == 0)
11159     language = DW_LANG_Pascal83;
11160   else if (strcmp (language_string, "GNU Java") == 0)
11161     language = DW_LANG_Java;
11162   else
11163     language = DW_LANG_C89;
11164
11165   add_AT_unsigned (die, DW_AT_language, language);
11166   return die;
11167 }
11168
11169 /* Generate a DIE for a string type.  */
11170
11171 static void
11172 gen_string_type_die (tree type, dw_die_ref context_die)
11173 {
11174   dw_die_ref type_die
11175     = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
11176
11177   equate_type_number_to_die (type, type_die);
11178
11179   /* ??? Fudge the string length attribute for now.
11180      TODO: add string length info.  */
11181 #if 0
11182   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
11183   bound_representation (upper_bound, 0, 'u');
11184 #endif
11185 }
11186
11187 /* Generate the DIE for a base class.  */
11188
11189 static void
11190 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
11191 {
11192   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
11193
11194   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
11195   add_data_member_location_attribute (die, binfo);
11196
11197   if (TREE_VIA_VIRTUAL (binfo))
11198     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11199
11200   if (access == access_public_node)
11201     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
11202   else if (access == access_protected_node)
11203     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
11204 }
11205
11206 /* Generate a DIE for a class member.  */
11207
11208 static void
11209 gen_member_die (tree type, dw_die_ref context_die)
11210 {
11211   tree member;
11212   tree binfo = TYPE_BINFO (type);
11213   dw_die_ref child;
11214
11215   /* If this is not an incomplete type, output descriptions of each of its
11216      members. Note that as we output the DIEs necessary to represent the
11217      members of this record or union type, we will also be trying to output
11218      DIEs to represent the *types* of those members. However the `type'
11219      function (above) will specifically avoid generating type DIEs for member
11220      types *within* the list of member DIEs for this (containing) type except
11221      for those types (of members) which are explicitly marked as also being
11222      members of this (containing) type themselves.  The g++ front- end can
11223      force any given type to be treated as a member of some other (containing)
11224      type by setting the TYPE_CONTEXT of the given (member) type to point to
11225      the TREE node representing the appropriate (containing) type.  */
11226
11227   /* First output info about the base classes.  */
11228   if (binfo && BINFO_BASETYPES (binfo))
11229     {
11230       tree bases = BINFO_BASETYPES (binfo);
11231       tree accesses = BINFO_BASEACCESSES (binfo);
11232       int n_bases = TREE_VEC_LENGTH (bases);
11233       int i;
11234
11235       for (i = 0; i < n_bases; i++)
11236         gen_inheritance_die (TREE_VEC_ELT (bases, i),
11237                              (accesses ? TREE_VEC_ELT (accesses, i)
11238                               : access_public_node), context_die);
11239     }
11240
11241   /* Now output info about the data members and type members.  */
11242   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
11243     {
11244       /* If we thought we were generating minimal debug info for TYPE
11245          and then changed our minds, some of the member declarations
11246          may have already been defined.  Don't define them again, but
11247          do put them in the right order.  */
11248
11249       child = lookup_decl_die (member);
11250       if (child)
11251         splice_child_die (context_die, child);
11252       else
11253         gen_decl_die (member, context_die);
11254     }
11255
11256   /* Now output info about the function members (if any).  */
11257   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
11258     {
11259       /* Don't include clones in the member list.  */
11260       if (DECL_ABSTRACT_ORIGIN (member))
11261         continue;
11262
11263       child = lookup_decl_die (member);
11264       if (child)
11265         splice_child_die (context_die, child);
11266       else
11267         gen_decl_die (member, context_die);
11268     }
11269 }
11270
11271 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
11272    is set, we pretend that the type was never defined, so we only get the
11273    member DIEs needed by later specification DIEs.  */
11274
11275 static void
11276 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
11277 {
11278   dw_die_ref type_die = lookup_type_die (type);
11279   dw_die_ref scope_die = 0;
11280   int nested = 0;
11281   int complete = (TYPE_SIZE (type)
11282                   && (! TYPE_STUB_DECL (type)
11283                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
11284
11285   if (type_die && ! complete)
11286     return;
11287
11288   if (TYPE_CONTEXT (type) != NULL_TREE
11289       && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
11290     nested = 1;
11291
11292   scope_die = scope_die_for (type, context_die);
11293
11294   if (! type_die || (nested && scope_die == comp_unit_die))
11295     /* First occurrence of type or toplevel definition of nested class.  */
11296     {
11297       dw_die_ref old_die = type_die;
11298
11299       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
11300                           ? DW_TAG_structure_type : DW_TAG_union_type,
11301                           scope_die, type);
11302       equate_type_number_to_die (type, type_die);
11303       if (old_die)
11304         add_AT_die_ref (type_die, DW_AT_specification, old_die);
11305       else
11306         add_name_attribute (type_die, type_tag (type));
11307     }
11308   else
11309     remove_AT (type_die, DW_AT_declaration);
11310
11311   /* If this type has been completed, then give it a byte_size attribute and
11312      then give a list of members.  */
11313   if (complete)
11314     {
11315       /* Prevent infinite recursion in cases where the type of some member of
11316          this type is expressed in terms of this type itself.  */
11317       TREE_ASM_WRITTEN (type) = 1;
11318       add_byte_size_attribute (type_die, type);
11319       if (TYPE_STUB_DECL (type) != NULL_TREE)
11320         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11321
11322       /* If the first reference to this type was as the return type of an
11323          inline function, then it may not have a parent.  Fix this now.  */
11324       if (type_die->die_parent == NULL)
11325         add_child_die (scope_die, type_die);
11326
11327       push_decl_scope (type);
11328       gen_member_die (type, type_die);
11329       pop_decl_scope ();
11330
11331       /* GNU extension: Record what type our vtable lives in.  */
11332       if (TYPE_VFIELD (type))
11333         {
11334           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
11335
11336           gen_type_die (vtype, context_die);
11337           add_AT_die_ref (type_die, DW_AT_containing_type,
11338                           lookup_type_die (vtype));
11339         }
11340     }
11341   else
11342     {
11343       add_AT_flag (type_die, DW_AT_declaration, 1);
11344
11345       /* We don't need to do this for function-local types.  */
11346       if (TYPE_STUB_DECL (type)
11347           && ! decl_function_context (TYPE_STUB_DECL (type)))
11348         VARRAY_PUSH_TREE (incomplete_types, type);
11349     }
11350 }
11351
11352 /* Generate a DIE for a subroutine _type_.  */
11353
11354 static void
11355 gen_subroutine_type_die (tree type, dw_die_ref context_die)
11356 {
11357   tree return_type = TREE_TYPE (type);
11358   dw_die_ref subr_die
11359     = new_die (DW_TAG_subroutine_type,
11360                scope_die_for (type, context_die), type);
11361
11362   equate_type_number_to_die (type, subr_die);
11363   add_prototyped_attribute (subr_die, type);
11364   add_type_attribute (subr_die, return_type, 0, 0, context_die);
11365   gen_formal_types_die (type, subr_die);
11366 }
11367
11368 /* Generate a DIE for a type definition.  */
11369
11370 static void
11371 gen_typedef_die (tree decl, dw_die_ref context_die)
11372 {
11373   dw_die_ref type_die;
11374   tree origin;
11375
11376   if (TREE_ASM_WRITTEN (decl))
11377     return;
11378
11379   TREE_ASM_WRITTEN (decl) = 1;
11380   type_die = new_die (DW_TAG_typedef, context_die, decl);
11381   origin = decl_ultimate_origin (decl);
11382   if (origin != NULL)
11383     add_abstract_origin_attribute (type_die, origin);
11384   else
11385     {
11386       tree type;
11387
11388       add_name_and_src_coords_attributes (type_die, decl);
11389       if (DECL_ORIGINAL_TYPE (decl))
11390         {
11391           type = DECL_ORIGINAL_TYPE (decl);
11392
11393           if (type == TREE_TYPE (decl))
11394             abort ();
11395           else
11396             equate_type_number_to_die (TREE_TYPE (decl), type_die);
11397         }
11398       else
11399         type = TREE_TYPE (decl);
11400
11401       add_type_attribute (type_die, type, TREE_READONLY (decl),
11402                           TREE_THIS_VOLATILE (decl), context_die);
11403     }
11404
11405   if (DECL_ABSTRACT (decl))
11406     equate_decl_number_to_die (decl, type_die);
11407 }
11408
11409 /* Generate a type description DIE.  */
11410
11411 static void
11412 gen_type_die (tree type, dw_die_ref context_die)
11413 {
11414   int need_pop;
11415
11416   if (type == NULL_TREE || type == error_mark_node)
11417     return;
11418
11419   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11420       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
11421     {
11422       if (TREE_ASM_WRITTEN (type))
11423         return;
11424
11425       /* Prevent broken recursion; we can't hand off to the same type.  */
11426       if (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) == type)
11427         abort ();
11428
11429       TREE_ASM_WRITTEN (type) = 1;
11430       gen_decl_die (TYPE_NAME (type), context_die);
11431       return;
11432     }
11433
11434   /* We are going to output a DIE to represent the unqualified version
11435      of this type (i.e. without any const or volatile qualifiers) so
11436      get the main variant (i.e. the unqualified version) of this type
11437      now.  (Vectors are special because the debugging info is in the
11438      cloned type itself).  */
11439   if (TREE_CODE (type) != VECTOR_TYPE)
11440     type = type_main_variant (type);
11441
11442   if (TREE_ASM_WRITTEN (type))
11443     return;
11444
11445   switch (TREE_CODE (type))
11446     {
11447     case ERROR_MARK:
11448       break;
11449
11450     case POINTER_TYPE:
11451     case REFERENCE_TYPE:
11452       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
11453          ensures that the gen_type_die recursion will terminate even if the
11454          type is recursive.  Recursive types are possible in Ada.  */
11455       /* ??? We could perhaps do this for all types before the switch
11456          statement.  */
11457       TREE_ASM_WRITTEN (type) = 1;
11458
11459       /* For these types, all that is required is that we output a DIE (or a
11460          set of DIEs) to represent the "basis" type.  */
11461       gen_type_die (TREE_TYPE (type), context_die);
11462       break;
11463
11464     case OFFSET_TYPE:
11465       /* This code is used for C++ pointer-to-data-member types.
11466          Output a description of the relevant class type.  */
11467       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
11468
11469       /* Output a description of the type of the object pointed to.  */
11470       gen_type_die (TREE_TYPE (type), context_die);
11471
11472       /* Now output a DIE to represent this pointer-to-data-member type
11473          itself.  */
11474       gen_ptr_to_mbr_type_die (type, context_die);
11475       break;
11476
11477     case SET_TYPE:
11478       gen_type_die (TYPE_DOMAIN (type), context_die);
11479       gen_set_type_die (type, context_die);
11480       break;
11481
11482     case FILE_TYPE:
11483       gen_type_die (TREE_TYPE (type), context_die);
11484       abort ();                 /* No way to represent these in Dwarf yet!  */
11485       break;
11486
11487     case FUNCTION_TYPE:
11488       /* Force out return type (in case it wasn't forced out already).  */
11489       gen_type_die (TREE_TYPE (type), context_die);
11490       gen_subroutine_type_die (type, context_die);
11491       break;
11492
11493     case METHOD_TYPE:
11494       /* Force out return type (in case it wasn't forced out already).  */
11495       gen_type_die (TREE_TYPE (type), context_die);
11496       gen_subroutine_type_die (type, context_die);
11497       break;
11498
11499     case ARRAY_TYPE:
11500       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
11501         {
11502           gen_type_die (TREE_TYPE (type), context_die);
11503           gen_string_type_die (type, context_die);
11504         }
11505       else
11506         gen_array_type_die (type, context_die);
11507       break;
11508
11509     case VECTOR_TYPE:
11510       gen_array_type_die (type, context_die);
11511       break;
11512
11513     case ENUMERAL_TYPE:
11514     case RECORD_TYPE:
11515     case UNION_TYPE:
11516     case QUAL_UNION_TYPE:
11517       /* If this is a nested type whose containing class hasn't been written
11518          out yet, writing it out will cover this one, too.  This does not apply
11519          to instantiations of member class templates; they need to be added to
11520          the containing class as they are generated.  FIXME: This hurts the
11521          idea of combining type decls from multiple TUs, since we can't predict
11522          what set of template instantiations we'll get.  */
11523       if (TYPE_CONTEXT (type)
11524           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
11525           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
11526         {
11527           gen_type_die (TYPE_CONTEXT (type), context_die);
11528
11529           if (TREE_ASM_WRITTEN (type))
11530             return;
11531
11532           /* If that failed, attach ourselves to the stub.  */
11533           push_decl_scope (TYPE_CONTEXT (type));
11534           context_die = lookup_type_die (TYPE_CONTEXT (type));
11535           need_pop = 1;
11536         }
11537       else
11538         need_pop = 0;
11539
11540       if (TREE_CODE (type) == ENUMERAL_TYPE)
11541         gen_enumeration_type_die (type, context_die);
11542       else
11543         gen_struct_or_union_type_die (type, context_die);
11544
11545       if (need_pop)
11546         pop_decl_scope ();
11547
11548       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
11549          it up if it is ever completed.  gen_*_type_die will set it for us
11550          when appropriate.  */
11551       return;
11552
11553     case VOID_TYPE:
11554     case INTEGER_TYPE:
11555     case REAL_TYPE:
11556     case COMPLEX_TYPE:
11557     case BOOLEAN_TYPE:
11558     case CHAR_TYPE:
11559       /* No DIEs needed for fundamental types.  */
11560       break;
11561
11562     case LANG_TYPE:
11563       /* No Dwarf representation currently defined.  */
11564       break;
11565
11566     default:
11567       abort ();
11568     }
11569
11570   TREE_ASM_WRITTEN (type) = 1;
11571 }
11572
11573 /* Generate a DIE for a tagged type instantiation.  */
11574
11575 static void
11576 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
11577 {
11578   if (type == NULL_TREE || type == error_mark_node)
11579     return;
11580
11581   /* We are going to output a DIE to represent the unqualified version of
11582      this type (i.e. without any const or volatile qualifiers) so make sure
11583      that we have the main variant (i.e. the unqualified version) of this
11584      type now.  */
11585   if (type != type_main_variant (type))
11586     abort ();
11587
11588   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
11589      an instance of an unresolved type.  */
11590
11591   switch (TREE_CODE (type))
11592     {
11593     case ERROR_MARK:
11594       break;
11595
11596     case ENUMERAL_TYPE:
11597       gen_inlined_enumeration_type_die (type, context_die);
11598       break;
11599
11600     case RECORD_TYPE:
11601       gen_inlined_structure_type_die (type, context_die);
11602       break;
11603
11604     case UNION_TYPE:
11605     case QUAL_UNION_TYPE:
11606       gen_inlined_union_type_die (type, context_die);
11607       break;
11608
11609     default:
11610       abort ();
11611     }
11612 }
11613
11614 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
11615    things which are local to the given block.  */
11616
11617 static void
11618 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
11619 {
11620   int must_output_die = 0;
11621   tree origin;
11622   tree decl;
11623   enum tree_code origin_code;
11624
11625   /* Ignore blocks never really used to make RTL.  */
11626   if (stmt == NULL_TREE || !TREE_USED (stmt)
11627       || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt)))
11628     return;
11629
11630   /* If the block is one fragment of a non-contiguous block, do not
11631      process the variables, since they will have been done by the
11632      origin block.  Do process subblocks.  */
11633   if (BLOCK_FRAGMENT_ORIGIN (stmt))
11634     {
11635       tree sub;
11636
11637       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
11638         gen_block_die (sub, context_die, depth + 1);
11639
11640       return;
11641     }
11642
11643   /* Determine the "ultimate origin" of this block.  This block may be an
11644      inlined instance of an inlined instance of inline function, so we have
11645      to trace all of the way back through the origin chain to find out what
11646      sort of node actually served as the original seed for the creation of
11647      the current block.  */
11648   origin = block_ultimate_origin (stmt);
11649   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
11650
11651   /* Determine if we need to output any Dwarf DIEs at all to represent this
11652      block.  */
11653   if (origin_code == FUNCTION_DECL)
11654     /* The outer scopes for inlinings *must* always be represented.  We
11655        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
11656     must_output_die = 1;
11657   else
11658     {
11659       /* In the case where the current block represents an inlining of the
11660          "body block" of an inline function, we must *NOT* output any DIE for
11661          this block because we have already output a DIE to represent the whole
11662          inlined function scope and the "body block" of any function doesn't
11663          really represent a different scope according to ANSI C rules.  So we
11664          check here to make sure that this block does not represent a "body
11665          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
11666       if (! is_body_block (origin ? origin : stmt))
11667         {
11668           /* Determine if this block directly contains any "significant"
11669              local declarations which we will need to output DIEs for.  */
11670           if (debug_info_level > DINFO_LEVEL_TERSE)
11671             /* We are not in terse mode so *any* local declaration counts
11672                as being a "significant" one.  */
11673             must_output_die = (BLOCK_VARS (stmt) != NULL);
11674           else
11675             /* We are in terse mode, so only local (nested) function
11676                definitions count as "significant" local declarations.  */
11677             for (decl = BLOCK_VARS (stmt);
11678                  decl != NULL; decl = TREE_CHAIN (decl))
11679               if (TREE_CODE (decl) == FUNCTION_DECL
11680                   && DECL_INITIAL (decl))
11681                 {
11682                   must_output_die = 1;
11683                   break;
11684                 }
11685         }
11686     }
11687
11688   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
11689      DIE for any block which contains no significant local declarations at
11690      all.  Rather, in such cases we just call `decls_for_scope' so that any
11691      needed Dwarf info for any sub-blocks will get properly generated. Note
11692      that in terse mode, our definition of what constitutes a "significant"
11693      local declaration gets restricted to include only inlined function
11694      instances and local (nested) function definitions.  */
11695   if (must_output_die)
11696     {
11697       if (origin_code == FUNCTION_DECL)
11698         gen_inlined_subroutine_die (stmt, context_die, depth);
11699       else
11700         gen_lexical_block_die (stmt, context_die, depth);
11701     }
11702   else
11703     decls_for_scope (stmt, context_die, depth);
11704 }
11705
11706 /* Generate all of the decls declared within a given scope and (recursively)
11707    all of its sub-blocks.  */
11708
11709 static void
11710 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
11711 {
11712   tree decl;
11713   tree subblocks;
11714
11715   /* Ignore blocks never really used to make RTL.  */
11716   if (stmt == NULL_TREE || ! TREE_USED (stmt))
11717     return;
11718
11719   /* Output the DIEs to represent all of the data objects and typedefs
11720      declared directly within this block but not within any nested
11721      sub-blocks.  Also, nested function and tag DIEs have been
11722      generated with a parent of NULL; fix that up now.  */
11723   for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
11724     {
11725       dw_die_ref die;
11726
11727       if (TREE_CODE (decl) == FUNCTION_DECL)
11728         die = lookup_decl_die (decl);
11729       else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
11730         die = lookup_type_die (TREE_TYPE (decl));
11731       else
11732         die = NULL;
11733
11734       if (die != NULL && die->die_parent == NULL)
11735         add_child_die (context_die, die);
11736       else
11737         gen_decl_die (decl, context_die);
11738     }
11739
11740   /* If we're at -g1, we're not interested in subblocks.  */
11741   if (debug_info_level <= DINFO_LEVEL_TERSE)
11742     return;
11743
11744   /* Output the DIEs to represent all sub-blocks (and the items declared
11745      therein) of this block.  */
11746   for (subblocks = BLOCK_SUBBLOCKS (stmt);
11747        subblocks != NULL;
11748        subblocks = BLOCK_CHAIN (subblocks))
11749     gen_block_die (subblocks, context_die, depth + 1);
11750 }
11751
11752 /* Is this a typedef we can avoid emitting?  */
11753
11754 static inline int
11755 is_redundant_typedef (tree decl)
11756 {
11757   if (TYPE_DECL_IS_STUB (decl))
11758     return 1;
11759
11760   if (DECL_ARTIFICIAL (decl)
11761       && DECL_CONTEXT (decl)
11762       && is_tagged_type (DECL_CONTEXT (decl))
11763       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
11764       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
11765     /* Also ignore the artificial member typedef for the class name.  */
11766     return 1;
11767
11768   return 0;
11769 }
11770
11771 /* Generate Dwarf debug information for a decl described by DECL.  */
11772
11773 static void
11774 gen_decl_die (tree decl, dw_die_ref context_die)
11775 {
11776   tree origin;
11777
11778   if (DECL_P (decl) && DECL_IGNORED_P (decl))
11779     return;
11780
11781   switch (TREE_CODE (decl))
11782     {
11783     case ERROR_MARK:
11784       break;
11785
11786     case CONST_DECL:
11787       /* The individual enumerators of an enum type get output when we output
11788          the Dwarf representation of the relevant enum type itself.  */
11789       break;
11790
11791     case FUNCTION_DECL:
11792       /* Don't output any DIEs to represent mere function declarations,
11793          unless they are class members or explicit block externs.  */
11794       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
11795           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
11796         break;
11797
11798       /* If we're emitting a clone, emit info for the abstract instance.  */
11799       if (DECL_ORIGIN (decl) != decl)
11800         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
11801
11802       /* If we're emitting an out-of-line copy of an inline function,
11803          emit info for the abstract instance and set up to refer to it.  */
11804       else if (cgraph_function_possibly_inlined_p (decl)
11805                && ! DECL_ABSTRACT (decl)
11806                && ! class_scope_p (context_die)
11807                /* dwarf2out_abstract_function won't emit a die if this is just
11808                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
11809                   that case, because that works only if we have a die.  */
11810                && DECL_INITIAL (decl) != NULL_TREE)
11811         {
11812           dwarf2out_abstract_function (decl);
11813           set_decl_origin_self (decl);
11814         }
11815
11816       /* Otherwise we're emitting the primary DIE for this decl.  */
11817       else if (debug_info_level > DINFO_LEVEL_TERSE)
11818         {
11819           /* Before we describe the FUNCTION_DECL itself, make sure that we
11820              have described its return type.  */
11821           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
11822
11823           /* And its virtual context.  */
11824           if (DECL_VINDEX (decl) != NULL_TREE)
11825             gen_type_die (DECL_CONTEXT (decl), context_die);
11826
11827           /* And its containing type.  */
11828           origin = decl_class_context (decl);
11829           if (origin != NULL_TREE)
11830             gen_type_die_for_member (origin, decl, context_die);
11831         }
11832
11833       /* Now output a DIE to represent the function itself.  */
11834       gen_subprogram_die (decl, context_die);
11835       break;
11836
11837     case TYPE_DECL:
11838       /* If we are in terse mode, don't generate any DIEs to represent any
11839          actual typedefs.  */
11840       if (debug_info_level <= DINFO_LEVEL_TERSE)
11841         break;
11842
11843       /* In the special case of a TYPE_DECL node representing the declaration
11844          of some type tag, if the given TYPE_DECL is marked as having been
11845          instantiated from some other (original) TYPE_DECL node (e.g. one which
11846          was generated within the original definition of an inline function) we
11847          have to generate a special (abbreviated) DW_TAG_structure_type,
11848          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
11849       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
11850         {
11851           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
11852           break;
11853         }
11854
11855       if (is_redundant_typedef (decl))
11856         gen_type_die (TREE_TYPE (decl), context_die);
11857       else
11858         /* Output a DIE to represent the typedef itself.  */
11859         gen_typedef_die (decl, context_die);
11860       break;
11861
11862     case LABEL_DECL:
11863       if (debug_info_level >= DINFO_LEVEL_NORMAL)
11864         gen_label_die (decl, context_die);
11865       break;
11866
11867     case VAR_DECL:
11868       /* If we are in terse mode, don't generate any DIEs to represent any
11869          variable declarations or definitions.  */
11870       if (debug_info_level <= DINFO_LEVEL_TERSE)
11871         break;
11872
11873       /* Output any DIEs that are needed to specify the type of this data
11874          object.  */
11875       gen_type_die (TREE_TYPE (decl), context_die);
11876
11877       /* And its containing type.  */
11878       origin = decl_class_context (decl);
11879       if (origin != NULL_TREE)
11880         gen_type_die_for_member (origin, decl, context_die);
11881
11882       /* Now output the DIE to represent the data object itself.  This gets
11883          complicated because of the possibility that the VAR_DECL really
11884          represents an inlined instance of a formal parameter for an inline
11885          function.  */
11886       origin = decl_ultimate_origin (decl);
11887       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
11888         gen_formal_parameter_die (decl, context_die);
11889       else
11890         gen_variable_die (decl, context_die);
11891       break;
11892
11893     case FIELD_DECL:
11894       /* Ignore the nameless fields that are used to skip bits but handle C++
11895          anonymous unions.  */
11896       if (DECL_NAME (decl) != NULL_TREE
11897           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
11898         {
11899           gen_type_die (member_declared_type (decl), context_die);
11900           gen_field_die (decl, context_die);
11901         }
11902       break;
11903
11904     case PARM_DECL:
11905       gen_type_die (TREE_TYPE (decl), context_die);
11906       gen_formal_parameter_die (decl, context_die);
11907       break;
11908
11909     case NAMESPACE_DECL:
11910       /* Ignore for now.  */
11911       break;
11912
11913     default:
11914       if ((int)TREE_CODE (decl) > NUM_TREE_CODES)
11915         /* Probably some frontend-internal decl.  Assume we don't care.  */
11916         break;
11917       abort ();
11918     }
11919 }
11920 \f
11921 /* Add Ada "use" clause information for SGI Workshop debugger.  */
11922
11923 void
11924 dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
11925 {
11926   unsigned int file_index;
11927
11928   if (filename != NULL)
11929     {
11930       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
11931       tree context_list_decl
11932         = build_decl (LABEL_DECL, get_identifier (context_list),
11933                       void_type_node);
11934
11935       TREE_PUBLIC (context_list_decl) = TRUE;
11936       add_name_attribute (unit_die, context_list);
11937       file_index = lookup_filename (filename);
11938       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
11939       add_pubname (context_list_decl, unit_die);
11940     }
11941 }
11942
11943 /* Output debug information for global decl DECL.  Called from toplev.c after
11944    compilation proper has finished.  */
11945
11946 static void
11947 dwarf2out_global_decl (tree decl)
11948 {
11949   /* Output DWARF2 information for file-scope tentative data object
11950      declarations, file-scope (extern) function declarations (which had no
11951      corresponding body) and file-scope tagged type declarations and
11952      definitions which have not yet been forced out.  */
11953   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
11954     dwarf2out_decl (decl);
11955 }
11956
11957 /* Write the debugging output for DECL.  */
11958
11959 void
11960 dwarf2out_decl (tree decl)
11961 {
11962   dw_die_ref context_die = comp_unit_die;
11963
11964   switch (TREE_CODE (decl))
11965     {
11966     case ERROR_MARK:
11967       return;
11968
11969     case FUNCTION_DECL:
11970       /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
11971          builtin function.  Explicit programmer-supplied declarations of
11972          these same functions should NOT be ignored however.  */
11973       if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
11974         return;
11975
11976       /* What we would really like to do here is to filter out all mere
11977          file-scope declarations of file-scope functions which are never
11978          referenced later within this translation unit (and keep all of ones
11979          that *are* referenced later on) but we aren't clairvoyant, so we have
11980          no idea which functions will be referenced in the future (i.e. later
11981          on within the current translation unit). So here we just ignore all
11982          file-scope function declarations which are not also definitions.  If
11983          and when the debugger needs to know something about these functions,
11984          it will have to hunt around and find the DWARF information associated
11985          with the definition of the function.
11986
11987          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
11988          nodes represent definitions and which ones represent mere
11989          declarations.  We have to check DECL_INITIAL instead. That's because
11990          the C front-end supports some weird semantics for "extern inline"
11991          function definitions.  These can get inlined within the current
11992          translation unit (an thus, we need to generate Dwarf info for their
11993          abstract instances so that the Dwarf info for the concrete inlined
11994          instances can have something to refer to) but the compiler never
11995          generates any out-of-lines instances of such things (despite the fact
11996          that they *are* definitions).
11997
11998          The important point is that the C front-end marks these "extern
11999          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
12000          them anyway. Note that the C++ front-end also plays some similar games
12001          for inline function definitions appearing within include files which
12002          also contain `#pragma interface' pragmas.  */
12003       if (DECL_INITIAL (decl) == NULL_TREE)
12004         return;
12005
12006       /* If we're a nested function, initially use a parent of NULL; if we're
12007          a plain function, this will be fixed up in decls_for_scope.  If
12008          we're a method, it will be ignored, since we already have a DIE.  */
12009       if (decl_function_context (decl)
12010           /* But if we're in terse mode, we don't care about scope.  */
12011           && debug_info_level > DINFO_LEVEL_TERSE)
12012         context_die = NULL;
12013       break;
12014
12015     case VAR_DECL:
12016       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12017          declaration and if the declaration was never even referenced from
12018          within this entire compilation unit.  We suppress these DIEs in
12019          order to save space in the .debug section (by eliminating entries
12020          which are probably useless).  Note that we must not suppress
12021          block-local extern declarations (whether used or not) because that
12022          would screw-up the debugger's name lookup mechanism and cause it to
12023          miss things which really ought to be in scope at a given point.  */
12024       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
12025         return;
12026
12027       /* If we are in terse mode, don't generate any DIEs to represent any
12028          variable declarations or definitions.  */
12029       if (debug_info_level <= DINFO_LEVEL_TERSE)
12030         return;
12031       break;
12032
12033     case TYPE_DECL:
12034       /* Don't emit stubs for types unless they are needed by other DIEs.  */
12035       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
12036         return;
12037
12038       /* Don't bother trying to generate any DIEs to represent any of the
12039          normal built-in types for the language we are compiling.  */
12040       if (DECL_SOURCE_LINE (decl) == 0)
12041         {
12042           /* OK, we need to generate one for `bool' so GDB knows what type
12043              comparisons have.  */
12044           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
12045                == DW_LANG_C_plus_plus)
12046               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
12047               && ! DECL_IGNORED_P (decl))
12048             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
12049
12050           return;
12051         }
12052
12053       /* If we are in terse mode, don't generate any DIEs for types.  */
12054       if (debug_info_level <= DINFO_LEVEL_TERSE)
12055         return;
12056
12057       /* If we're a function-scope tag, initially use a parent of NULL;
12058          this will be fixed up in decls_for_scope.  */
12059       if (decl_function_context (decl))
12060         context_die = NULL;
12061
12062       break;
12063
12064     default:
12065       return;
12066     }
12067
12068   gen_decl_die (decl, context_die);
12069 }
12070
12071 /* Output a marker (i.e. a label) for the beginning of the generated code for
12072    a lexical block.  */
12073
12074 static void
12075 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
12076                        unsigned int blocknum)
12077 {
12078   function_section (current_function_decl);
12079   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
12080 }
12081
12082 /* Output a marker (i.e. a label) for the end of the generated code for a
12083    lexical block.  */
12084
12085 static void
12086 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
12087 {
12088   function_section (current_function_decl);
12089   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
12090 }
12091
12092 /* Returns nonzero if it is appropriate not to emit any debugging
12093    information for BLOCK, because it doesn't contain any instructions.
12094
12095    Don't allow this for blocks with nested functions or local classes
12096    as we would end up with orphans, and in the presence of scheduling
12097    we may end up calling them anyway.  */
12098
12099 static bool
12100 dwarf2out_ignore_block (tree block)
12101 {
12102   tree decl;
12103
12104   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
12105     if (TREE_CODE (decl) == FUNCTION_DECL
12106         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
12107       return 0;
12108
12109   return 1;
12110 }
12111
12112 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12113    dwarf2out.c) and return its "index".  The index of each (known) filename is
12114    just a unique number which is associated with only that one filename.  We
12115    need such numbers for the sake of generating labels (in the .debug_sfnames
12116    section) and references to those files numbers (in the .debug_srcinfo
12117    and.debug_macinfo sections).  If the filename given as an argument is not
12118    found in our current list, add it to the list and assign it the next
12119    available unique index number.  In order to speed up searches, we remember
12120    the index of the filename was looked up last.  This handles the majority of
12121    all searches.  */
12122
12123 static unsigned
12124 lookup_filename (const char *file_name)
12125 {
12126   size_t i, n;
12127   char *save_file_name;
12128
12129   /* Check to see if the file name that was searched on the previous
12130      call matches this file name.  If so, return the index.  */
12131   if (file_table_last_lookup_index != 0)
12132     {
12133       const char *last
12134         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
12135       if (strcmp (file_name, last) == 0)
12136         return file_table_last_lookup_index;
12137     }
12138
12139   /* Didn't match the previous lookup, search the table */
12140   n = VARRAY_ACTIVE_SIZE (file_table);
12141   for (i = 1; i < n; i++)
12142     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
12143       {
12144         file_table_last_lookup_index = i;
12145         return i;
12146       }
12147
12148   /* Add the new entry to the end of the filename table.  */
12149   file_table_last_lookup_index = n;
12150   save_file_name = (char *) ggc_strdup (file_name);
12151   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
12152   VARRAY_PUSH_UINT (file_table_emitted, 0);
12153
12154   return i;
12155 }
12156
12157 static int
12158 maybe_emit_file (int fileno)
12159 {
12160   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
12161     {
12162       if (!VARRAY_UINT (file_table_emitted, fileno))
12163         {
12164           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
12165           fprintf (asm_out_file, "\t.file %u ",
12166                    VARRAY_UINT (file_table_emitted, fileno));
12167           output_quoted_string (asm_out_file,
12168                                 VARRAY_CHAR_PTR (file_table, fileno));
12169           fputc ('\n', asm_out_file);
12170         }
12171       return VARRAY_UINT (file_table_emitted, fileno);
12172     }
12173   else
12174     return fileno;
12175 }
12176
12177 static void
12178 init_file_table (void)
12179 {
12180   /* Allocate the initial hunk of the file_table.  */
12181   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
12182   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
12183
12184   /* Skip the first entry - file numbers begin at 1.  */
12185   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
12186   VARRAY_PUSH_UINT (file_table_emitted, 0);
12187   file_table_last_lookup_index = 0;
12188 }
12189
12190 /* Output a label to mark the beginning of a source code line entry
12191    and record information relating to this source line, in
12192    'line_info_table' for later output of the .debug_line section.  */
12193
12194 static void
12195 dwarf2out_source_line (unsigned int line, const char *filename)
12196 {
12197   if (debug_info_level >= DINFO_LEVEL_NORMAL
12198       && line != 0)
12199     {
12200       function_section (current_function_decl);
12201
12202       /* If requested, emit something human-readable.  */
12203       if (flag_debug_asm)
12204         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
12205                  filename, line);
12206
12207       if (DWARF2_ASM_LINE_DEBUG_INFO)
12208         {
12209           unsigned file_num = lookup_filename (filename);
12210
12211           file_num = maybe_emit_file (file_num);
12212
12213           /* Emit the .loc directive understood by GNU as.  */
12214           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
12215
12216           /* Indicate that line number info exists.  */
12217           line_info_table_in_use++;
12218
12219           /* Indicate that multiple line number tables exist.  */
12220           if (DECL_SECTION_NAME (current_function_decl))
12221             separate_line_info_table_in_use++;
12222         }
12223       else if (DECL_SECTION_NAME (current_function_decl))
12224         {
12225           dw_separate_line_info_ref line_info;
12226           (*targetm.asm_out.internal_label) (asm_out_file, SEPARATE_LINE_CODE_LABEL,
12227                                      separate_line_info_table_in_use);
12228
12229           /* expand the line info table if necessary */
12230           if (separate_line_info_table_in_use
12231               == separate_line_info_table_allocated)
12232             {
12233               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12234               separate_line_info_table
12235                 = ggc_realloc (separate_line_info_table,
12236                                separate_line_info_table_allocated
12237                                * sizeof (dw_separate_line_info_entry));
12238               memset (separate_line_info_table
12239                        + separate_line_info_table_in_use,
12240                       0,
12241                       (LINE_INFO_TABLE_INCREMENT
12242                        * sizeof (dw_separate_line_info_entry)));
12243             }
12244
12245           /* Add the new entry at the end of the line_info_table.  */
12246           line_info
12247             = &separate_line_info_table[separate_line_info_table_in_use++];
12248           line_info->dw_file_num = lookup_filename (filename);
12249           line_info->dw_line_num = line;
12250           line_info->function = current_function_funcdef_no;
12251         }
12252       else
12253         {
12254           dw_line_info_ref line_info;
12255
12256           (*targetm.asm_out.internal_label) (asm_out_file, LINE_CODE_LABEL,
12257                                      line_info_table_in_use);
12258
12259           /* Expand the line info table if necessary.  */
12260           if (line_info_table_in_use == line_info_table_allocated)
12261             {
12262               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12263               line_info_table
12264                 = ggc_realloc (line_info_table,
12265                                (line_info_table_allocated
12266                                 * sizeof (dw_line_info_entry)));
12267               memset (line_info_table + line_info_table_in_use, 0,
12268                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
12269             }
12270
12271           /* Add the new entry at the end of the line_info_table.  */
12272           line_info = &line_info_table[line_info_table_in_use++];
12273           line_info->dw_file_num = lookup_filename (filename);
12274           line_info->dw_line_num = line;
12275         }
12276     }
12277 }
12278
12279 /* Record the beginning of a new source file.  */
12280
12281 static void
12282 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
12283 {
12284   if (flag_eliminate_dwarf2_dups)
12285     {
12286       /* Record the beginning of the file for break_out_includes.  */
12287       dw_die_ref bincl_die;
12288
12289       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
12290       add_AT_string (bincl_die, DW_AT_name, filename);
12291     }
12292
12293   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12294     {
12295       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12296       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
12297       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
12298                                    lineno);
12299       maybe_emit_file (lookup_filename (filename));
12300       dw2_asm_output_data_uleb128 (lookup_filename (filename),
12301                                    "Filename we just started");
12302     }
12303 }
12304
12305 /* Record the end of a source file.  */
12306
12307 static void
12308 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
12309 {
12310   if (flag_eliminate_dwarf2_dups)
12311     /* Record the end of the file for break_out_includes.  */
12312     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
12313
12314   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12315     {
12316       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12317       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
12318     }
12319 }
12320
12321 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
12322    the tail part of the directive line, i.e. the part which is past the
12323    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12324
12325 static void
12326 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
12327                   const char *buffer ATTRIBUTE_UNUSED)
12328 {
12329   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12330     {
12331       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12332       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
12333       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12334       dw2_asm_output_nstring (buffer, -1, "The macro");
12335     }
12336 }
12337
12338 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
12339    the tail part of the directive line, i.e. the part which is past the
12340    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12341
12342 static void
12343 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
12344                  const char *buffer ATTRIBUTE_UNUSED)
12345 {
12346   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12347     {
12348       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12349       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
12350       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12351       dw2_asm_output_nstring (buffer, -1, "The macro");
12352     }
12353 }
12354
12355 /* Set up for Dwarf output at the start of compilation.  */
12356
12357 static void
12358 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
12359 {
12360   init_file_table ();
12361
12362   /* Allocate the initial hunk of the decl_die_table.  */
12363   decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
12364                                       * sizeof (dw_die_ref));
12365   decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
12366   decl_die_table_in_use = 0;
12367
12368   /* Allocate the initial hunk of the decl_scope_table.  */
12369   VARRAY_TREE_INIT (decl_scope_table, 256, "decl_scope_table");
12370
12371   /* Allocate the initial hunk of the abbrev_die_table.  */
12372   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
12373                                         * sizeof (dw_die_ref));
12374   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
12375   /* Zero-th entry is allocated, but unused */
12376   abbrev_die_table_in_use = 1;
12377
12378   /* Allocate the initial hunk of the line_info_table.  */
12379   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
12380                                        * sizeof (dw_line_info_entry));
12381   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
12382
12383   /* Zero-th entry is allocated, but unused */
12384   line_info_table_in_use = 1;
12385
12386   /* Generate the initial DIE for the .debug section.  Note that the (string)
12387      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
12388      will (typically) be a relative pathname and that this pathname should be
12389      taken as being relative to the directory from which the compiler was
12390      invoked when the given (base) source file was compiled.  We will fill
12391      in this value in dwarf2out_finish.  */
12392   comp_unit_die = gen_compile_unit_die (NULL);
12393
12394   VARRAY_TREE_INIT (incomplete_types, 64, "incomplete_types");
12395
12396   VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray");
12397
12398   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
12399   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
12400                                DEBUG_ABBREV_SECTION_LABEL, 0);
12401   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12402     ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
12403   else
12404     strcpy (text_section_label, stripattributes (TEXT_SECTION_NAME));
12405
12406   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
12407                                DEBUG_INFO_SECTION_LABEL, 0);
12408   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
12409                                DEBUG_LINE_SECTION_LABEL, 0);
12410   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
12411                                DEBUG_RANGES_SECTION_LABEL, 0);
12412   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
12413   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
12414   named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG);
12415   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
12416   named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
12417   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
12418
12419   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12420     {
12421       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12422       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
12423                                    DEBUG_MACINFO_SECTION_LABEL, 0);
12424       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
12425     }
12426
12427   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12428     {
12429       text_section ();
12430       ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
12431     }
12432 }
12433
12434 /* A helper function for dwarf2out_finish called through
12435    ht_forall.  Emit one queued .debug_str string.  */
12436
12437 static int
12438 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
12439 {
12440   struct indirect_string_node *node = (struct indirect_string_node *) *h;
12441
12442   if (node->form == DW_FORM_strp)
12443     {
12444       named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS);
12445       ASM_OUTPUT_LABEL (asm_out_file, node->label);
12446       assemble_string (node->str, strlen (node->str) + 1);
12447     }
12448
12449   return 1;
12450 }
12451
12452
12453
12454 /* Clear the marks for a die and its children.
12455    Be cool if the mark isn't set.  */
12456
12457 static void
12458 prune_unmark_dies (dw_die_ref die)
12459 {
12460   dw_die_ref c;
12461   die->die_mark = 0;
12462   for (c = die->die_child; c; c = c->die_sib)
12463     prune_unmark_dies (c);
12464 }
12465
12466
12467 /* Given DIE that we're marking as used, find any other dies
12468    it references as attributes and mark them as used.  */
12469
12470 static void
12471 prune_unused_types_walk_attribs (dw_die_ref die)
12472 {
12473   dw_attr_ref a;
12474
12475   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
12476     {
12477       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
12478         {
12479           /* A reference to another DIE.
12480              Make sure that it will get emitted.  */
12481           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
12482         }
12483       else if (a->dw_attr == DW_AT_decl_file)
12484         {
12485           /* A reference to a file.  Make sure the file name is emitted.  */
12486           a->dw_attr_val.v.val_unsigned =
12487             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
12488         }
12489     }
12490 }
12491
12492
12493 /* Mark DIE as being used.  If DOKIDS is true, then walk down
12494    to DIE's children.  */
12495
12496 static void
12497 prune_unused_types_mark (dw_die_ref die, int dokids)
12498 {
12499   dw_die_ref c;
12500
12501   if (die->die_mark == 0)
12502     {
12503       /* We haven't done this node yet.  Mark it as used.  */
12504       die->die_mark = 1;
12505
12506       /* We also have to mark its parents as used.
12507          (But we don't want to mark our parents' kids due to this.)  */
12508       if (die->die_parent)
12509         prune_unused_types_mark (die->die_parent, 0);
12510
12511       /* Mark any referenced nodes.  */
12512       prune_unused_types_walk_attribs (die);
12513     }
12514
12515   if (dokids && die->die_mark != 2)
12516     {
12517       /* We need to walk the children, but haven't done so yet.
12518          Remember that we've walked the kids.  */
12519       die->die_mark = 2;
12520
12521       /* Walk them.  */
12522       for (c = die->die_child; c; c = c->die_sib)
12523         {
12524           /* If this is an array type, we need to make sure our
12525              kids get marked, even if they're types.  */
12526           if (die->die_tag == DW_TAG_array_type)
12527             prune_unused_types_mark (c, 1);
12528           else
12529             prune_unused_types_walk (c);
12530         }
12531     }
12532 }
12533
12534
12535 /* Walk the tree DIE and mark types that we actually use.  */
12536
12537 static void
12538 prune_unused_types_walk (dw_die_ref die)
12539 {
12540   dw_die_ref c;
12541
12542   /* Don't do anything if this node is already marked.  */
12543   if (die->die_mark)
12544     return;
12545
12546   switch (die->die_tag) {
12547   case DW_TAG_const_type:
12548   case DW_TAG_packed_type:
12549   case DW_TAG_pointer_type:
12550   case DW_TAG_reference_type:
12551   case DW_TAG_volatile_type:
12552   case DW_TAG_typedef:
12553   case DW_TAG_array_type:
12554   case DW_TAG_structure_type:
12555   case DW_TAG_union_type:
12556   case DW_TAG_class_type:
12557   case DW_TAG_friend:
12558   case DW_TAG_variant_part:
12559   case DW_TAG_enumeration_type:
12560   case DW_TAG_subroutine_type:
12561   case DW_TAG_string_type:
12562   case DW_TAG_set_type:
12563   case DW_TAG_subrange_type:
12564   case DW_TAG_ptr_to_member_type:
12565   case DW_TAG_file_type:
12566     /* It's a type node --- don't mark it.  */
12567     return;
12568
12569   default:
12570     /* Mark everything else.  */
12571     break;
12572   }
12573
12574   die->die_mark = 1;
12575
12576   /* Now, mark any dies referenced from here.  */
12577   prune_unused_types_walk_attribs (die);
12578
12579   /* Mark children.  */
12580   for (c = die->die_child; c; c = c->die_sib)
12581     prune_unused_types_walk (c);
12582 }
12583
12584
12585 /* Remove from the tree DIE any dies that aren't marked.  */
12586
12587 static void
12588 prune_unused_types_prune (dw_die_ref die)
12589 {
12590   dw_die_ref c, p, n;
12591   if (!die->die_mark)
12592     abort();
12593
12594   p = NULL;
12595   for (c = die->die_child; c; c = n)
12596     {
12597       n = c->die_sib;
12598       if (c->die_mark)
12599         {
12600           prune_unused_types_prune (c);
12601           p = c;
12602         }
12603       else
12604         {
12605           if (p)
12606             p->die_sib = n;
12607           else
12608             die->die_child = n;
12609           free_die (c);
12610         }
12611     }
12612 }
12613
12614
12615 /* Remove dies representing declarations that we never use.  */
12616
12617 static void
12618 prune_unused_types (void)
12619 {
12620   unsigned int i;
12621   limbo_die_node *node;
12622
12623   /* Clear all the marks.  */
12624   prune_unmark_dies (comp_unit_die);
12625   for (node = limbo_die_list; node; node = node->next)
12626     prune_unmark_dies (node->die);
12627
12628   /* Set the mark on nodes that are actually used.  */
12629   prune_unused_types_walk (comp_unit_die);
12630   for (node = limbo_die_list; node; node = node->next)
12631     prune_unused_types_walk (node->die);
12632
12633   /* Also set the mark on nodes referenced from the
12634      pubname_table or arange_table.  */
12635   for (i = 0; i < pubname_table_in_use; i++)
12636     prune_unused_types_mark (pubname_table[i].die, 1);
12637   for (i = 0; i < arange_table_in_use; i++)
12638     prune_unused_types_mark (arange_table[i], 1);
12639
12640   /* Get rid of nodes that aren't marked.  */
12641   prune_unused_types_prune (comp_unit_die);
12642   for (node = limbo_die_list; node; node = node->next)
12643     prune_unused_types_prune (node->die);
12644
12645   /* Leave the marks clear.  */
12646   prune_unmark_dies (comp_unit_die);
12647   for (node = limbo_die_list; node; node = node->next)
12648     prune_unmark_dies (node->die);
12649 }
12650
12651 /* Output stuff that dwarf requires at the end of every file,
12652    and generate the DWARF-2 debugging info.  */
12653
12654 static void
12655 dwarf2out_finish (const char *filename)
12656 {
12657   limbo_die_node *node, *next_node;
12658   dw_die_ref die = 0;
12659
12660   /* Add the name for the main input file now.  We delayed this from
12661      dwarf2out_init to avoid complications with PCH.  */
12662   add_name_attribute (comp_unit_die, filename);
12663   if (filename[0] != DIR_SEPARATOR)
12664     add_comp_dir_attribute (comp_unit_die);
12665   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
12666     {
12667       size_t i;
12668       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
12669         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
12670             /* Don't add cwd for <built-in>.  */
12671             && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
12672           {
12673             add_comp_dir_attribute (comp_unit_die);
12674             break;
12675           }
12676     }
12677
12678   /* Traverse the limbo die list, and add parent/child links.  The only
12679      dies without parents that should be here are concrete instances of
12680      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
12681      For concrete instances, we can get the parent die from the abstract
12682      instance.  */
12683   for (node = limbo_die_list; node; node = next_node)
12684     {
12685       next_node = node->next;
12686       die = node->die;
12687
12688       if (die->die_parent == NULL)
12689         {
12690           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
12691           tree context;
12692
12693           if (origin)
12694             add_child_die (origin->die_parent, die);
12695           else if (die == comp_unit_die)
12696             ;
12697           /* If this was an expression for a bound involved in a function
12698              return type, it may be a SAVE_EXPR for which we weren't able
12699              to find a DIE previously.  So try now.  */
12700           else if (node->created_for
12701                    && TREE_CODE (node->created_for) == SAVE_EXPR
12702                    && 0 != (origin = (lookup_decl_die
12703                                       (SAVE_EXPR_CONTEXT
12704                                        (node->created_for)))))
12705             add_child_die (origin, die);
12706           else if (errorcount > 0 || sorrycount > 0)
12707             /* It's OK to be confused by errors in the input.  */
12708             add_child_die (comp_unit_die, die);
12709           else if (node->created_for
12710                    && ((DECL_P (node->created_for)
12711                         && (context = DECL_CONTEXT (node->created_for)))
12712                        || (TYPE_P (node->created_for)
12713                            && (context = TYPE_CONTEXT (node->created_for))))
12714                    && TREE_CODE (context) == FUNCTION_DECL)
12715             {
12716               /* In certain situations, the lexical block containing a
12717                  nested function can be optimized away, which results
12718                  in the nested function die being orphaned.  Likewise
12719                  with the return type of that nested function.  Force
12720                  this to be a child of the containing function.  */
12721               origin = lookup_decl_die (context);
12722               if (! origin)
12723                 abort ();
12724               add_child_die (origin, die);
12725             }
12726           else
12727             abort ();
12728         }
12729     }
12730
12731   limbo_die_list = NULL;
12732
12733   /* Walk through the list of incomplete types again, trying once more to
12734      emit full debugging info for them.  */
12735   retry_incomplete_types ();
12736
12737   /* We need to reverse all the dies before break_out_includes, or
12738      we'll see the end of an include file before the beginning.  */
12739   reverse_all_dies (comp_unit_die);
12740
12741   if (flag_eliminate_unused_debug_types)
12742     prune_unused_types ();
12743
12744   /* Generate separate CUs for each of the include files we've seen.
12745      They will go into limbo_die_list.  */
12746   if (flag_eliminate_dwarf2_dups)
12747     break_out_includes (comp_unit_die);
12748
12749   /* Traverse the DIE's and add add sibling attributes to those DIE's
12750      that have children.  */
12751   add_sibling_attributes (comp_unit_die);
12752   for (node = limbo_die_list; node; node = node->next)
12753     add_sibling_attributes (node->die);
12754
12755   /* Output a terminator label for the .text section.  */
12756   text_section ();
12757   (*targetm.asm_out.internal_label) (asm_out_file, TEXT_END_LABEL, 0);
12758
12759   /* Output the source line correspondence table.  We must do this
12760      even if there is no line information.  Otherwise, on an empty
12761      translation unit, we will generate a present, but empty,
12762      .debug_info section.  IRIX 6.5 `nm' will then complain when
12763      examining the file.  */
12764   if (! DWARF2_ASM_LINE_DEBUG_INFO)
12765     {
12766       named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
12767       output_line_info ();
12768     }
12769
12770   /* Output location list section if necessary.  */
12771   if (have_location_lists)
12772     {
12773       /* Output the location lists info.  */
12774       named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG);
12775       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
12776                                    DEBUG_LOC_SECTION_LABEL, 0);
12777       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
12778       output_location_lists (die);
12779       have_location_lists = 0;
12780     }
12781
12782   /* We can only use the low/high_pc attributes if all of the code was
12783      in .text.  */
12784   if (separate_line_info_table_in_use == 0)
12785     {
12786       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
12787       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
12788     }
12789
12790   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
12791      "base address".  Use zero so that these addresses become absolute.  */
12792   else if (have_location_lists || ranges_table_in_use)
12793     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
12794
12795   if (debug_info_level >= DINFO_LEVEL_NORMAL)
12796     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
12797                        debug_line_section_label);
12798
12799   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12800     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
12801
12802   /* Output all of the compilation units.  We put the main one last so that
12803      the offsets are available to output_pubnames.  */
12804   for (node = limbo_die_list; node; node = node->next)
12805     output_comp_unit (node->die, 0);
12806
12807   output_comp_unit (comp_unit_die, 0);
12808
12809   /* Output the abbreviation table.  */
12810   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
12811   output_abbrev_section ();
12812
12813   /* Output public names table if necessary.  */
12814   if (pubname_table_in_use)
12815     {
12816       named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG);
12817       output_pubnames ();
12818     }
12819
12820   /* Output the address range information.  We only put functions in the arange
12821      table, so don't write it out if we don't have any.  */
12822   if (fde_table_in_use)
12823     {
12824       named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG);
12825       output_aranges ();
12826     }
12827
12828   /* Output ranges section if necessary.  */
12829   if (ranges_table_in_use)
12830     {
12831       named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG);
12832       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
12833       output_ranges ();
12834     }
12835
12836   /* Have to end the primary source file.  */
12837   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12838     {
12839       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12840       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
12841       dw2_asm_output_data (1, 0, "End compilation unit");
12842     }
12843
12844   /* If we emitted any DW_FORM_strp form attribute, output the string
12845      table too.  */
12846   if (debug_str_hash)
12847     htab_traverse (debug_str_hash, output_indirect_string, NULL);
12848 }
12849 #else
12850
12851 /* This should never be used, but its address is needed for comparisons.  */
12852 const struct gcc_debug_hooks dwarf2_debug_hooks;
12853
12854 #endif /* DWARF2_DEBUGGING_INFO */
12855
12856 #include "gt-dwarf2out.h"