OSDN Git Service

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