gcc/dwarf2out.c

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