gcc/dwarf2out.c

   1 /* Output Dwarf2 format symbol table information from GCC.
   2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
  23 02110-1301, USA.  */
  24
  25 /* TODO: Emit .debug_line header even when there are no functions, since
  26            the file numbers are used by .debug_info.  Alternately, leave
  27            out locations for types and decls.
  28          Avoid talking about ctors and op= for PODs.
  29          Factor out common prologue sequences into multiple CIEs.  */
  30
  31 /* The first part of this file deals with the DWARF 2 frame unwind
  32    information, which is also used by the GCC efficient exception handling
  33    mechanism.  The second part, controlled only by an #ifdef
  34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  35    information.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "coretypes.h"
  40 #include "tm.h"
  41 #include "tree.h"
  42 #include "version.h"
  43 #include "flags.h"
  44 #include "real.h"
  45 #include "rtl.h"
  46 #include "hard-reg-set.h"
  47 #include "regs.h"
  48 #include "insn-config.h"
  49 #include "reload.h"
  50 #include "function.h"
  51 #include "output.h"
  52 #include "expr.h"
  53 #include "libfuncs.h"
  54 #include "except.h"
  55 #include "dwarf2.h"
  56 #include "dwarf2out.h"
  57 #include "dwarf2asm.h"
  58 #include "toplev.h"
  59 #include "varray.h"
  60 #include "ggc.h"
  61 #include "md5.h"
  62 #include "tm_p.h"
  63 #include "diagnostic.h"
  64 #include "debug.h"
  65 #include "target.h"
  66 #include "langhooks.h"
  67 #include "hashtab.h"
  68 #include "cgraph.h"
  69 #include "input.h"
  70
  71 #ifdef DWARF2_DEBUGGING_INFO
  72 static void dwarf2out_source_line (unsigned int, const char *);
  73 #endif
  74
  75 /* DWARF2 Abbreviation Glossary:
  76    CFA = Canonical Frame Address
  77            a fixed address on the stack which identifies a call frame.
  78            We define it to be the value of SP just before the call insn.
  79            The CFA register and offset, which may change during the course
  80            of the function, are used to calculate its value at runtime.
  81    CFI = Call Frame Instruction
  82            an instruction for the DWARF2 abstract machine
  83    CIE = Common Information Entry
  84            information describing information common to one or more FDEs
  85    DIE = Debugging Information Entry
  86    FDE = Frame Description Entry
  87            information describing the stack call frame, in particular,
  88            how to restore registers
  89
  90    DW_CFA_... = DWARF2 CFA call frame instruction
  91    DW_TAG_... = DWARF2 DIE tag */
  92
  93 /* Decide whether we want to emit frame unwind information for the current
  94    translation unit.  */
  95
  96 int
  97 dwarf2out_do_frame (void)
  98 {
  99   return (write_symbols == DWARF2_DEBUG
 100           || write_symbols == VMS_AND_DWARF2_DEBUG
 101 #ifdef DWARF2_FRAME_INFO
 102           || DWARF2_FRAME_INFO
 103 #endif
 104 #ifdef DWARF2_UNWIND_INFO
 105           || flag_unwind_tables
 106           || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)
 107 #endif
 108           );
 109 }
 110
 111 /* The size of the target's pointer type.  */
 112 #ifndef PTR_SIZE
 113 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 114 #endif
 115
 116 /* Various versions of targetm.eh_frame_section.  Note these must appear
 117    outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards.  */
 118
 119 /* Version of targetm.eh_frame_section for systems with named sections.  */
 120 void
 121 named_section_eh_frame_section (void)
 122 {
 123 #ifdef EH_FRAME_SECTION_NAME
 124   int flags;
 125
 126   if (EH_TABLES_CAN_BE_READ_ONLY)
 127     {
 128       int fde_encoding;
 129       int per_encoding;
 130       int lsda_encoding;
 131
 132       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
 133       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
 134       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
 135       flags = (! flag_pic
 136                || ((fde_encoding & 0x70) != DW_EH_PE_absptr
 137                    && (fde_encoding & 0x70) != DW_EH_PE_aligned
 138                    && (per_encoding & 0x70) != DW_EH_PE_absptr
 139                    && (per_encoding & 0x70) != DW_EH_PE_aligned
 140                    && (lsda_encoding & 0x70) != DW_EH_PE_absptr
 141                    && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
 142               ? 0 : SECTION_WRITE;
 143     }
 144   else
 145     flags = SECTION_WRITE;
 146   named_section_flags (EH_FRAME_SECTION_NAME, flags);
 147 #endif
 148 }
 149
 150 /* Version of targetm.eh_frame_section for systems using collect2.  */
 151 void
 152 collect2_eh_frame_section (void)
 153 {
 154   tree label = get_file_function_name ('F');
 155
 156   data_section ();
 157   ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
 158   targetm.asm_out.globalize_label (asm_out_file, IDENTIFIER_POINTER (label));
 159   ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
 160 }
 161
 162 /* Default version of targetm.eh_frame_section.  */
 163 void
 164 default_eh_frame_section (void)
 165 {
 166 #ifdef EH_FRAME_SECTION_NAME
 167   named_section_eh_frame_section ();
 168 #else
 169   collect2_eh_frame_section ();
 170 #endif
 171 }
 172
 173 DEF_VEC_P(rtx);
 174 DEF_VEC_ALLOC_P(rtx,gc);
 175
 176 /* Array of RTXes referenced by the debugging information, which therefore
 177    must be kept around forever.  */
 178 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 179
 180 /* A pointer to the base of a list of incomplete types which might be
 181    completed at some later time.  incomplete_types_list needs to be a
 182    VEC(tree,gc) because we want to tell the garbage collector about
 183    it.  */
 184 static GTY(()) VEC(tree,gc) *incomplete_types;
 185
 186 /* A pointer to the base of a table of references to declaration
 187    scopes.  This table is a display which tracks the nesting
 188    of declaration scopes at the current scope and containing
 189    scopes.  This table is used to find the proper place to
 190    define type declaration DIE's.  */
 191 static GTY(()) VEC(tree,gc) *decl_scope_table;
 192
 193 /* How to start an assembler comment.  */
 194 #ifndef ASM_COMMENT_START
 195 #define ASM_COMMENT_START ";#"
 196 #endif
 197
 198 typedef struct dw_cfi_struct *dw_cfi_ref;
 199 typedef struct dw_fde_struct *dw_fde_ref;
 200 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 201
 202 /* Call frames are described using a sequence of Call Frame
 203    Information instructions.  The register number, offset
 204    and address fields are provided as possible operands;
 205    their use is selected by the opcode field.  */
 206
 207 enum dw_cfi_oprnd_type {
 208   dw_cfi_oprnd_unused,
 209   dw_cfi_oprnd_reg_num,
 210   dw_cfi_oprnd_offset,
 211   dw_cfi_oprnd_addr,
 212   dw_cfi_oprnd_loc
 213 };
 214
 215 typedef union dw_cfi_oprnd_struct GTY(())
 216 {
 217   unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 218   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 219   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 220   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 221 }
 222 dw_cfi_oprnd;
 223
 224 typedef struct dw_cfi_struct GTY(())
 225 {
 226   dw_cfi_ref dw_cfi_next;
 227   enum dwarf_call_frame_info dw_cfi_opc;
 228   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 229     dw_cfi_oprnd1;
 230   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 231     dw_cfi_oprnd2;
 232 }
 233 dw_cfi_node;
 234
 235 /* This is how we define the location of the CFA. We use to handle it
 236    as REG + OFFSET all the time,  but now it can be more complex.
 237    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 238    Instead of passing around REG and OFFSET, we pass a copy
 239    of this structure.  */
 240 typedef struct cfa_loc GTY(())
 241 {
 242   unsigned long reg;
 243   HOST_WIDE_INT offset;
 244   HOST_WIDE_INT base_offset;
 245   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 246 } dw_cfa_location;
 247
 248 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 249    refer to a single Common Information Entry (CIE), defined at
 250    the beginning of the .debug_frame section.  This use of a single
 251    CIE obviates the need to keep track of multiple CIE's
 252    in the DWARF generation routines below.  */
 253
 254 typedef struct dw_fde_struct GTY(())
 255 {
 256   tree decl;
 257   const char *dw_fde_begin;
 258   const char *dw_fde_current_label;
 259   const char *dw_fde_end;
 260   const char *dw_fde_hot_section_label;
 261   const char *dw_fde_hot_section_end_label;
 262   const char *dw_fde_unlikely_section_label;
 263   const char *dw_fde_unlikely_section_end_label;
 264   bool dw_fde_switched_sections;
 265   dw_cfi_ref dw_fde_cfi;
 266   unsigned funcdef_number;
 267   unsigned all_throwers_are_sibcalls : 1;
 268   unsigned nothrow : 1;
 269   unsigned uses_eh_lsda : 1;
 270 }
 271 dw_fde_node;
 272
 273 /* Maximum size (in bytes) of an artificially generated label.  */
 274 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 275
 276 /* The size of addresses as they appear in the Dwarf 2 data.
 277    Some architectures use word addresses to refer to code locations,
 278    but Dwarf 2 info always uses byte addresses.  On such machines,
 279    Dwarf 2 addresses need to be larger than the architecture's
 280    pointers.  */
 281 #ifndef DWARF2_ADDR_SIZE
 282 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 283 #endif
 284
 285 /* The size in bytes of a DWARF field indicating an offset or length
 286    relative to a debug info section, specified to be 4 bytes in the
 287    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 288    as PTR_SIZE.  */
 289
 290 #ifndef DWARF_OFFSET_SIZE
 291 #define DWARF_OFFSET_SIZE 4
 292 #endif
 293
 294 /* According to the (draft) DWARF 3 specification, the initial length
 295    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 296    bytes are 0xffffffff, followed by the length stored in the next 8
 297    bytes.
 298
 299    However, the SGI/MIPS ABI uses an initial length which is equal to
 300    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 301
 302 #ifndef DWARF_INITIAL_LENGTH_SIZE
 303 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 304 #endif
 305
 306 #define DWARF_VERSION 2
 307
 308 /* Round SIZE up to the nearest BOUNDARY.  */
 309 #define DWARF_ROUND(SIZE,BOUNDARY) \
 310   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 311
 312 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 313 #ifndef DWARF_CIE_DATA_ALIGNMENT
 314 #ifdef STACK_GROWS_DOWNWARD
 315 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 316 #else
 317 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 318 #endif
 319 #endif
 320
 321 /* A pointer to the base of a table that contains frame description
 322    information for each routine.  */
 323 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 324
 325 /* Number of elements currently allocated for fde_table.  */
 326 static GTY(()) unsigned fde_table_allocated;
 327
 328 /* Number of elements in fde_table currently in use.  */
 329 static GTY(()) unsigned fde_table_in_use;
 330
 331 /* Size (in elements) of increments by which we may expand the
 332    fde_table.  */
 333 #define FDE_TABLE_INCREMENT 256
 334
 335 /* A list of call frame insns for the CIE.  */
 336 static GTY(()) dw_cfi_ref cie_cfi_head;
 337
 338 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 339 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 340    attribute that accelerates the lookup of the FDE associated
 341    with the subprogram.  This variable holds the table index of the FDE
 342    associated with the current function (body) definition.  */
 343 static unsigned current_funcdef_fde;
 344 #endif
 345
 346 struct indirect_string_node GTY(())
 347 {
 348   const char *str;
 349   unsigned int refcount;
 350   unsigned int form;
 351   char *label;
 352 };
 353
 354 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 355
 356 static GTY(()) int dw2_string_counter;
 357 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 358
 359 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 360
 361 /* Forward declarations for functions defined in this file.  */
 362
 363 static char *stripattributes (const char *);
 364 static const char *dwarf_cfi_name (unsigned);
 365 static dw_cfi_ref new_cfi (void);
 366 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 367 static void add_fde_cfi (const char *, dw_cfi_ref);
 368 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
 369 static void lookup_cfa (dw_cfa_location *);
 370 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 371 static void initial_return_save (rtx);
 372 static HOST_WIDE_INT stack_adjust_offset (rtx);
 373 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 374 static void output_call_frame_info (int);
 375 static void dwarf2out_stack_adjust (rtx, bool);
 376 static void flush_queued_reg_saves (void);
 377 static bool clobbers_queued_reg_save (rtx);
 378 static void dwarf2out_frame_debug_expr (rtx, const char *);
 379
 380 /* Support for complex CFA locations.  */
 381 static void output_cfa_loc (dw_cfi_ref);
 382 static void get_cfa_from_loc_descr (dw_cfa_location *,
 383                                     struct dw_loc_descr_struct *);
 384 static struct dw_loc_descr_struct *build_cfa_loc
 385  (dw_cfa_location *);
 386 static void def_cfa_1 (const char *, dw_cfa_location *);
 387
 388 /* How to start an assembler comment.  */
 389 #ifndef ASM_COMMENT_START
 390 #define ASM_COMMENT_START ";#"
 391 #endif
 392
 393 /* Data and reference forms for relocatable data.  */
 394 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 395 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 396
 397 #ifndef DEBUG_FRAME_SECTION
 398 #define DEBUG_FRAME_SECTION     ".debug_frame"
 399 #endif
 400
 401 #ifndef FUNC_BEGIN_LABEL
 402 #define FUNC_BEGIN_LABEL        "LFB"
 403 #endif
 404
 405 #ifndef FUNC_END_LABEL
 406 #define FUNC_END_LABEL          "LFE"
 407 #endif
 408
 409 #ifndef FRAME_BEGIN_LABEL
 410 #define FRAME_BEGIN_LABEL       "Lframe"
 411 #endif
 412 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 413 #define CIE_END_LABEL           "LECIE"
 414 #define FDE_LABEL               "LSFDE"
 415 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 416 #define FDE_END_LABEL           "LEFDE"
 417 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 418 #define LINE_NUMBER_END_LABEL   "LELT"
 419 #define LN_PROLOG_AS_LABEL      "LASLTP"
 420 #define LN_PROLOG_END_LABEL     "LELTP"
 421 #define DIE_LABEL_PREFIX        "DW"
 422
 423 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 424    is the column for PC, or the first column after all of the hard
 425    registers.  */
 426 #ifndef DWARF_FRAME_RETURN_COLUMN
 427 #ifdef PC_REGNUM
 428 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 429 #else
 430 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 431 #endif
 432 #endif
 433
 434 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 435    default, we just provide columns for all registers.  */
 436 #ifndef DWARF_FRAME_REGNUM
 437 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 438 #endif
 439
 440 /* The offset from the incoming value of %sp to the top of the stack frame
 441    for the current function.  */
 442 #ifndef INCOMING_FRAME_SP_OFFSET
 443 #define INCOMING_FRAME_SP_OFFSET 0
 444 #endif
 445 \f
 446 /* Hook used by __throw.  */
 447
 448 rtx
 449 expand_builtin_dwarf_sp_column (void)
 450 {
 451   return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
 452 }
 453
 454 /* Return a pointer to a copy of the section string name S with all
 455    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 456
 457 static inline char *
 458 stripattributes (const char *s)
 459 {
 460   char *stripped = xmalloc (strlen (s) + 2);
 461   char *p = stripped;
 462
 463   *p++ = '*';
 464
 465   while (*s && *s != ',')
 466     *p++ = *s++;
 467
 468   *p = '\0';
 469   return stripped;
 470 }
 471
 472 /* Generate code to initialize the register size table.  */
 473
 474 void
 475 expand_builtin_init_dwarf_reg_sizes (tree address)
 476 {
 477   int i;
 478   enum machine_mode mode = TYPE_MODE (char_type_node);
 479   rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
 480   rtx mem = gen_rtx_MEM (BLKmode, addr);
 481   bool wrote_return_column = false;
 482
 483   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 484     if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
 485       {
 486         HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
 487         enum machine_mode save_mode = reg_raw_mode[i];
 488         HOST_WIDE_INT size;
 489
 490         if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 491           save_mode = choose_hard_reg_mode (i, 1, true);
 492         if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 493           {
 494             if (save_mode == VOIDmode)
 495               continue;
 496             wrote_return_column = true;
 497           }
 498         size = GET_MODE_SIZE (save_mode);
 499         if (offset < 0)
 500           continue;
 501
 502         emit_move_insn (adjust_address (mem, mode, offset),
 503                         gen_int_mode (size, mode));
 504       }
 505
 506 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 507   gcc_assert (wrote_return_column);
 508   i = DWARF_ALT_FRAME_RETURN_COLUMN;
 509   wrote_return_column = false;
 510 #else
 511   i = DWARF_FRAME_RETURN_COLUMN;
 512 #endif
 513
 514   if (! wrote_return_column)
 515     {
 516       enum machine_mode save_mode = Pmode;
 517       HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
 518       HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
 519       emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 520     }
 521 }
 522
 523 /* Convert a DWARF call frame info. operation to its string name */
 524
 525 static const char *
 526 dwarf_cfi_name (unsigned int cfi_opc)
 527 {
 528   switch (cfi_opc)
 529     {
 530     case DW_CFA_advance_loc:
 531       return "DW_CFA_advance_loc";
 532     case DW_CFA_offset:
 533       return "DW_CFA_offset";
 534     case DW_CFA_restore:
 535       return "DW_CFA_restore";
 536     case DW_CFA_nop:
 537       return "DW_CFA_nop";
 538     case DW_CFA_set_loc:
 539       return "DW_CFA_set_loc";
 540     case DW_CFA_advance_loc1:
 541       return "DW_CFA_advance_loc1";
 542     case DW_CFA_advance_loc2:
 543       return "DW_CFA_advance_loc2";
 544     case DW_CFA_advance_loc4:
 545       return "DW_CFA_advance_loc4";
 546     case DW_CFA_offset_extended:
 547       return "DW_CFA_offset_extended";
 548     case DW_CFA_restore_extended:
 549       return "DW_CFA_restore_extended";
 550     case DW_CFA_undefined:
 551       return "DW_CFA_undefined";
 552     case DW_CFA_same_value:
 553       return "DW_CFA_same_value";
 554     case DW_CFA_register:
 555       return "DW_CFA_register";
 556     case DW_CFA_remember_state:
 557       return "DW_CFA_remember_state";
 558     case DW_CFA_restore_state:
 559       return "DW_CFA_restore_state";
 560     case DW_CFA_def_cfa:
 561       return "DW_CFA_def_cfa";
 562     case DW_CFA_def_cfa_register:
 563       return "DW_CFA_def_cfa_register";
 564     case DW_CFA_def_cfa_offset:
 565       return "DW_CFA_def_cfa_offset";
 566
 567     /* DWARF 3 */
 568     case DW_CFA_def_cfa_expression:
 569       return "DW_CFA_def_cfa_expression";
 570     case DW_CFA_expression:
 571       return "DW_CFA_expression";
 572     case DW_CFA_offset_extended_sf:
 573       return "DW_CFA_offset_extended_sf";
 574     case DW_CFA_def_cfa_sf:
 575       return "DW_CFA_def_cfa_sf";
 576     case DW_CFA_def_cfa_offset_sf:
 577       return "DW_CFA_def_cfa_offset_sf";
 578
 579     /* SGI/MIPS specific */
 580     case DW_CFA_MIPS_advance_loc8:
 581       return "DW_CFA_MIPS_advance_loc8";
 582
 583     /* GNU extensions */
 584     case DW_CFA_GNU_window_save:
 585       return "DW_CFA_GNU_window_save";
 586     case DW_CFA_GNU_args_size:
 587       return "DW_CFA_GNU_args_size";
 588     case DW_CFA_GNU_negative_offset_extended:
 589       return "DW_CFA_GNU_negative_offset_extended";
 590
 591     default:
 592       return "DW_CFA_<unknown>";
 593     }
 594 }
 595
 596 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 597
 598 static inline dw_cfi_ref
 599 new_cfi (void)
 600 {
 601   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
 602
 603   cfi->dw_cfi_next = NULL;
 604   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 605   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 606
 607   return cfi;
 608 }
 609
 610 /* Add a Call Frame Instruction to list of instructions.  */
 611
 612 static inline void
 613 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 614 {
 615   dw_cfi_ref *p;
 616
 617   /* Find the end of the chain.  */
 618   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 619     ;
 620
 621   *p = cfi;
 622 }
 623
 624 /* Generate a new label for the CFI info to refer to.  */
 625
 626 char *
 627 dwarf2out_cfi_label (void)
 628 {
 629   static char label[20];
 630
 631   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 632   ASM_OUTPUT_LABEL (asm_out_file, label);
 633   return label;
 634 }
 635
 636 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 637    or to the CIE if LABEL is NULL.  */
 638
 639 static void
 640 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 641 {
 642   if (label)
 643     {
 644       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 645
 646       if (*label == 0)
 647         label = dwarf2out_cfi_label ();
 648
 649       if (fde->dw_fde_current_label == NULL
 650           || strcmp (label, fde->dw_fde_current_label) != 0)
 651         {
 652           dw_cfi_ref xcfi;
 653
 654           fde->dw_fde_current_label = label = xstrdup (label);
 655
 656           /* Set the location counter to the new label.  */
 657           xcfi = new_cfi ();
 658           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
 659           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 660           add_cfi (&fde->dw_fde_cfi, xcfi);
 661         }
 662
 663       add_cfi (&fde->dw_fde_cfi, cfi);
 664     }
 665
 666   else
 667     add_cfi (&cie_cfi_head, cfi);
 668 }
 669
 670 /* Subroutine of lookup_cfa.  */
 671
 672 static inline void
 673 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
 674 {
 675   switch (cfi->dw_cfi_opc)
 676     {
 677     case DW_CFA_def_cfa_offset:
 678       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 679       break;
 680     case DW_CFA_def_cfa_register:
 681       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 682       break;
 683     case DW_CFA_def_cfa:
 684       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 685       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 686       break;
 687     case DW_CFA_def_cfa_expression:
 688       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 689       break;
 690     default:
 691       break;
 692     }
 693 }
 694
 695 /* Find the previous value for the CFA.  */
 696
 697 static void
 698 lookup_cfa (dw_cfa_location *loc)
 699 {
 700   dw_cfi_ref cfi;
 701
 702   loc->reg = (unsigned long) -1;
 703   loc->offset = 0;
 704   loc->indirect = 0;
 705   loc->base_offset = 0;
 706
 707   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 708     lookup_cfa_1 (cfi, loc);
 709
 710   if (fde_table_in_use)
 711     {
 712       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 713       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 714         lookup_cfa_1 (cfi, loc);
 715     }
 716 }
 717
 718 /* The current rule for calculating the DWARF2 canonical frame address.  */
 719 static dw_cfa_location cfa;
 720
 721 /* The register used for saving registers to the stack, and its offset
 722    from the CFA.  */
 723 static dw_cfa_location cfa_store;
 724
 725 /* The running total of the size of arguments pushed onto the stack.  */
 726 static HOST_WIDE_INT args_size;
 727
 728 /* The last args_size we actually output.  */
 729 static HOST_WIDE_INT old_args_size;
 730
 731 /* Entry point to update the canonical frame address (CFA).
 732    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 733    calculated from REG+OFFSET.  */
 734
 735 void
 736 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 737 {
 738   dw_cfa_location loc;
 739   loc.indirect = 0;
 740   loc.base_offset = 0;
 741   loc.reg = reg;
 742   loc.offset = offset;
 743   def_cfa_1 (label, &loc);
 744 }
 745
 746 /* This routine does the actual work.  The CFA is now calculated from
 747    the dw_cfa_location structure.  */
 748
 749 static void
 750 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
 751 {
 752   dw_cfi_ref cfi;
 753   dw_cfa_location old_cfa, loc;
 754
 755   cfa = *loc_p;
 756   loc = *loc_p;
 757
 758   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 759     cfa_store.offset = loc.offset;
 760
 761   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 762   lookup_cfa (&old_cfa);
 763
 764   /* If nothing changed, no need to issue any call frame instructions.  */
 765   if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset
 766       && loc.indirect == old_cfa.indirect
 767       && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset))
 768     return;
 769
 770   cfi = new_cfi ();
 771
 772   if (loc.reg == old_cfa.reg && !loc.indirect)
 773     {
 774       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
 775          indicating the CFA register did not change but the offset
 776          did.  */
 777       cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 778       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 779     }
 780
 781 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 782   else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1
 783            && !loc.indirect)
 784     {
 785       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 786          indicating the CFA register has changed to <register> but the
 787          offset has not changed.  */
 788       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 789       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 790     }
 791 #endif
 792
 793   else if (loc.indirect == 0)
 794     {
 795       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 796          indicating the CFA register has changed to <register> with
 797          the specified offset.  */
 798       cfi->dw_cfi_opc = DW_CFA_def_cfa;
 799       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 800       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 801     }
 802   else
 803     {
 804       /* Construct a DW_CFA_def_cfa_expression instruction to
 805          calculate the CFA using a full location expression since no
 806          register-offset pair is available.  */
 807       struct dw_loc_descr_struct *loc_list;
 808
 809       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 810       loc_list = build_cfa_loc (&loc);
 811       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 812     }
 813
 814   add_fde_cfi (label, cfi);
 815 }
 816
 817 /* Add the CFI for saving a register.  REG is the CFA column number.
 818    LABEL is passed to add_fde_cfi.
 819    If SREG is -1, the register is saved at OFFSET from the CFA;
 820    otherwise it is saved in SREG.  */
 821
 822 static void
 823 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
 824 {
 825   dw_cfi_ref cfi = new_cfi ();
 826
 827   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 828
 829   if (sreg == INVALID_REGNUM)
 830     {
 831       if (reg & ~0x3f)
 832         /* The register number won't fit in 6 bits, so we have to use
 833            the long form.  */
 834         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 835       else
 836         cfi->dw_cfi_opc = DW_CFA_offset;
 837
 838 #ifdef ENABLE_CHECKING
 839       {
 840         /* If we get an offset that is not a multiple of
 841            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 842            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 843            description.  */
 844         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 845
 846         gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
 847       }
 848 #endif
 849       offset /= DWARF_CIE_DATA_ALIGNMENT;
 850       if (offset < 0)
 851         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 852
 853       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 854     }
 855   else if (sreg == reg)
 856     cfi->dw_cfi_opc = DW_CFA_same_value;
 857   else
 858     {
 859       cfi->dw_cfi_opc = DW_CFA_register;
 860       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 861     }
 862
 863   add_fde_cfi (label, cfi);
 864 }
 865
 866 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 867    This CFI tells the unwinder that it needs to restore the window registers
 868    from the previous frame's window save area.
 869
 870    ??? Perhaps we should note in the CIE where windows are saved (instead of
 871    assuming 0(cfa)) and what registers are in the window.  */
 872
 873 void
 874 dwarf2out_window_save (const char *label)
 875 {
 876   dw_cfi_ref cfi = new_cfi ();
 877
 878   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 879   add_fde_cfi (label, cfi);
 880 }
 881
 882 /* Add a CFI to update the running total of the size of arguments
 883    pushed onto the stack.  */
 884
 885 void
 886 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
 887 {
 888   dw_cfi_ref cfi;
 889
 890   if (size == old_args_size)
 891     return;
 892
 893   old_args_size = size;
 894
 895   cfi = new_cfi ();
 896   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 897   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 898   add_fde_cfi (label, cfi);
 899 }
 900
 901 /* Entry point for saving a register to the stack.  REG is the GCC register
 902    number.  LABEL and OFFSET are passed to reg_save.  */
 903
 904 void
 905 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 906 {
 907   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
 908 }
 909
 910 /* Entry point for saving the return address in the stack.
 911    LABEL and OFFSET are passed to reg_save.  */
 912
 913 void
 914 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
 915 {
 916   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
 917 }
 918
 919 /* Entry point for saving the return address in a register.
 920    LABEL and SREG are passed to reg_save.  */
 921
 922 void
 923 dwarf2out_return_reg (const char *label, unsigned int sreg)
 924 {
 925   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
 926 }
 927
 928 /* Record the initial position of the return address.  RTL is
 929    INCOMING_RETURN_ADDR_RTX.  */
 930
 931 static void
 932 initial_return_save (rtx rtl)
 933 {
 934   unsigned int reg = INVALID_REGNUM;
 935   HOST_WIDE_INT offset = 0;
 936
 937   switch (GET_CODE (rtl))
 938     {
 939     case REG:
 940       /* RA is in a register.  */
 941       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 942       break;
 943
 944     case MEM:
 945       /* RA is on the stack.  */
 946       rtl = XEXP (rtl, 0);
 947       switch (GET_CODE (rtl))
 948         {
 949         case REG:
 950           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
 951           offset = 0;
 952           break;
 953
 954         case PLUS:
 955           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 956           offset = INTVAL (XEXP (rtl, 1));
 957           break;
 958
 959         case MINUS:
 960           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 961           offset = -INTVAL (XEXP (rtl, 1));
 962           break;
 963
 964         default:
 965           gcc_unreachable ();
 966         }
 967
 968       break;
 969
 970     case PLUS:
 971       /* The return address is at some offset from any value we can
 972          actually load.  For instance, on the SPARC it is in %i7+8. Just
 973          ignore the offset for now; it doesn't matter for unwinding frames.  */
 974       gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
 975       initial_return_save (XEXP (rtl, 0));
 976       return;
 977
 978     default:
 979       gcc_unreachable ();
 980     }
 981
 982   if (reg != DWARF_FRAME_RETURN_COLUMN)
 983     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
 984 }
 985
 986 /* Given a SET, calculate the amount of stack adjustment it
 987    contains.  */
 988
 989 static HOST_WIDE_INT
 990 stack_adjust_offset (rtx pattern)
 991 {
 992   rtx src = SET_SRC (pattern);
 993   rtx dest = SET_DEST (pattern);
 994   HOST_WIDE_INT offset = 0;
 995   enum rtx_code code;
 996
 997   if (dest == stack_pointer_rtx)
 998     {
 999       /* (set (reg sp) (plus (reg sp) (const_int))) */
1000       code = GET_CODE (src);
1001       if (! (code == PLUS || code == MINUS)
1002           || XEXP (src, 0) != stack_pointer_rtx
1003           || GET_CODE (XEXP (src, 1)) != CONST_INT)
1004         return 0;
1005
1006       offset = INTVAL (XEXP (src, 1));
1007       if (code == PLUS)
1008         offset = -offset;
1009     }
1010   else if (MEM_P (dest))
1011     {
1012       /* (set (mem (pre_dec (reg sp))) (foo)) */
1013       src = XEXP (dest, 0);
1014       code = GET_CODE (src);
1015
1016       switch (code)
1017         {
1018         case PRE_MODIFY:
1019         case POST_MODIFY:
1020           if (XEXP (src, 0) == stack_pointer_rtx)
1021             {
1022               rtx val = XEXP (XEXP (src, 1), 1);
1023               /* We handle only adjustments by constant amount.  */
1024               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1025                           && GET_CODE (val) == CONST_INT);
1026               offset = -INTVAL (val);
1027               break;
1028             }
1029           return 0;
1030
1031         case PRE_DEC:
1032         case POST_DEC:
1033           if (XEXP (src, 0) == stack_pointer_rtx)
1034             {
1035               offset = GET_MODE_SIZE (GET_MODE (dest));
1036               break;
1037             }
1038           return 0;
1039
1040         case PRE_INC:
1041         case POST_INC:
1042           if (XEXP (src, 0) == stack_pointer_rtx)
1043             {
1044               offset = -GET_MODE_SIZE (GET_MODE (dest));
1045               break;
1046             }
1047           return 0;
1048
1049         default:
1050           return 0;
1051         }
1052     }
1053   else
1054     return 0;
1055
1056   return offset;
1057 }
1058
1059 /* Check INSN to see if it looks like a push or a stack adjustment, and
1060    make a note of it if it does.  EH uses this information to find out how
1061    much extra space it needs to pop off the stack.  */
1062
1063 static void
1064 dwarf2out_stack_adjust (rtx insn, bool after_p)
1065 {
1066   HOST_WIDE_INT offset;
1067   const char *label;
1068   int i;
1069
1070   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1071      with this function.  Proper support would require all frame-related
1072      insns to be marked, and to be able to handle saving state around
1073      epilogues textually in the middle of the function.  */
1074   if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1075     return;
1076
1077   /* If only calls can throw, and we have a frame pointer,
1078      save up adjustments until we see the CALL_INSN.  */
1079   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1080     {
1081       if (CALL_P (insn) && !after_p)
1082         {
1083           /* Extract the size of the args from the CALL rtx itself.  */
1084           insn = PATTERN (insn);
1085           if (GET_CODE (insn) == PARALLEL)
1086             insn = XVECEXP (insn, 0, 0);
1087           if (GET_CODE (insn) == SET)
1088             insn = SET_SRC (insn);
1089           gcc_assert (GET_CODE (insn) == CALL);
1090           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1091         }
1092       return;
1093     }
1094
1095   if (CALL_P (insn) && !after_p)
1096     {
1097       if (!flag_asynchronous_unwind_tables)
1098         dwarf2out_args_size ("", args_size);
1099       return;
1100     }
1101   else if (BARRIER_P (insn))
1102     {
1103       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1104          the compiler will have already emitted a stack adjustment, but
1105          doesn't bother for calls to noreturn functions.  */
1106 #ifdef STACK_GROWS_DOWNWARD
1107       offset = -args_size;
1108 #else
1109       offset = args_size;
1110 #endif
1111     }
1112   else if (GET_CODE (PATTERN (insn)) == SET)
1113     offset = stack_adjust_offset (PATTERN (insn));
1114   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1115            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1116     {
1117       /* There may be stack adjustments inside compound insns.  Search
1118          for them.  */
1119       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1120         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1121           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1122     }
1123   else
1124     return;
1125
1126   if (offset == 0)
1127     return;
1128
1129   if (cfa.reg == STACK_POINTER_REGNUM)
1130     cfa.offset += offset;
1131
1132 #ifndef STACK_GROWS_DOWNWARD
1133   offset = -offset;
1134 #endif
1135
1136   args_size += offset;
1137   if (args_size < 0)
1138     args_size = 0;
1139
1140   label = dwarf2out_cfi_label ();
1141   def_cfa_1 (label, &cfa);
1142   if (flag_asynchronous_unwind_tables)
1143     dwarf2out_args_size (label, args_size);
1144 }
1145
1146 #endif
1147
1148 /* We delay emitting a register save until either (a) we reach the end
1149    of the prologue or (b) the register is clobbered.  This clusters
1150    register saves so that there are fewer pc advances.  */
1151
1152 struct queued_reg_save GTY(())
1153 {
1154   struct queued_reg_save *next;
1155   rtx reg;
1156   HOST_WIDE_INT cfa_offset;
1157   rtx saved_reg;
1158 };
1159
1160 static GTY(()) struct queued_reg_save *queued_reg_saves;
1161
1162 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1163 struct reg_saved_in_data GTY(()) {
1164   rtx orig_reg;
1165   rtx saved_in_reg;
1166 };
1167
1168 /* A list of registers saved in other registers.
1169    The list intentionally has a small maximum capacity of 4; if your
1170    port needs more than that, you might consider implementing a
1171    more efficient data structure.  */
1172 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1173 static GTY(()) size_t num_regs_saved_in_regs;
1174
1175 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1176 static const char *last_reg_save_label;
1177
1178 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1179    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1180
1181 static void
1182 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1183 {
1184   struct queued_reg_save *q;
1185
1186   /* Duplicates waste space, but it's also necessary to remove them
1187      for correctness, since the queue gets output in reverse
1188      order.  */
1189   for (q = queued_reg_saves; q != NULL; q = q->next)
1190     if (REGNO (q->reg) == REGNO (reg))
1191       break;
1192
1193   if (q == NULL)
1194     {
1195       q = ggc_alloc (sizeof (*q));
1196       q->next = queued_reg_saves;
1197       queued_reg_saves = q;
1198     }
1199
1200   q->reg = reg;
1201   q->cfa_offset = offset;
1202   q->saved_reg = sreg;
1203
1204   last_reg_save_label = label;
1205 }
1206
1207 /* Output all the entries in QUEUED_REG_SAVES.  */
1208
1209 static void
1210 flush_queued_reg_saves (void)
1211 {
1212   struct queued_reg_save *q;
1213
1214   for (q = queued_reg_saves; q; q = q->next)
1215     {
1216       size_t i;
1217       unsigned int reg, sreg;
1218
1219       for (i = 0; i < num_regs_saved_in_regs; i++)
1220         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1221           break;
1222       if (q->saved_reg && i == num_regs_saved_in_regs)
1223         {
1224           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1225           num_regs_saved_in_regs++;
1226         }
1227       if (i != num_regs_saved_in_regs)
1228         {
1229           regs_saved_in_regs[i].orig_reg = q->reg;
1230           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1231         }
1232
1233       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1234       if (q->saved_reg)
1235         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1236       else
1237         sreg = INVALID_REGNUM;
1238       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1239     }
1240
1241   queued_reg_saves = NULL;
1242   last_reg_save_label = NULL;
1243 }
1244
1245 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1246    location for?  Or, does it clobber a register which we've previously
1247    said that some other register is saved in, and for which we now
1248    have a new location for?  */
1249
1250 static bool
1251 clobbers_queued_reg_save (rtx insn)
1252 {
1253   struct queued_reg_save *q;
1254
1255   for (q = queued_reg_saves; q; q = q->next)
1256     {
1257       size_t i;
1258       if (modified_in_p (q->reg, insn))
1259         return true;
1260       for (i = 0; i < num_regs_saved_in_regs; i++)
1261         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1262             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1263           return true;
1264     }
1265
1266   return false;
1267 }
1268
1269 /* What register, if any, is currently saved in REG?  */
1270
1271 static rtx
1272 reg_saved_in (rtx reg)
1273 {
1274   unsigned int regn = REGNO (reg);
1275   size_t i;
1276   struct queued_reg_save *q;
1277
1278   for (q = queued_reg_saves; q; q = q->next)
1279     if (q->saved_reg && regn == REGNO (q->saved_reg))
1280       return q->reg;
1281
1282   for (i = 0; i < num_regs_saved_in_regs; i++)
1283     if (regs_saved_in_regs[i].saved_in_reg
1284         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1285       return regs_saved_in_regs[i].orig_reg;
1286
1287   return NULL_RTX;
1288 }
1289
1290
1291 /* A temporary register holding an integral value used in adjusting SP
1292    or setting up the store_reg.  The "offset" field holds the integer
1293    value, not an offset.  */
1294 static dw_cfa_location cfa_temp;
1295
1296 /* Record call frame debugging information for an expression EXPR,
1297    which either sets SP or FP (adjusting how we calculate the frame
1298    address) or saves a register to the stack or another register.
1299    LABEL indicates the address of EXPR.
1300
1301    This function encodes a state machine mapping rtxes to actions on
1302    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1303    users need not read the source code.
1304
1305   The High-Level Picture
1306
1307   Changes in the register we use to calculate the CFA: Currently we
1308   assume that if you copy the CFA register into another register, we
1309   should take the other one as the new CFA register; this seems to
1310   work pretty well.  If it's wrong for some target, it's simple
1311   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1312
1313   Changes in the register we use for saving registers to the stack:
1314   This is usually SP, but not always.  Again, we deduce that if you
1315   copy SP into another register (and SP is not the CFA register),
1316   then the new register is the one we will be using for register
1317   saves.  This also seems to work.
1318
1319   Register saves: There's not much guesswork about this one; if
1320   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1321   register save, and the register used to calculate the destination
1322   had better be the one we think we're using for this purpose.
1323   It's also assumed that a copy from a call-saved register to another
1324   register is saving that register if RTX_FRAME_RELATED_P is set on
1325   that instruction.  If the copy is from a call-saved register to
1326   the *same* register, that means that the register is now the same
1327   value as in the caller.
1328
1329   Except: If the register being saved is the CFA register, and the
1330   offset is nonzero, we are saving the CFA, so we assume we have to
1331   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1332   the intent is to save the value of SP from the previous frame.
1333
1334   In addition, if a register has previously been saved to a different
1335   register,
1336
1337   Invariants / Summaries of Rules
1338
1339   cfa          current rule for calculating the CFA.  It usually
1340                consists of a register and an offset.
1341   cfa_store    register used by prologue code to save things to the stack
1342                cfa_store.offset is the offset from the value of
1343                cfa_store.reg to the actual CFA
1344   cfa_temp     register holding an integral value.  cfa_temp.offset
1345                stores the value, which will be used to adjust the
1346                stack pointer.  cfa_temp is also used like cfa_store,
1347                to track stores to the stack via fp or a temp reg.
1348
1349   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1350                with cfa.reg as the first operand changes the cfa.reg and its
1351                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1352                cfa_temp.offset.
1353
1354   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1355                expression yielding a constant.  This sets cfa_temp.reg
1356                and cfa_temp.offset.
1357
1358   Rule 5:      Create a new register cfa_store used to save items to the
1359                stack.
1360
1361   Rules 10-14: Save a register to the stack.  Define offset as the
1362                difference of the original location and cfa_store's
1363                location (or cfa_temp's location if cfa_temp is used).
1364
1365   The Rules
1366
1367   "{a,b}" indicates a choice of a xor b.
1368   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1369
1370   Rule 1:
1371   (set <reg1> <reg2>:cfa.reg)
1372   effects: cfa.reg = <reg1>
1373            cfa.offset unchanged
1374            cfa_temp.reg = <reg1>
1375            cfa_temp.offset = cfa.offset
1376
1377   Rule 2:
1378   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1379                               {<const_int>,<reg>:cfa_temp.reg}))
1380   effects: cfa.reg = sp if fp used
1381            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1382            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1383              if cfa_store.reg==sp
1384
1385   Rule 3:
1386   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1387   effects: cfa.reg = fp
1388            cfa_offset += +/- <const_int>
1389
1390   Rule 4:
1391   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1392   constraints: <reg1> != fp
1393                <reg1> != sp
1394   effects: cfa.reg = <reg1>
1395            cfa_temp.reg = <reg1>
1396            cfa_temp.offset = cfa.offset
1397
1398   Rule 5:
1399   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1400   constraints: <reg1> != fp
1401                <reg1> != sp
1402   effects: cfa_store.reg = <reg1>
1403            cfa_store.offset = cfa.offset - cfa_temp.offset
1404
1405   Rule 6:
1406   (set <reg> <const_int>)
1407   effects: cfa_temp.reg = <reg>
1408            cfa_temp.offset = <const_int>
1409
1410   Rule 7:
1411   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1412   effects: cfa_temp.reg = <reg1>
1413            cfa_temp.offset |= <const_int>
1414
1415   Rule 8:
1416   (set <reg> (high <exp>))
1417   effects: none
1418
1419   Rule 9:
1420   (set <reg> (lo_sum <exp> <const_int>))
1421   effects: cfa_temp.reg = <reg>
1422            cfa_temp.offset = <const_int>
1423
1424   Rule 10:
1425   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1426   effects: cfa_store.offset -= <const_int>
1427            cfa.offset = cfa_store.offset if cfa.reg == sp
1428            cfa.reg = sp
1429            cfa.base_offset = -cfa_store.offset
1430
1431   Rule 11:
1432   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1433   effects: cfa_store.offset += -/+ mode_size(mem)
1434            cfa.offset = cfa_store.offset if cfa.reg == sp
1435            cfa.reg = sp
1436            cfa.base_offset = -cfa_store.offset
1437
1438   Rule 12:
1439   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1440
1441        <reg2>)
1442   effects: cfa.reg = <reg1>
1443            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1444
1445   Rule 13:
1446   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1447   effects: cfa.reg = <reg1>
1448            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1449
1450   Rule 14:
1451   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1452   effects: cfa.reg = <reg1>
1453            cfa.base_offset = -cfa_temp.offset
1454            cfa_temp.offset -= mode_size(mem)
1455
1456   Rule 15:
1457   (set <reg> {unspec, unspec_volatile})
1458   effects: target-dependent  */
1459
1460 static void
1461 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1462 {
1463   rtx src, dest;
1464   HOST_WIDE_INT offset;
1465
1466   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1467      the PARALLEL independently. The first element is always processed if
1468      it is a SET. This is for backward compatibility.   Other elements
1469      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1470      flag is set in them.  */
1471   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1472     {
1473       int par_index;
1474       int limit = XVECLEN (expr, 0);
1475
1476       for (par_index = 0; par_index < limit; par_index++)
1477         if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1478             && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1479                 || par_index == 0))
1480           dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1481
1482       return;
1483     }
1484
1485   gcc_assert (GET_CODE (expr) == SET);
1486
1487   src = SET_SRC (expr);
1488   dest = SET_DEST (expr);
1489
1490   if (REG_P (src))
1491     {
1492       rtx rsi = reg_saved_in (src);
1493       if (rsi)
1494         src = rsi;
1495     }
1496
1497   switch (GET_CODE (dest))
1498     {
1499     case REG:
1500       switch (GET_CODE (src))
1501         {
1502           /* Setting FP from SP.  */
1503         case REG:
1504           if (cfa.reg == (unsigned) REGNO (src))
1505             {
1506               /* Rule 1 */
1507               /* Update the CFA rule wrt SP or FP.  Make sure src is
1508                  relative to the current CFA register.
1509
1510                  We used to require that dest be either SP or FP, but the
1511                  ARM copies SP to a temporary register, and from there to
1512                  FP.  So we just rely on the backends to only set
1513                  RTX_FRAME_RELATED_P on appropriate insns.  */
1514               cfa.reg = REGNO (dest);
1515               cfa_temp.reg = cfa.reg;
1516               cfa_temp.offset = cfa.offset;
1517             }
1518           else
1519             {
1520               /* Saving a register in a register.  */
1521               gcc_assert (call_used_regs [REGNO (dest)]
1522                           && (!fixed_regs [REGNO (dest)]
1523                               /* For the SPARC and its register window.  */
1524                               || DWARF_FRAME_REGNUM (REGNO (src))
1525                                    == DWARF_FRAME_RETURN_COLUMN));
1526               queue_reg_save (label, src, dest, 0);
1527             }
1528           break;
1529
1530         case PLUS:
1531         case MINUS:
1532         case LO_SUM:
1533           if (dest == stack_pointer_rtx)
1534             {
1535               /* Rule 2 */
1536               /* Adjusting SP.  */
1537               switch (GET_CODE (XEXP (src, 1)))
1538                 {
1539                 case CONST_INT:
1540                   offset = INTVAL (XEXP (src, 1));
1541                   break;
1542                 case REG:
1543                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1544                               == cfa_temp.reg);
1545                   offset = cfa_temp.offset;
1546                   break;
1547                 default:
1548                   gcc_unreachable ();
1549                 }
1550
1551               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1552                 {
1553                   /* Restoring SP from FP in the epilogue.  */
1554                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1555                   cfa.reg = STACK_POINTER_REGNUM;
1556                 }
1557               else if (GET_CODE (src) == LO_SUM)
1558                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1559                 ;
1560               else
1561                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1562
1563               if (GET_CODE (src) != MINUS)
1564                 offset = -offset;
1565               if (cfa.reg == STACK_POINTER_REGNUM)
1566                 cfa.offset += offset;
1567               if (cfa_store.reg == STACK_POINTER_REGNUM)
1568                 cfa_store.offset += offset;
1569             }
1570           else if (dest == hard_frame_pointer_rtx)
1571             {
1572               /* Rule 3 */
1573               /* Either setting the FP from an offset of the SP,
1574                  or adjusting the FP */
1575               gcc_assert (frame_pointer_needed);
1576
1577               gcc_assert (REG_P (XEXP (src, 0))
1578                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1579                           && GET_CODE (XEXP (src, 1)) == CONST_INT);
1580               offset = INTVAL (XEXP (src, 1));
1581               if (GET_CODE (src) != MINUS)
1582                 offset = -offset;
1583               cfa.offset += offset;
1584               cfa.reg = HARD_FRAME_POINTER_REGNUM;
1585             }
1586           else
1587             {
1588               gcc_assert (GET_CODE (src) != MINUS);
1589
1590               /* Rule 4 */
1591               if (REG_P (XEXP (src, 0))
1592                   && REGNO (XEXP (src, 0)) == cfa.reg
1593                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1594                 {
1595                   /* Setting a temporary CFA register that will be copied
1596                      into the FP later on.  */
1597                   offset = - INTVAL (XEXP (src, 1));
1598                   cfa.offset += offset;
1599                   cfa.reg = REGNO (dest);
1600                   /* Or used to save regs to the stack.  */
1601                   cfa_temp.reg = cfa.reg;
1602                   cfa_temp.offset = cfa.offset;
1603                 }
1604
1605               /* Rule 5 */
1606               else if (REG_P (XEXP (src, 0))
1607                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1608                        && XEXP (src, 1) == stack_pointer_rtx)
1609                 {
1610                   /* Setting a scratch register that we will use instead
1611                      of SP for saving registers to the stack.  */
1612                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1613                   cfa_store.reg = REGNO (dest);
1614                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1615                 }
1616
1617               /* Rule 9 */
1618               else if (GET_CODE (src) == LO_SUM
1619                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1620                 {
1621                   cfa_temp.reg = REGNO (dest);
1622                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1623                 }
1624               else
1625                 gcc_unreachable ();
1626             }
1627           break;
1628
1629           /* Rule 6 */
1630         case CONST_INT:
1631           cfa_temp.reg = REGNO (dest);
1632           cfa_temp.offset = INTVAL (src);
1633           break;
1634
1635           /* Rule 7 */
1636         case IOR:
1637           gcc_assert (REG_P (XEXP (src, 0))
1638                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1639                       && GET_CODE (XEXP (src, 1)) == CONST_INT);
1640
1641           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1642             cfa_temp.reg = REGNO (dest);
1643           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1644           break;
1645
1646           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1647              which will fill in all of the bits.  */
1648           /* Rule 8 */
1649         case HIGH:
1650           break;
1651
1652           /* Rule 15 */
1653         case UNSPEC:
1654         case UNSPEC_VOLATILE:
1655           gcc_assert (targetm.dwarf_handle_frame_unspec);
1656           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1657           break;
1658
1659         default:
1660           gcc_unreachable ();
1661         }
1662
1663       def_cfa_1 (label, &cfa);
1664       break;
1665
1666     case MEM:
1667       gcc_assert (REG_P (src));
1668
1669       /* Saving a register to the stack.  Make sure dest is relative to the
1670          CFA register.  */
1671       switch (GET_CODE (XEXP (dest, 0)))
1672         {
1673           /* Rule 10 */
1674           /* With a push.  */
1675         case PRE_MODIFY:
1676           /* We can't handle variable size modifications.  */
1677           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1678                       == CONST_INT);
1679           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1680
1681           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1682                       && cfa_store.reg == STACK_POINTER_REGNUM);
1683
1684           cfa_store.offset += offset;
1685           if (cfa.reg == STACK_POINTER_REGNUM)
1686             cfa.offset = cfa_store.offset;
1687
1688           offset = -cfa_store.offset;
1689           break;
1690
1691           /* Rule 11 */
1692         case PRE_INC:
1693         case PRE_DEC:
1694           offset = GET_MODE_SIZE (GET_MODE (dest));
1695           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1696             offset = -offset;
1697
1698           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1699                       && cfa_store.reg == STACK_POINTER_REGNUM);
1700
1701           cfa_store.offset += offset;
1702           if (cfa.reg == STACK_POINTER_REGNUM)
1703             cfa.offset = cfa_store.offset;
1704
1705           offset = -cfa_store.offset;
1706           break;
1707
1708           /* Rule 12 */
1709           /* With an offset.  */
1710         case PLUS:
1711         case MINUS:
1712         case LO_SUM:
1713           {
1714             int regno;
1715
1716             gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT);
1717             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1718             if (GET_CODE (XEXP (dest, 0)) == MINUS)
1719               offset = -offset;
1720
1721             regno = REGNO (XEXP (XEXP (dest, 0), 0));
1722
1723             if (cfa_store.reg == (unsigned) regno)
1724               offset -= cfa_store.offset;
1725             else
1726               {
1727                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1728                 offset -= cfa_temp.offset;
1729               }
1730           }
1731           break;
1732
1733           /* Rule 13 */
1734           /* Without an offset.  */
1735         case REG:
1736           {
1737             int regno = REGNO (XEXP (dest, 0));
1738
1739             if (cfa_store.reg == (unsigned) regno)
1740               offset = -cfa_store.offset;
1741             else
1742               {
1743                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1744                 offset = -cfa_temp.offset;
1745               }
1746           }
1747           break;
1748
1749           /* Rule 14 */
1750         case POST_INC:
1751           gcc_assert (cfa_temp.reg
1752                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1753           offset = -cfa_temp.offset;
1754           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1755           break;
1756
1757         default:
1758           gcc_unreachable ();
1759         }
1760
1761       if (REGNO (src) != STACK_POINTER_REGNUM
1762           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1763           && (unsigned) REGNO (src) == cfa.reg)
1764         {
1765           /* We're storing the current CFA reg into the stack.  */
1766
1767           if (cfa.offset == 0)
1768             {
1769               /* If the source register is exactly the CFA, assume
1770                  we're saving SP like any other register; this happens
1771                  on the ARM.  */
1772               def_cfa_1 (label, &cfa);
1773               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1774               break;
1775             }
1776           else
1777             {
1778               /* Otherwise, we'll need to look in the stack to
1779                  calculate the CFA.  */
1780               rtx x = XEXP (dest, 0);
1781
1782               if (!REG_P (x))
1783                 x = XEXP (x, 0);
1784               gcc_assert (REG_P (x));
1785
1786               cfa.reg = REGNO (x);
1787               cfa.base_offset = offset;
1788               cfa.indirect = 1;
1789               def_cfa_1 (label, &cfa);
1790               break;
1791             }
1792         }
1793
1794       def_cfa_1 (label, &cfa);
1795       queue_reg_save (label, src, NULL_RTX, offset);
1796       break;
1797
1798     default:
1799       gcc_unreachable ();
1800     }
1801 }
1802
1803 /* Record call frame debugging information for INSN, which either
1804    sets SP or FP (adjusting how we calculate the frame address) or saves a
1805    register to the stack.  If INSN is NULL_RTX, initialize our state.
1806
1807    If AFTER_P is false, we're being called before the insn is emitted,
1808    otherwise after.  Call instructions get invoked twice.  */
1809
1810 void
1811 dwarf2out_frame_debug (rtx insn, bool after_p)
1812 {
1813   const char *label;
1814   rtx src;
1815
1816   if (insn == NULL_RTX)
1817     {
1818       size_t i;
1819
1820       /* Flush any queued register saves.  */
1821       flush_queued_reg_saves ();
1822
1823       /* Set up state for generating call frame debug info.  */
1824       lookup_cfa (&cfa);
1825       gcc_assert (cfa.reg
1826                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1827
1828       cfa.reg = STACK_POINTER_REGNUM;
1829       cfa_store = cfa;
1830       cfa_temp.reg = -1;
1831       cfa_temp.offset = 0;
1832
1833       for (i = 0; i < num_regs_saved_in_regs; i++)
1834         {
1835           regs_saved_in_regs[i].orig_reg = NULL_RTX;
1836           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1837         }
1838       num_regs_saved_in_regs = 0;
1839       return;
1840     }
1841
1842   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1843     flush_queued_reg_saves ();
1844
1845   if (! RTX_FRAME_RELATED_P (insn))
1846     {
1847       if (!ACCUMULATE_OUTGOING_ARGS)
1848         dwarf2out_stack_adjust (insn, after_p);
1849       return;
1850     }
1851
1852   label = dwarf2out_cfi_label ();
1853   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1854   if (src)
1855     insn = XEXP (src, 0);
1856   else
1857     insn = PATTERN (insn);
1858
1859   dwarf2out_frame_debug_expr (insn, label);
1860 }
1861
1862 #endif
1863
1864 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1865 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1866  (enum dwarf_call_frame_info cfi);
1867
1868 static enum dw_cfi_oprnd_type
1869 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1870 {
1871   switch (cfi)
1872     {
1873     case DW_CFA_nop:
1874     case DW_CFA_GNU_window_save:
1875       return dw_cfi_oprnd_unused;
1876
1877     case DW_CFA_set_loc:
1878     case DW_CFA_advance_loc1:
1879     case DW_CFA_advance_loc2:
1880     case DW_CFA_advance_loc4:
1881     case DW_CFA_MIPS_advance_loc8:
1882       return dw_cfi_oprnd_addr;
1883
1884     case DW_CFA_offset:
1885     case DW_CFA_offset_extended:
1886     case DW_CFA_def_cfa:
1887     case DW_CFA_offset_extended_sf:
1888     case DW_CFA_def_cfa_sf:
1889     case DW_CFA_restore_extended:
1890     case DW_CFA_undefined:
1891     case DW_CFA_same_value:
1892     case DW_CFA_def_cfa_register:
1893     case DW_CFA_register:
1894       return dw_cfi_oprnd_reg_num;
1895
1896     case DW_CFA_def_cfa_offset:
1897     case DW_CFA_GNU_args_size:
1898     case DW_CFA_def_cfa_offset_sf:
1899       return dw_cfi_oprnd_offset;
1900
1901     case DW_CFA_def_cfa_expression:
1902     case DW_CFA_expression:
1903       return dw_cfi_oprnd_loc;
1904
1905     default:
1906       gcc_unreachable ();
1907     }
1908 }
1909
1910 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1911 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1912  (enum dwarf_call_frame_info cfi);
1913
1914 static enum dw_cfi_oprnd_type
1915 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1916 {
1917   switch (cfi)
1918     {
1919     case DW_CFA_def_cfa:
1920     case DW_CFA_def_cfa_sf:
1921     case DW_CFA_offset:
1922     case DW_CFA_offset_extended_sf:
1923     case DW_CFA_offset_extended:
1924       return dw_cfi_oprnd_offset;
1925
1926     case DW_CFA_register:
1927       return dw_cfi_oprnd_reg_num;
1928
1929     default:
1930       return dw_cfi_oprnd_unused;
1931     }
1932 }
1933
1934 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1935
1936 /* Map register numbers held in the call frame info that gcc has
1937    collected using DWARF_FRAME_REGNUM to those that should be output in
1938    .debug_frame and .eh_frame.  */
1939 #ifndef DWARF2_FRAME_REG_OUT
1940 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
1941 #endif
1942
1943 /* Output a Call Frame Information opcode and its operand(s).  */
1944
1945 static void
1946 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
1947 {
1948   unsigned long r;
1949   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1950     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1951                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
1952                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
1953                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
1954   else if (cfi->dw_cfi_opc == DW_CFA_offset)
1955     {
1956       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
1957       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
1958                            "DW_CFA_offset, column 0x%lx", r);
1959       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1960     }
1961   else if (cfi->dw_cfi_opc == DW_CFA_restore)
1962     {
1963       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
1964       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
1965                            "DW_CFA_restore, column 0x%lx", r);
1966     }
1967   else
1968     {
1969       dw2_asm_output_data (1, cfi->dw_cfi_opc,
1970                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
1971
1972       switch (cfi->dw_cfi_opc)
1973         {
1974         case DW_CFA_set_loc:
1975           if (for_eh)
1976             dw2_asm_output_encoded_addr_rtx (
1977                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1978                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
1979                 NULL);
1980           else
1981             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
1982                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
1983           break;
1984
1985         case DW_CFA_advance_loc1:
1986           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1987                                 fde->dw_fde_current_label, NULL);
1988           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1989           break;
1990
1991         case DW_CFA_advance_loc2:
1992           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1993                                 fde->dw_fde_current_label, NULL);
1994           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1995           break;
1996
1997         case DW_CFA_advance_loc4:
1998           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1999                                 fde->dw_fde_current_label, NULL);
2000           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2001           break;
2002
2003         case DW_CFA_MIPS_advance_loc8:
2004           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2005                                 fde->dw_fde_current_label, NULL);
2006           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2007           break;
2008
2009         case DW_CFA_offset_extended:
2010         case DW_CFA_def_cfa:
2011           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2012           dw2_asm_output_data_uleb128 (r, NULL);
2013           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2014           break;
2015
2016         case DW_CFA_offset_extended_sf:
2017         case DW_CFA_def_cfa_sf:
2018           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2019           dw2_asm_output_data_uleb128 (r, NULL);
2020           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2021           break;
2022
2023         case DW_CFA_restore_extended:
2024         case DW_CFA_undefined:
2025         case DW_CFA_same_value:
2026         case DW_CFA_def_cfa_register:
2027           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2028           dw2_asm_output_data_uleb128 (r, NULL);
2029           break;
2030
2031         case DW_CFA_register:
2032           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2033           dw2_asm_output_data_uleb128 (r, NULL);
2034           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2035           dw2_asm_output_data_uleb128 (r, NULL);
2036           break;
2037
2038         case DW_CFA_def_cfa_offset:
2039         case DW_CFA_GNU_args_size:
2040           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2041           break;
2042
2043         case DW_CFA_def_cfa_offset_sf:
2044           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2045           break;
2046
2047         case DW_CFA_GNU_window_save:
2048           break;
2049
2050         case DW_CFA_def_cfa_expression:
2051         case DW_CFA_expression:
2052           output_cfa_loc (cfi);
2053           break;
2054
2055         case DW_CFA_GNU_negative_offset_extended:
2056           /* Obsoleted by DW_CFA_offset_extended_sf.  */
2057           gcc_unreachable ();
2058
2059         default:
2060           break;
2061         }
2062     }
2063 }
2064
2065 /* Output the call frame information used to record information
2066    that relates to calculating the frame pointer, and records the
2067    location of saved registers.  */
2068
2069 static void
2070 output_call_frame_info (int for_eh)
2071 {
2072   unsigned int i;
2073   dw_fde_ref fde;
2074   dw_cfi_ref cfi;
2075   char l1[20], l2[20], section_start_label[20];
2076   bool any_lsda_needed = false;
2077   char augmentation[6];
2078   int augmentation_size;
2079   int fde_encoding = DW_EH_PE_absptr;
2080   int per_encoding = DW_EH_PE_absptr;
2081   int lsda_encoding = DW_EH_PE_absptr;
2082   int return_reg;
2083
2084   /* Don't emit a CIE if there won't be any FDEs.  */
2085   if (fde_table_in_use == 0)
2086     return;
2087
2088   /* If we make FDEs linkonce, we may have to emit an empty label for
2089      an FDE that wouldn't otherwise be emitted.  We want to avoid
2090      having an FDE kept around when the function it refers to is
2091      discarded.  Example where this matters: a primary function
2092      template in C++ requires EH information, but an explicit
2093      specialization doesn't.  */
2094   if (TARGET_USES_WEAK_UNWIND_INFO
2095       && ! flag_asynchronous_unwind_tables
2096       && for_eh)
2097     for (i = 0; i < fde_table_in_use; i++)
2098       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2099           && !fde_table[i].uses_eh_lsda
2100           && ! DECL_WEAK (fde_table[i].decl))
2101         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2102                                       for_eh, /* empty */ 1);
2103
2104   /* If we don't have any functions we'll want to unwind out of, don't
2105      emit any EH unwind information.  Note that if exceptions aren't
2106      enabled, we won't have collected nothrow information, and if we
2107      asked for asynchronous tables, we always want this info.  */
2108   if (for_eh)
2109     {
2110       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2111
2112       for (i = 0; i < fde_table_in_use; i++)
2113         if (fde_table[i].uses_eh_lsda)
2114           any_eh_needed = any_lsda_needed = true;
2115         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2116           any_eh_needed = true;
2117         else if (! fde_table[i].nothrow
2118                  && ! fde_table[i].all_throwers_are_sibcalls)
2119           any_eh_needed = true;
2120
2121       if (! any_eh_needed)
2122         return;
2123     }
2124
2125   /* We're going to be generating comments, so turn on app.  */
2126   if (flag_debug_asm)
2127     app_enable ();
2128
2129   if (for_eh)
2130     targetm.asm_out.eh_frame_section ();
2131   else
2132     named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
2133
2134   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2135   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2136
2137   /* Output the CIE.  */
2138   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2139   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2140   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2141                         "Length of Common Information Entry");
2142   ASM_OUTPUT_LABEL (asm_out_file, l1);
2143
2144   /* Now that the CIE pointer is PC-relative for EH,
2145      use 0 to identify the CIE.  */
2146   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2147                        (for_eh ? 0 : DW_CIE_ID),
2148                        "CIE Identifier Tag");
2149
2150   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2151
2152   augmentation[0] = 0;
2153   augmentation_size = 0;
2154   if (for_eh)
2155     {
2156       char *p;
2157
2158       /* Augmentation:
2159          z      Indicates that a uleb128 is present to size the
2160                 augmentation section.
2161          L      Indicates the encoding (and thus presence) of
2162                 an LSDA pointer in the FDE augmentation.
2163          R      Indicates a non-default pointer encoding for
2164                 FDE code pointers.
2165          P      Indicates the presence of an encoding + language
2166                 personality routine in the CIE augmentation.  */
2167
2168       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2169       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2170       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2171
2172       p = augmentation + 1;
2173       if (eh_personality_libfunc)
2174         {
2175           *p++ = 'P';
2176           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2177         }
2178       if (any_lsda_needed)
2179         {
2180           *p++ = 'L';
2181           augmentation_size += 1;
2182         }
2183       if (fde_encoding != DW_EH_PE_absptr)
2184         {
2185           *p++ = 'R';
2186           augmentation_size += 1;
2187         }
2188       if (p > augmentation + 1)
2189         {
2190           augmentation[0] = 'z';
2191           *p = '\0';
2192         }
2193
2194       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2195       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2196         {
2197           int offset = (  4             /* Length */
2198                         + 4             /* CIE Id */
2199                         + 1             /* CIE version */
2200                         + strlen (augmentation) + 1     /* Augmentation */
2201                         + size_of_uleb128 (1)           /* Code alignment */
2202                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2203                         + 1             /* RA column */
2204                         + 1             /* Augmentation size */
2205                         + 1             /* Personality encoding */ );
2206           int pad = -offset & (PTR_SIZE - 1);
2207
2208           augmentation_size += pad;
2209
2210           /* Augmentations should be small, so there's scarce need to
2211              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2212           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2213         }
2214     }
2215
2216   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2217   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2218   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2219                                "CIE Data Alignment Factor");
2220
2221   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2222   if (DW_CIE_VERSION == 1)
2223     dw2_asm_output_data (1, return_reg, "CIE RA Column");
2224   else
2225     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2226
2227   if (augmentation[0])
2228     {
2229       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2230       if (eh_personality_libfunc)
2231         {
2232           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2233                                eh_data_format_name (per_encoding));
2234           dw2_asm_output_encoded_addr_rtx (per_encoding,
2235                                            eh_personality_libfunc, NULL);
2236         }
2237
2238       if (any_lsda_needed)
2239         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2240                              eh_data_format_name (lsda_encoding));
2241
2242       if (fde_encoding != DW_EH_PE_absptr)
2243         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2244                              eh_data_format_name (fde_encoding));
2245     }
2246
2247   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2248     output_cfi (cfi, NULL, for_eh);
2249
2250   /* Pad the CIE out to an address sized boundary.  */
2251   ASM_OUTPUT_ALIGN (asm_out_file,
2252                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2253   ASM_OUTPUT_LABEL (asm_out_file, l2);
2254
2255   /* Loop through all of the FDE's.  */
2256   for (i = 0; i < fde_table_in_use; i++)
2257     {
2258       fde = &fde_table[i];
2259
2260       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2261       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2262           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2263           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2264           && !fde->uses_eh_lsda)
2265         continue;
2266
2267       targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2268       targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2269       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2270       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2271       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2272                             "FDE Length");
2273       ASM_OUTPUT_LABEL (asm_out_file, l1);
2274
2275       if (for_eh)
2276         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2277       else
2278         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2279                                "FDE CIE offset");
2280
2281       if (for_eh)
2282         {
2283           rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2284           SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2285           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2286                                            sym_ref,
2287                                            "FDE initial location");
2288           if (fde->dw_fde_switched_sections)
2289             {
2290               rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2291                                       fde->dw_fde_unlikely_section_label);
2292               rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2293                                       fde->dw_fde_hot_section_label);
2294               SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2295               SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2296               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3,
2297                                                "FDE initial location");
2298               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2299                                     fde->dw_fde_hot_section_end_label,
2300                                     fde->dw_fde_hot_section_label,
2301                                     "FDE address range");
2302               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2,
2303                                                "FDE initial location");
2304               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2305                                     fde->dw_fde_unlikely_section_end_label,
2306                                     fde->dw_fde_unlikely_section_label,
2307                                     "FDE address range");
2308             }
2309           else
2310             dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2311                                   fde->dw_fde_end, fde->dw_fde_begin,
2312                                   "FDE address range");
2313         }
2314       else
2315         {
2316           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2317                                "FDE initial location");
2318           if (fde->dw_fde_switched_sections)
2319             {
2320               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2321                                    fde->dw_fde_hot_section_label,
2322                                    "FDE initial location");
2323               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2324                                     fde->dw_fde_hot_section_end_label,
2325                                     fde->dw_fde_hot_section_label,
2326                                     "FDE address range");
2327               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2328                                    fde->dw_fde_unlikely_section_label,
2329                                    "FDE initial location");
2330               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2331                                     fde->dw_fde_unlikely_section_end_label,
2332                                     fde->dw_fde_unlikely_section_label,
2333                                     "FDE address range");
2334             }
2335           else
2336             dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2337                                   fde->dw_fde_end, fde->dw_fde_begin,
2338                                   "FDE address range");
2339         }
2340
2341       if (augmentation[0])
2342         {
2343           if (any_lsda_needed)
2344             {
2345               int size = size_of_encoded_value (lsda_encoding);
2346
2347               if (lsda_encoding == DW_EH_PE_aligned)
2348                 {
2349                   int offset = (  4             /* Length */
2350                                 + 4             /* CIE offset */
2351                                 + 2 * size_of_encoded_value (fde_encoding)
2352                                 + 1             /* Augmentation size */ );
2353                   int pad = -offset & (PTR_SIZE - 1);
2354
2355                   size += pad;
2356                   gcc_assert (size_of_uleb128 (size) == 1);
2357                 }
2358
2359               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2360
2361               if (fde->uses_eh_lsda)
2362                 {
2363                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2364                                                fde->funcdef_number);
2365                   dw2_asm_output_encoded_addr_rtx (
2366                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2367                         "Language Specific Data Area");
2368                 }
2369               else
2370                 {
2371                   if (lsda_encoding == DW_EH_PE_aligned)
2372                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2373                   dw2_asm_output_data
2374                     (size_of_encoded_value (lsda_encoding), 0,
2375                      "Language Specific Data Area (none)");
2376                 }
2377             }
2378           else
2379             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2380         }
2381
2382       /* Loop through the Call Frame Instructions associated with
2383          this FDE.  */
2384       fde->dw_fde_current_label = fde->dw_fde_begin;
2385       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2386         output_cfi (cfi, fde, for_eh);
2387
2388       /* Pad the FDE out to an address sized boundary.  */
2389       ASM_OUTPUT_ALIGN (asm_out_file,
2390                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2391       ASM_OUTPUT_LABEL (asm_out_file, l2);
2392     }
2393
2394   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2395     dw2_asm_output_data (4, 0, "End of Table");
2396 #ifdef MIPS_DEBUGGING_INFO
2397   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2398      get a value of 0.  Putting .align 0 after the label fixes it.  */
2399   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2400 #endif
2401
2402   /* Turn off app to make assembly quicker.  */
2403   if (flag_debug_asm)
2404     app_disable ();
2405 }
2406
2407 /* Output a marker (i.e. a label) for the beginning of a function, before
2408    the prologue.  */
2409
2410 void
2411 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2412                           const char *file ATTRIBUTE_UNUSED)
2413 {
2414   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2415   char * dup_label;
2416   dw_fde_ref fde;
2417
2418   current_function_func_begin_label = NULL;
2419
2420 #ifdef TARGET_UNWIND_INFO
2421   /* ??? current_function_func_begin_label is also used by except.c
2422      for call-site information.  We must emit this label if it might
2423      be used.  */
2424   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2425       && ! dwarf2out_do_frame ())
2426     return;
2427 #else
2428   if (! dwarf2out_do_frame ())
2429     return;
2430 #endif
2431
2432   function_section (current_function_decl);
2433   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2434                                current_function_funcdef_no);
2435   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2436                           current_function_funcdef_no);
2437   dup_label = xstrdup (label);
2438   current_function_func_begin_label = dup_label;
2439
2440 #ifdef TARGET_UNWIND_INFO
2441   /* We can elide the fde allocation if we're not emitting debug info.  */
2442   if (! dwarf2out_do_frame ())
2443     return;
2444 #endif
2445
2446   /* Expand the fde table if necessary.  */
2447   if (fde_table_in_use == fde_table_allocated)
2448     {
2449       fde_table_allocated += FDE_TABLE_INCREMENT;
2450       fde_table = ggc_realloc (fde_table,
2451                                fde_table_allocated * sizeof (dw_fde_node));
2452       memset (fde_table + fde_table_in_use, 0,
2453               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2454     }
2455
2456   /* Record the FDE associated with this function.  */
2457   current_funcdef_fde = fde_table_in_use;
2458
2459   /* Add the new FDE at the end of the fde_table.  */
2460   fde = &fde_table[fde_table_in_use++];
2461   fde->decl = current_function_decl;
2462   fde->dw_fde_begin = dup_label;
2463   fde->dw_fde_current_label = NULL;
2464   fde->dw_fde_hot_section_label = NULL;
2465   fde->dw_fde_hot_section_end_label = NULL;
2466   fde->dw_fde_unlikely_section_label = NULL;
2467   fde->dw_fde_unlikely_section_end_label = NULL;
2468   fde->dw_fde_switched_sections = false;
2469   fde->dw_fde_end = NULL;
2470   fde->dw_fde_cfi = NULL;
2471   fde->funcdef_number = current_function_funcdef_no;
2472   fde->nothrow = TREE_NOTHROW (current_function_decl);
2473   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2474   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2475
2476   args_size = old_args_size = 0;
2477
2478   /* We only want to output line number information for the genuine dwarf2
2479      prologue case, not the eh frame case.  */
2480 #ifdef DWARF2_DEBUGGING_INFO
2481   if (file)
2482     dwarf2out_source_line (line, file);
2483 #endif
2484 }
2485
2486 /* Output a marker (i.e. a label) for the absolute end of the generated code
2487    for a function definition.  This gets called *after* the epilogue code has
2488    been generated.  */
2489
2490 void
2491 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2492                         const char *file ATTRIBUTE_UNUSED)
2493 {
2494   dw_fde_ref fde;
2495   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2496
2497   /* Output a label to mark the endpoint of the code generated for this
2498      function.  */
2499   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2500                                current_function_funcdef_no);
2501   ASM_OUTPUT_LABEL (asm_out_file, label);
2502   fde = &fde_table[fde_table_in_use - 1];
2503   fde->dw_fde_end = xstrdup (label);
2504 }
2505
2506 void
2507 dwarf2out_frame_init (void)
2508 {
2509   /* Allocate the initial hunk of the fde_table.  */
2510   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2511   fde_table_allocated = FDE_TABLE_INCREMENT;
2512   fde_table_in_use = 0;
2513
2514   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2515      sake of lookup_cfa.  */
2516
2517 #ifdef DWARF2_UNWIND_INFO
2518   /* On entry, the Canonical Frame Address is at SP.  */
2519   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2520   initial_return_save (INCOMING_RETURN_ADDR_RTX);
2521 #endif
2522 }
2523
2524 void
2525 dwarf2out_frame_finish (void)
2526 {
2527   /* Output call frame information.  */
2528   if (write_symbols == DWARF2_DEBUG
2529       || write_symbols == VMS_AND_DWARF2_DEBUG
2530 #ifdef DWARF2_FRAME_INFO
2531       || DWARF2_FRAME_INFO
2532 #endif
2533       )
2534     output_call_frame_info (0);
2535
2536 #ifndef TARGET_UNWIND_INFO
2537   /* Output another copy for the unwinder.  */
2538   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2539     output_call_frame_info (1);
2540 #endif
2541 }
2542 #endif
2543 \f
2544 /* And now, the subset of the debugging information support code necessary
2545    for emitting location expressions.  */
2546
2547 /* We need some way to distinguish DW_OP_addr with a direct symbol
2548    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2549 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2550
2551
2552 typedef struct dw_val_struct *dw_val_ref;
2553 typedef struct die_struct *dw_die_ref;
2554 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2555 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2556
2557 /* Each DIE may have a series of attribute/value pairs.  Values
2558    can take on several forms.  The forms that are used in this
2559    implementation are listed below.  */
2560
2561 enum dw_val_class
2562 {
2563   dw_val_class_addr,
2564   dw_val_class_offset,
2565   dw_val_class_loc,
2566   dw_val_class_loc_list,
2567   dw_val_class_range_list,
2568   dw_val_class_const,
2569   dw_val_class_unsigned_const,
2570   dw_val_class_long_long,
2571   dw_val_class_vec,
2572   dw_val_class_flag,
2573   dw_val_class_die_ref,
2574   dw_val_class_fde_ref,
2575   dw_val_class_lbl_id,
2576   dw_val_class_lbl_offset,
2577   dw_val_class_str
2578 };
2579
2580 /* Describe a double word constant value.  */
2581 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2582
2583 typedef struct dw_long_long_struct GTY(())
2584 {
2585   unsigned long hi;
2586   unsigned long low;
2587 }
2588 dw_long_long_const;
2589
2590 /* Describe a floating point constant value, or a vector constant value.  */
2591
2592 typedef struct dw_vec_struct GTY(())
2593 {
2594   unsigned char * GTY((length ("%h.length"))) array;
2595   unsigned length;
2596   unsigned elt_size;
2597 }
2598 dw_vec_const;
2599
2600 /* The dw_val_node describes an attribute's value, as it is
2601    represented internally.  */
2602
2603 typedef struct dw_val_struct GTY(())
2604 {
2605   enum dw_val_class val_class;
2606   union dw_val_struct_union
2607     {
2608       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2609       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2610       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2611       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2612       HOST_WIDE_INT GTY ((default)) val_int;
2613       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2614       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2615       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2616       struct dw_val_die_union
2617         {
2618           dw_die_ref die;
2619           int external;
2620         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2621       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2622       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2623       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2624       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2625     }
2626   GTY ((desc ("%1.val_class"))) v;
2627 }
2628 dw_val_node;
2629
2630 /* Locations in memory are described using a sequence of stack machine
2631    operations.  */
2632
2633 typedef struct dw_loc_descr_struct GTY(())
2634 {
2635   dw_loc_descr_ref dw_loc_next;
2636   enum dwarf_location_atom dw_loc_opc;
2637   dw_val_node dw_loc_oprnd1;
2638   dw_val_node dw_loc_oprnd2;
2639   int dw_loc_addr;
2640 }
2641 dw_loc_descr_node;
2642
2643 /* Location lists are ranges + location descriptions for that range,
2644    so you can track variables that are in different places over
2645    their entire life.  */
2646 typedef struct dw_loc_list_struct GTY(())
2647 {
2648   dw_loc_list_ref dw_loc_next;
2649   const char *begin; /* Label for begin address of range */
2650   const char *end;  /* Label for end address of range */
2651   char *ll_symbol; /* Label for beginning of location list.
2652                       Only on head of list */
2653   const char *section; /* Section this loclist is relative to */
2654   dw_loc_descr_ref expr;
2655 } dw_loc_list_node;
2656
2657 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2658
2659 static const char *dwarf_stack_op_name (unsigned);
2660 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2661                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2662 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2663 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2664 static unsigned long size_of_locs (dw_loc_descr_ref);
2665 static void output_loc_operands (dw_loc_descr_ref);
2666 static void output_loc_sequence (dw_loc_descr_ref);
2667
2668 /* Convert a DWARF stack opcode into its string name.  */
2669
2670 static const char *
2671 dwarf_stack_op_name (unsigned int op)
2672 {
2673   switch (op)
2674     {
2675     case DW_OP_addr:
2676     case INTERNAL_DW_OP_tls_addr:
2677       return "DW_OP_addr";
2678     case DW_OP_deref:
2679       return "DW_OP_deref";
2680     case DW_OP_const1u:
2681       return "DW_OP_const1u";
2682     case DW_OP_const1s:
2683       return "DW_OP_const1s";
2684     case DW_OP_const2u:
2685       return "DW_OP_const2u";
2686     case DW_OP_const2s:
2687       return "DW_OP_const2s";
2688     case DW_OP_const4u:
2689       return "DW_OP_const4u";
2690     case DW_OP_const4s:
2691       return "DW_OP_const4s";
2692     case DW_OP_const8u:
2693       return "DW_OP_const8u";
2694     case DW_OP_const8s:
2695       return "DW_OP_const8s";
2696     case DW_OP_constu:
2697       return "DW_OP_constu";
2698     case DW_OP_consts:
2699       return "DW_OP_consts";
2700     case DW_OP_dup:
2701       return "DW_OP_dup";
2702     case DW_OP_drop:
2703       return "DW_OP_drop";
2704     case DW_OP_over:
2705       return "DW_OP_over";
2706     case DW_OP_pick:
2707       return "DW_OP_pick";
2708     case DW_OP_swap:
2709       return "DW_OP_swap";
2710     case DW_OP_rot:
2711       return "DW_OP_rot";
2712     case DW_OP_xderef:
2713       return "DW_OP_xderef";
2714     case DW_OP_abs:
2715       return "DW_OP_abs";
2716     case DW_OP_and:
2717       return "DW_OP_and";
2718     case DW_OP_div:
2719       return "DW_OP_div";
2720     case DW_OP_minus:
2721       return "DW_OP_minus";
2722     case DW_OP_mod:
2723       return "DW_OP_mod";
2724     case DW_OP_mul:
2725       return "DW_OP_mul";
2726     case DW_OP_neg:
2727       return "DW_OP_neg";
2728     case DW_OP_not:
2729       return "DW_OP_not";
2730     case DW_OP_or:
2731       return "DW_OP_or";
2732     case DW_OP_plus:
2733       return "DW_OP_plus";
2734     case DW_OP_plus_uconst:
2735       return "DW_OP_plus_uconst";
2736     case DW_OP_shl:
2737       return "DW_OP_shl";
2738     case DW_OP_shr:
2739       return "DW_OP_shr";
2740     case DW_OP_shra:
2741       return "DW_OP_shra";
2742     case DW_OP_xor:
2743       return "DW_OP_xor";
2744     case DW_OP_bra:
2745       return "DW_OP_bra";
2746     case DW_OP_eq:
2747       return "DW_OP_eq";
2748     case DW_OP_ge:
2749       return "DW_OP_ge";
2750     case DW_OP_gt:
2751       return "DW_OP_gt";
2752     case DW_OP_le:
2753       return "DW_OP_le";
2754     case DW_OP_lt:
2755       return "DW_OP_lt";
2756     case DW_OP_ne:
2757       return "DW_OP_ne";
2758     case DW_OP_skip:
2759       return "DW_OP_skip";
2760     case DW_OP_lit0:
2761       return "DW_OP_lit0";
2762     case DW_OP_lit1:
2763       return "DW_OP_lit1";
2764     case DW_OP_lit2:
2765       return "DW_OP_lit2";
2766     case DW_OP_lit3:
2767       return "DW_OP_lit3";
2768     case DW_OP_lit4:
2769       return "DW_OP_lit4";
2770     case DW_OP_lit5:
2771       return "DW_OP_lit5";
2772     case DW_OP_lit6:
2773       return "DW_OP_lit6";
2774     case DW_OP_lit7:
2775       return "DW_OP_lit7";
2776     case DW_OP_lit8:
2777       return "DW_OP_lit8";
2778     case DW_OP_lit9:
2779       return "DW_OP_lit9";
2780     case DW_OP_lit10:
2781       return "DW_OP_lit10";
2782     case DW_OP_lit11:
2783       return "DW_OP_lit11";
2784     case DW_OP_lit12:
2785       return "DW_OP_lit12";
2786     case DW_OP_lit13:
2787       return "DW_OP_lit13";
2788     case DW_OP_lit14:
2789       return "DW_OP_lit14";
2790     case DW_OP_lit15:
2791       return "DW_OP_lit15";
2792     case DW_OP_lit16:
2793       return "DW_OP_lit16";
2794     case DW_OP_lit17:
2795       return "DW_OP_lit17";
2796     case DW_OP_lit18:
2797       return "DW_OP_lit18";
2798     case DW_OP_lit19:
2799       return "DW_OP_lit19";
2800     case DW_OP_lit20:
2801       return "DW_OP_lit20";
2802     case DW_OP_lit21:
2803       return "DW_OP_lit21";
2804     case DW_OP_lit22:
2805       return "DW_OP_lit22";
2806     case DW_OP_lit23:
2807       return "DW_OP_lit23";
2808     case DW_OP_lit24:
2809       return "DW_OP_lit24";
2810     case DW_OP_lit25:
2811       return "DW_OP_lit25";
2812     case DW_OP_lit26:
2813       return "DW_OP_lit26";
2814     case DW_OP_lit27:
2815       return "DW_OP_lit27";
2816     case DW_OP_lit28:
2817       return "DW_OP_lit28";
2818     case DW_OP_lit29:
2819       return "DW_OP_lit29";
2820     case DW_OP_lit30:
2821       return "DW_OP_lit30";
2822     case DW_OP_lit31:
2823       return "DW_OP_lit31";
2824     case DW_OP_reg0:
2825       return "DW_OP_reg0";
2826     case DW_OP_reg1:
2827       return "DW_OP_reg1";
2828     case DW_OP_reg2:
2829       return "DW_OP_reg2";
2830     case DW_OP_reg3:
2831       return "DW_OP_reg3";
2832     case DW_OP_reg4:
2833       return "DW_OP_reg4";
2834     case DW_OP_reg5:
2835       return "DW_OP_reg5";
2836     case DW_OP_reg6:
2837       return "DW_OP_reg6";
2838     case DW_OP_reg7:
2839       return "DW_OP_reg7";
2840     case DW_OP_reg8:
2841       return "DW_OP_reg8";
2842     case DW_OP_reg9:
2843       return "DW_OP_reg9";
2844     case DW_OP_reg10:
2845       return "DW_OP_reg10";
2846     case DW_OP_reg11:
2847       return "DW_OP_reg11";
2848     case DW_OP_reg12:
2849       return "DW_OP_reg12";
2850     case DW_OP_reg13:
2851       return "DW_OP_reg13";
2852     case DW_OP_reg14:
2853       return "DW_OP_reg14";
2854     case DW_OP_reg15:
2855       return "DW_OP_reg15";
2856     case DW_OP_reg16:
2857       return "DW_OP_reg16";
2858     case DW_OP_reg17:
2859       return "DW_OP_reg17";
2860     case DW_OP_reg18:
2861       return "DW_OP_reg18";
2862     case DW_OP_reg19:
2863       return "DW_OP_reg19";
2864     case DW_OP_reg20:
2865       return "DW_OP_reg20";
2866     case DW_OP_reg21:
2867       return "DW_OP_reg21";
2868     case DW_OP_reg22:
2869       return "DW_OP_reg22";
2870     case DW_OP_reg23:
2871       return "DW_OP_reg23";
2872     case DW_OP_reg24:
2873       return "DW_OP_reg24";
2874     case DW_OP_reg25:
2875       return "DW_OP_reg25";
2876     case DW_OP_reg26:
2877       return "DW_OP_reg26";
2878     case DW_OP_reg27:
2879       return "DW_OP_reg27";
2880     case DW_OP_reg28:
2881       return "DW_OP_reg28";
2882     case DW_OP_reg29:
2883       return "DW_OP_reg29";
2884     case DW_OP_reg30:
2885       return "DW_OP_reg30";
2886     case DW_OP_reg31:
2887       return "DW_OP_reg31";
2888     case DW_OP_breg0:
2889       return "DW_OP_breg0";
2890     case DW_OP_breg1:
2891       return "DW_OP_breg1";
2892     case DW_OP_breg2:
2893       return "DW_OP_breg2";
2894     case DW_OP_breg3:
2895       return "DW_OP_breg3";
2896     case DW_OP_breg4:
2897       return "DW_OP_breg4";
2898     case DW_OP_breg5:
2899       return "DW_OP_breg5";
2900     case DW_OP_breg6:
2901       return "DW_OP_breg6";
2902     case DW_OP_breg7:
2903       return "DW_OP_breg7";
2904     case DW_OP_breg8:
2905       return "DW_OP_breg8";
2906     case DW_OP_breg9:
2907       return "DW_OP_breg9";
2908     case DW_OP_breg10:
2909       return "DW_OP_breg10";
2910     case DW_OP_breg11:
2911       return "DW_OP_breg11";
2912     case DW_OP_breg12:
2913       return "DW_OP_breg12";
2914     case DW_OP_breg13:
2915       return "DW_OP_breg13";
2916     case DW_OP_breg14:
2917       return "DW_OP_breg14";
2918     case DW_OP_breg15:
2919       return "DW_OP_breg15";
2920     case DW_OP_breg16:
2921       return "DW_OP_breg16";
2922     case DW_OP_breg17:
2923       return "DW_OP_breg17";
2924     case DW_OP_breg18:
2925       return "DW_OP_breg18";
2926     case DW_OP_breg19:
2927       return "DW_OP_breg19";
2928     case DW_OP_breg20:
2929       return "DW_OP_breg20";
2930     case DW_OP_breg21:
2931       return "DW_OP_breg21";
2932     case DW_OP_breg22:
2933       return "DW_OP_breg22";
2934     case DW_OP_breg23:
2935       return "DW_OP_breg23";
2936     case DW_OP_breg24:
2937       return "DW_OP_breg24";
2938     case DW_OP_breg25:
2939       return "DW_OP_breg25";
2940     case DW_OP_breg26:
2941       return "DW_OP_breg26";
2942     case DW_OP_breg27:
2943       return "DW_OP_breg27";
2944     case DW_OP_breg28:
2945       return "DW_OP_breg28";
2946     case DW_OP_breg29:
2947       return "DW_OP_breg29";
2948     case DW_OP_breg30:
2949       return "DW_OP_breg30";
2950     case DW_OP_breg31:
2951       return "DW_OP_breg31";
2952     case DW_OP_regx:
2953       return "DW_OP_regx";
2954     case DW_OP_fbreg:
2955       return "DW_OP_fbreg";
2956     case DW_OP_bregx:
2957       return "DW_OP_bregx";
2958     case DW_OP_piece:
2959       return "DW_OP_piece";
2960     case DW_OP_deref_size:
2961       return "DW_OP_deref_size";
2962     case DW_OP_xderef_size:
2963       return "DW_OP_xderef_size";
2964     case DW_OP_nop:
2965       return "DW_OP_nop";
2966     case DW_OP_push_object_address:
2967       return "DW_OP_push_object_address";
2968     case DW_OP_call2:
2969       return "DW_OP_call2";
2970     case DW_OP_call4:
2971       return "DW_OP_call4";
2972     case DW_OP_call_ref:
2973       return "DW_OP_call_ref";
2974     case DW_OP_GNU_push_tls_address:
2975       return "DW_OP_GNU_push_tls_address";
2976     default:
2977       return "OP_<unknown>";
2978     }
2979 }
2980
2981 /* Return a pointer to a newly allocated location description.  Location
2982    descriptions are simple expression terms that can be strung
2983    together to form more complicated location (address) descriptions.  */
2984
2985 static inline dw_loc_descr_ref
2986 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
2987                unsigned HOST_WIDE_INT oprnd2)
2988 {
2989   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
2990
2991   descr->dw_loc_opc = op;
2992   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2993   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2994   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2995   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2996
2997   return descr;
2998 }
2999
3000 /* Add a location description term to a location description expression.  */
3001
3002 static inline void
3003 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3004 {
3005   dw_loc_descr_ref *d;
3006
3007   /* Find the end of the chain.  */
3008   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3009     ;
3010
3011   *d = descr;
3012 }
3013
3014 /* Return the size of a location descriptor.  */
3015
3016 static unsigned long
3017 size_of_loc_descr (dw_loc_descr_ref loc)
3018 {
3019   unsigned long size = 1;
3020
3021   switch (loc->dw_loc_opc)
3022     {
3023     case DW_OP_addr:
3024     case INTERNAL_DW_OP_tls_addr:
3025       size += DWARF2_ADDR_SIZE;
3026       break;
3027     case DW_OP_const1u:
3028     case DW_OP_const1s:
3029       size += 1;
3030       break;
3031     case DW_OP_const2u:
3032     case DW_OP_const2s:
3033       size += 2;
3034       break;
3035     case DW_OP_const4u:
3036     case DW_OP_const4s:
3037       size += 4;
3038       break;
3039     case DW_OP_const8u:
3040     case DW_OP_const8s:
3041       size += 8;
3042       break;
3043     case DW_OP_constu:
3044       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3045       break;
3046     case DW_OP_consts:
3047       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3048       break;
3049     case DW_OP_pick:
3050       size += 1;
3051       break;
3052     case DW_OP_plus_uconst:
3053       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3054       break;
3055     case DW_OP_skip:
3056     case DW_OP_bra:
3057       size += 2;
3058       break;
3059     case DW_OP_breg0:
3060     case DW_OP_breg1:
3061     case DW_OP_breg2:
3062     case DW_OP_breg3:
3063     case DW_OP_breg4:
3064     case DW_OP_breg5:
3065     case DW_OP_breg6:
3066     case DW_OP_breg7:
3067     case DW_OP_breg8:
3068     case DW_OP_breg9:
3069     case DW_OP_breg10:
3070     case DW_OP_breg11:
3071     case DW_OP_breg12:
3072     case DW_OP_breg13:
3073     case DW_OP_breg14:
3074     case DW_OP_breg15:
3075     case DW_OP_breg16:
3076     case DW_OP_breg17:
3077     case DW_OP_breg18:
3078     case DW_OP_breg19:
3079     case DW_OP_breg20:
3080     case DW_OP_breg21:
3081     case DW_OP_breg22:
3082     case DW_OP_breg23:
3083     case DW_OP_breg24:
3084     case DW_OP_breg25:
3085     case DW_OP_breg26:
3086     case DW_OP_breg27:
3087     case DW_OP_breg28:
3088     case DW_OP_breg29:
3089     case DW_OP_breg30:
3090     case DW_OP_breg31:
3091       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3092       break;
3093     case DW_OP_regx:
3094       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3095       break;
3096     case DW_OP_fbreg:
3097       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3098       break;
3099     case DW_OP_bregx:
3100       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3101       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3102       break;
3103     case DW_OP_piece:
3104       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3105       break;
3106     case DW_OP_deref_size:
3107     case DW_OP_xderef_size:
3108       size += 1;
3109       break;
3110     case DW_OP_call2:
3111       size += 2;
3112       break;
3113     case DW_OP_call4:
3114       size += 4;
3115       break;
3116     case DW_OP_call_ref:
3117       size += DWARF2_ADDR_SIZE;
3118       break;
3119     default:
3120       break;
3121     }
3122
3123   return size;
3124 }
3125
3126 /* Return the size of a series of location descriptors.  */
3127
3128 static unsigned long
3129 size_of_locs (dw_loc_descr_ref loc)
3130 {
3131   unsigned long size;
3132
3133   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
3134     {
3135       loc->dw_loc_addr = size;
3136       size += size_of_loc_descr (loc);
3137     }
3138
3139   return size;
3140 }
3141
3142 /* Output location description stack opcode's operands (if any).  */
3143
3144 static void
3145 output_loc_operands (dw_loc_descr_ref loc)
3146 {
3147   dw_val_ref val1 = &loc->dw_loc_oprnd1;
3148   dw_val_ref val2 = &loc->dw_loc_oprnd2;
3149
3150   switch (loc->dw_loc_opc)
3151     {
3152 #ifdef DWARF2_DEBUGGING_INFO
3153     case DW_OP_addr:
3154       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3155       break;
3156     case DW_OP_const2u:
3157     case DW_OP_const2s:
3158       dw2_asm_output_data (2, val1->v.val_int, NULL);
3159       break;
3160     case DW_OP_const4u:
3161     case DW_OP_const4s:
3162       dw2_asm_output_data (4, val1->v.val_int, NULL);
3163       break;
3164     case DW_OP_const8u:
3165     case DW_OP_const8s:
3166       gcc_assert (HOST_BITS_PER_LONG >= 64);
3167       dw2_asm_output_data (8, val1->v.val_int, NULL);
3168       break;
3169     case DW_OP_skip:
3170     case DW_OP_bra:
3171       {
3172         int offset;
3173
3174         gcc_assert (val1->val_class == dw_val_class_loc);
3175         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3176
3177         dw2_asm_output_data (2, offset, NULL);
3178       }
3179       break;
3180 #else
3181     case DW_OP_addr:
3182     case DW_OP_const2u:
3183     case DW_OP_const2s:
3184     case DW_OP_const4u:
3185     case DW_OP_const4s:
3186     case DW_OP_const8u:
3187     case DW_OP_const8s:
3188     case DW_OP_skip:
3189     case DW_OP_bra:
3190       /* We currently don't make any attempt to make sure these are
3191          aligned properly like we do for the main unwind info, so
3192          don't support emitting things larger than a byte if we're
3193          only doing unwinding.  */
3194       gcc_unreachable ();
3195 #endif
3196     case DW_OP_const1u:
3197     case DW_OP_const1s:
3198       dw2_asm_output_data (1, val1->v.val_int, NULL);
3199       break;
3200     case DW_OP_constu:
3201       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3202       break;
3203     case DW_OP_consts:
3204       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3205       break;
3206     case DW_OP_pick:
3207       dw2_asm_output_data (1, val1->v.val_int, NULL);
3208       break;
3209     case DW_OP_plus_uconst:
3210       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3211       break;
3212     case DW_OP_breg0:
3213     case DW_OP_breg1:
3214     case DW_OP_breg2:
3215     case DW_OP_breg3:
3216     case DW_OP_breg4:
3217     case DW_OP_breg5:
3218     case DW_OP_breg6:
3219     case DW_OP_breg7:
3220     case DW_OP_breg8:
3221     case DW_OP_breg9:
3222     case DW_OP_breg10:
3223     case DW_OP_breg11:
3224     case DW_OP_breg12:
3225     case DW_OP_breg13:
3226     case DW_OP_breg14:
3227     case DW_OP_breg15:
3228     case DW_OP_breg16:
3229     case DW_OP_breg17:
3230     case DW_OP_breg18:
3231     case DW_OP_breg19:
3232     case DW_OP_breg20:
3233     case DW_OP_breg21:
3234     case DW_OP_breg22:
3235     case DW_OP_breg23:
3236     case DW_OP_breg24:
3237     case DW_OP_breg25:
3238     case DW_OP_breg26:
3239     case DW_OP_breg27:
3240     case DW_OP_breg28:
3241     case DW_OP_breg29:
3242     case DW_OP_breg30:
3243     case DW_OP_breg31:
3244       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3245       break;
3246     case DW_OP_regx:
3247       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3248       break;
3249     case DW_OP_fbreg:
3250       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3251       break;
3252     case DW_OP_bregx:
3253       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3254       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3255       break;
3256     case DW_OP_piece:
3257       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3258       break;
3259     case DW_OP_deref_size:
3260     case DW_OP_xderef_size:
3261       dw2_asm_output_data (1, val1->v.val_int, NULL);
3262       break;
3263
3264     case INTERNAL_DW_OP_tls_addr:
3265       if (targetm.asm_out.output_dwarf_dtprel)
3266         {
3267           targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3268                                                DWARF2_ADDR_SIZE,
3269                                                val1->v.val_addr);
3270           fputc ('\n', asm_out_file);
3271         }
3272       else
3273         gcc_unreachable ();
3274       break;
3275
3276     default:
3277       /* Other codes have no operands.  */
3278       break;
3279     }
3280 }
3281
3282 /* Output a sequence of location operations.  */
3283
3284 static void
3285 output_loc_sequence (dw_loc_descr_ref loc)
3286 {
3287   for (; loc != NULL; loc = loc->dw_loc_next)
3288     {
3289       /* Output the opcode.  */
3290       dw2_asm_output_data (1, loc->dw_loc_opc,
3291                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3292
3293       /* Output the operand(s) (if any).  */
3294       output_loc_operands (loc);
3295     }
3296 }
3297
3298 /* This routine will generate the correct assembly data for a location
3299    description based on a cfi entry with a complex address.  */
3300
3301 static void
3302 output_cfa_loc (dw_cfi_ref cfi)
3303 {
3304   dw_loc_descr_ref loc;
3305   unsigned long size;
3306
3307   /* Output the size of the block.  */
3308   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3309   size = size_of_locs (loc);
3310   dw2_asm_output_data_uleb128 (size, NULL);
3311
3312   /* Now output the operations themselves.  */
3313   output_loc_sequence (loc);
3314 }
3315
3316 /* This function builds a dwarf location descriptor sequence from
3317    a dw_cfa_location.  */
3318
3319 static struct dw_loc_descr_struct *
3320 build_cfa_loc (dw_cfa_location *cfa)
3321 {
3322   struct dw_loc_descr_struct *head, *tmp;
3323
3324   gcc_assert (cfa->indirect);
3325
3326   if (cfa->base_offset)
3327     {
3328       if (cfa->reg <= 31)
3329         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3330       else
3331         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3332     }
3333   else if (cfa->reg <= 31)
3334     head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3335   else
3336     head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3337
3338   head->dw_loc_oprnd1.val_class = dw_val_class_const;
3339   tmp = new_loc_descr (DW_OP_deref, 0, 0);
3340   add_loc_descr (&head, tmp);
3341   if (cfa->offset != 0)
3342     {
3343       tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3344       add_loc_descr (&head, tmp);
3345     }
3346
3347   return head;
3348 }
3349
3350 /* This function fills in aa dw_cfa_location structure from a dwarf location
3351    descriptor sequence.  */
3352
3353 static void
3354 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3355 {
3356   struct dw_loc_descr_struct *ptr;
3357   cfa->offset = 0;
3358   cfa->base_offset = 0;
3359   cfa->indirect = 0;
3360   cfa->reg = -1;
3361
3362   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3363     {
3364       enum dwarf_location_atom op = ptr->dw_loc_opc;
3365
3366       switch (op)
3367         {
3368         case DW_OP_reg0:
3369         case DW_OP_reg1:
3370         case DW_OP_reg2:
3371         case DW_OP_reg3:
3372         case DW_OP_reg4:
3373         case DW_OP_reg5:
3374         case DW_OP_reg6:
3375         case DW_OP_reg7:
3376         case DW_OP_reg8:
3377         case DW_OP_reg9:
3378         case DW_OP_reg10:
3379         case DW_OP_reg11:
3380         case DW_OP_reg12:
3381         case DW_OP_reg13:
3382         case DW_OP_reg14:
3383         case DW_OP_reg15:
3384         case DW_OP_reg16:
3385         case DW_OP_reg17:
3386         case DW_OP_reg18:
3387         case DW_OP_reg19:
3388         case DW_OP_reg20:
3389         case DW_OP_reg21:
3390         case DW_OP_reg22:
3391         case DW_OP_reg23:
3392         case DW_OP_reg24:
3393         case DW_OP_reg25:
3394         case DW_OP_reg26:
3395         case DW_OP_reg27:
3396         case DW_OP_reg28:
3397         case DW_OP_reg29:
3398         case DW_OP_reg30:
3399         case DW_OP_reg31:
3400           cfa->reg = op - DW_OP_reg0;
3401           break;
3402         case DW_OP_regx:
3403           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3404           break;
3405         case DW_OP_breg0:
3406         case DW_OP_breg1:
3407         case DW_OP_breg2:
3408         case DW_OP_breg3:
3409         case DW_OP_breg4:
3410         case DW_OP_breg5:
3411         case DW_OP_breg6:
3412         case DW_OP_breg7:
3413         case DW_OP_breg8:
3414         case DW_OP_breg9:
3415         case DW_OP_breg10:
3416         case DW_OP_breg11:
3417         case DW_OP_breg12:
3418         case DW_OP_breg13:
3419         case DW_OP_breg14:
3420         case DW_OP_breg15:
3421         case DW_OP_breg16:
3422         case DW_OP_breg17:
3423         case DW_OP_breg18:
3424         case DW_OP_breg19:
3425         case DW_OP_breg20:
3426         case DW_OP_breg21:
3427         case DW_OP_breg22:
3428         case DW_OP_breg23:
3429         case DW_OP_breg24:
3430         case DW_OP_breg25:
3431         case DW_OP_breg26:
3432         case DW_OP_breg27:
3433         case DW_OP_breg28:
3434         case DW_OP_breg29:
3435         case DW_OP_breg30:
3436         case DW_OP_breg31:
3437           cfa->reg = op - DW_OP_breg0;
3438           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3439           break;
3440         case DW_OP_bregx:
3441           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3442           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3443           break;
3444         case DW_OP_deref:
3445           cfa->indirect = 1;
3446           break;
3447         case DW_OP_plus_uconst:
3448           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3449           break;
3450         default:
3451           internal_error ("DW_LOC_OP %s not implemented",
3452                           dwarf_stack_op_name (ptr->dw_loc_opc));
3453         }
3454     }
3455 }
3456 #endif /* .debug_frame support */
3457 \f
3458 /* And now, the support for symbolic debugging information.  */
3459 #ifdef DWARF2_DEBUGGING_INFO
3460
3461 /* .debug_str support.  */
3462 static int output_indirect_string (void **, void *);
3463
3464 static void dwarf2out_init (const char *);
3465 static void dwarf2out_finish (const char *);
3466 static void dwarf2out_define (unsigned int, const char *);
3467 static void dwarf2out_undef (unsigned int, const char *);
3468 static void dwarf2out_start_source_file (unsigned, const char *);
3469 static void dwarf2out_end_source_file (unsigned);
3470 static void dwarf2out_begin_block (unsigned, unsigned);
3471 static void dwarf2out_end_block (unsigned, unsigned);
3472 static bool dwarf2out_ignore_block (tree);
3473 static void dwarf2out_global_decl (tree);
3474 static void dwarf2out_type_decl (tree, int);
3475 static void dwarf2out_imported_module_or_decl (tree, tree);
3476 static void dwarf2out_abstract_function (tree);
3477 static void dwarf2out_var_location (rtx);
3478 static void dwarf2out_begin_function (tree);
3479 static void dwarf2out_switch_text_section (void);
3480
3481 /* The debug hooks structure.  */
3482
3483 const struct gcc_debug_hooks dwarf2_debug_hooks =
3484 {
3485   dwarf2out_init,
3486   dwarf2out_finish,
3487   dwarf2out_define,
3488   dwarf2out_undef,
3489   dwarf2out_start_source_file,
3490   dwarf2out_end_source_file,
3491   dwarf2out_begin_block,
3492   dwarf2out_end_block,
3493   dwarf2out_ignore_block,
3494   dwarf2out_source_line,
3495   dwarf2out_begin_prologue,
3496   debug_nothing_int_charstar,   /* end_prologue */
3497   dwarf2out_end_epilogue,
3498   dwarf2out_begin_function,
3499   debug_nothing_int,            /* end_function */
3500   dwarf2out_decl,               /* function_decl */
3501   dwarf2out_global_decl,
3502   dwarf2out_type_decl,          /* type_decl */
3503   dwarf2out_imported_module_or_decl,
3504   debug_nothing_tree,           /* deferred_inline_function */
3505   /* The DWARF 2 backend tries to reduce debugging bloat by not
3506      emitting the abstract description of inline functions until
3507      something tries to reference them.  */
3508   dwarf2out_abstract_function,  /* outlining_inline_function */
3509   debug_nothing_rtx,            /* label */
3510   debug_nothing_int,            /* handle_pch */
3511   dwarf2out_var_location,
3512   dwarf2out_switch_text_section,
3513   1                             /* start_end_main_source_file */
3514 };
3515 #endif
3516 \f
3517 /* NOTE: In the comments in this file, many references are made to
3518    "Debugging Information Entries".  This term is abbreviated as `DIE'
3519    throughout the remainder of this file.  */
3520
3521 /* An internal representation of the DWARF output is built, and then
3522    walked to generate the DWARF debugging info.  The walk of the internal
3523    representation is done after the entire program has been compiled.
3524    The types below are used to describe the internal representation.  */
3525
3526 /* Various DIE's use offsets relative to the beginning of the
3527    .debug_info section to refer to each other.  */
3528
3529 typedef long int dw_offset;
3530
3531 /* Define typedefs here to avoid circular dependencies.  */
3532
3533 typedef struct dw_attr_struct *dw_attr_ref;
3534 typedef struct dw_line_info_struct *dw_line_info_ref;
3535 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3536 typedef struct pubname_struct *pubname_ref;
3537 typedef struct dw_ranges_struct *dw_ranges_ref;
3538
3539 /* Each entry in the line_info_table maintains the file and
3540    line number associated with the label generated for that
3541    entry.  The label gives the PC value associated with
3542    the line number entry.  */
3543
3544 typedef struct dw_line_info_struct GTY(())
3545 {
3546   unsigned long dw_file_num;
3547   unsigned long dw_line_num;
3548 }
3549 dw_line_info_entry;
3550
3551 /* Line information for functions in separate sections; each one gets its
3552    own sequence.  */
3553 typedef struct dw_separate_line_info_struct GTY(())
3554 {
3555   unsigned long dw_file_num;
3556   unsigned long dw_line_num;
3557   unsigned long function;
3558 }
3559 dw_separate_line_info_entry;
3560
3561 /* Each DIE attribute has a field specifying the attribute kind,
3562    a link to the next attribute in the chain, and an attribute value.
3563    Attributes are typically linked below the DIE they modify.  */
3564
3565 typedef struct dw_attr_struct GTY(())
3566 {
3567   enum dwarf_attribute dw_attr;
3568   dw_attr_ref dw_attr_next;
3569   dw_val_node dw_attr_val;
3570 }
3571 dw_attr_node;
3572
3573 /* The Debugging Information Entry (DIE) structure */
3574
3575 typedef struct die_struct GTY(())
3576 {
3577   enum dwarf_tag die_tag;
3578   char *die_symbol;
3579   dw_attr_ref die_attr;
3580   dw_die_ref die_parent;
3581   dw_die_ref die_child;
3582   dw_die_ref die_sib;
3583   dw_die_ref die_definition; /* ref from a specification to its definition */
3584   dw_offset die_offset;
3585   unsigned long die_abbrev;
3586   int die_mark;
3587   unsigned int decl_id;
3588 }
3589 die_node;
3590
3591 /* The pubname structure */
3592
3593 typedef struct pubname_struct GTY(())
3594 {
3595   dw_die_ref die;
3596   char *name;
3597 }
3598 pubname_entry;
3599
3600 struct dw_ranges_struct GTY(())
3601 {
3602   int block_num;
3603 };
3604
3605 /* The limbo die list structure.  */
3606 typedef struct limbo_die_struct GTY(())
3607 {
3608   dw_die_ref die;
3609   tree created_for;
3610   struct limbo_die_struct *next;
3611 }
3612 limbo_die_node;
3613
3614 /* How to start an assembler comment.  */
3615 #ifndef ASM_COMMENT_START
3616 #define ASM_COMMENT_START ";#"
3617 #endif
3618