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