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 "varray.h"
  83 #include "ggc.h"
  84 #include "md5.h"
  85 #include "tm_p.h"
  86 #include "diagnostic.h"
  87 #include "debug.h"
  88 #include "target.h"
  89 #include "langhooks.h"
  90 #include "hashtab.h"
  91 #include "cgraph.h"
  92 #include "input.h"
  93 #include "gimple.h"
  94 #include "tree-pass.h"
  95
  96 #ifdef DWARF2_DEBUGGING_INFO
  97 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
  98
  99 static rtx last_var_location_insn;
 100 #endif
 101
 102 #ifdef VMS_DEBUGGING_INFO
 103 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
 104
 105 /* Define this macro to be a nonzero value if the directory specifications
 106     which are output in the debug info should end with a separator.  */
 107 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
 108 /* Define this macro to evaluate to a nonzero value if GCC should refrain
 109    from generating indirect strings in DWARF2 debug information, for instance
 110    if your target is stuck with an old version of GDB that is unable to
 111    process them properly or uses VMS Debug.  */
 112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
 113 #else
 114 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
 115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
 116 #endif
 117
 118 #ifndef DWARF2_FRAME_INFO
 119 # ifdef DWARF2_DEBUGGING_INFO
 120 #  define DWARF2_FRAME_INFO \
 121   (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
 122 # else
 123 #  define DWARF2_FRAME_INFO 0
 124 # endif
 125 #endif
 126
 127 /* Map register numbers held in the call frame info that gcc has
 128    collected using DWARF_FRAME_REGNUM to those that should be output in
 129    .debug_frame and .eh_frame.  */
 130 #ifndef DWARF2_FRAME_REG_OUT
 131 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
 132 #endif
 133
 134 /* Save the result of dwarf2out_do_frame across PCH.  */
 135 static GTY(()) bool saved_do_cfi_asm = 0;
 136
 137 /* Decide whether we want to emit frame unwind information for the current
 138    translation unit.  */
 139
 140 int
 141 dwarf2out_do_frame (void)
 142 {
 143   /* We want to emit correct CFA location expressions or lists, so we
 144      have to return true if we're going to output debug info, even if
 145      we're not going to output frame or unwind info.  */
 146   return (write_symbols == DWARF2_DEBUG
 147           || write_symbols == VMS_AND_DWARF2_DEBUG
 148           || DWARF2_FRAME_INFO || saved_do_cfi_asm
 149 #ifdef DWARF2_UNWIND_INFO
 150           || (DWARF2_UNWIND_INFO
 151               && (flag_unwind_tables
 152                   || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
 153 #endif
 154           );
 155 }
 156
 157 /* Decide whether to emit frame unwind via assembler directives.  */
 158
 159 int
 160 dwarf2out_do_cfi_asm (void)
 161 {
 162   int enc;
 163
 164 #ifdef MIPS_DEBUGGING_INFO
 165   return false;
 166 #endif
 167   if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
 168     return false;
 169   if (saved_do_cfi_asm)
 170     return true;
 171   if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
 172     return false;
 173
 174   /* Make sure the personality encoding is one the assembler can support.
 175      In particular, aligned addresses can't be handled.  */
 176   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
 177   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
 178     return false;
 179   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
 180   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
 181     return false;
 182
 183   if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
 184     {
 185 #ifdef TARGET_UNWIND_INFO
 186       return false;
 187 #else
 188       if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
 189         return false;
 190 #endif
 191     }
 192
 193   saved_do_cfi_asm = true;
 194   return true;
 195 }
 196
 197 /* The size of the target's pointer type.  */
 198 #ifndef PTR_SIZE
 199 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 200 #endif
 201
 202 /* Array of RTXes referenced by the debugging information, which therefore
 203    must be kept around forever.  */
 204 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 205
 206 /* A pointer to the base of a list of incomplete types which might be
 207    completed at some later time.  incomplete_types_list needs to be a
 208    VEC(tree,gc) because we want to tell the garbage collector about
 209    it.  */
 210 static GTY(()) VEC(tree,gc) *incomplete_types;
 211
 212 /* A pointer to the base of a table of references to declaration
 213    scopes.  This table is a display which tracks the nesting
 214    of declaration scopes at the current scope and containing
 215    scopes.  This table is used to find the proper place to
 216    define type declaration DIE's.  */
 217 static GTY(()) VEC(tree,gc) *decl_scope_table;
 218
 219 /* Pointers to various DWARF2 sections.  */
 220 static GTY(()) section *debug_info_section;
 221 static GTY(()) section *debug_abbrev_section;
 222 static GTY(()) section *debug_aranges_section;
 223 static GTY(()) section *debug_macinfo_section;
 224 static GTY(()) section *debug_line_section;
 225 static GTY(()) section *debug_loc_section;
 226 static GTY(()) section *debug_pubnames_section;
 227 static GTY(()) section *debug_pubtypes_section;
 228 static GTY(()) section *debug_dcall_section;
 229 static GTY(()) section *debug_vcall_section;
 230 static GTY(()) section *debug_str_section;
 231 static GTY(()) section *debug_ranges_section;
 232 static GTY(()) section *debug_frame_section;
 233
 234 /* Personality decl of current unit.  Used only when assembler does not support
 235    personality CFI.  */
 236 static GTY(()) rtx current_unit_personality;
 237
 238 /* How to start an assembler comment.  */
 239 #ifndef ASM_COMMENT_START
 240 #define ASM_COMMENT_START ";#"
 241 #endif
 242
 243 typedef struct dw_cfi_struct *dw_cfi_ref;
 244 typedef struct dw_fde_struct *dw_fde_ref;
 245 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 246
 247 /* Call frames are described using a sequence of Call Frame
 248    Information instructions.  The register number, offset
 249    and address fields are provided as possible operands;
 250    their use is selected by the opcode field.  */
 251
 252 enum dw_cfi_oprnd_type {
 253   dw_cfi_oprnd_unused,
 254   dw_cfi_oprnd_reg_num,
 255   dw_cfi_oprnd_offset,
 256   dw_cfi_oprnd_addr,
 257   dw_cfi_oprnd_loc
 258 };
 259
 260 typedef union GTY(()) dw_cfi_oprnd_struct {
 261   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 262   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 263   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 264   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 265 }
 266 dw_cfi_oprnd;
 267
 268 typedef struct GTY(()) dw_cfi_struct {
 269   dw_cfi_ref dw_cfi_next;
 270   enum dwarf_call_frame_info dw_cfi_opc;
 271   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 272     dw_cfi_oprnd1;
 273   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 274     dw_cfi_oprnd2;
 275 }
 276 dw_cfi_node;
 277
 278 /* This is how we define the location of the CFA. We use to handle it
 279    as REG + OFFSET all the time,  but now it can be more complex.
 280    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 281    Instead of passing around REG and OFFSET, we pass a copy
 282    of this structure.  */
 283 typedef struct GTY(()) cfa_loc {
 284   HOST_WIDE_INT offset;
 285   HOST_WIDE_INT base_offset;
 286   unsigned int reg;
 287   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
 288   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
 289 } dw_cfa_location;
 290
 291 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 292    refer to a single Common Information Entry (CIE), defined at
 293    the beginning of the .debug_frame section.  This use of a single
 294    CIE obviates the need to keep track of multiple CIE's
 295    in the DWARF generation routines below.  */
 296
 297 typedef struct GTY(()) dw_fde_struct {
 298   tree decl;
 299   const char *dw_fde_begin;
 300   const char *dw_fde_current_label;
 301   const char *dw_fde_end;
 302   const char *dw_fde_hot_section_label;
 303   const char *dw_fde_hot_section_end_label;
 304   const char *dw_fde_unlikely_section_label;
 305   const char *dw_fde_unlikely_section_end_label;
 306   dw_cfi_ref dw_fde_cfi;
 307   dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections.  */
 308   unsigned funcdef_number;
 309   HOST_WIDE_INT stack_realignment;
 310   /* Dynamic realign argument pointer register.  */
 311   unsigned int drap_reg;
 312   /* Virtual dynamic realign argument pointer register.  */
 313   unsigned int vdrap_reg;
 314   unsigned all_throwers_are_sibcalls : 1;
 315   unsigned nothrow : 1;
 316   unsigned uses_eh_lsda : 1;
 317   /* Whether we did stack realign in this call frame.  */
 318   unsigned stack_realign : 1;
 319   /* Whether dynamic realign argument pointer register has been saved.  */
 320   unsigned drap_reg_saved: 1;
 321   /* True iff dw_fde_begin label is in text_section or cold_text_section.  */
 322   unsigned in_std_section : 1;
 323   /* True iff dw_fde_unlikely_section_label is in text_section or
 324      cold_text_section.  */
 325   unsigned cold_in_std_section : 1;
 326   /* True iff switched sections.  */
 327   unsigned dw_fde_switched_sections : 1;
 328   /* True iff switching from cold to hot section.  */
 329   unsigned dw_fde_switched_cold_to_hot : 1;
 330 }
 331 dw_fde_node;
 332
 333 /* Maximum size (in bytes) of an artificially generated label.  */
 334 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 335
 336 /* The size of addresses as they appear in the Dwarf 2 data.
 337    Some architectures use word addresses to refer to code locations,
 338    but Dwarf 2 info always uses byte addresses.  On such machines,
 339    Dwarf 2 addresses need to be larger than the architecture's
 340    pointers.  */
 341 #ifndef DWARF2_ADDR_SIZE
 342 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 343 #endif
 344
 345 /* The size in bytes of a DWARF field indicating an offset or length
 346    relative to a debug info section, specified to be 4 bytes in the
 347    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 348    as PTR_SIZE.  */
 349
 350 #ifndef DWARF_OFFSET_SIZE
 351 #define DWARF_OFFSET_SIZE 4
 352 #endif
 353
 354 /* The size in bytes of a DWARF 4 type signature.  */
 355
 356 #ifndef DWARF_TYPE_SIGNATURE_SIZE
 357 #define DWARF_TYPE_SIGNATURE_SIZE 8
 358 #endif
 359
 360 /* According to the (draft) DWARF 3 specification, the initial length
 361    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 362    bytes are 0xffffffff, followed by the length stored in the next 8
 363    bytes.
 364
 365    However, the SGI/MIPS ABI uses an initial length which is equal to
 366    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 367
 368 #ifndef DWARF_INITIAL_LENGTH_SIZE
 369 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 370 #endif
 371
 372 /* Round SIZE up to the nearest BOUNDARY.  */
 373 #define DWARF_ROUND(SIZE,BOUNDARY) \
 374   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 375
 376 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 377 #ifndef DWARF_CIE_DATA_ALIGNMENT
 378 #ifdef STACK_GROWS_DOWNWARD
 379 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 380 #else
 381 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 382 #endif
 383 #endif
 384
 385 /* CIE identifier.  */
 386 #if HOST_BITS_PER_WIDE_INT >= 64
 387 #define DWARF_CIE_ID \
 388   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
 389 #else
 390 #define DWARF_CIE_ID DW_CIE_ID
 391 #endif
 392
 393 /* A pointer to the base of a table that contains frame description
 394    information for each routine.  */
 395 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 396
 397 /* Number of elements currently allocated for fde_table.  */
 398 static GTY(()) unsigned fde_table_allocated;
 399
 400 /* Number of elements in fde_table currently in use.  */
 401 static GTY(()) unsigned fde_table_in_use;
 402
 403 /* Size (in elements) of increments by which we may expand the
 404    fde_table.  */
 405 #define FDE_TABLE_INCREMENT 256
 406
 407 /* Get the current fde_table entry we should use.  */
 408
 409 static inline dw_fde_ref
 410 current_fde (void)
 411 {
 412   return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
 413 }
 414
 415 /* A list of call frame insns for the CIE.  */
 416 static GTY(()) dw_cfi_ref cie_cfi_head;
 417
 418 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 419 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 420    attribute that accelerates the lookup of the FDE associated
 421    with the subprogram.  This variable holds the table index of the FDE
 422    associated with the current function (body) definition.  */
 423 static unsigned current_funcdef_fde;
 424 #endif
 425
 426 struct GTY(()) indirect_string_node {
 427   const char *str;
 428   unsigned int refcount;
 429   enum dwarf_form form;
 430   char *label;
 431 };
 432
 433 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 434
 435 /* True if the compilation unit has location entries that reference
 436    debug strings.  */
 437 static GTY(()) bool debug_str_hash_forced = false;
 438
 439 static GTY(()) int dw2_string_counter;
 440 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 441
 442 /* True if the compilation unit places functions in more than one section.  */
 443 static GTY(()) bool have_multiple_function_sections = false;
 444
 445 /* Whether the default text and cold text sections have been used at all.  */
 446
 447 static GTY(()) bool text_section_used = false;
 448 static GTY(()) bool cold_text_section_used = false;
 449
 450 /* The default cold text section.  */
 451 static GTY(()) section *cold_text_section;
 452
 453 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 454
 455 /* Forward declarations for functions defined in this file.  */
 456
 457 static char *stripattributes (const char *);
 458 static const char *dwarf_cfi_name (unsigned);
 459 static dw_cfi_ref new_cfi (void);
 460 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 461 static void add_fde_cfi (const char *, dw_cfi_ref);
 462 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
 463 static void lookup_cfa (dw_cfa_location *);
 464 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 465 #ifdef DWARF2_UNWIND_INFO
 466 static void initial_return_save (rtx);
 467 #endif
 468 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
 469                                           HOST_WIDE_INT);
 470 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 471 static void output_cfi_directive (dw_cfi_ref);
 472 static void output_call_frame_info (int);
 473 static void dwarf2out_note_section_used (void);
 474 static void flush_queued_reg_saves (void);
 475 static bool clobbers_queued_reg_save (const_rtx);
 476 static void dwarf2out_frame_debug_expr (rtx, const char *);
 477
 478 /* Support for complex CFA locations.  */
 479 static void output_cfa_loc (dw_cfi_ref);
 480 static void output_cfa_loc_raw (dw_cfi_ref);
 481 static void get_cfa_from_loc_descr (dw_cfa_location *,
 482                                     struct dw_loc_descr_struct *);
 483 static struct dw_loc_descr_struct *build_cfa_loc
 484   (dw_cfa_location *, HOST_WIDE_INT);
 485 static struct dw_loc_descr_struct *build_cfa_aligned_loc
 486   (HOST_WIDE_INT, HOST_WIDE_INT);
 487 static void def_cfa_1 (const char *, dw_cfa_location *);
 488
 489 /* How to start an assembler comment.  */
 490 #ifndef ASM_COMMENT_START
 491 #define ASM_COMMENT_START ";#"
 492 #endif
 493
 494 /* Data and reference forms for relocatable data.  */
 495 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 496 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 497
 498 #ifndef DEBUG_FRAME_SECTION
 499 #define DEBUG_FRAME_SECTION     ".debug_frame"
 500 #endif
 501
 502 #ifndef FUNC_BEGIN_LABEL
 503 #define FUNC_BEGIN_LABEL        "LFB"
 504 #endif
 505
 506 #ifndef FUNC_END_LABEL
 507 #define FUNC_END_LABEL          "LFE"
 508 #endif
 509
 510 #ifndef FRAME_BEGIN_LABEL
 511 #define FRAME_BEGIN_LABEL       "Lframe"
 512 #endif
 513 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 514 #define CIE_END_LABEL           "LECIE"
 515 #define FDE_LABEL               "LSFDE"
 516 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 517 #define FDE_END_LABEL           "LEFDE"
 518 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 519 #define LINE_NUMBER_END_LABEL   "LELT"
 520 #define LN_PROLOG_AS_LABEL      "LASLTP"
 521 #define LN_PROLOG_END_LABEL     "LELTP"
 522 #define DIE_LABEL_PREFIX        "DW"
 523
 524 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 525    is the column for PC, or the first column after all of the hard
 526    registers.  */
 527 #ifndef DWARF_FRAME_RETURN_COLUMN
 528 #ifdef PC_REGNUM
 529 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 530 #else
 531 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 532 #endif
 533 #endif
 534
 535 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 536    default, we just provide columns for all registers.  */
 537 #ifndef DWARF_FRAME_REGNUM
 538 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 539 #endif
 540 \f
 541 /* Hook used by __throw.  */
 542
 543 rtx
 544 expand_builtin_dwarf_sp_column (void)
 545 {
 546   unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
 547   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
 548 }
 549
 550 /* Return a pointer to a copy of the section string name S with all
 551    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 552
 553 static inline char *
 554 stripattributes (const char *s)
 555 {
 556   char *stripped = XNEWVEC (char, strlen (s) + 2);
 557   char *p = stripped;
 558
 559   *p++ = '*';
 560
 561   while (*s && *s != ',')
 562     *p++ = *s++;
 563
 564   *p = '\0';
 565   return stripped;
 566 }
 567
 568 /* MEM is a memory reference for the register size table, each element of
 569    which has mode MODE.  Initialize column C as a return address column.  */
 570
 571 static void
 572 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
 573 {
 574   HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
 575   HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
 576   emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 577 }
 578
 579 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder.  */
 580
 581 static inline HOST_WIDE_INT
 582 div_data_align (HOST_WIDE_INT off)
 583 {
 584   HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
 585   gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
 586   return r;
 587 }
 588
 589 /* Return true if we need a signed version of a given opcode
 590    (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended).  */
 591
 592 static inline bool
 593 need_data_align_sf_opcode (HOST_WIDE_INT off)
 594 {
 595   return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
 596 }
 597
 598 /* Generate code to initialize the register size table.  */
 599
 600 void
 601 expand_builtin_init_dwarf_reg_sizes (tree address)
 602 {
 603   unsigned int i;
 604   enum machine_mode mode = TYPE_MODE (char_type_node);
 605   rtx addr = expand_normal (address);
 606   rtx mem = gen_rtx_MEM (BLKmode, addr);
 607   bool wrote_return_column = false;
 608
 609   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 610     {
 611       int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
 612
 613       if (rnum < DWARF_FRAME_REGISTERS)
 614         {
 615           HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
 616           enum machine_mode save_mode = reg_raw_mode[i];
 617           HOST_WIDE_INT size;
 618
 619           if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 620             save_mode = choose_hard_reg_mode (i, 1, true);
 621           if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 622             {
 623               if (save_mode == VOIDmode)
 624                 continue;
 625               wrote_return_column = true;
 626             }
 627           size = GET_MODE_SIZE (save_mode);
 628           if (offset < 0)
 629             continue;
 630
 631           emit_move_insn (adjust_address (mem, mode, offset),
 632                           gen_int_mode (size, mode));
 633         }
 634     }
 635
 636   if (!wrote_return_column)
 637     init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
 638
 639 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 640   init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
 641 #endif
 642
 643   targetm.init_dwarf_reg_sizes_extra (address);
 644 }
 645
 646 /* Convert a DWARF call frame info. operation to its string name */
 647
 648 static const char *
 649 dwarf_cfi_name (unsigned int cfi_opc)
 650 {
 651   switch (cfi_opc)
 652     {
 653     case DW_CFA_advance_loc:
 654       return "DW_CFA_advance_loc";
 655     case DW_CFA_offset:
 656       return "DW_CFA_offset";
 657     case DW_CFA_restore:
 658       return "DW_CFA_restore";
 659     case DW_CFA_nop:
 660       return "DW_CFA_nop";
 661     case DW_CFA_set_loc:
 662       return "DW_CFA_set_loc";
 663     case DW_CFA_advance_loc1:
 664       return "DW_CFA_advance_loc1";
 665     case DW_CFA_advance_loc2:
 666       return "DW_CFA_advance_loc2";
 667     case DW_CFA_advance_loc4:
 668       return "DW_CFA_advance_loc4";
 669     case DW_CFA_offset_extended:
 670       return "DW_CFA_offset_extended";
 671     case DW_CFA_restore_extended:
 672       return "DW_CFA_restore_extended";
 673     case DW_CFA_undefined:
 674       return "DW_CFA_undefined";
 675     case DW_CFA_same_value:
 676       return "DW_CFA_same_value";
 677     case DW_CFA_register:
 678       return "DW_CFA_register";
 679     case DW_CFA_remember_state:
 680       return "DW_CFA_remember_state";
 681     case DW_CFA_restore_state:
 682       return "DW_CFA_restore_state";
 683     case DW_CFA_def_cfa:
 684       return "DW_CFA_def_cfa";
 685     case DW_CFA_def_cfa_register:
 686       return "DW_CFA_def_cfa_register";
 687     case DW_CFA_def_cfa_offset:
 688       return "DW_CFA_def_cfa_offset";
 689
 690     /* DWARF 3 */
 691     case DW_CFA_def_cfa_expression:
 692       return "DW_CFA_def_cfa_expression";
 693     case DW_CFA_expression:
 694       return "DW_CFA_expression";
 695     case DW_CFA_offset_extended_sf:
 696       return "DW_CFA_offset_extended_sf";
 697     case DW_CFA_def_cfa_sf:
 698       return "DW_CFA_def_cfa_sf";
 699     case DW_CFA_def_cfa_offset_sf:
 700       return "DW_CFA_def_cfa_offset_sf";
 701
 702     /* SGI/MIPS specific */
 703     case DW_CFA_MIPS_advance_loc8:
 704       return "DW_CFA_MIPS_advance_loc8";
 705
 706     /* GNU extensions */
 707     case DW_CFA_GNU_window_save:
 708       return "DW_CFA_GNU_window_save";
 709     case DW_CFA_GNU_args_size:
 710       return "DW_CFA_GNU_args_size";
 711     case DW_CFA_GNU_negative_offset_extended:
 712       return "DW_CFA_GNU_negative_offset_extended";
 713
 714     default:
 715       return "DW_CFA_<unknown>";
 716     }
 717 }
 718
 719 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 720
 721 static inline dw_cfi_ref
 722 new_cfi (void)
 723 {
 724   dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
 725
 726   cfi->dw_cfi_next = NULL;
 727   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 728   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 729
 730   return cfi;
 731 }
 732
 733 /* Add a Call Frame Instruction to list of instructions.  */
 734
 735 static inline void
 736 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 737 {
 738   dw_cfi_ref *p;
 739   dw_fde_ref fde = current_fde ();
 740
 741   /* When DRAP is used, CFA is defined with an expression.  Redefine
 742      CFA may lead to a different CFA value.   */
 743   /* ??? Of course, this heuristic fails when we're annotating epilogues,
 744      because of course we'll always want to redefine the CFA back to the
 745      stack pointer on the way out.  Where should we move this check?  */
 746   if (0 && fde && fde->drap_reg != INVALID_REGNUM)
 747     switch (cfi->dw_cfi_opc)
 748       {
 749         case DW_CFA_def_cfa_register:
 750         case DW_CFA_def_cfa_offset:
 751         case DW_CFA_def_cfa_offset_sf:
 752         case DW_CFA_def_cfa:
 753         case DW_CFA_def_cfa_sf:
 754           gcc_unreachable ();
 755
 756         default:
 757           break;
 758       }
 759
 760   /* Find the end of the chain.  */
 761   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 762     ;
 763
 764   *p = cfi;
 765 }
 766
 767 /* Generate a new label for the CFI info to refer to.  FORCE is true
 768    if a label needs to be output even when using .cfi_* directives.  */
 769
 770 char *
 771 dwarf2out_cfi_label (bool force)
 772 {
 773   static char label[20];
 774
 775   if (!force && dwarf2out_do_cfi_asm ())
 776     {
 777       /* In this case, we will be emitting the asm directive instead of
 778          the label, so just return a placeholder to keep the rest of the
 779          interfaces happy.  */
 780       strcpy (label, "<do not output>");
 781     }
 782   else
 783     {
 784       ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 785       ASM_OUTPUT_LABEL (asm_out_file, label);
 786     }
 787
 788   return label;
 789 }
 790
 791 /* True if remember_state should be emitted before following CFI directive.  */
 792 static bool emit_cfa_remember;
 793
 794 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 795    or to the CIE if LABEL is NULL.  */
 796
 797 static void
 798 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 799 {
 800   dw_cfi_ref *list_head;
 801
 802   if (emit_cfa_remember)
 803     {
 804       dw_cfi_ref cfi_remember;
 805
 806       /* Emit the state save.  */
 807       emit_cfa_remember = false;
 808       cfi_remember = new_cfi ();
 809       cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
 810       add_fde_cfi (label, cfi_remember);
 811     }
 812
 813   list_head = &cie_cfi_head;
 814
 815   if (dwarf2out_do_cfi_asm ())
 816     {
 817       if (label)
 818         {
 819           dw_fde_ref fde = current_fde ();
 820
 821           gcc_assert (fde != NULL);
 822
 823           /* We still have to add the cfi to the list so that lookup_cfa
 824              works later on.  When -g2 and above we even need to force
 825              emitting of CFI labels and add to list a DW_CFA_set_loc for
 826              convert_cfa_to_fb_loc_list purposes.  If we're generating
 827              DWARF3 output we use DW_OP_call_frame_cfa and so don't use
 828              convert_cfa_to_fb_loc_list.  */
 829           if (dwarf_version == 2
 830               && debug_info_level > DINFO_LEVEL_TERSE
 831               && (write_symbols == DWARF2_DEBUG
 832                   || write_symbols == VMS_AND_DWARF2_DEBUG))
 833             {
 834               switch (cfi->dw_cfi_opc)
 835                 {
 836                 case DW_CFA_def_cfa_offset:
 837                 case DW_CFA_def_cfa_offset_sf:
 838                 case DW_CFA_def_cfa_register:
 839                 case DW_CFA_def_cfa:
 840                 case DW_CFA_def_cfa_sf:
 841                 case DW_CFA_def_cfa_expression:
 842                 case DW_CFA_restore_state:
 843                   if (*label == 0 || strcmp (label, "<do not output>") == 0)
 844                     label = dwarf2out_cfi_label (true);
 845
 846                   if (fde->dw_fde_current_label == NULL
 847                       || strcmp (label, fde->dw_fde_current_label) != 0)
 848                     {
 849                       dw_cfi_ref xcfi;
 850
 851                       label = xstrdup (label);
 852
 853                       /* Set the location counter to the new label.  */
 854                       xcfi = new_cfi ();
 855                       /* It doesn't metter whether DW_CFA_set_loc
 856                          or DW_CFA_advance_loc4 is added here, those aren't
 857                          emitted into assembly, only looked up by
 858                          convert_cfa_to_fb_loc_list.  */
 859                       xcfi->dw_cfi_opc = DW_CFA_set_loc;
 860                       xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 861                       add_cfi (&fde->dw_fde_cfi, xcfi);
 862                       fde->dw_fde_current_label = label;
 863                     }
 864                   break;
 865                 default:
 866                   break;
 867                 }
 868             }
 869
 870           output_cfi_directive (cfi);
 871
 872           list_head = &fde->dw_fde_cfi;
 873         }
 874       /* ??? If this is a CFI for the CIE, we don't emit.  This
 875          assumes that the standard CIE contents that the assembler
 876          uses matches the standard CIE contents that the compiler
 877          uses.  This is probably a bad assumption.  I'm not quite
 878          sure how to address this for now.  */
 879     }
 880   else if (label)
 881     {
 882       dw_fde_ref fde = current_fde ();
 883
 884       gcc_assert (fde != NULL);
 885
 886       if (*label == 0)
 887         label = dwarf2out_cfi_label (false);
 888
 889       if (fde->dw_fde_current_label == NULL
 890           || strcmp (label, fde->dw_fde_current_label) != 0)
 891         {
 892           dw_cfi_ref xcfi;
 893
 894           label = xstrdup (label);
 895
 896           /* Set the location counter to the new label.  */
 897           xcfi = new_cfi ();
 898           /* If we have a current label, advance from there, otherwise
 899              set the location directly using set_loc.  */
 900           xcfi->dw_cfi_opc = fde->dw_fde_current_label
 901                              ? DW_CFA_advance_loc4
 902                              : DW_CFA_set_loc;
 903           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 904           add_cfi (&fde->dw_fde_cfi, xcfi);
 905
 906           fde->dw_fde_current_label = label;
 907         }
 908
 909       list_head = &fde->dw_fde_cfi;
 910     }
 911
 912   add_cfi (list_head, cfi);
 913 }
 914
 915 /* Subroutine of lookup_cfa.  */
 916
 917 static void
 918 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
 919 {
 920   switch (cfi->dw_cfi_opc)
 921     {
 922     case DW_CFA_def_cfa_offset:
 923     case DW_CFA_def_cfa_offset_sf:
 924       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 925       break;
 926     case DW_CFA_def_cfa_register:
 927       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 928       break;
 929     case DW_CFA_def_cfa:
 930     case DW_CFA_def_cfa_sf:
 931       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 932       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 933       break;
 934     case DW_CFA_def_cfa_expression:
 935       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 936       break;
 937
 938     case DW_CFA_remember_state:
 939       gcc_assert (!remember->in_use);
 940       *remember = *loc;
 941       remember->in_use = 1;
 942       break;
 943     case DW_CFA_restore_state:
 944       gcc_assert (remember->in_use);
 945       *loc = *remember;
 946       remember->in_use = 0;
 947       break;
 948
 949     default:
 950       break;
 951     }
 952 }
 953
 954 /* Find the previous value for the CFA.  */
 955
 956 static void
 957 lookup_cfa (dw_cfa_location *loc)
 958 {
 959   dw_cfi_ref cfi;
 960   dw_fde_ref fde;
 961   dw_cfa_location remember;
 962
 963   memset (loc, 0, sizeof (*loc));
 964   loc->reg = INVALID_REGNUM;
 965   remember = *loc;
 966
 967   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 968     lookup_cfa_1 (cfi, loc, &remember);
 969
 970   fde = current_fde ();
 971   if (fde)
 972     for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 973       lookup_cfa_1 (cfi, loc, &remember);
 974 }
 975
 976 /* The current rule for calculating the DWARF2 canonical frame address.  */
 977 static dw_cfa_location cfa;
 978
 979 /* The register used for saving registers to the stack, and its offset
 980    from the CFA.  */
 981 static dw_cfa_location cfa_store;
 982
 983 /* The current save location around an epilogue.  */
 984 static dw_cfa_location cfa_remember;
 985
 986 /* The running total of the size of arguments pushed onto the stack.  */
 987 static HOST_WIDE_INT args_size;
 988
 989 /* The last args_size we actually output.  */
 990 static HOST_WIDE_INT old_args_size;
 991
 992 /* Entry point to update the canonical frame address (CFA).
 993    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 994    calculated from REG+OFFSET.  */
 995
 996 void
 997 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 998 {
 999   dw_cfa_location loc;
1000   loc.indirect = 0;
1001   loc.base_offset = 0;
1002   loc.reg = reg;
1003   loc.offset = offset;
1004   def_cfa_1 (label, &loc);
1005 }
1006
1007 /* Determine if two dw_cfa_location structures define the same data.  */
1008
1009 static bool
1010 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1011 {
1012   return (loc1->reg == loc2->reg
1013           && loc1->offset == loc2->offset
1014           && loc1->indirect == loc2->indirect
1015           && (loc1->indirect == 0
1016               || loc1->base_offset == loc2->base_offset));
1017 }
1018
1019 /* This routine does the actual work.  The CFA is now calculated from
1020    the dw_cfa_location structure.  */
1021
1022 static void
1023 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1024 {
1025   dw_cfi_ref cfi;
1026   dw_cfa_location old_cfa, loc;
1027
1028   cfa = *loc_p;
1029   loc = *loc_p;
1030
1031   if (cfa_store.reg == loc.reg && loc.indirect == 0)
1032     cfa_store.offset = loc.offset;
1033
1034   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1035   lookup_cfa (&old_cfa);
1036
1037   /* If nothing changed, no need to issue any call frame instructions.  */
1038   if (cfa_equal_p (&loc, &old_cfa))
1039     return;
1040
1041   cfi = new_cfi ();
1042
1043   if (loc.reg == old_cfa.reg && !loc.indirect)
1044     {
1045       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1046          the CFA register did not change but the offset did.  The data
1047          factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1048          in the assembler via the .cfi_def_cfa_offset directive.  */
1049       if (loc.offset < 0)
1050         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1051       else
1052         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1053       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1054     }
1055
1056 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
1057   else if (loc.offset == old_cfa.offset
1058            && old_cfa.reg != INVALID_REGNUM
1059            && !loc.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)