OSDN Git Service

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