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