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