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, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5    Contributed by Gary Funck (gary@intrepid.com).
   6    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
   7    Extensively modified by Jason Merrill (jason@cygnus.com).
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  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 /* DWARF2 Abbreviation Glossary:
  38
  39    CFA = Canonical Frame Address
  40            a fixed address on the stack which identifies a call frame.
  41            We define it to be the value of SP just before the call insn.
  42            The CFA register and offset, which may change during the course
  43            of the function, are used to calculate its value at runtime.
  44
  45    CFI = Call Frame Instruction
  46            an instruction for the DWARF2 abstract machine
  47
  48    CIE = Common Information Entry
  49            information describing information common to one or more FDEs
  50
  51    DIE = Debugging Information Entry
  52
  53    FDE = Frame Description Entry
  54            information describing the stack call frame, in particular,
  55            how to restore registers
  56
  57    DW_CFA_... = DWARF2 CFA call frame instruction
  58    DW_TAG_... = DWARF2 DIE tag */
  59
  60 #include "config.h"
  61 #include "system.h"
  62 #include "coretypes.h"
  63 #include "tm.h"
  64 #include "tree.h"
  65 #include "version.h"
  66 #include "flags.h"
  67 #include "real.h"
  68 #include "rtl.h"
  69 #include "hard-reg-set.h"
  70 #include "regs.h"
  71 #include "insn-config.h"
  72 #include "reload.h"
  73 #include "function.h"
  74 #include "output.h"
  75 #include "expr.h"
  76 #include "libfuncs.h"
  77 #include "except.h"
  78 #include "dwarf2.h"
  79 #include "dwarf2out.h"
  80 #include "dwarf2asm.h"
  81 #include "toplev.h"
  82 #include "ggc.h"
  83 #include "md5.h"
  84 #include "tm_p.h"
  85 #include "diagnostic.h"
  86 #include "debug.h"
  87 #include "target.h"
  88 #include "langhooks.h"
  89 #include "hashtab.h"
  90 #include "cgraph.h"
  91 #include "input.h"
  92 #include "gimple.h"
  93 #include "tree-pass.h"
  94
  95 #ifdef DWARF2_DEBUGGING_INFO
  96 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
  97
  98 static rtx last_var_location_insn;
  99 #endif
 100
 101 #ifdef VMS_DEBUGGING_INFO
 102 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
 103
 104 /* Define this macro to be a nonzero value if the directory specifications
 105     which are output in the debug info should end with a separator.  */
 106 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
 107 /* Define this macro to evaluate to a nonzero value if GCC should refrain
 108    from generating indirect strings in DWARF2 debug information, for instance
 109    if your target is stuck with an old version of GDB that is unable to
 110    process them properly or uses VMS Debug.  */
 111 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
 112 #else
 113 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
 114 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
 115 #endif
 116
 117 #ifndef DWARF2_FRAME_INFO
 118 # ifdef DWARF2_DEBUGGING_INFO
 119 #  define DWARF2_FRAME_INFO \
 120   (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
 121 # else
 122 #  define DWARF2_FRAME_INFO 0
 123 # endif
 124 #endif
 125
 126 /* Map register numbers held in the call frame info that gcc has
 127    collected using DWARF_FRAME_REGNUM to those that should be output in
 128    .debug_frame and .eh_frame.  */
 129 #ifndef DWARF2_FRAME_REG_OUT
 130 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
 131 #endif
 132
 133 /* Save the result of dwarf2out_do_frame across PCH.  */
 134 static GTY(()) bool saved_do_cfi_asm = 0;
 135
 136 /* Decide whether we want to emit frame unwind information for the current
 137    translation unit.  */
 138
 139 int
 140 dwarf2out_do_frame (void)
 141 {
 142   /* We want to emit correct CFA location expressions or lists, so we
 143      have to return true if we're going to output debug info, even if
 144      we're not going to output frame or unwind info.  */
 145   return (write_symbols == DWARF2_DEBUG
 146           || write_symbols == VMS_AND_DWARF2_DEBUG
 147           || DWARF2_FRAME_INFO || saved_do_cfi_asm
 148 #ifdef DWARF2_UNWIND_INFO
 149           || (DWARF2_UNWIND_INFO
 150               && (flag_unwind_tables
 151                   || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
 152 #endif
 153           );
 154 }
 155
 156 /* Decide whether to emit frame unwind via assembler directives.  */
 157
 158 int
 159 dwarf2out_do_cfi_asm (void)
 160 {
 161   int enc;
 162
 163 #ifdef MIPS_DEBUGGING_INFO
 164   return false;
 165 #endif
 166   if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
 167     return false;
 168   if (saved_do_cfi_asm)
 169     return true;
 170   if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
 171     return false;
 172
 173   /* Make sure the personality encoding is one the assembler can support.
 174      In particular, aligned addresses can't be handled.  */
 175   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
 176   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
 177     return false;
 178   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
 179   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
 180     return false;
 181
 182   if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
 183     {
 184 #ifdef TARGET_UNWIND_INFO
 185       return false;
 186 #else
 187       if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
 188         return false;
 189 #endif
 190     }
 191
 192   saved_do_cfi_asm = true;
 193   return true;
 194 }
 195
 196 /* The size of the target's pointer type.  */
 197 #ifndef PTR_SIZE
 198 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 199 #endif
 200
 201 /* Array of RTXes referenced by the debugging information, which therefore
 202    must be kept around forever.  */
 203 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 204
 205 /* A pointer to the base of a list of incomplete types which might be
 206    completed at some later time.  incomplete_types_list needs to be a
 207    VEC(tree,gc) because we want to tell the garbage collector about
 208    it.  */
 209 static GTY(()) VEC(tree,gc) *incomplete_types;
 210
 211 /* A pointer to the base of a table of references to declaration
 212    scopes.  This table is a display which tracks the nesting
 213    of declaration scopes at the current scope and containing
 214    scopes.  This table is used to find the proper place to
 215    define type declaration DIE's.  */
 216 static GTY(()) VEC(tree,gc) *decl_scope_table;
 217
 218 /* Pointers to various DWARF2 sections.  */
 219 static GTY(()) section *debug_info_section;
 220 static GTY(()) section *debug_abbrev_section;
 221 static GTY(()) section *debug_aranges_section;
 222 static GTY(()) section *debug_macinfo_section;
 223 static GTY(()) section *debug_line_section;
 224 static GTY(()) section *debug_loc_section;
 225 static GTY(()) section *debug_pubnames_section;
 226 static GTY(()) section *debug_pubtypes_section;
 227 static GTY(()) section *debug_dcall_section;
 228 static GTY(()) section *debug_vcall_section;
 229 static GTY(()) section *debug_str_section;
 230 static GTY(()) section *debug_ranges_section;
 231 static GTY(()) section *debug_frame_section;
 232
 233 /* Personality decl of current unit.  Used only when assembler does not support
 234    personality CFI.  */
 235 static GTY(()) rtx current_unit_personality;
 236
 237 /* How to start an assembler comment.  */
 238 #ifndef ASM_COMMENT_START
 239 #define ASM_COMMENT_START ";#"
 240 #endif
 241
 242 typedef struct dw_cfi_struct *dw_cfi_ref;
 243 typedef struct dw_fde_struct *dw_fde_ref;
 244 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 245
 246 /* Call frames are described using a sequence of Call Frame
 247    Information instructions.  The register number, offset
 248    and address fields are provided as possible operands;
 249    their use is selected by the opcode field.  */
 250
 251 enum dw_cfi_oprnd_type {
 252   dw_cfi_oprnd_unused,
 253   dw_cfi_oprnd_reg_num,
 254   dw_cfi_oprnd_offset,
 255   dw_cfi_oprnd_addr,
 256   dw_cfi_oprnd_loc
 257 };
 258
 259 typedef union GTY(()) dw_cfi_oprnd_struct {
 260   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 261   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 262   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 263   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 264 }
 265 dw_cfi_oprnd;
 266
 267 typedef struct GTY(()) dw_cfi_struct {
 268   dw_cfi_ref dw_cfi_next;
 269   enum dwarf_call_frame_info dw_cfi_opc;
 270   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 271     dw_cfi_oprnd1;
 272   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 273     dw_cfi_oprnd2;
 274 }
 275 dw_cfi_node;
 276
 277 /* This is how we define the location of the CFA. We use to handle it
 278    as REG + OFFSET all the time,  but now it can be more complex.
 279    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 280    Instead of passing around REG and OFFSET, we pass a copy
 281    of this structure.  */
 282 typedef struct GTY(()) cfa_loc {
 283   HOST_WIDE_INT offset;
 284   HOST_WIDE_INT base_offset;
 285   unsigned int reg;
 286   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
 287   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
 288 } dw_cfa_location;
 289
 290 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 291    refer to a single Common Information Entry (CIE), defined at
 292    the beginning of the .debug_frame section.  This use of a single
 293    CIE obviates the need to keep track of multiple CIE's
 294    in the DWARF generation routines below.  */
 295
 296 typedef struct GTY(()) dw_fde_struct {
 297   tree decl;
 298   const char *dw_fde_begin;
 299   const char *dw_fde_current_label;
 300   const char *dw_fde_end;
 301   const char *dw_fde_hot_section_label;
 302   const char *dw_fde_hot_section_end_label;
 303   const char *dw_fde_unlikely_section_label;
 304   const char *dw_fde_unlikely_section_end_label;
 305   dw_cfi_ref dw_fde_cfi;
 306   dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections.  */
 307   unsigned funcdef_number;
 308   HOST_WIDE_INT stack_realignment;
 309   /* Dynamic realign argument pointer register.  */
 310   unsigned int drap_reg;
 311   /* Virtual dynamic realign argument pointer register.  */
 312   unsigned int vdrap_reg;
 313   unsigned all_throwers_are_sibcalls : 1;
 314   unsigned nothrow : 1;
 315   unsigned uses_eh_lsda : 1;
 316   /* Whether we did stack realign in this call frame.  */
 317   unsigned stack_realign : 1;
 318   /* Whether dynamic realign argument pointer register has been saved.  */
 319   unsigned drap_reg_saved: 1;
 320   /* True iff dw_fde_begin label is in text_section or cold_text_section.  */
 321   unsigned in_std_section : 1;
 322   /* True iff dw_fde_unlikely_section_label is in text_section or
 323      cold_text_section.  */
 324   unsigned cold_in_std_section : 1;
 325   /* True iff switched sections.  */
 326   unsigned dw_fde_switched_sections : 1;
 327   /* True iff switching from cold to hot section.  */
 328   unsigned dw_fde_switched_cold_to_hot : 1;
 329 }
 330 dw_fde_node;
 331
 332 /* Maximum size (in bytes) of an artificially generated label.  */
 333 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 334
 335 /* The size of addresses as they appear in the Dwarf 2 data.
 336    Some architectures use word addresses to refer to code locations,
 337    but Dwarf 2 info always uses byte addresses.  On such machines,
 338    Dwarf 2 addresses need to be larger than the architecture's
 339    pointers.  */
 340 #ifndef DWARF2_ADDR_SIZE
 341 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 342 #endif
 343
 344 /* The size in bytes of a DWARF field indicating an offset or length
 345    relative to a debug info section, specified to be 4 bytes in the
 346    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 347    as PTR_SIZE.  */
 348
 349 #ifndef DWARF_OFFSET_SIZE
 350 #define DWARF_OFFSET_SIZE 4
 351 #endif
 352
 353 /* The size in bytes of a DWARF 4 type signature.  */
 354
 355 #ifndef DWARF_TYPE_SIGNATURE_SIZE
 356 #define DWARF_TYPE_SIGNATURE_SIZE 8
 357 #endif
 358
 359 /* According to the (draft) DWARF 3 specification, the initial length
 360    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 361    bytes are 0xffffffff, followed by the length stored in the next 8
 362    bytes.
 363
 364    However, the SGI/MIPS ABI uses an initial length which is equal to
 365    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 366
 367 #ifndef DWARF_INITIAL_LENGTH_SIZE
 368 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 369 #endif
 370
 371 /* Round SIZE up to the nearest BOUNDARY.  */
 372 #define DWARF_ROUND(SIZE,BOUNDARY) \
 373   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 374
 375 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 376 #ifndef DWARF_CIE_DATA_ALIGNMENT
 377 #ifdef STACK_GROWS_DOWNWARD
 378 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 379 #else
 380 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 381 #endif
 382 #endif
 383
 384 /* CIE identifier.  */
 385 #if HOST_BITS_PER_WIDE_INT >= 64
 386 #define DWARF_CIE_ID \
 387   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
 388 #else
 389 #define DWARF_CIE_ID DW_CIE_ID
 390 #endif
 391
 392 /* A pointer to the base of a table that contains frame description
 393    information for each routine.  */
 394 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 395
 396 /* Number of elements currently allocated for fde_table.  */
 397 static GTY(()) unsigned fde_table_allocated;
 398
 399 /* Number of elements in fde_table currently in use.  */
 400 static GTY(()) unsigned fde_table_in_use;
 401
 402 /* Size (in elements) of increments by which we may expand the
 403    fde_table.  */
 404 #define FDE_TABLE_INCREMENT 256
 405
 406 /* Get the current fde_table entry we should use.  */
 407
 408 static inline dw_fde_ref
 409 current_fde (void)
 410 {
 411   return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
 412 }
 413
 414 /* A list of call frame insns for the CIE.  */
 415 static GTY(()) dw_cfi_ref cie_cfi_head;
 416
 417 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 418 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 419    attribute that accelerates the lookup of the FDE associated
 420    with the subprogram.  This variable holds the table index of the FDE
 421    associated with the current function (body) definition.  */
 422 static unsigned current_funcdef_fde;
 423 #endif
 424
 425 struct GTY(()) indirect_string_node {
 426   const char *str;
 427   unsigned int refcount;
 428   enum dwarf_form form;
 429   char *label;
 430 };
 431
 432 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 433
 434 /* True if the compilation unit has location entries that reference
 435    debug strings.  */
 436 static GTY(()) bool debug_str_hash_forced = false;
 437
 438 static GTY(()) int dw2_string_counter;
 439 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 440
 441 /* True if the compilation unit places functions in more than one section.  */
 442 static GTY(()) bool have_multiple_function_sections = false;
 443
 444 /* Whether the default text and cold text sections have been used at all.  */
 445
 446 static GTY(()) bool text_section_used = false;
 447 static GTY(()) bool cold_text_section_used = false;
 448
 449 /* The default cold text section.  */
 450 static GTY(()) section *cold_text_section;
 451
 452 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 453
 454 /* Forward declarations for functions defined in this file.  */
 455
 456 static char *stripattributes (const char *);
 457 static const char *dwarf_cfi_name (unsigned);
 458 static dw_cfi_ref new_cfi (void);
 459 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 460 static void add_fde_cfi (const char *, dw_cfi_ref);
 461 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
 462 static void lookup_cfa (dw_cfa_location *);
 463 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 464 #ifdef DWARF2_UNWIND_INFO
 465 static void initial_return_save (rtx);
 466 #endif
 467 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
 468                                           HOST_WIDE_INT);
 469 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 470 static void output_cfi_directive (dw_cfi_ref);
 471 static void output_call_frame_info (int);
 472 static void dwarf2out_note_section_used (void);
 473 static void flush_queued_reg_saves (void);
 474 static bool clobbers_queued_reg_save (const_rtx);
 475 static void dwarf2out_frame_debug_expr (rtx, const char *);
 476
 477 /* Support for complex CFA locations.  */
 478 static void output_cfa_loc (dw_cfi_ref);
 479 static void output_cfa_loc_raw (dw_cfi_ref);
 480 static void get_cfa_from_loc_descr (dw_cfa_location *,
 481                                     struct dw_loc_descr_struct *);
 482 static struct dw_loc_descr_struct *build_cfa_loc
 483   (dw_cfa_location *, HOST_WIDE_INT);
 484 static struct dw_loc_descr_struct *build_cfa_aligned_loc
 485   (HOST_WIDE_INT, HOST_WIDE_INT);
 486 static void def_cfa_1 (const char *, dw_cfa_location *);
 487
 488 /* How to start an assembler comment.  */
 489 #ifndef ASM_COMMENT_START
 490 #define ASM_COMMENT_START ";#"
 491 #endif
 492
 493 /* Data and reference forms for relocatable data.  */
 494 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 495 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 496
 497 #ifndef DEBUG_FRAME_SECTION
 498 #define DEBUG_FRAME_SECTION     ".debug_frame"
 499 #endif
 500
 501 #ifndef FUNC_BEGIN_LABEL
 502 #define FUNC_BEGIN_LABEL        "LFB"
 503 #endif
 504
 505 #ifndef FUNC_END_LABEL
 506 #define FUNC_END_LABEL          "LFE"
 507 #endif
 508
 509 #ifndef FRAME_BEGIN_LABEL
 510 #define FRAME_BEGIN_LABEL       "Lframe"
 511 #endif
 512 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 513 #define CIE_END_LABEL           "LECIE"
 514 #define FDE_LABEL               "LSFDE"
 515 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 516 #define FDE_END_LABEL           "LEFDE"
 517 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 518 #define LINE_NUMBER_END_LABEL   "LELT"
 519 #define LN_PROLOG_AS_LABEL      "LASLTP"
 520 #define LN_PROLOG_END_LABEL     "LELTP"
 521 #define DIE_LABEL_PREFIX        "DW"
 522
 523 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 524    is the column for PC, or the first column after all of the hard
 525    registers.  */
 526 #ifndef DWARF_FRAME_RETURN_COLUMN
 527 #ifdef PC_REGNUM
 528 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 529 #else
 530 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 531 #endif
 532 #endif
 533
 534 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 535    default, we just provide columns for all registers.  */
 536 #ifndef DWARF_FRAME_REGNUM
 537 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 538 #endif
 539 \f
 540 /* Hook used by __throw.  */
 541
 542 rtx
 543 expand_builtin_dwarf_sp_column (void)
 544 {
 545   unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
 546   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
 547 }
 548
 549 /* Return a pointer to a copy of the section string name S with all
 550    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 551
 552 static inline char *
 553 stripattributes (const char *s)
 554 {
 555   char *stripped = XNEWVEC (char, strlen (s) + 2);
 556   char *p = stripped;
 557
 558   *p++ = '*';
 559
 560   while (*s && *s != ',')
 561     *p++ = *s++;
 562
 563   *p = '\0';
 564   return stripped;
 565 }
 566
 567 /* MEM is a memory reference for the register size table, each element of
 568    which has mode MODE.  Initialize column C as a return address column.  */
 569
 570 static void
 571 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
 572 {
 573   HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
 574   HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
 575   emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 576 }
 577
 578 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder.  */
 579
 580 static inline HOST_WIDE_INT
 581 div_data_align (HOST_WIDE_INT off)
 582 {
 583   HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
 584   gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
 585   return r;
 586 }
 587
 588 /* Return true if we need a signed version of a given opcode
 589    (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended).  */
 590
 591 static inline bool
 592 need_data_align_sf_opcode (HOST_WIDE_INT off)
 593 {
 594   return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
 595 }
 596
 597 /* Generate code to initialize the register size table.  */
 598
 599 void
 600 expand_builtin_init_dwarf_reg_sizes (tree address)
 601 {
 602   unsigned int i;
 603   enum machine_mode mode = TYPE_MODE (char_type_node);
 604   rtx addr = expand_normal (address);
 605   rtx mem = gen_rtx_MEM (BLKmode, addr);
 606   bool wrote_return_column = false;
 607
 608   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 609     {
 610       int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
 611
 612       if (rnum < DWARF_FRAME_REGISTERS)
 613         {
 614           HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
 615           enum machine_mode save_mode = reg_raw_mode[i];
 616           HOST_WIDE_INT size;
 617
 618           if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 619             save_mode = choose_hard_reg_mode (i, 1, true);
 620           if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 621             {
 622               if (save_mode == VOIDmode)
 623                 continue;
 624               wrote_return_column = true;
 625             }
 626           size = GET_MODE_SIZE (save_mode);
 627           if (offset < 0)
 628             continue;
 629
 630           emit_move_insn (adjust_address (mem, mode, offset),
 631                           gen_int_mode (size, mode));
 632         }
 633     }
 634
 635   if (!wrote_return_column)
 636     init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
 637
 638 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 639   init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
 640 #endif
 641
 642   targetm.init_dwarf_reg_sizes_extra (address);
 643 }
 644
 645 /* Convert a DWARF call frame info. operation to its string name */
 646
 647 static const char *
 648 dwarf_cfi_name (unsigned int cfi_opc)
 649 {
 650   switch (cfi_opc)
 651     {
 652     case DW_CFA_advance_loc:
 653       return "DW_CFA_advance_loc";
 654     case DW_CFA_offset:
 655       return "DW_CFA_offset";
 656     case DW_CFA_restore:
 657       return "DW_CFA_restore";
 658     case DW_CFA_nop:
 659       return "DW_CFA_nop";
 660     case DW_CFA_set_loc:
 661       return "DW_CFA_set_loc";
 662     case DW_CFA_advance_loc1:
 663       return "DW_CFA_advance_loc1";
 664     case DW_CFA_advance_loc2:
 665       return "DW_CFA_advance_loc2";
 666     case DW_CFA_advance_loc4:
 667       return "DW_CFA_advance_loc4";
 668     case DW_CFA_offset_extended:
 669       return "DW_CFA_offset_extended";
 670     case DW_CFA_restore_extended:
 671       return "DW_CFA_restore_extended";
 672     case DW_CFA_undefined:
 673       return "DW_CFA_undefined";
 674     case DW_CFA_same_value:
 675       return "DW_CFA_same_value";
 676     case DW_CFA_register:
 677       return "DW_CFA_register";
 678     case DW_CFA_remember_state:
 679       return "DW_CFA_remember_state";
 680     case DW_CFA_restore_state:
 681       return "DW_CFA_restore_state";
 682     case DW_CFA_def_cfa:
 683       return "DW_CFA_def_cfa";
 684     case DW_CFA_def_cfa_register:
 685       return "DW_CFA_def_cfa_register";
 686     case DW_CFA_def_cfa_offset:
 687       return "DW_CFA_def_cfa_offset";
 688
 689     /* DWARF 3 */
 690     case DW_CFA_def_cfa_expression:
 691       return "DW_CFA_def_cfa_expression";
 692     case DW_CFA_expression:
 693       return "DW_CFA_expression";
 694     case DW_CFA_offset_extended_sf:
 695       return "DW_CFA_offset_extended_sf";
 696     case DW_CFA_def_cfa_sf:
 697       return "DW_CFA_def_cfa_sf";
 698     case DW_CFA_def_cfa_offset_sf:
 699       return "DW_CFA_def_cfa_offset_sf";
 700
 701     /* SGI/MIPS specific */
 702     case DW_CFA_MIPS_advance_loc8:
 703       return "DW_CFA_MIPS_advance_loc8";
 704
 705     /* GNU extensions */
 706     case DW_CFA_GNU_window_save:
 707       return "DW_CFA_GNU_window_save";
 708     case DW_CFA_GNU_args_size:
 709       return "DW_CFA_GNU_args_size";
 710     case DW_CFA_GNU_negative_offset_extended:
 711       return "DW_CFA_GNU_negative_offset_extended";
 712
 713     default:
 714       return "DW_CFA_<unknown>";
 715     }
 716 }
 717
 718 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 719
 720 static inline dw_cfi_ref
 721 new_cfi (void)
 722 {
 723   dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
 724
 725   cfi->dw_cfi_next = NULL;
 726   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 727   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 728
 729   return cfi;
 730 }
 731
 732 /* Add a Call Frame Instruction to list of instructions.  */
 733
 734 static inline void
 735 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 736 {
 737   dw_cfi_ref *p;
 738   dw_fde_ref fde = current_fde ();
 739
 740   /* When DRAP is used, CFA is defined with an expression.  Redefine
 741      CFA may lead to a different CFA value.   */
 742   /* ??? Of course, this heuristic fails when we're annotating epilogues,
 743      because of course we'll always want to redefine the CFA back to the
 744      stack pointer on the way out.  Where should we move this check?  */
 745   if (0 && fde && fde->drap_reg != INVALID_REGNUM)
 746     switch (cfi->dw_cfi_opc)
 747       {
 748         case DW_CFA_def_cfa_register:
 749         case DW_CFA_def_cfa_offset:
 750         case DW_CFA_def_cfa_offset_sf:
 751         case DW_CFA_def_cfa:
 752         case DW_CFA_def_cfa_sf:
 753           gcc_unreachable ();
 754
 755         default:
 756           break;
 757       }
 758
 759   /* Find the end of the chain.  */
 760   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 761     ;
 762
 763   *p = cfi;
 764 }
 765
 766 /* Generate a new label for the CFI info to refer to.  FORCE is true
 767    if a label needs to be output even when using .cfi_* directives.  */
 768
 769 char *
 770 dwarf2out_cfi_label (bool force)
 771 {
 772   static char label[20];
 773
 774   if (!force && dwarf2out_do_cfi_asm ())
 775     {
 776       /* In this case, we will be emitting the asm directive instead of
 777          the label, so just return a placeholder to keep the rest of the
 778          interfaces happy.  */
 779       strcpy (label, "<do not output>");
 780     }
 781   else
 782     {
 783       ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 784       ASM_OUTPUT_LABEL (asm_out_file, label);
 785     }
 786
 787   return label;
 788 }
 789
 790 /* True if remember_state should be emitted before following CFI directive.  */
 791 static bool emit_cfa_remember;
 792
 793 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 794    or to the CIE if LABEL is NULL.  */
 795
 796 static void
 797 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 798 {
 799   dw_cfi_ref *list_head;
 800
 801   if (emit_cfa_remember)
 802     {
 803       dw_cfi_ref cfi_remember;
 804
 805       /* Emit the state save.  */
 806       emit_cfa_remember = false;
 807       cfi_remember = new_cfi ();
 808       cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
 809       add_fde_cfi (label, cfi_remember);
 810     }
 811
 812   list_head = &cie_cfi_head;
 813
 814   if (dwarf2out_do_cfi_asm ())
 815     {
 816       if (label)
 817         {
 818           dw_fde_ref fde = current_fde ();
 819
 820           gcc_assert (fde != NULL);
 821
 822           /* We still have to add the cfi to the list so that lookup_cfa
 823              works later on.  When -g2 and above we even need to force
 824              emitting of CFI labels and add to list a DW_CFA_set_loc for
 825              convert_cfa_to_fb_loc_list purposes.  If we're generating
 826              DWARF3 output we use DW_OP_call_frame_cfa and so don't use
 827              convert_cfa_to_fb_loc_list.  */
 828           if (dwarf_version == 2
 829               && debug_info_level > DINFO_LEVEL_TERSE
 830               && (write_symbols == DWARF2_DEBUG
 831                   || write_symbols == VMS_AND_DWARF2_DEBUG))
 832             {
 833               switch (cfi->dw_cfi_opc)
 834                 {
 835                 case DW_CFA_def_cfa_offset:
 836                 case DW_CFA_def_cfa_offset_sf:
 837                 case DW_CFA_def_cfa_register:
 838                 case DW_CFA_def_cfa:
 839                 case DW_CFA_def_cfa_sf:
 840                 case DW_CFA_def_cfa_expression:
 841                 case DW_CFA_restore_state:
 842                   if (*label == 0 || strcmp (label, "<do not output>") == 0)
 843                     label = dwarf2out_cfi_label (true);
 844
 845                   if (fde->dw_fde_current_label == NULL
 846                       || strcmp (label, fde->dw_fde_current_label) != 0)
 847                     {
 848                       dw_cfi_ref xcfi;
 849
 850                       label = xstrdup (label);
 851
 852                       /* Set the location counter to the new label.  */
 853                       xcfi = new_cfi ();
 854                       /* It doesn't metter whether DW_CFA_set_loc
 855                          or DW_CFA_advance_loc4 is added here, those aren't
 856                          emitted into assembly, only looked up by
 857                          convert_cfa_to_fb_loc_list.  */
 858                       xcfi->dw_cfi_opc = DW_CFA_set_loc;
 859                       xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 860                       add_cfi (&fde->dw_fde_cfi, xcfi);
 861                       fde->dw_fde_current_label = label;
 862                     }
 863                   break;
 864                 default:
 865                   break;
 866                 }
 867             }
 868
 869           output_cfi_directive (cfi);
 870
 871           list_head = &fde->dw_fde_cfi;
 872         }
 873       /* ??? If this is a CFI for the CIE, we don't emit.  This
 874          assumes that the standard CIE contents that the assembler
 875          uses matches the standard CIE contents that the compiler
 876          uses.  This is probably a bad assumption.  I'm not quite
 877          sure how to address this for now.  */
 878     }
 879   else if (label)
 880     {
 881       dw_fde_ref fde = current_fde ();
 882
 883       gcc_assert (fde != NULL);
 884
 885       if (*label == 0)
 886         label = dwarf2out_cfi_label (false);
 887
 888       if (fde->dw_fde_current_label == NULL
 889           || strcmp (label, fde->dw_fde_current_label) != 0)
 890         {
 891           dw_cfi_ref xcfi;
 892
 893           label = xstrdup (label);
 894
 895           /* Set the location counter to the new label.  */
 896           xcfi = new_cfi ();
 897           /* If we have a current label, advance from there, otherwise
 898              set the location directly using set_loc.  */
 899           xcfi->dw_cfi_opc = fde->dw_fde_current_label
 900                              ? DW_CFA_advance_loc4
 901                              : DW_CFA_set_loc;
 902           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 903           add_cfi (&fde->dw_fde_cfi, xcfi);
 904
 905           fde->dw_fde_current_label = label;
 906         }
 907
 908       list_head = &fde->dw_fde_cfi;
 909     }
 910
 911   add_cfi (list_head, cfi);
 912 }
 913
 914 /* Subroutine of lookup_cfa.  */
 915
 916 static void
 917 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
 918 {
 919   switch (cfi->dw_cfi_opc)
 920     {
 921     case DW_CFA_def_cfa_offset:
 922     case DW_CFA_def_cfa_offset_sf:
 923       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 924       break;
 925     case DW_CFA_def_cfa_register:
 926       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 927       break;
 928     case DW_CFA_def_cfa:
 929     case DW_CFA_def_cfa_sf:
 930       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 931       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 932       break;
 933     case DW_CFA_def_cfa_expression:
 934       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 935       break;
 936
 937     case DW_CFA_remember_state:
 938       gcc_assert (!remember->in_use);
 939       *remember = *loc;
 940       remember->in_use = 1;
 941       break;
 942     case DW_CFA_restore_state:
 943       gcc_assert (remember->in_use);
 944       *loc = *remember;
 945       remember->in_use = 0;
 946       break;
 947
 948     default:
 949       break;
 950     }
 951 }
 952
 953 /* Find the previous value for the CFA.  */
 954
 955 static void
 956 lookup_cfa (dw_cfa_location *loc)
 957 {
 958   dw_cfi_ref cfi;
 959   dw_fde_ref fde;
 960   dw_cfa_location remember;
 961
 962   memset (loc, 0, sizeof (*loc));
 963   loc->reg = INVALID_REGNUM;
 964   remember = *loc;
 965
 966   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 967     lookup_cfa_1 (cfi, loc, &remember);
 968
 969   fde = current_fde ();
 970   if (fde)
 971     for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 972       lookup_cfa_1 (cfi, loc, &remember);
 973 }
 974
 975 /* The current rule for calculating the DWARF2 canonical frame address.  */
 976 static dw_cfa_location cfa;
 977
 978 /* The register used for saving registers to the stack, and its offset
 979    from the CFA.  */
 980 static dw_cfa_location cfa_store;
 981
 982 /* The current save location around an epilogue.  */
 983 static dw_cfa_location cfa_remember;
 984
 985 /* The running total of the size of arguments pushed onto the stack.  */
 986 static HOST_WIDE_INT args_size;
 987
 988 /* The last args_size we actually output.  */
 989 static HOST_WIDE_INT old_args_size;
 990
 991 /* Entry point to update the canonical frame address (CFA).
 992    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 993    calculated from REG+OFFSET.  */
 994
 995 void
 996 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 997 {
 998   dw_cfa_location loc;
 999   loc.indirect = 0;
1000   loc.base_offset = 0;
1001   loc.reg = reg;
1002   loc.offset = offset;
1003   def_cfa_1 (label, &loc);
1004 }
1005
1006 /* Determine if two dw_cfa_location structures define the same data.  */
1007
1008 static bool
1009 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1010 {
1011   return (loc1->reg == loc2->reg
1012           && loc1->offset == loc2->offset
1013           && loc1->indirect == loc2->indirect
1014           && (loc1->indirect == 0
1015               || loc1->base_offset == loc2->base_offset));
1016 }
1017
1018 /* This routine does the actual work.  The CFA is now calculated from
1019    the dw_cfa_location structure.  */
1020
1021 static void
1022 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1023 {
1024   dw_cfi_ref cfi;
1025   dw_cfa_location old_cfa, loc;
1026
1027   cfa = *loc_p;
1028   loc = *loc_p;
1029
1030   if (cfa_store.reg == loc.reg && loc.indirect == 0)
1031     cfa_store.offset = loc.offset;
1032
1033   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1034   lookup_cfa (&old_cfa);
1035
1036   /* If nothing changed, no need to issue any call frame instructions.  */
1037   if (cfa_equal_p (&loc, &old_cfa))
1038     return;
1039
1040   cfi = new_cfi ();
1041
1042   if (loc.reg == old_cfa.reg && !loc.indirect && !old_cfa.indirect)
1043     {
1044       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1045          the CFA register did not change but the offset did.  The data
1046          factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1047          in the assembler via the .cfi_def_cfa_offset directive.  */
1048       if (loc.offset < 0)
1049         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1050       else
1051         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1052       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1053     }
1054
1055 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
1056   else if (loc.offset == old_cfa.offset
1057            && old_cfa.reg != INVALID_REGNUM
1058            && !loc.indirect
1059            && !old_cfa.indirect)
1060     {
1061       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1062          indicating the CFA register has changed to <register> but the
1063          offset has not changed.  */
1064       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1065       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1066     }
1067 #endif
1068
1069   else if (loc.indirect == 0)
1070     {
1071       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1072          indicating the CFA register has changed to <register> with
1073          the specified offset.  The data factoring for DW_CFA_def_cfa_sf
1074          happens in output_cfi, or in the assembler via the .cfi_def_cfa
1075          directive.  */
1076       if (loc.offset < 0)
1077         cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1078       else
1079         cfi->dw_cfi_opc = DW_CFA_def_cfa;
1080       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1081       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1082     }
1083   else
1084     {
1085       /* Construct a DW_CFA_def_cfa_expression instruction to
1086          calculate the CFA using a full location expression since no
1087          register-offset pair is available.  */
1088       struct dw_loc_descr_struct *loc_list;
1089
1090       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1091       loc_list = build_cfa_loc (&loc, 0);
1092       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1093     }
1094
1095   add_fde_cfi (label, cfi);
1096 }
1097
1098 /* Add the CFI for saving a register.  REG is the CFA column number.
1099    LABEL is passed to add_fde_cfi.
1100    If SREG is -1, the register is saved at OFFSET from the CFA;
1101    otherwise it is saved in SREG.  */
1102
1103 static void
1104 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1105 {
1106   dw_cfi_ref cfi = new_cfi ();
1107   dw_fde_ref fde = current_fde ();
1108
1109   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1110
1111   /* When stack is aligned, store REG using DW_CFA_expression with
1112      FP.  */
1113   if (fde
1114       && fde->stack_realign
1115       && sreg == INVALID_REGNUM)
1116     {
1117       cfi->dw_cfi_opc = DW_CFA_expression;
1118       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1119       cfi->dw_cfi_oprnd2.dw_cfi_loc
1120         = build_cfa_aligned_loc (offset, fde->stack_realignment);
1121     }
1122   else if (sreg == INVALID_REGNUM)
1123     {
1124       if (need_data_align_sf_opcode (offset))
1125         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1126       else if (reg & ~0x3f)
1127         cfi->dw_cfi_opc = DW_CFA_offset_extended;
1128       else
1129         cfi->dw_cfi_opc = DW_CFA_offset;
1130       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1131     }
1132   else if (sreg == reg)
1133     cfi->dw_cfi_opc = DW_CFA_same_value;
1134   else
1135     {
1136       cfi->dw_cfi_opc = DW_CFA_register;
1137       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1138     }
1139
1140   add_fde_cfi (label, cfi);
1141 }
1142
1143 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
1144    This CFI tells the unwinder that it needs to restore the window registers
1145    from the previous frame's window save area.
1146
1147    ??? Perhaps we should note in the CIE where windows are saved (instead of
1148    assuming 0(cfa)) and what registers are in the window.  */
1149
1150 void
1151 dwarf2out_window_save (const char *label)
1152 {
1153   dw_cfi_ref cfi = new_cfi ();
1154
1155   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1156   add_fde_cfi (label, cfi);
1157 }
1158
1159 /* Entry point for saving a register to the stack.  REG is the GCC register
1160    number.  LABEL and OFFSET are passed to reg_save.  */
1161
1162 void
1163 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1164 {
1165   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1166 }
1167
1168 /* Entry point for saving the return address in the stack.
1169    LABEL and OFFSET are passed to reg_save.  */
1170
1171 void
1172 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1173 {
1174   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1175 }
1176
1177 /* Entry point for saving the return address in a register.
1178    LABEL and SREG are passed to reg_save.  */
1179
1180 void
1181 dwarf2out_return_reg (const char *label, unsigned int sreg)
1182 {
1183   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1184 }
1185
1186 #ifdef DWARF2_UNWIND_INFO
1187 /* Record the initial position of the return address.  RTL is
1188    INCOMING_RETURN_ADDR_RTX.  */
1189
1190 static void
1191 initial_return_save (rtx rtl)
1192 {
1193   unsigned int reg = INVALID_REGNUM;
1194   HOST_WIDE_INT offset = 0;
1195
1196   switch (GET_CODE (rtl))
1197     {
1198     case REG:
1199       /* RA is in a register.  */
1200       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1201       break;
1202
1203     case MEM:
1204       /* RA is on the stack.  */
1205       rtl = XEXP (rtl, 0);
1206       switch (GET_CODE (rtl))
1207         {
1208         case REG:
1209           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1210           offset = 0;
1211           break;
1212
1213         case PLUS:
1214           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1215           offset = INTVAL (XEXP (rtl, 1));
1216           break;
1217
1218         case MINUS:
1219           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1220           offset = -INTVAL (XEXP (rtl, 1));
1221           break;
1222
1223         default:
1224           gcc_unreachable ();
1225         }
1226
1227       break;
1228
1229     case PLUS:
1230       /* The return address is at some offset from any value we can
1231          actually load.  For instance, on the SPARC it is in %i7+8. Just
1232          ignore the offset for now; it doesn't matter for unwinding frames.  */
1233       gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1234       initial_return_save (XEXP (rtl, 0));
1235       return;
1236
1237     default:
1238       gcc_unreachable ();
1239     }
1240
1241   if (reg != DWARF_FRAME_RETURN_COLUMN)
1242     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1243 }
1244 #endif
1245
1246 /* Given a SET, calculate the amount of stack adjustment it
1247    contains.  */
1248
1249 static HOST_WIDE_INT
1250 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1251                      HOST_WIDE_INT cur_offset)
1252 {
1253   const_rtx src = SET_SRC (pattern);
1254   const_rtx dest = SET_DEST (pattern);
1255   HOST_WIDE_INT offset = 0;
1256   enum rtx_code code;
1257
1258   if (dest == stack_pointer_rtx)
1259     {
1260       code = GET_CODE (src);
1261
1262       /* Assume (set (reg sp) (reg whatever)) sets args_size
1263          level to 0.  */
1264       if (code == REG && src != stack_pointer_rtx)
1265         {
1266           offset = -cur_args_size;
1267 #ifndef STACK_GROWS_DOWNWARD
1268           offset = -offset;
1269 #endif
1270           return offset - cur_offset;
1271         }
1272
1273       if (! (code == PLUS || code == MINUS)
1274           || XEXP (src, 0) != stack_pointer_rtx
1275           || !CONST_INT_P (XEXP (src, 1)))
1276         return 0;
1277
1278       /* (set (reg sp) (plus (reg sp) (const_int))) */
1279       offset = INTVAL (XEXP (src, 1));
1280       if (code == PLUS)
1281         offset = -offset;
1282       return offset;
1283     }
1284
1285   if (MEM_P (src) && !MEM_P (dest))
1286     dest = src;
1287   if (MEM_P (dest))
1288     {
1289       /* (set (mem (pre_dec (reg sp))) (foo)) */
1290       src = XEXP (dest, 0);
1291       code = GET_CODE (src);
1292
1293       switch (code)
1294         {
1295         case PRE_MODIFY:
1296         case POST_MODIFY:
1297           if (XEXP (src, 0) == stack_pointer_rtx)
1298             {
1299               rtx val = XEXP (XEXP (src, 1), 1);
1300               /* We handle only adjustments by constant amount.  */
1301               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1302                           && CONST_INT_P (val));
1303               offset = -INTVAL (val);
1304               break;
1305             }
1306           return 0;
1307
1308         case PRE_DEC:
1309         case POST_DEC:
1310           if (XEXP (src, 0) == stack_pointer_rtx)
1311             {
1312               offset = GET_MODE_SIZE (GET_MODE (dest));
1313               break;
1314             }
1315           return 0;
1316
1317         case PRE_INC:
1318         case POST_INC:
1319           if (XEXP (src, 0) == stack_pointer_rtx)
1320             {
1321               offset = -GET_MODE_SIZE (GET_MODE (dest));
1322               break;
1323             }
1324           return 0;
1325
1326         default:
1327           return 0;
1328         }
1329     }
1330   else
1331     return 0;
1332
1333   return offset;
1334 }
1335
1336 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1337    indexed by INSN_UID.  */
1338
1339 static HOST_WIDE_INT *barrier_args_size;
1340
1341 /* Helper function for compute_barrier_args_size.  Handle one insn.  */
1342
1343 static HOST_WIDE_INT
1344 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1345                              VEC (rtx, heap) **next)
1346 {
1347   HOST_WIDE_INT offset = 0;
1348   int i;
1349
1350   if (! RTX_FRAME_RELATED_P (insn))
1351     {
1352       if (prologue_epilogue_contains (insn))
1353         /* Nothing */;
1354       else if (GET_CODE (PATTERN (insn)) == SET)
1355         offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1356       else if (GET_CODE (PATTERN (insn)) == PARALLEL
1357                || GET_CODE (PATTERN (insn)) == SEQUENCE)
1358         {
1359           /* There may be stack adjustments inside compound insns.  Search
1360              for them.  */
1361           for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1362             if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1363               offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1364                                              cur_args_size, offset);
1365         }
1366     }
1367   else
1368     {
1369       rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1370
1371       if (expr)
1372         {
1373           expr = XEXP (expr, 0);
1374           if (GET_CODE (expr) == PARALLEL
1375               || GET_CODE (expr) == SEQUENCE)
1376             for (i = 1; i < XVECLEN (expr, 0); i++)
1377               {
1378                 rtx elem = XVECEXP (expr, 0, i);
1379
1380                 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1381                   offset += stack_adjust_offset (elem, cur_args_size, offset);
1382               }
1383         }
1384     }
1385
1386 #ifndef STACK_GROWS_DOWNWARD
1387   offset = -offset;
1388 #endif
1389
1390   cur_args_size += offset;
1391   if (cur_args_size < 0)
1392     cur_args_size = 0;
1393
1394   if (JUMP_P (insn))
1395     {
1396       rtx dest = JUMP_LABEL (insn);
1397
1398       if (dest)
1399         {
1400           if (barrier_args_size [INSN_UID (dest)] < 0)
1401             {
1402               barrier_args_size [INSN_UID (dest)] = cur_args_size;
1403               VEC_safe_push (rtx, heap, *next, dest);
1404             }
1405         }
1406     }
1407
1408   return cur_args_size;
1409 }
1410
1411 /* Walk the whole function and compute args_size on BARRIERs.  */
1412
1413 static void
1414 compute_barrier_args_size (void)
1415 {
1416   int max_uid = get_max_uid (), i;
1417   rtx insn;
1418   VEC (rtx, heap) *worklist, *next, *tmp;
1419
1420   barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1421   for (i = 0; i < max_uid; i++)
1422     barrier_args_size[i] = -1;
1423
1424   worklist = VEC_alloc (rtx, heap, 20);
1425   next = VEC_alloc (rtx, heap, 20);
1426   insn = get_insns ();
1427   barrier_args_size[INSN_UID (insn)] = 0;
1428   VEC_quick_push (rtx, worklist, insn);
1429   for (;;)
1430     {
1431       while (!VEC_empty (rtx, worklist))
1432         {
1433           rtx prev, body, first_insn;
1434           HOST_WIDE_INT cur_args_size;
1435
1436           first_insn = insn = VEC_pop (rtx, worklist);
1437           cur_args_size = barrier_args_size[INSN_UID (insn)];
1438           prev = prev_nonnote_insn (insn);
1439           if (prev && BARRIER_P (prev))
1440             barrier_args_size[INSN_UID (prev)] = cur_args_size;
1441
1442           for (; insn; insn = NEXT_INSN (insn))
1443             {
1444               if (INSN_DELETED_P (insn) || NOTE_P (insn))
1445                 continue;
1446               if (BARRIER_P (insn))
1447                 break;
1448
1449               if (LABEL_P (insn))
1450                 {
1451                   if (insn == first_insn)
1452                     continue;
1453                   else if (barrier_args_size[INSN_UID (insn)] < 0)
1454                     {
1455                       barrier_args_size[INSN_UID (insn)] = cur_args_size;
1456                       continue;
1457                     }
1458                   else
1459                     {
1460                       /* The insns starting with this label have been
1461                          already scanned or are in the worklist.  */
1462                       break;
1463                     }
1464                 }
1465
1466               body = PATTERN (insn);
1467               if (GET_CODE (body) == SEQUENCE)
1468                 {
1469                   HOST_WIDE_INT dest_args_size = cur_args_size;
1470                   for (i = 1; i < XVECLEN (body, 0); i++)
1471                     if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1472                         && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1473                       dest_args_size
1474                         = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1475                                                        dest_args_size, &next);
1476                     else
1477                       cur_args_size
1478                         = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1479                                                        cur_args_size, &next);
1480
1481                   if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1482                     compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1483                                                  dest_args_size, &next);
1484                   else
1485                     cur_args_size
1486                       = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1487                                                      cur_args_size, &next);
1488                 }
1489               else
1490                 cur_args_size
1491                   = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1492             }
1493         }
1494
1495       if (VEC_empty (rtx, next))
1496         break;
1497
1498       /* Swap WORKLIST with NEXT and truncate NEXT for next iteration.  */
1499       tmp = next;
1500       next = worklist;
1501       worklist = tmp;
1502       VEC_truncate (rtx, next, 0);
1503     }
1504
1505   VEC_free (rtx, heap, worklist);
1506   VEC_free (rtx, heap, next);
1507 }
1508
1509 /* Add a CFI to update the running total of the size of arguments
1510    pushed onto the stack.  */
1511
1512 static void
1513 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1514 {
1515   dw_cfi_ref cfi;
1516
1517   if (size == old_args_size)
1518     return;
1519
1520   old_args_size = size;
1521
1522   cfi = new_cfi ();
1523   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1524   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1525   add_fde_cfi (label, cfi);
1526 }
1527
1528 /* Record a stack adjustment of OFFSET bytes.  */
1529
1530 static void
1531 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1532 {
1533   if (cfa.reg == STACK_POINTER_REGNUM)
1534     cfa.offset += offset;
1535
1536   if (cfa_store.reg == STACK_POINTER_REGNUM)
1537     cfa_store.offset += offset;
1538
1539   if (ACCUMULATE_OUTGOING_ARGS)
1540     return;
1541
1542 #ifndef STACK_GROWS_DOWNWARD
1543   offset = -offset;
1544 #endif
1545
1546   args_size += offset;
1547   if (args_size < 0)
1548     args_size = 0;
1549
1550   def_cfa_1 (label, &cfa);
1551   if (flag_asynchronous_unwind_tables)
1552     dwarf2out_args_size (label, args_size);
1553 }
1554
1555 /* Check INSN to see if it looks like a push or a stack adjustment, and
1556    make a note of it if it does.  EH uses this information to find out
1557    how much extra space it needs to pop off the stack.  */
1558
1559 static void
1560 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1561 {
1562   HOST_WIDE_INT offset;
1563   const char *label;
1564   int i;
1565
1566   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1567      with this function.  Proper support would require all frame-related
1568      insns to be marked, and to be able to handle saving state around
1569      epilogues textually in the middle of the function.  */
1570   if (prologue_epilogue_contains (insn))
1571     return;
1572
1573   /* If INSN is an instruction from target of an annulled branch, the
1574      effects are for the target only and so current argument size
1575      shouldn't change at all.  */
1576   if (final_sequence
1577       && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1578       && INSN_FROM_TARGET_P (insn))
1579     return;
1580
1581   /* If only calls can throw, and we have a frame pointer,
1582      save up adjustments until we see the CALL_INSN.  */
1583   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1584     {
1585       if (CALL_P (insn) && !after_p)
1586         {
1587           /* Extract the size of the args from the CALL rtx itself.  */
1588           insn = PATTERN (insn);
1589           if (GET_CODE (insn) == PARALLEL)
1590             insn = XVECEXP (insn, 0, 0);
1591           if (GET_CODE (insn) == SET)
1592             insn = SET_SRC (insn);
1593           gcc_assert (GET_CODE (insn) == CALL);
1594           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1595         }
1596       return;
1597     }
1598
1599   if (CALL_P (insn) && !after_p)
1600     {
1601       if (!flag_asynchronous_unwind_tables)
1602         dwarf2out_args_size ("", args_size);
1603       return;
1604     }
1605   else if (BARRIER_P (insn))
1606     {
1607       /* Don't call compute_barrier_args_size () if the only
1608          BARRIER is at the end of function.  */
1609       if (barrier_args_size == NULL && next_nonnote_insn (insn))
1610         compute_barrier_args_size ();
1611       if (barrier_args_size == NULL)
1612         offset = 0;
1613       else
1614         {
1615           offset = barrier_args_size[INSN_UID (insn)];
1616           if (offset < 0)
1617             offset = 0;
1618         }
1619
1620       offset -= args_size;
1621 #ifndef STACK_GROWS_DOWNWARD
1622       offset = -offset;
1623 #endif
1624     }
1625   else if (GET_CODE (PATTERN (insn)) == SET)
1626     offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1627   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1628            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1629     {
1630       /* There may be stack adjustments inside compound insns.  Search
1631          for them.  */
1632       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1633         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1634           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1635                                          args_size, offset);
1636     }
1637   else
1638     return;
1639
1640   if (offset == 0)
1641     return;
1642
1643   label = dwarf2out_cfi_label (false);
1644   dwarf2out_stack_adjust (offset, label);
1645 }
1646
1647 #endif
1648
1649 /* We delay emitting a register save until either (a) we reach the end
1650    of the prologue or (b) the register is clobbered.  This clusters
1651    register saves so that there are fewer pc advances.  */
1652
1653 struct GTY(()) queued_reg_save {
1654   struct queued_reg_save *next;
1655   rtx reg;
1656   HOST_WIDE_INT cfa_offset;
1657   rtx saved_reg;
1658 };
1659
1660 static GTY(()) struct queued_reg_save *queued_reg_saves;
1661
1662 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1663 struct GTY(()) reg_saved_in_data {
1664   rtx orig_reg;
1665   rtx saved_in_reg;
1666 };
1667
1668 /* A list of registers saved in other registers.
1669    The list intentionally has a small maximum capacity of 4; if your
1670    port needs more than that, you might consider implementing a
1671    more efficient data structure.  */
1672 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1673 static GTY(()) size_t num_regs_saved_in_regs;
1674
1675 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1676 static const char *last_reg_save_label;
1677
1678 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1679    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1680
1681 static void
1682 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1683 {
1684   struct queued_reg_save *q;
1685
1686   /* Duplicates waste space, but it's also necessary to remove them
1687      for correctness, since the queue gets output in reverse
1688      order.  */
1689   for (q = queued_reg_saves; q != NULL; q = q->next)
1690     if (REGNO (q->reg) == REGNO (reg))
1691       break;
1692
1693   if (q == NULL)
1694     {
1695       q = GGC_NEW (struct queued_reg_save);
1696       q->next = queued_reg_saves;
1697       queued_reg_saves = q;
1698     }
1699
1700   q->reg = reg;
1701   q->cfa_offset = offset;
1702   q->saved_reg = sreg;
1703
1704   last_reg_save_label = label;
1705 }
1706
1707 /* Output all the entries in QUEUED_REG_SAVES.  */
1708
1709 static void
1710 flush_queued_reg_saves (void)
1711 {
1712   struct queued_reg_save *q;
1713
1714   for (q = queued_reg_saves; q; q = q->next)
1715     {
1716       size_t i;
1717       unsigned int reg, sreg;
1718
1719       for (i = 0; i < num_regs_saved_in_regs; i++)
1720         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1721           break;
1722       if (q->saved_reg && i == num_regs_saved_in_regs)
1723         {
1724           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1725           num_regs_saved_in_regs++;
1726         }
1727       if (i != num_regs_saved_in_regs)
1728         {
1729           regs_saved_in_regs[i].orig_reg = q->reg;
1730           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1731         }
1732
1733       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1734       if (q->saved_reg)
1735         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1736       else
1737         sreg = INVALID_REGNUM;
1738       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1739     }
1740
1741   queued_reg_saves = NULL;
1742   last_reg_save_label = NULL;
1743 }
1744
1745 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1746    location for?  Or, does it clobber a register which we've previously
1747    said that some other register is saved in, and for which we now
1748    have a new location for?  */
1749
1750 static bool
1751 clobbers_queued_reg_save (const_rtx insn)
1752 {
1753   struct queued_reg_save *q;
1754
1755   for (q = queued_reg_saves; q; q = q->next)
1756     {
1757       size_t i;
1758       if (modified_in_p (q->reg, insn))
1759         return true;
1760       for (i = 0; i < num_regs_saved_in_regs; i++)
1761         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1762             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1763           return true;
1764     }
1765
1766   return false;
1767 }
1768
1769 /* Entry point for saving the first register into the second.  */
1770
1771 void
1772 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1773 {
1774   size_t i;
1775   unsigned int regno, sregno;
1776
1777   for (i = 0; i < num_regs_saved_in_regs; i++)
1778     if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1779       break;
1780   if (i == num_regs_saved_in_regs)
1781     {
1782       gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1783       num_regs_saved_in_regs++;
1784     }
1785   regs_saved_in_regs[i].orig_reg = reg;
1786   regs_saved_in_regs[i].saved_in_reg = sreg;
1787
1788   regno = DWARF_FRAME_REGNUM (REGNO (reg));
1789   sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1790   reg_save (label, regno, sregno, 0);
1791 }
1792
1793 /* What register, if any, is currently saved in REG?  */
1794
1795 static rtx
1796 reg_saved_in (rtx reg)
1797 {
1798   unsigned int regn = REGNO (reg);
1799   size_t i;
1800   struct queued_reg_save *q;
1801
1802   for (q = queued_reg_saves; q; q = q->next)
1803     if (q->saved_reg && regn == REGNO (q->saved_reg))
1804       return q->reg;
1805
1806   for (i = 0; i < num_regs_saved_in_regs; i++)
1807     if (regs_saved_in_regs[i].saved_in_reg
1808         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1809       return regs_saved_in_regs[i].orig_reg;
1810
1811   return NULL_RTX;
1812 }
1813
1814
1815 /* A temporary register holding an integral value used in adjusting SP
1816    or setting up the store_reg.  The "offset" field holds the integer
1817    value, not an offset.  */
1818 static dw_cfa_location cfa_temp;
1819
1820 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note.  */
1821
1822 static void
1823 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1824 {
1825   memset (&cfa, 0, sizeof (cfa));
1826
1827   switch (GET_CODE (pat))
1828     {
1829     case PLUS:
1830       cfa.reg = REGNO (XEXP (pat, 0));
1831       cfa.offset = INTVAL (XEXP (pat, 1));
1832       break;
1833
1834     case REG:
1835       cfa.reg = REGNO (pat);
1836       break;
1837
1838     default:
1839       /* Recurse and define an expression.  */
1840       gcc_unreachable ();
1841     }
1842
1843   def_cfa_1 (label, &cfa);
1844 }
1845
1846 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note.  */
1847
1848 static void
1849 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1850 {
1851   rtx src, dest;
1852
1853   gcc_assert (GET_CODE (pat) == SET);
1854   dest = XEXP (pat, 0);
1855   src = XEXP (pat, 1);
1856
1857   switch (GET_CODE (src))
1858     {
1859     case PLUS:
1860       gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1861       cfa.offset -= INTVAL (XEXP (src, 1));
1862       break;
1863
1864     case REG:
1865         break;
1866
1867     default:
1868         gcc_unreachable ();
1869     }
1870
1871   cfa.reg = REGNO (dest);
1872   gcc_assert (cfa.indirect == 0);
1873
1874   def_cfa_1 (label, &cfa);
1875 }
1876
1877 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note.  */
1878
1879 static void
1880 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1881 {
1882   HOST_WIDE_INT offset;
1883   rtx src, addr, span;
1884
1885   src = XEXP (set, 1);
1886   addr = XEXP (set, 0);
1887   gcc_assert (MEM_P (addr));
1888   addr = XEXP (addr, 0);
1889
1890   /* As documented, only consider extremely simple addresses.  */
1891   switch (GET_CODE (addr))
1892     {
1893     case REG:
1894       gcc_assert (REGNO (addr) == cfa.reg);
1895       offset = -cfa.offset;
1896       break;
1897     case PLUS:
1898       gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1899       offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1900       break;
1901     default:
1902       gcc_unreachable ();
1903     }
1904
1905   span = targetm.dwarf_register_span (src);
1906
1907   /* ??? We'd like to use queue_reg_save, but we need to come up with
1908      a different flushing heuristic for epilogues.  */
1909   if (!span)
1910     reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1911   else
1912     {
1913       /* We have a PARALLEL describing where the contents of SRC live.
1914          Queue register saves for each piece of the PARALLEL.  */
1915       int par_index;
1916       int limit;
1917       HOST_WIDE_INT span_offset = offset;
1918
1919       gcc_assert (GET_CODE (span) == PARALLEL);
1920
1921       limit = XVECLEN (span, 0);
1922       for (par_index = 0; par_index < limit; par_index++)
1923         {
1924           rtx elem = XVECEXP (span, 0, par_index);
1925
1926           reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1927                     INVALID_REGNUM, span_offset);
1928           span_offset += GET_MODE_SIZE (GET_MODE (elem));
1929         }
1930     }
1931 }
1932
1933 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note.  */
1934
1935 static void
1936 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1937 {
1938   rtx src, dest;
1939   unsigned sregno, dregno;
1940
1941   src = XEXP (set, 1);
1942   dest = XEXP (set, 0);
1943
1944   if (src == pc_rtx)
1945     sregno = DWARF_FRAME_RETURN_COLUMN;
1946   else
1947     sregno = DWARF_FRAME_REGNUM (REGNO (src));
1948
1949   dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1950
1951   /* ??? We'd like to use queue_reg_save, but we need to come up with
1952      a different flushing heuristic for epilogues.  */
1953   reg_save (label, sregno, dregno, 0);
1954 }
1955
1956 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note.  */
1957
1958 static void
1959 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1960 {
1961   dw_cfi_ref cfi = new_cfi ();
1962   unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1963
1964   cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1965   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1966
1967   add_fde_cfi (label, cfi);
1968 }
1969
1970 /* Record call frame debugging information for an expression EXPR,
1971    which either sets SP or FP (adjusting how we calculate the frame
1972    address) or saves a register to the stack or another register.
1973    LABEL indicates the address of EXPR.
1974
1975    This function encodes a state machine mapping rtxes to actions on
1976    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1977    users need not read the source code.
1978
1979   The High-Level Picture
1980
1981   Changes in the register we use to calculate the CFA: Currently we
1982   assume that if you copy the CFA register into another register, we
1983   should take the other one as the new CFA register; this seems to
1984   work pretty well.  If it's wrong for some target, it's simple
1985   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1986
1987   Changes in the register we use for saving registers to the stack:
1988   This is usually SP, but not always.  Again, we deduce that if you
1989   copy SP into another register (and SP is not the CFA register),
1990   then the new register is the one we will be using for register
1991   saves.  This also seems to work.
1992
1993   Register saves: There's not much guesswork about this one; if
1994   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1995   register save, and the register used to calculate the destination
1996   had better be the one we think we're using for this purpose.
1997   It's also assumed that a copy from a call-saved register to another
1998   register is saving that register if RTX_FRAME_RELATED_P is set on
1999   that instruction.  If the copy is from a call-saved register to
2000   the *same* register, that means that the register is now the same
2001   value as in the caller.
2002
2003   Except: If the register being saved is the CFA register, and the
2004   offset is nonzero, we are saving the CFA, so we assume we have to
2005   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
2006   the intent is to save the value of SP from the previous frame.
2007
2008   In addition, if a register has previously been saved to a different
2009   register,
2010
2011   Invariants / Summaries of Rules
2012
2013   cfa          current rule for calculating the CFA.  It usually
2014                consists of a register and an offset.
2015   cfa_store    register used by prologue code to save things to the stack
2016                cfa_store.offset is the offset from the value of
2017                cfa_store.reg to the actual CFA
2018   cfa_temp     register holding an integral value.  cfa_temp.offset
2019                stores the value, which will be used to adjust the
2020                stack pointer.  cfa_temp is also used like cfa_store,
2021                to track stores to the stack via fp or a temp reg.
2022
2023   Rules  1- 4: Setting a register's value to cfa.reg or an expression
2024                with cfa.reg as the first operand changes the cfa.reg and its
2025                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
2026                cfa_temp.offset.
2027
2028   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
2029                expression yielding a constant.  This sets cfa_temp.reg
2030                and cfa_temp.offset.
2031
2032   Rule 5:      Create a new register cfa_store used to save items to the
2033                stack.
2034
2035   Rules 10-14: Save a register to the stack.  Define offset as the
2036                difference of the original location and cfa_store's
2037                location (or cfa_temp's location if cfa_temp is used).
2038
2039   Rules 16-20: If AND operation happens on sp in prologue, we assume
2040                stack is realigned.  We will use a group of DW_OP_XXX
2041                expressions to represent the location of the stored
2042                register instead of CFA+offset.
2043
2044   The Rules
2045
2046   "{a,b}" indicates a choice of a xor b.
2047   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2048
2049   Rule 1:
2050   (set <reg1> <reg2>:cfa.reg)
2051   effects: cfa.reg = <reg1>
2052            cfa.offset unchanged
2053            cfa_temp.reg = <reg1>
2054            cfa_temp.offset = cfa.offset
2055
2056   Rule 2:
2057   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2058                               {<const_int>,<reg>:cfa_temp.reg}))
2059   effects: cfa.reg = sp if fp used
2060            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2061            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2062              if cfa_store.reg==sp
2063
2064   Rule 3:
2065   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2066   effects: cfa.reg = fp
2067            cfa_offset += +/- <const_int>
2068
2069   Rule 4:
2070   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2071   constraints: <reg1> != fp
2072                <reg1> != sp
2073   effects: cfa.reg = <reg1>
2074            cfa_temp.reg = <reg1>
2075            cfa_temp.offset = cfa.offset
2076
2077   Rule 5:
2078   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2079   constraints: <reg1> != fp
2080                <reg1> != sp
2081   effects: cfa_store.reg = <reg1>
2082            cfa_store.offset = cfa.offset - cfa_temp.offset
2083
2084   Rule 6:
2085   (set <reg> <const_int>)
2086   effects: cfa_temp.reg = <reg>
2087            cfa_temp.offset = <const_int>
2088
2089   Rule 7:
2090   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2091   effects: cfa_temp.reg = <reg1>
2092            cfa_temp.offset |= <const_int>
2093
2094   Rule 8:
2095   (set <reg> (high <exp>))
2096   effects: none
2097
2098   Rule 9:
2099   (set <reg> (lo_sum <exp> <const_int>))
2100   effects: cfa_temp.reg = <reg>
2101            cfa_temp.offset = <const_int>
2102
2103   Rule 10:
2104   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2105   effects: cfa_store.offset -= <const_int>
2106            cfa.offset = cfa_store.offset if cfa.reg == sp
2107            cfa.reg = sp
2108            cfa.base_offset = -cfa_store.offset
2109
2110   Rule 11:
2111   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2112   effects: cfa_store.offset += -/+ mode_size(mem)
2113            cfa.offset = cfa_store.offset if cfa.reg == sp
2114            cfa.reg = sp
2115            cfa.base_offset = -cfa_store.offset
2116
2117   Rule 12:
2118   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2119
2120        <reg2>)
2121   effects: cfa.reg = <reg1>
2122            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2123
2124   Rule 13:
2125   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2126   effects: cfa.reg = <reg1>
2127            cfa.base_offset = -{cfa_store,cfa_temp}.offset
2128
2129   Rule 14:
2130   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2131   effects: cfa.reg = <reg1>
2132            cfa.base_offset = -cfa_temp.offset
2133            cfa_temp.offset -= mode_size(mem)
2134
2135   Rule 15:
2136   (set <reg> {unspec, unspec_volatile})
2137   effects: target-dependent
2138
2139   Rule 16:
2140   (set sp (and: sp <const_int>))
2141   constraints: cfa_store.reg == sp
2142   effects: current_fde.stack_realign = 1
2143            cfa_store.offset = 0
2144            fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2145
2146   Rule 17:
2147   (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2148   effects: cfa_store.offset += -/+ mode_size(mem)
2149
2150   Rule 18:
2151   (set (mem ({pre_inc, pre_dec} sp)) fp)
2152   constraints: fde->stack_realign == 1
2153   effects: cfa_store.offset = 0
2154            cfa.reg != HARD_FRAME_POINTER_REGNUM
2155
2156   Rule 19:
2157   (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2158   constraints: fde->stack_realign == 1
2159                && cfa.offset == 0
2160                && cfa.indirect == 0
2161                && cfa.reg != HARD_FRAME_POINTER_REGNUM
2162   effects: Use DW_CFA_def_cfa_expression to define cfa
2163            cfa.reg == fde->drap_reg  */
2164
2165 static void
2166 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2167 {
2168   rtx src, dest, span;
2169   HOST_WIDE_INT offset;
2170   dw_fde_ref fde;
2171
2172   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2173      the PARALLEL independently. The first element is always processed if
2174      it is a SET. This is for backward compatibility.   Other elements
2175      are processed only if they are SETs and the RTX_FRAME_RELATED_P
2176      flag is set in them.  */
2177   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2178     {
2179       int par_index;
2180       int limit = XVECLEN (expr, 0);
2181       rtx elem;
2182
2183       /* PARALLELs have strict read-modify-write semantics, so we
2184          ought to evaluate every rvalue before changing any lvalue.
2185          It's cumbersome to do that in general, but there's an
2186          easy approximation that is enough for all current users:
2187          handle register saves before register assignments.  */
2188       if (GET_CODE (expr) == PARALLEL)
2189         for (par_index = 0; par_index < limit; par_index++)
2190           {
2191             elem = XVECEXP (expr, 0, par_index);
2192             if (GET_CODE (elem) == SET
2193                 && MEM_P (SET_DEST (elem))
2194                 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2195               dwarf2out_frame_debug_expr (elem, label);
2196           }
2197
2198       for (par_index = 0; par_index < limit; par_index++)
2199         {
2200           elem = XVECEXP (expr, 0, par_index);
2201           if (GET_CODE (elem) == SET
2202               && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2203               && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2204             dwarf2out_frame_debug_expr (elem, label);
2205           else if (GET_CODE (elem) == SET
2206                    && par_index != 0
2207                    && !RTX_FRAME_RELATED_P (elem))
2208             {
2209               /* Stack adjustment combining might combine some post-prologue
2210                  stack adjustment into a prologue stack adjustment.  */
2211               HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2212
2213               if (offset != 0)
2214                 dwarf2out_stack_adjust (offset, label);
2215             }
2216         }
2217       return;
2218     }
2219
2220   gcc_assert (GET_CODE (expr) == SET);
2221
2222   src = SET_SRC (expr);
2223   dest = SET_DEST (expr);
2224
2225   if (REG_P (src))
2226     {
2227       rtx rsi = reg_saved_in (src);
2228       if (rsi)
2229         src = rsi;
2230     }
2231
2232   fde = current_fde ();
2233
2234   switch (GET_CODE (dest))
2235     {
2236     case REG:
2237       switch (GET_CODE (src))
2238         {
2239           /* Setting FP from SP.  */
2240         case REG:
2241           if (cfa.reg == (unsigned) REGNO (src))
2242             {
2243               /* Rule 1 */
2244               /* Update the CFA rule wrt SP or FP.  Make sure src is
2245                  relative to the current CFA register.
2246
2247                  We used to require that dest be either SP or FP, but the
2248                  ARM copies SP to a temporary register, and from there to
2249                  FP.  So we just rely on the backends to only set
2250                  RTX_FRAME_RELATED_P on appropriate insns.  */
2251               cfa.reg = REGNO (dest);
2252               cfa_temp.reg = cfa.reg;
2253               cfa_temp.offset = cfa.offset;
2254             }
2255           else
2256             {
2257               /* Saving a register in a register.  */
2258               gcc_assert (!fixed_regs [REGNO (dest)]
2259                           /* For the SPARC and its register window.  */
2260                           || (DWARF_FRAME_REGNUM (REGNO (src))
2261                               == DWARF_FRAME_RETURN_COLUMN));
2262
2263               /* After stack is aligned, we can only save SP in FP
2264                  if drap register is used.  In this case, we have
2265                  to restore stack pointer with the CFA value and we
2266                  don't generate this DWARF information.  */
2267               if (fde
2268                   && fde->stack_realign
2269                   && REGNO (src) == STACK_POINTER_REGNUM)
2270                 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2271                             && fde->drap_reg != INVALID_REGNUM
2272                             && cfa.reg != REGNO (src));
2273               else
2274                 queue_reg_save (label, src, dest, 0);
2275             }
2276           break;
2277
2278         case PLUS:
2279         case MINUS:
2280         case LO_SUM:
2281           if (dest == stack_pointer_rtx)
2282             {
2283               /* Rule 2 */
2284               /* Adjusting SP.  */
2285               switch (GET_CODE (XEXP (src, 1)))
2286                 {
2287                 case CONST_INT:
2288                   offset = INTVAL (XEXP (src, 1));
2289                   break;
2290                 case REG:
2291                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2292                               == cfa_temp.reg);
2293                   offset = cfa_temp.offset;
2294                   break;
2295                 default:
2296                   gcc_unreachable ();
2297                 }
2298
2299               if (XEXP (src, 0) == hard_frame_pointer_rtx)
2300                 {
2301                   /* Restoring SP from FP in the epilogue.  */
2302                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2303                   cfa.reg = STACK_POINTER_REGNUM;
2304                 }
2305               else if (GET_CODE (src) == LO_SUM)
2306                 /* Assume we've set the source reg of the LO_SUM from sp.  */
2307                 ;
2308               else
2309                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2310
2311               if (GET_CODE (src) != MINUS)
2312                 offset = -offset;
2313               if (cfa.reg == STACK_POINTER_REGNUM)
2314                 cfa.offset += offset;
2315               if (cfa_store.reg == STACK_POINTER_REGNUM)
2316                 cfa_store.offset += offset;
2317             }
2318           else if (dest == hard_frame_pointer_rtx)
2319             {
2320               /* Rule 3 */
2321               /* Either setting the FP from an offset of the SP,
2322                  or adjusting the FP */
2323               gcc_assert (frame_pointer_needed);
2324
2325               gcc_assert (REG_P (XEXP (src, 0))
2326                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2327                           && CONST_INT_P (XEXP (src, 1)));
2328               offset = INTVAL (XEXP (src, 1));
2329               if (GET_CODE (src) != MINUS)
2330                 offset = -offset;
2331               cfa.offset += offset;
2332               cfa.reg = HARD_FRAME_POINTER_REGNUM;
2333             }
2334           else
2335             {
2336               gcc_assert (GET_CODE (src) != MINUS);
2337
2338               /* Rule 4 */
2339               if (REG_P (XEXP (src, 0))
2340                   && REGNO (XEXP (src, 0)) == cfa.reg
2341                   && CONST_INT_P (XEXP (src, 1)))
2342                 {
2343                   /* Setting a temporary CFA register that will be copied
2344                      into the FP later on.  */
2345                   offset = - INTVAL (XEXP (src, 1));
2346                   cfa.offset += offset;
2347                   cfa.reg = REGNO (dest);
2348                   /* Or used to save regs to the stack.  */
2349                   cfa_temp.reg = cfa.reg;
2350                   cfa_temp.offset = cfa.offset;
2351                 }
2352
2353               /* Rule 5 */
2354               else if (REG_P (XEXP (src, 0))
2355                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
2356                        && XEXP (src, 1) == stack_pointer_rtx)
2357                 {
2358                   /* Setting a scratch register that we will use instead
2359                      of SP for saving registers to the stack.  */
2360                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2361                   cfa_store.reg = REGNO (dest);
2362                   cfa_store.offset = cfa.offset - cfa_temp.offset;
2363                 }
2364
2365               /* Rule 9 */
2366               else if (GET_CODE (src) == LO_SUM
2367                        && CONST_INT_P (XEXP (src, 1)))
2368                 {
2369                   cfa_temp.reg = REGNO (dest);
2370                   cfa_temp.offset = INTVAL (XEXP (src, 1));
2371                 }
2372               else
2373                 gcc_unreachable ();
2374             }
2375           break;
2376
2377           /* Rule 6 */
2378         case CONST_INT:
2379           cfa_temp.reg = REGNO (dest);
2380           cfa_temp.offset = INTVAL (src);
2381           break;
2382
2383           /* Rule 7 */
2384         case IOR:
2385           gcc_assert (REG_P (XEXP (src, 0))
2386                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2387                       && CONST_INT_P (XEXP (src, 1)));
2388
2389           if ((unsigned) REGNO (dest) != cfa_temp.reg)
2390             cfa_temp.reg = REGNO (dest);
2391           cfa_temp.offset |= INTVAL (XEXP (src, 1));
2392           break;
2393
2394           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2395              which will fill in all of the bits.  */
2396           /* Rule 8 */
2397         case HIGH:
2398           break;
2399
2400           /* Rule 15 */
2401         case UNSPEC:
2402         case UNSPEC_VOLATILE:
2403           gcc_assert (targetm.dwarf_handle_frame_unspec);
2404           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2405           return;
2406
2407           /* Rule 16 */
2408         case AND:
2409           /* If this AND operation happens on stack pointer in prologue,
2410              we assume the stack is realigned and we extract the
2411              alignment.  */
2412           if (fde && XEXP (src, 0) == stack_pointer_rtx)
2413             {
2414               gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2415               fde->stack_realign = 1;
2416               fde->stack_realignment = INTVAL (XEXP (src, 1));
2417               cfa_store.offset = 0;
2418
2419               if (cfa.reg != STACK_POINTER_REGNUM
2420                   && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2421                 fde->drap_reg = cfa.reg;
2422             }
2423           return;
2424
2425         default:
2426           gcc_unreachable ();
2427         }
2428
2429       def_cfa_1 (label, &cfa);
2430       break;
2431
2432     case MEM:
2433
2434       /* Saving a register to the stack.  Make sure dest is relative to the
2435          CFA register.  */
2436       switch (GET_CODE (XEXP (dest, 0)))
2437         {
2438           /* Rule 10 */
2439           /* With a push.  */
2440         case PRE_MODIFY:
2441           /* We can't handle variable size modifications.  */
2442           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2443                       == CONST_INT);
2444           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2445
2446           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2447                       && cfa_store.reg == STACK_POINTER_REGNUM);
2448
2449           cfa_store.offset += offset;
2450           if (cfa.reg == STACK_POINTER_REGNUM)
2451             cfa.offset = cfa_store.offset;
2452
2453           offset = -cfa_store.offset;
2454           break;
2455
2456           /* Rule 11 */
2457         case PRE_INC:
2458         case PRE_DEC:
2459           offset = GET_MODE_SIZE (GET_MODE (dest));
2460           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2461             offset = -offset;
2462
2463           gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2464                        == STACK_POINTER_REGNUM)
2465                       && cfa_store.reg == STACK_POINTER_REGNUM);
2466
2467           cfa_store.offset += offset;
2468
2469           /* Rule 18: If stack is aligned, we will use FP as a
2470              reference to represent the address of the stored
2471              regiser.  */
2472           if (fde
2473               && fde->stack_realign
2474               && src == hard_frame_pointer_rtx)
2475             {
2476               gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2477               cfa_store.offset = 0;
2478             }
2479
2480           if (cfa.reg == STACK_POINTER_REGNUM)
2481             cfa.offset = cfa_store.offset;
2482
2483           offset = -cfa_store.offset;
2484           break;
2485
2486           /* Rule 12 */
2487           /* With an offset.  */
2488         case PLUS:
2489         case MINUS:
2490         case LO_SUM:
2491           {
2492             int regno;
2493
2494             gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2495                         && REG_P (XEXP (XEXP (dest, 0), 0)));
2496             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2497             if (GET_CODE (XEXP (dest, 0)) == MINUS)
2498               offset = -offset;
2499
2500             regno = REGNO (XEXP (XEXP (dest, 0), 0));
2501
2502             if (cfa_store.reg == (unsigned) regno)
2503               offset -= cfa_store.offset;
2504             else
2505               {
2506                 gcc_assert (cfa_temp.reg == (unsigned) regno);
2507                 offset -= cfa_temp.offset;
2508               }
2509           }
2510           break;
2511
2512           /* Rule 13 */
2513           /* Without an offset.  */
2514         case REG:
2515           {
2516             int regno = REGNO (XEXP (dest, 0));
2517
2518             if (cfa_store.reg == (unsigned) regno)
2519               offset = -cfa_store.offset;
2520             else
2521               {
2522                 gcc_assert (cfa_temp.reg == (unsigned) regno);
2523                 offset = -cfa_temp.offset;
2524               }
2525           }
2526           break;
2527
2528           /* Rule 14 */
2529         case POST_INC:
2530           gcc_assert (cfa_temp.reg
2531                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2532           offset = -cfa_temp.offset;
2533           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2534           break;
2535
2536         default:
2537           gcc_unreachable ();
2538         }
2539
2540         /* Rule 17 */
2541         /* If the source operand of this MEM operation is not a
2542            register, basically the source is return address.  Here
2543            we only care how much stack grew and we don't save it.  */
2544       if (!REG_P (src))
2545         break;
2546
2547       if (REGNO (src) != STACK_POINTER_REGNUM
2548           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2549           && (unsigned) REGNO (src) == cfa.reg)
2550         {
2551           /* We're storing the current CFA reg into the stack.  */
2552
2553           if (cfa.offset == 0)
2554             {
2555               /* Rule 19 */
2556               /* If stack is aligned, putting CFA reg into stack means
2557                  we can no longer use reg + offset to represent CFA.
2558                  Here we use DW_CFA_def_cfa_expression instead.  The
2559                  result of this expression equals to the original CFA
2560                  value.  */
2561               if (fde
2562                   && fde->stack_realign
2563                   && cfa.indirect == 0
2564                   && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2565                 {
2566                   dw_cfa_location cfa_exp;
2567
2568                   gcc_assert (fde->drap_reg == cfa.reg);
2569
2570                   cfa_exp.indirect = 1;
2571                   cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2572                   cfa_exp.base_offset = offset;
2573                   cfa_exp.offset = 0;
2574
2575                   fde->drap_reg_saved = 1;
2576
2577                   def_cfa_1 (label, &cfa_exp);
2578                   break;
2579                 }
2580
2581               /* If the source register is exactly the CFA, assume
2582                  we're saving SP like any other register; this happens
2583                  on the ARM.  */
2584               def_cfa_1 (label, &cfa);
2585               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2586               break;
2587             }
2588           else
2589             {
2590               /* Otherwise, we'll need to look in the stack to
2591                  calculate the CFA.  */
2592               rtx x = XEXP (dest, 0);
2593
2594               if (!REG_P (x))
2595                 x = XEXP (x, 0);
2596               gcc_assert (REG_P (x));
2597
2598               cfa.reg = REGNO (x);
2599               cfa.base_offset = offset;
2600               cfa.indirect = 1;
2601               def_cfa_1 (label, &cfa);
2602               break;
2603             }
2604         }
2605
2606       def_cfa_1 (label, &cfa);
2607       {
2608         span = targetm.dwarf_register_span (src);
2609
2610         if (!span)
2611           queue_reg_save (label, src, NULL_RTX, offset);
2612         else
2613           {
2614             /* We have a PARALLEL describing where the contents of SRC
2615                live.  Queue register saves for each piece of the
2616                PARALLEL.  */
2617             int par_index;
2618             int limit;
2619             HOST_WIDE_INT span_offset = offset;
2620
2621             gcc_assert (GET_CODE (span) == PARALLEL);
2622
2623             limit = XVECLEN (span, 0);
2624             for (par_index = 0; par_index < limit; par_index++)
2625               {
2626                 rtx elem = XVECEXP (span, 0, par_index);
2627
2628                 queue_reg_save (label, elem, NULL_RTX, span_offset);
2629                 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2630               }
2631           }
2632       }
2633       break;
2634
2635     default:
2636       gcc_unreachable ();
2637     }
2638 }
2639
2640 /* Record call frame debugging information for INSN, which either
2641    sets SP or FP (adjusting how we calculate the frame address) or saves a
2642    register to the stack.  If INSN is NULL_RTX, initialize our state.
2643
2644    If AFTER_P is false, we're being called before the insn is emitted,
2645    otherwise after.  Call instructions get invoked twice.  */
2646
2647 void
2648 dwarf2out_frame_debug (rtx insn, bool after_p)
2649 {
2650   const char *label;
2651   rtx note, n;
2652   bool handled_one = false;
2653
2654   if (insn == NULL_RTX)
2655     {
2656       size_t i;
2657
2658       /* Flush any queued register saves.  */
2659       flush_queued_reg_saves ();
2660
2661       /* Set up state for generating call frame debug info.  */
2662       lookup_cfa (&cfa);
2663       gcc_assert (cfa.reg
2664                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2665
2666       cfa.reg = STACK_POINTER_REGNUM;
2667       cfa_store = cfa;
2668       cfa_temp.reg = -1;
2669       cfa_temp.offset = 0;
2670
2671       for (i = 0; i < num_regs_saved_in_regs; i++)
2672         {
2673           regs_saved_in_regs[i].orig_reg = NULL_RTX;
2674           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2675         }
2676       num_regs_saved_in_regs = 0;
2677
2678       if (barrier_args_size)
2679         {
2680           XDELETEVEC (barrier_args_size);
2681           barrier_args_size = NULL;
2682         }
2683       return;
2684     }
2685
2686   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2687     flush_queued_reg_saves ();
2688
2689   if (!RTX_FRAME_RELATED_P (insn))
2690     {
2691       /* ??? This should be done unconditionally since stack adjustments
2692          matter if the stack pointer is not the CFA register anymore but
2693          is still used to save registers.  */
2694       if (!ACCUMULATE_OUTGOING_ARGS)
2695         dwarf2out_notice_stack_adjust (insn, after_p);
2696       return;
2697     }
2698
2699   label = dwarf2out_cfi_label (false);
2700
2701   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2702     switch (REG_NOTE_KIND (note))
2703       {
2704       case REG_FRAME_RELATED_EXPR:
2705         insn = XEXP (note, 0);
2706         goto found;
2707
2708       case REG_CFA_DEF_CFA:
2709         dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2710         handled_one = true;
2711         break;
2712
2713       case REG_CFA_ADJUST_CFA:
2714         n = XEXP (note, 0);
2715         if (n == NULL)
2716           {
2717             n = PATTERN (insn);
2718             if (GET_CODE (n) == PARALLEL)
2719               n = XVECEXP (n, 0, 0);
2720           }
2721         dwarf2out_frame_debug_adjust_cfa (n, label);
2722         handled_one = true;
2723         break;
2724
2725       case REG_CFA_OFFSET:
2726         n = XEXP (note, 0);
2727         if (n == NULL)
2728           n = single_set (insn);
2729         dwarf2out_frame_debug_cfa_offset (n, label);
2730         handled_one = true;
2731         break;
2732
2733       case REG_CFA_REGISTER:
2734         n = XEXP (note, 0);
2735         if (n == NULL)
2736           {
2737             n = PATTERN (insn);
2738             if (GET_CODE (n) == PARALLEL)
2739               n = XVECEXP (n, 0, 0);
2740           }
2741         dwarf2out_frame_debug_cfa_register (n, label);
2742         handled_one = true;
2743         break;
2744
2745       case REG_CFA_RESTORE:
2746         n = XEXP (note, 0);
2747         if (n == NULL)
2748           {
2749             n = PATTERN (insn);
2750             if (GET_CODE (n) == PARALLEL)
2751               n = XVECEXP (n, 0, 0);
2752             n = XEXP (n, 0);
2753           }
2754         dwarf2out_frame_debug_cfa_restore (n, label);
2755         handled_one = true;
2756         break;
2757
2758       case REG_CFA_SET_VDRAP:
2759         n = XEXP (note, 0);
2760         if (REG_P (n))
2761           {
2762             dw_fde_ref fde = current_fde ();
2763             if (fde)
2764               {
2765                 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2766                 if (REG_P (n))
2767                   fde->vdrap_reg = REGNO (n);
2768               }
2769           }
2770         handled_one = true;
2771         break;
2772
2773       default:
2774         break;
2775       }
2776   if (handled_one)
2777     return;
2778
2779   insn = PATTERN (insn);
2780  found:
2781   dwarf2out_frame_debug_expr (insn, label);
2782 }
2783
2784 /* Determine if we need to save and restore CFI information around this
2785    epilogue.  If SIBCALL is true, then this is a sibcall epilogue.  If
2786    we do need to save/restore, then emit the save now, and insert a
2787    NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream.  */
2788
2789 void
2790 dwarf2out_begin_epilogue (rtx insn)
2791 {
2792   bool saw_frp = false;
2793   rtx i;
2794
2795   /* Scan forward to the return insn, noticing if there are possible
2796      frame related insns.  */
2797   for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2798     {
2799       if (!INSN_P (i))
2800         continue;
2801
2802       /* Look for both regular and sibcalls to end the block.  */
2803       if (returnjump_p (i))
2804         break;
2805       if (CALL_P (i) && SIBLING_CALL_P (i))
2806         break;
2807
2808       if (GET_CODE (PATTERN (i)) == SEQUENCE)
2809         {
2810           int idx;
2811           rtx seq = PATTERN (i);
2812
2813           if (returnjump_p (XVECEXP (seq, 0, 0)))
2814             break;
2815           if (CALL_P (XVECEXP (seq, 0, 0))
2816               && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2817             break;
2818
2819           for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2820             if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2821               saw_frp = true;
2822         }
2823
2824       if (RTX_FRAME_RELATED_P (i))
2825         saw_frp = true;
2826     }
2827
2828   /* If the port doesn't emit epilogue unwind info, we don't need a
2829      save/restore pair.  */
2830   if (!saw_frp)
2831     return;
2832
2833   /* Otherwise, search forward to see if the return insn was the last
2834      basic block of the function.  If so, we don't need save/restore.  */
2835   gcc_assert (i != NULL);
2836   i = next_real_insn (i);
2837   if (i == NULL)
2838     return;
2839
2840   /* Insert the restore before that next real insn in the stream, and before
2841      a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2842      properly nested.  This should be after any label or alignment.  This
2843      will be pushed into the CFI stream by the function below.  */
2844   while (1)
2845     {
2846       rtx p = PREV_INSN (i);
2847       if (!NOTE_P (p))
2848         break;
2849       if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2850         break;
2851       i = p;
2852     }
2853   emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2854
2855   emit_cfa_remember = true;
2856
2857   /* And emulate the state save.  */
2858   gcc_assert (!cfa_remember.in_use);
2859   cfa_remember = cfa;
2860   cfa_remember.in_use = 1;
2861 }
2862
2863 /* A "subroutine" of dwarf2out_begin_epilogue.  Emit the restore required.  */
2864
2865 void
2866 dwarf2out_frame_debug_restore_state (void)
2867 {
2868   dw_cfi_ref cfi = new_cfi ();
2869   const char *label = dwarf2out_cfi_label (false);
2870
2871   cfi->dw_cfi_opc = DW_CFA_restore_state;
2872   add_fde_cfi (label, cfi);
2873
2874   gcc_assert (cfa_remember.in_use);
2875   cfa = cfa_remember;
2876   cfa_remember.in_use = 0;
2877 }
2878
2879 #endif
2880
2881 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
2882 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2883  (enum dwarf_call_frame_info cfi);
2884
2885 static enum dw_cfi_oprnd_type
2886 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2887 {
2888   switch (cfi)
2889     {
2890     case DW_CFA_nop:
2891     case DW_CFA_GNU_window_save:
2892     case DW_CFA_remember_state:
2893     case DW_CFA_restore_state:
2894       return dw_cfi_oprnd_unused;
2895
2896     case DW_CFA_set_loc:
2897     case DW_CFA_advance_loc1:
2898     case DW_CFA_advance_loc2:
2899     case DW_CFA_advance_loc4:
2900     case DW_CFA_MIPS_advance_loc8:
2901       return dw_cfi_oprnd_addr;
2902
2903     case DW_CFA_offset:
2904     case DW_CFA_offset_extended:
2905     case DW_CFA_def_cfa:
2906     case DW_CFA_offset_extended_sf:
2907     case DW_CFA_def_cfa_sf:
2908     case DW_CFA_restore:
2909     case DW_CFA_restore_extended:
2910     case DW_CFA_undefined:
2911     case DW_CFA_same_value:
2912     case DW_CFA_def_cfa_register:
2913     case DW_CFA_register:
2914     case DW_CFA_expression:
2915       return dw_cfi_oprnd_reg_num;
2916
2917     case DW_CFA_def_cfa_offset:
2918     case DW_CFA_GNU_args_size:
2919     case DW_CFA_def_cfa_offset_sf:
2920       return dw_cfi_oprnd_offset;
2921
2922     case DW_CFA_def_cfa_expression:
2923       return dw_cfi_oprnd_loc;
2924
2925     default:
2926       gcc_unreachable ();
2927     }
2928 }
2929
2930 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
2931 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2932  (enum dwarf_call_frame_info cfi);
2933
2934 static enum dw_cfi_oprnd_type
2935 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2936 {
2937   switch (cfi)
2938     {
2939     case DW_CFA_def_cfa:
2940     case DW_CFA_def_cfa_sf:
2941     case DW_CFA_offset:
2942     case DW_CFA_offset_extended_sf:
2943     case DW_CFA_offset_extended:
2944       return dw_cfi_oprnd_offset;
2945
2946     case DW_CFA_register:
2947       return dw_cfi_oprnd_reg_num;
2948
2949     case DW_CFA_expression:
2950       return dw_cfi_oprnd_loc;
2951
2952     default:
2953       return dw_cfi_oprnd_unused;
2954     }
2955 }
2956
2957 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2958
2959 /* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,
2960    switch to the data section instead, and write out a synthetic start label
2961    for collect2 the first time around.  */
2962
2963 static void
2964 switch_to_eh_frame_section (bool back)
2965 {
2966   tree label;
2967
2968 #ifdef EH_FRAME_SECTION_NAME
2969   if (eh_frame_section == 0)
2970     {
2971       int flags;
2972
2973       if (EH_TABLES_CAN_BE_READ_ONLY)
2974         {
2975           int fde_encoding;
2976           int per_encoding;
2977           int lsda_encoding;
2978
2979           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2980                                                        /*global=*/0);
2981           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2982                                                        /*global=*/1);
2983           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2984                                                         /*global=*/0);
2985           flags = ((! flag_pic
2986                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2987                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
2988                         && (per_encoding & 0x70) != DW_EH_PE_absptr
2989                         && (per_encoding & 0x70) != DW_EH_PE_aligned
2990                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2991                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2992                    ? 0 : SECTION_WRITE);
2993         }
2994       else
2995         flags = SECTION_WRITE;
2996       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2997     }
2998 #endif
2999
3000   if (eh_frame_section)
3001     switch_to_section (eh_frame_section);
3002   else
3003     {
3004       /* We have no special eh_frame section.  Put the information in
3005          the data section and emit special labels to guide collect2.  */
3006       switch_to_section (data_section);
3007
3008       if (!back)
3009         {
3010           label = get_file_function_name ("F");
3011           ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3012           targetm.asm_out.globalize_label (asm_out_file,
3013                                            IDENTIFIER_POINTER (label));
3014           ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3015         }
3016     }
3017 }
3018
3019 /* Switch [BACK] to the eh or debug frame table section, depending on
3020    FOR_EH.  */
3021
3022 static void
3023 switch_to_frame_table_section (int for_eh, bool back)
3024 {
3025   if (for_eh)
3026     switch_to_eh_frame_section (back);
3027   else
3028     {
3029       if (!debug_frame_section)
3030         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3031                                            SECTION_DEBUG, NULL);
3032       switch_to_section (debug_frame_section);
3033     }
3034 }
3035
3036 /* Output a Call Frame Information opcode and its operand(s).  */
3037
3038 static void
3039 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3040 {
3041   unsigned long r;
3042   HOST_WIDE_INT off;
3043
3044   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3045     dw2_asm_output_data (1, (cfi->dw_cfi_opc
3046                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3047                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3048                          ((unsigned HOST_WIDE_INT)
3049                           cfi->dw_cfi_oprnd1.dw_cfi_offset));
3050   else if (cfi->dw_cfi_opc == DW_CFA_offset)
3051     {
3052       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3053       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3054                            "DW_CFA_offset, column %#lx", r);
3055       off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3056       dw2_asm_output_data_uleb128 (off, NULL);
3057     }
3058   else if (cfi->dw_cfi_opc == DW_CFA_restore)
3059     {
3060       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3061       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3062                            "DW_CFA_restore, column %#lx", r);
3063     }
3064   else
3065     {
3066       dw2_asm_output_data (1, cfi->dw_cfi_opc,
3067                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3068
3069       switch (cfi->dw_cfi_opc)
3070         {
3071         case DW_CFA_set_loc:
3072           if (for_eh)
3073             dw2_asm_output_encoded_addr_rtx (
3074                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3075                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3076                 false, NULL);
3077           else
3078             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3079                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3080           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3081           break;
3082
3083         case DW_CFA_advance_loc1:
3084           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3085                                 fde->dw_fde_current_label, NULL);
3086           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3087           break;
3088
3089         case DW_CFA_advance_loc2:
3090           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3091                                 fde->dw_fde_current_label, NULL);
3092           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3093           break;
3094
3095         case DW_CFA_advance_loc4:
3096           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3097                                 fde->dw_fde_current_label, NULL);
3098           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3099           break;
3100
3101         case DW_CFA_MIPS_advance_loc8:
3102           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3103                                 fde->dw_fde_current_label, NULL);
3104           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3105           break;
3106
3107         case DW_CFA_offset_extended:
3108           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3109           dw2_asm_output_data_uleb128 (r, NULL);
3110           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3111           dw2_asm_output_data_uleb128 (off, NULL);
3112           break;
3113
3114         case DW_CFA_def_cfa:
3115           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3116           dw2_asm_output_data_uleb128 (r, NULL);
3117           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3118           break;
3119
3120         case DW_CFA_offset_extended_sf:
3121           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3122           dw2_asm_output_data_uleb128 (r, NULL);
3123           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3124           dw2_asm_output_data_sleb128 (off, NULL);
3125           break;
3126
3127         case DW_CFA_def_cfa_sf:
3128           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3129           dw2_asm_output_data_uleb128 (r, NULL);
3130           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3131           dw2_asm_output_data_sleb128 (off, NULL);
3132           break;
3133
3134         case DW_CFA_restore_extended:
3135         case DW_CFA_undefined:
3136         case DW_CFA_same_value:
3137         case DW_CFA_def_cfa_register:
3138           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3139           dw2_asm_output_data_uleb128 (r, NULL);
3140           break;
3141
3142         case DW_CFA_register:
3143           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3144           dw2_asm_output_data_uleb128 (r, NULL);
3145           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3146           dw2_asm_output_data_uleb128 (r, NULL);
3147           break;
3148
3149         case DW_CFA_def_cfa_offset:
3150         case DW_CFA_GNU_args_size:
3151           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3152           break;
3153
3154         case DW_CFA_def_cfa_offset_sf:
3155           off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3156           dw2_asm_output_data_sleb128 (off, NULL);
3157           break;
3158
3159         case DW_CFA_GNU_window_save:
3160           break;
3161
3162         case DW_CFA_def_cfa_expression:
3163         case DW_CFA_expression:
3164           output_cfa_loc (cfi);
3165           break;
3166
3167         case DW_CFA_GNU_negative_offset_extended:
3168           /* Obsoleted by DW_CFA_offset_extended_sf.  */
3169           gcc_unreachable ();
3170
3171         default:
3172           break;
3173         }
3174     }
3175 }
3176
3177 /* Similar, but do it via assembler directives instead.  */
3178
3179 static void
3180 output_cfi_directive (dw_cfi_ref cfi)
3181 {
3182   unsigned long r, r2;
3183
3184   switch (cfi->dw_cfi_opc)
3185     {
3186     case DW_CFA_advance_loc:
3187     case DW_CFA_advance_loc1:
3188     case DW_CFA_advance_loc2:
3189     case DW_CFA_advance_loc4:
3190     case DW_CFA_MIPS_advance_loc8:
3191     case DW_CFA_set_loc:
3192       /* Should only be created by add_fde_cfi in a code path not
3193          followed when emitting via directives.  The assembler is
3194          going to take care of this for us.  */
3195       gcc_unreachable ();
3196
3197     case DW_CFA_offset:
3198     case DW_CFA_offset_extended:
3199     case DW_CFA_offset_extended_sf:
3200       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3201       fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3202                r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3203       break;
3204
3205     case DW_CFA_restore:
3206     case DW_CFA_restore_extended:
3207       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3208       fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3209       break;
3210
3211     case DW_CFA_undefined:
3212       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3213       fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3214       break;
3215
3216     case DW_CFA_same_value:
3217       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3218       fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3219       break;
3220
3221     case DW_CFA_def_cfa:
3222     case DW_CFA_def_cfa_sf:
3223       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3224       fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3225                r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3226       break;
3227
3228     case DW_CFA_def_cfa_register:
3229       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3230       fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3231       break;
3232
3233     case DW_CFA_register:
3234       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3235       r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3236       fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3237       break;
3238
3239     case DW_CFA_def_cfa_offset:
3240     case DW_CFA_def_cfa_offset_sf:
3241       fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3242                HOST_WIDE_INT_PRINT_DEC"\n",
3243                cfi->dw_cfi_oprnd1.dw_cfi_offset);
3244       break;
3245
3246     case DW_CFA_remember_state:
3247       fprintf (asm_out_file, "\t.cfi_remember_state\n");
3248       break;
3249     case DW_CFA_restore_state:
3250       fprintf (asm_out_file, "\t.cfi_restore_state\n");
3251       break;
3252
3253     case DW_CFA_GNU_args_size:
3254       fprintf (asm_out_file, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size);
3255       dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3256       if (flag_debug_asm)
3257         fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3258                  ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3259       fputc ('\n', asm_out_file);
3260       break;
3261
3262     case DW_CFA_GNU_window_save:
3263       fprintf (asm_out_file, "\t.cfi_window_save\n");
3264       break;
3265
3266     case DW_CFA_def_cfa_expression:
3267     case DW_CFA_expression:
3268       fprintf (asm_out_file, "\t.cfi_escape %#x,", cfi->dw_cfi_opc);
3269       output_cfa_loc_raw (cfi);
3270       fputc ('\n', asm_out_file);
3271       break;
3272
3273     default:
3274       gcc_unreachable ();
3275     }
3276 }
3277
3278 DEF_VEC_P (dw_cfi_ref);
3279 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3280
3281 /* Output CFIs to bring current FDE to the same state as after executing
3282    CFIs in CFI chain.  DO_CFI_ASM is true if .cfi_* directives shall
3283    be emitted, false otherwise.  If it is false, FDE and FOR_EH are the
3284    other arguments to pass to output_cfi.  */
3285
3286 static void
3287 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3288 {
3289   struct dw_cfi_struct cfi_buf;
3290   dw_cfi_ref cfi2;
3291   dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3292   VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3293   unsigned int len, idx;
3294
3295   for (;; cfi = cfi->dw_cfi_next)
3296     switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3297       {
3298       case DW_CFA_advance_loc:
3299       case DW_CFA_advance_loc1:
3300       case DW_CFA_advance_loc2:
3301       case DW_CFA_advance_loc4:
3302       case DW_CFA_MIPS_advance_loc8:
3303       case DW_CFA_set_loc:
3304         /* All advances should be ignored.  */
3305         break;
3306       case DW_CFA_remember_state:
3307         {
3308           dw_cfi_ref args_size = cfi_args_size;
3309
3310           /* Skip everything between .cfi_remember_state and
3311              .cfi_restore_state.  */
3312           for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3313             if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3314               break;
3315             else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3316               args_size = cfi2;
3317             else
3318               gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3319
3320           if (cfi2 == NULL)
3321             goto flush_all;
3322           else
3323             {
3324               cfi = cfi2;
3325               cfi_args_size = args_size;
3326             }
3327           break;
3328         }
3329       case DW_CFA_GNU_args_size:
3330         cfi_args_size = cfi;
3331         break;
3332       case DW_CFA_GNU_window_save:
3333         goto flush_all;
3334       case DW_CFA_offset:
3335       case DW_CFA_offset_extended:
3336       case DW_CFA_offset_extended_sf:
3337       case DW_CFA_restore:
3338       case DW_CFA_restore_extended:
3339       case DW_CFA_undefined:
3340       case DW_CFA_same_value:
3341       case DW_CFA_register:
3342       case DW_CFA_val_offset:
3343       case DW_CFA_val_offset_sf:
3344       case DW_CFA_expression:
3345       case DW_CFA_val_expression:
3346       case DW_CFA_GNU_negative_offset_extended:
3347         if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3348           VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3349                                  cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3350         VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3351         break;
3352       case DW_CFA_def_cfa:
3353       case DW_CFA_def_cfa_sf:
3354       case DW_CFA_def_cfa_expression:
3355         cfi_cfa = cfi;
3356         cfi_cfa_offset = cfi;
3357         break;
3358       case DW_CFA_def_cfa_register:
3359         cfi_cfa = cfi;
3360         break;
3361       case DW_CFA_def_cfa_offset:
3362       case DW_CFA_def_cfa_offset_sf:
3363         cfi_cfa_offset = cfi;
3364         break;
3365       case DW_CFA_nop:
3366         gcc_assert (cfi == NULL);
3367       flush_all:
3368         len = VEC_length (dw_cfi_ref, regs);
3369         for (idx = 0; idx < len; idx++)
3370           {
3371             cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3372             if (cfi2 != NULL
3373                 && cfi2->dw_cfi_opc != DW_CFA_restore
3374                 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3375               {
3376                 if (do_cfi_asm)
3377                   output_cfi_directive (cfi2);
3378                 else
3379                   output_cfi (cfi2, fde, for_eh);
3380               }
3381           }
3382         if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3383           {
3384             gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3385             cfi_buf = *cfi_cfa;
3386             switch (cfi_cfa_offset->dw_cfi_opc)
3387               {
3388               case DW_CFA_def_cfa_offset:
3389                 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3390                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3391                 break;
3392               case DW_CFA_def_cfa_offset_sf:
3393                 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3394                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3395                 break;
3396               case DW_CFA_def_cfa:
3397               case DW_CFA_def_cfa_sf:
3398                 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3399                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3400                 break;
3401               default:
3402                 gcc_unreachable ();
3403               }
3404             cfi_cfa = &cfi_buf;
3405           }
3406         else if (cfi_cfa_offset)
3407           cfi_cfa = cfi_cfa_offset;
3408         if (cfi_cfa)
3409           {
3410             if (do_cfi_asm)
3411               output_cfi_directive (cfi_cfa);
3412             else
3413               output_cfi (cfi_cfa, fde, for_eh);
3414           }
3415         cfi_cfa = NULL;
3416         cfi_cfa_offset = NULL;
3417         if (cfi_args_size
3418             && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3419           {
3420             if (do_cfi_asm)
3421               output_cfi_directive (cfi_args_size);
3422             else
3423               output_cfi (cfi_args_size, fde, for_eh);
3424           }
3425         cfi_args_size = NULL;
3426         if (cfi == NULL)
3427           {
3428             VEC_free (dw_cfi_ref, heap, regs);
3429             return;
3430           }
3431         else if (do_cfi_asm)
3432           output_cfi_directive (cfi);
3433         else
3434           output_cfi (cfi, fde, for_eh);
3435         break;
3436       default:
3437         gcc_unreachable ();
3438     }
3439 }
3440
3441 /* Output one FDE.  */
3442
3443 static void
3444 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3445             char *section_start_label, int fde_encoding, char *augmentation,
3446             bool any_lsda_needed, int lsda_encoding)
3447 {
3448   const char *begin, *end;
3449   static unsigned int j;
3450   char l1[20], l2[20];
3451   dw_cfi_ref cfi;
3452
3453   targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh,
3454                                 /* empty */ 0);
3455   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3456                                   for_eh + j);
3457   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3458   ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3459   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3460     dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3461                          " indicating 64-bit DWARF extension");
3462   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3463                         "FDE Length");
3464   ASM_OUTPUT_LABEL (asm_out_file, l1);
3465
3466   if (for_eh)
3467     dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3468   else
3469     dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3470                            debug_frame_section, "FDE CIE offset");
3471
3472   if (!fde->dw_fde_switched_sections)
3473     {
3474       begin = fde->dw_fde_begin;
3475       end = fde->dw_fde_end;
3476     }
3477   else
3478     {
3479       /* For the first section, prefer dw_fde_begin over
3480          dw_fde_{hot,cold}_section_label, as the latter
3481          might be separated from the real start of the
3482          function by alignment padding.  */
3483       if (!second)
3484         begin = fde->dw_fde_begin;
3485       else if (fde->dw_fde_switched_cold_to_hot)
3486         begin = fde->dw_fde_hot_section_label;
3487       else
3488         begin = fde->dw_fde_unlikely_section_label;
3489       if (second ^ fde->dw_fde_switched_cold_to_hot)
3490         end = fde->dw_fde_unlikely_section_end_label;
3491       else
3492         end = fde->dw_fde_hot_section_end_label;
3493     }
3494
3495   if (for_eh)
3496     {
3497       rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3498       SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3499       dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3500                                        "FDE initial location");
3501       dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3502                             end, begin, "FDE address range");
3503     }
3504   else
3505     {
3506       dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3507       dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3508     }
3509
3510   if (augmentation[0])
3511     {
3512       if (any_lsda_needed)
3513         {
3514           int size = size_of_encoded_value (lsda_encoding);
3515
3516           if (lsda_encoding == DW_EH_PE_aligned)
3517             {
3518               int offset = (  4         /* Length */
3519                             + 4         /* CIE offset */
3520                             + 2 * size_of_encoded_value (fde_encoding)
3521                             + 1         /* Augmentation size */ );
3522               int pad = -offset & (PTR_SIZE - 1);
3523
3524               size += pad;
3525               gcc_assert (size_of_uleb128 (size) == 1);
3526             }
3527
3528           dw2_asm_output_data_uleb128 (size, "Augmentation size");
3529
3530           if (fde->uses_eh_lsda)
3531             {
3532               ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3533                                            fde->funcdef_number);
3534               dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3535                                                gen_rtx_SYMBOL_REF (Pmode, l1),
3536                                                false,
3537                                                "Language Specific Data Area");
3538             }
3539           else
3540             {
3541               if (lsda_encoding == DW_EH_PE_aligned)
3542                 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3543               dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3544                                    "Language Specific Data Area (none)");
3545             }
3546         }
3547       else
3548         dw2_asm_output_data_uleb128 (0, "Augmentation size");
3549     }
3550
3551   /* Loop through the Call Frame Instructions associated with
3552      this FDE.  */
3553   fde->dw_fde_current_label = begin;
3554   if (!fde->dw_fde_switched_sections)
3555     for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3556       output_cfi (cfi, fde, for_eh);
3557   else if (!second)
3558     {
3559       if (fde->dw_fde_switch_cfi)
3560         for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3561           {
3562             output_cfi (cfi, fde, for_eh);
3563             if (cfi == fde->dw_fde_switch_cfi)
3564               break;
3565           }
3566     }
3567   else
3568     {
3569       dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3570
3571       if (fde->dw_fde_switch_cfi)
3572         {
3573           cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3574           fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3575           output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3576           fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3577         }
3578       for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3579         output_cfi (cfi, fde, for_eh);
3580     }
3581
3582   /* If we are to emit a ref/link from function bodies to their frame tables,
3583      do it now.  This is typically performed to make sure that tables
3584      associated with functions are dragged with them and not discarded in
3585      garbage collecting links. We need to do this on a per function basis to
3586      cope with -ffunction-sections.  */
3587
3588 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3589   /* Switch to the function section, emit the ref to the tables, and
3590      switch *back* into the table section.  */
3591   switch_to_section (function_section (fde->decl));
3592   ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3593   switch_to_frame_table_section (for_eh, true);
3594 #endif
3595
3596   /* Pad the FDE out to an address sized boundary.  */
3597   ASM_OUTPUT_ALIGN (asm_out_file,
3598                     floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3599   ASM_OUTPUT_LABEL (asm_out_file, l2);
3600
3601   j += 2;
3602 }
3603
3604 /* Output the call frame information used to record information
3605    that relates to calculating the frame pointer, and records the
3606    location of saved registers.  */
3607
3608 static void
3609 output_call_frame_info (int for_eh)
3610 {
3611   unsigned int i;
3612   dw_fde_ref fde;
3613   dw_cfi_ref cfi;
3614   char l1[20], l2[20], section_start_label[20];
3615   bool any_lsda_needed = false;
3616   char augmentation[6];
3617   int augmentation_size;
3618   int fde_encoding = DW_EH_PE_absptr;
3619   int per_encoding = DW_EH_PE_absptr;
3620   int lsda_encoding = DW_EH_PE_absptr;
3621   int return_reg;
3622   rtx personality = NULL;
3623   int dw_cie_version;
3624
3625   /* Don't emit a CIE if there won't be any FDEs.  */
3626   if (fde_table_in_use == 0)
3627     return;
3628
3629   /* Nothing to do if the assembler's doing it all.  */
3630   if (dwarf2out_do_cfi_asm ())
3631     return;
3632
3633   /* If we make FDEs linkonce, we may have to emit an empty label for
3634      an FDE that wouldn't otherwise be emitted.  We want to avoid
3635      having an FDE kept around when the function it refers to is
3636      discarded.  Example where this matters: a primary function
3637      template in C++ requires EH information, but an explicit
3638      specialization doesn't.  */
3639   if (TARGET_USES_WEAK_UNWIND_INFO
3640       && ! flag_asynchronous_unwind_tables
3641       && flag_exceptions
3642       && for_eh)
3643     for (i = 0; i < fde_table_in_use; i++)
3644       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
3645           && !fde_table[i].uses_eh_lsda
3646           && ! DECL_WEAK (fde_table[i].decl))
3647         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
3648                                       for_eh, /* empty */ 1);
3649
3650   /* If we don't have any functions we'll want to unwind out of, don't
3651      emit any EH unwind information.  Note that if exceptions aren't
3652      enabled, we won't have collected nothrow information, and if we
3653      asked for asynchronous tables, we always want this info.  */
3654   if (for_eh)
3655     {
3656       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
3657
3658       for (i = 0; i < fde_table_in_use; i++)
3659         if (fde_table[i].uses_eh_lsda)
3660           any_eh_needed = any_lsda_needed = true;
3661         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3662           any_eh_needed = true;
3663         else if (! fde_table[i].nothrow
3664                  && ! fde_table[i].all_throwers_are_sibcalls)
3665           any_eh_needed = true;
3666
3667       if (! any_eh_needed)
3668         return;
3669     }
3670
3671   /* We're going to be generating comments, so turn on app.  */
3672   if (flag_debug_asm)
3673     app_enable ();
3674
3675   /* Switch to the proper frame section, first time.  */
3676   switch_to_frame_table_section (for_eh, false);
3677
3678   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3679   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3680
3681   /* Output the CIE.  */
3682   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3683   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3684   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3685     dw2_asm_output_data (4, 0xffffffff,
3686       "Initial length escape value indicating 64-bit DWARF extension");
3687   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3688                         "Length of Common Information Entry");
3689   ASM_OUTPUT_LABEL (asm_out_file, l1);
3690
3691   /* Now that the CIE pointer is PC-relative for EH,
3692      use 0 to identify the CIE.  */
3693   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3694                        (for_eh ? 0 : DWARF_CIE_ID),
3695                        "CIE Identifier Tag");
3696
3697   /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3698      use CIE version 1, unless that would produce incorrect results
3699      due to overflowing the return register column.  */
3700   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3701   dw_cie_version = 1;
3702   if (return_reg >= 256 || dwarf_version > 2)
3703     dw_cie_version = 3;
3704   dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3705
3706   augmentation[0] = 0;
3707   augmentation_size = 0;
3708
3709   personality = current_unit_personality;
3710   if (for_eh)
3711     {
3712       char *p;
3713
3714       /* Augmentation:
3715          z      Indicates that a uleb128 is present to size the
3716                 augmentation section.
3717          L      Indicates the encoding (and thus presence) of
3718                 an LSDA pointer in the FDE augmentation.
3719          R      Indicates a non-default pointer encoding for
3720                 FDE code pointers.
3721          P      Indicates the presence of an encoding + language
3722                 personality routine in the CIE augmentation.  */
3723
3724       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3725       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3726       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3727
3728       p = augmentation + 1;
3729       if (personality)
3730         {
3731           *p++ = 'P';
3732           augmentation_size += 1 + size_of_encoded_value (per_encoding);
3733           assemble_external_libcall (personality);
3734         }
3735       if (any_lsda_needed)
3736         {
3737           *p++ = 'L';
3738           augmentation_size += 1;
3739         }
3740       if (fde_encoding != DW_EH_PE_absptr)
3741         {
3742           *p++ = 'R';
3743           augmentation_size += 1;
3744         }
3745       if (p > augmentation + 1)
3746         {
3747           augmentation[0] = 'z';
3748           *p = '\0';
3749         }
3750
3751       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
3752       if (personality && per_encoding == DW_EH_PE_aligned)
3753         {
3754           int offset = (  4             /* Length */
3755                         + 4             /* CIE Id */
3756                         + 1             /* CIE version */
3757                         + strlen (augmentation) + 1     /* Augmentation */
3758                         + size_of_uleb128 (1)           /* Code alignment */
3759                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3760                         + 1             /* RA column */
3761                         + 1             /* Augmentation size */
3762                         + 1             /* Personality encoding */ );
3763           int pad = -offset & (PTR_SIZE - 1);
3764
3765           augmentation_size += pad;
3766
3767           /* Augmentations should be small, so there's scarce need to
3768              iterate for a solution.  Die if we exceed one uleb128 byte.  */
3769           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3770         }
3771     }
3772
3773   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3774   if (dw_cie_version >= 4)
3775     {
3776       dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
3777       dw2_asm_output_data (1, 0, "CIE Segment Size");
3778     }
3779   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3780   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3781                                "CIE Data Alignment Factor");
3782
3783   if (dw_cie_version == 1)
3784     dw2_asm_output_data (1, return_reg, "CIE RA Column");
3785   else
3786     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3787
3788   if (augmentation[0])
3789     {
3790       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3791       if (personality)
3792         {
3793           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3794                                eh_data_format_name (per_encoding));
3795           dw2_asm_output_encoded_addr_rtx (per_encoding,
3796                                            personality,
3797                                            true, NULL);
3798         }
3799
3800       if (any_lsda_needed)
3801         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3802                              eh_data_format_name (lsda_encoding));
3803
3804       if (fde_encoding != DW_EH_PE_absptr)
3805         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3806                              eh_data_format_name (fde_encoding));
3807     }
3808
3809   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3810     output_cfi (cfi, NULL, for_eh);
3811
3812   /* Pad the CIE out to an address sized boundary.  */
3813   ASM_OUTPUT_ALIGN (asm_out_file,
3814                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3815   ASM_OUTPUT_LABEL (asm_out_file, l2);
3816
3817   /* Loop through all of the FDE's.  */
3818   for (i = 0; i < fde_table_in_use; i++)
3819     {
3820       unsigned int k;
3821       fde = &fde_table[i];
3822
3823       /* Don't emit EH unwind info for leaf functions that don't need it.  */
3824       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3825           && (fde->nothrow || fde->all_throwers_are_sibcalls)
3826           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3827           && !fde->uses_eh_lsda)
3828         continue;
3829
3830       for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3831         output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3832                     augmentation, any_lsda_needed, lsda_encoding);
3833     }
3834
3835   if (for_eh && targetm.terminate_dw2_eh_frame_info)
3836     dw2_asm_output_data (4, 0, "End of Table");
3837 #ifdef MIPS_DEBUGGING_INFO
3838   /* Work around Irix 6 assembler bug whereby labels at the end of a section
3839      get a value of 0.  Putting .align 0 after the label fixes it.  */
3840   ASM_OUTPUT_ALIGN (asm_out_file, 0);
3841 #endif
3842
3843   /* Turn off app to make assembly quicker.  */
3844   if (flag_debug_asm)
3845     app_disable ();
3846 }
3847
3848 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed.  */
3849
3850 static void
3851 dwarf2out_do_cfi_startproc (bool second)
3852 {
3853   int enc;
3854   rtx ref;
3855   rtx personality = get_personality_function (current_function_decl);
3856
3857   fprintf (asm_out_file, "\t.cfi_startproc\n");
3858
3859   if (personality)
3860     {
3861       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3862       ref = personality;
3863
3864       /* ??? The GAS support isn't entirely consistent.  We have to
3865          handle indirect support ourselves, but PC-relative is done
3866          in the assembler.  Further, the assembler can't handle any
3867          of the weirder relocation types.  */
3868       if (enc & DW_EH_PE_indirect)
3869         ref = dw2_force_const_mem (ref, true);
3870
3871       fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
3872       output_addr_const (asm_out_file, ref);
3873       fputc ('\n', asm_out_file);
3874     }
3875
3876   if (crtl->uses_eh_lsda)
3877     {
3878       char lab[20];
3879
3880       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3881       ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3882                                    current_function_funcdef_no);
3883       ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3884       SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3885
3886       if (enc & DW_EH_PE_indirect)
3887         ref = dw2_force_const_mem (ref, true);
3888
3889       fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
3890       output_addr_const (asm_out_file, ref);
3891       fputc ('\n', asm_out_file);
3892     }
3893 }
3894
3895 /* Output a marker (i.e. a label) for the beginning of a function, before
3896    the prologue.  */
3897
3898 void
3899 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3900                           const char *file ATTRIBUTE_UNUSED)
3901 {
3902   char label[MAX_ARTIFICIAL_LABEL_BYTES];
3903   char * dup_label;
3904   dw_fde_ref fde;
3905   section *fnsec;
3906
3907   current_function_func_begin_label = NULL;
3908
3909 #ifdef TARGET_UNWIND_INFO
3910   /* ??? current_function_func_begin_label is also used by except.c
3911      for call-site information.  We must emit this label if it might
3912      be used.  */
3913   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3914       && ! dwarf2out_do_frame ())
3915     return;
3916 #else
3917   if (! dwarf2out_do_frame ())
3918     return;
3919 #endif
3920
3921   fnsec = function_section (current_function_decl);
3922   switch_to_section (fnsec);
3923   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3924                                current_function_funcdef_no);
3925   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3926                           current_function_funcdef_no);
3927   dup_label = xstrdup (label);
3928   current_function_func_begin_label = dup_label;
3929
3930 #ifdef TARGET_UNWIND_INFO
3931   /* We can elide the fde allocation if we're not emitting debug info.  */
3932   if (! dwarf2out_do_frame ())
3933     return;
3934 #endif
3935
3936   /* Expand the fde table if necessary.  */
3937   if (fde_table_in_use == fde_table_allocated)
3938     {
3939       fde_table_allocated += FDE_TABLE_INCREMENT;
3940       fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3941       memset (fde_table + fde_table_in_use, 0,
3942               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3943     }
3944
3945   /* Record the FDE associated with this function.  */
3946   current_funcdef_fde = fde_table_in_use;
3947
3948   /* Add the new FDE at the end of the fde_table.  */
3949   fde = &fde_table[fde_table_in_use++];
3950   fde->decl = current_function_decl;
3951   fde->dw_fde_begin = dup_label;
3952   fde->dw_fde_current_label = dup_label;
3953   fde->dw_fde_hot_section_label = NULL;
3954   fde->dw_fde_hot_section_end_label = NULL;
3955   fde->dw_fde_unlikely_section_label = NULL;
3956   fde->dw_fde_unlikely_section_end_label = NULL;
3957   fde->dw_fde_switched_sections = 0;
3958   fde->dw_fde_switched_cold_to_hot = 0;
3959   fde->dw_fde_end = NULL;
3960   fde->dw_fde_cfi = NULL;
3961   fde->dw_fde_switch_cfi = NULL;
3962   fde->funcdef_number = current_function_funcdef_no;
3963   fde->nothrow = crtl->nothrow;
3964   fde->uses_eh_lsda = crtl->uses_eh_lsda;
3965   fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3966   fde->drap_reg = INVALID_REGNUM;
3967   fde->vdrap_reg = INVALID_REGNUM;
3968   if (flag_reorder_blocks_and_partition)
3969     {
3970       section *unlikelysec;
3971       if (first_function_block_is_cold)
3972         fde->in_std_section = 1;
3973       else
3974         fde->in_std_section
3975           = (fnsec == text_section
3976              || (cold_text_section && fnsec == cold_text_section));
3977       unlikelysec = unlikely_text_section ();
3978       fde->cold_in_std_section
3979         = (unlikelysec == text_section
3980            || (cold_text_section && unlikelysec == cold_text_section));
3981     }
3982   else
3983     {
3984       fde->in_std_section
3985         = (fnsec == text_section
3986            || (cold_text_section && fnsec == cold_text_section));
3987       fde->cold_in_std_section = 0;
3988     }
3989
3990   args_size = old_args_size = 0;
3991
3992   /* We only want to output line number information for the genuine dwarf2
3993      prologue case, not the eh frame case.  */
3994 #ifdef DWARF2_DEBUGGING_INFO
3995   if (file)
3996     dwarf2out_source_line (line, file, 0, true);
3997 #endif
3998
3999   if (dwarf2out_do_cfi_asm ())
4000     dwarf2out_do_cfi_startproc (false);
4001   else
4002     {
4003       rtx personality = get_personality_function (current_function_decl);
4004       if (!current_unit_personality)
4005         current_unit_personality = personality;
4006
4007       /* We cannot keep a current personality per function as without CFI
4008          asm at the point where we emit the CFI data there is no current
4009          function anymore.  */
4010       if (personality
4011           && current_unit_personality != personality)
4012         sorry ("Multiple EH personalities are supported only with assemblers "
4013                "supporting .cfi.personality directive.");
4014     }
4015 }
4016
4017 /* Output a marker (i.e. a label) for the absolute end of the generated code
4018    for a function definition.  This gets called *after* the epilogue code has
4019    been generated.  */
4020
4021 void
4022 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4023                         const char *file ATTRIBUTE_UNUSED)
4024 {
4025   dw_fde_ref fde;
4026   char label[MAX_ARTIFICIAL_LABEL_BYTES];
4027
4028 #ifdef DWARF2_DEBUGGING_INFO
4029   last_var_location_insn = NULL_RTX;
4030 #endif
4031
4032   if (dwarf2out_do_cfi_asm ())
4033     fprintf (asm_out_file, "\t.cfi_endproc\n");
4034
4035   /* Output a label to mark the endpoint of the code generated for this
4036      function.  */
4037   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4038                                current_function_funcdef_no);
4039   ASM_OUTPUT_LABEL (asm_out_file, label);
4040   fde = current_fde ();
4041   gcc_assert (fde != NULL);
4042   fde->dw_fde_end = xstrdup (label);
4043 }
4044
4045 void
4046 dwarf2out_frame_init (void)
4047 {
4048   /* Allocate the initial hunk of the fde_table.  */
4049   fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
4050   fde_table_allocated = FDE_TABLE_INCREMENT;
4051   fde_table_in_use = 0;
4052
4053   /* Generate the CFA instructions common to all FDE's.  Do it now for the
4054      sake of lookup_cfa.  */
4055
4056   /* On entry, the Canonical Frame Address is at SP.  */
4057   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4058
4059 #ifdef DWARF2_UNWIND_INFO
4060   if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
4061     initial_return_save (INCOMING_RETURN_ADDR_RTX);
4062 #endif
4063 }
4064
4065 void
4066 dwarf2out_frame_finish (void)
4067 {
4068   /* Output call frame information.  */
4069   if (DWARF2_FRAME_INFO)
4070     output_call_frame_info (0);
4071
4072 #ifndef TARGET_UNWIND_INFO
4073   /* Output another copy for the unwinder.  */
4074   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
4075     output_call_frame_info (1);
4076 #endif
4077 }
4078
4079 /* Note that the current function section is being used for code.  */
4080
4081 static void
4082 dwarf2out_note_section_used (void)
4083 {
4084   section *sec = current_function_section ();
4085   if (sec == text_section)
4086     text_section_used = true;
4087   else if (sec == cold_text_section)
4088     cold_text_section_used = true;
4089 }
4090
4091 void
4092 dwarf2out_switch_text_section (void)
4093 {
4094   dw_fde_ref fde = current_fde ();
4095
4096   gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4097
4098   fde->dw_fde_switched_sections = 1;
4099   fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4100
4101   fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4102   fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4103   fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4104   fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4105   have_multiple_function_sections = true;
4106
4107   /* Reset the current label on switching text sections, so that we
4108      don't attempt to advance_loc4 between labels in different sections.  */
4109   fde->dw_fde_current_label = NULL;
4110
4111   /* There is no need to mark used sections when not debugging.  */
4112   if (cold_text_section != NULL)
4113     dwarf2out_note_section_used ();
4114
4115   if (dwarf2out_do_cfi_asm ())
4116     fprintf (asm_out_file, "\t.cfi_endproc\n");
4117
4118   /* Now do the real section switch.  */
4119   switch_to_section (current_function_section ());
4120
4121   if (dwarf2out_do_cfi_asm ())
4122     {
4123       dwarf2out_do_cfi_startproc (true);
4124       /* As this is a different FDE, insert all current CFI instructions
4125          again.  */
4126       output_cfis (fde->dw_fde_cfi, true, fde, true);
4127     }
4128   else
4129     {
4130       dw_cfi_ref cfi = fde->dw_fde_cfi;
4131
4132       cfi = fde->dw_fde_cfi;
4133       if (cfi)
4134         while (cfi->dw_cfi_next != NULL)
4135           cfi = cfi->dw_cfi_next;
4136       fde->dw_fde_switch_cfi = cfi;
4137     }
4138 }
4139 #endif
4140 \f
4141 /* And now, the subset of the debugging information support code necessary
4142    for emitting location expressions.  */
4143
4144 /* Data about a single source file.  */
4145 struct GTY(()) dwarf_file_data {
4146   const char * filename;
4147   int emitted_number;
4148 };
4149
4150 typedef struct dw_val_struct *dw_val_ref;
4151 typedef struct die_struct *dw_die_ref;
4152 typedef const struct die_struct *const_dw_die_ref;
4153 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4154 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4155
4156 typedef struct GTY(()) deferred_locations_struct
4157 {
4158   tree variable;
4159   dw_die_ref die;
4160 } deferred_locations;
4161
4162 DEF_VEC_O(deferred_locations);
4163 DEF_VEC_ALLOC_O(deferred_locations,gc);
4164
4165 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4166
4167 DEF_VEC_P(dw_die_ref);
4168 DEF_VEC_ALLOC_P(dw_die_ref,heap);
4169
4170 /* Each DIE may have a series of attribute/value pairs.  Values
4171    can take on several forms.  The forms that are used in this
4172    implementation are listed below.  */
4173
4174 enum dw_val_class
4175 {
4176   dw_val_class_addr,
4177   dw_val_class_offset,
4178   dw_val_class_loc,
4179   dw_val_class_loc_list,
4180   dw_val_class_range_list,
4181   dw_val_class_const,
4182   dw_val_class_unsigned_const,
4183   dw_val_class_const_double,
4184   dw_val_class_vec,
4185   dw_val_class_flag,
4186   dw_val_class_die_ref,
4187   dw_val_class_fde_ref,
4188   dw_val_class_lbl_id,
4189   dw_val_class_lineptr,
4190   dw_val_class_str,
4191   dw_val_class_macptr,
4192   dw_val_class_file,
4193   dw_val_class_data8
4194 };
4195
4196 /* Describe a floating point constant value, or a vector constant value.  */
4197
4198 typedef struct GTY(()) dw_vec_struct {
4199   unsigned char * GTY((length ("%h.length"))) array;
4200   unsigned length;