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