OSDN Git Service

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