1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* Logical line numbers can be controlled by the compiler via the
27 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
28 [epilogue_begin] [is_stmt VALUE] [isa VALUE]
33 #include "safe-ctype.h"
38 #ifdef HAVE_SYS_PARAM_H
39 #include <sys/param.h>
42 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
46 #include "dwarf2dbg.h"
47 #include <filenames.h>
50 # define DWARF2_FORMAT() dwarf2_format_32bit
53 #ifndef DWARF2_ADDR_SIZE
54 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
59 #include "elf/dwarf2.h"
61 /* Since we can't generate the prolog until the body is complete, we
62 use three different subsegments for .debug_line: one holding the
63 prolog, one for the directory and filename info, and one for the
64 body ("statement program"). */
69 /* First special line opcde - leave room for the standard opcodes.
70 Note: If you want to change this, you'll have to update the
71 "standard_opcode_lengths" table that is emitted below in
73 #define DWARF2_LINE_OPCODE_BASE 13
75 #ifndef DWARF2_LINE_BASE
76 /* Minimum line offset in a special line info. opcode. This value
77 was chosen to give a reasonable range of values. */
78 # define DWARF2_LINE_BASE -5
81 /* Range of line offsets in a special line info. opcode. */
82 #ifndef DWARF2_LINE_RANGE
83 # define DWARF2_LINE_RANGE 14
86 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
87 /* Define the architecture-dependent minimum instruction length (in
88 bytes). This value should be rather too small than too big. */
89 # define DWARF2_LINE_MIN_INSN_LENGTH 1
92 /* Flag that indicates the initial value of the is_stmt_start flag. */
93 #define DWARF2_LINE_DEFAULT_IS_STMT 1
95 /* Given a special op, return the line skip amount. */
96 #define SPECIAL_LINE(op) \
97 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
99 /* Given a special op, return the address skip amount (in units of
100 DWARF2_LINE_MIN_INSN_LENGTH. */
101 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
103 /* The maximum address skip amount that can be encoded with a special op. */
104 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
107 struct line_entry
*next
;
109 struct dwarf2_line_info loc
;
113 struct line_subseg
*next
;
115 struct line_entry
*head
;
116 struct line_entry
**ptail
;
120 struct line_seg
*next
;
122 struct line_subseg
*head
;
127 /* Collects data for all line table entries during assembly. */
128 static struct line_seg
*all_segs
;
131 const char *filename
;
135 /* Table of files used by .debug_line. */
136 static struct file_entry
*files
;
137 static unsigned int files_in_use
;
138 static unsigned int files_allocated
;
140 /* Table of directories used by .debug_line. */
142 static unsigned int dirs_in_use
;
143 static unsigned int dirs_allocated
;
145 /* TRUE when we've seen a .loc directive recently. Used to avoid
146 doing work when there's nothing to do. */
147 static bfd_boolean loc_directive_seen
;
149 /* TRUE when we're supposed to set the basic block mark whenever a
151 bfd_boolean dwarf2_loc_mark_labels
;
153 /* Current location as indicated by the most recent .loc directive. */
154 static struct dwarf2_line_info current
= {
156 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0
159 /* The size of an address on the target. */
160 static unsigned int sizeof_address
;
162 static struct line_subseg
*get_line_subseg (segT
, subsegT
);
163 static unsigned int get_filenum (const char *, unsigned int);
164 static struct frag
*first_frag_for_seg (segT
);
165 static struct frag
*last_frag_for_seg (segT
);
166 static void out_byte (int);
167 static void out_opcode (int);
168 static void out_two (int);
169 static void out_four (int);
170 static void out_abbrev (int, int);
171 static void out_uleb128 (addressT
);
172 static offsetT
get_frag_fix (fragS
*);
173 static void out_set_addr (symbolS
*);
174 static int size_inc_line_addr (int, addressT
);
175 static void emit_inc_line_addr (int, addressT
, char *, int);
176 static void out_inc_line_addr (int, addressT
);
177 static void relax_inc_line_addr (int, symbolS
*, symbolS
*);
178 static void process_entries (segT
, struct line_entry
*);
179 static void out_file_list (void);
180 static void out_debug_line (segT
);
181 static void out_debug_aranges (segT
, segT
);
182 static void out_debug_abbrev (segT
);
183 static void out_debug_info (segT
, segT
, segT
);
185 #ifndef TC_DWARF2_EMIT_OFFSET
186 # define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
187 static void generic_dwarf2_emit_offset (symbolS
*, unsigned int);
189 /* Create an offset to .dwarf2_*. */
192 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
196 expr
.X_op
= O_symbol
;
197 expr
.X_add_symbol
= symbol
;
198 expr
.X_add_number
= 0;
199 emit_expr (&expr
, size
);
203 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
205 static struct line_subseg
*
206 get_line_subseg (segT seg
, subsegT subseg
)
208 static segT last_seg
;
209 static subsegT last_subseg
;
210 static struct line_subseg
*last_line_subseg
;
213 struct line_subseg
**pss
, *ss
;
215 if (seg
== last_seg
&& subseg
== last_subseg
)
216 return last_line_subseg
;
218 for (s
= all_segs
; s
; s
= s
->next
)
222 s
= (struct line_seg
*) xmalloc (sizeof (*s
));
229 for (pss
= &s
->head
; (ss
= *pss
) != NULL
; pss
= &ss
->next
)
231 if (ss
->subseg
== subseg
)
233 if (ss
->subseg
> subseg
)
237 ss
= (struct line_subseg
*) xmalloc (sizeof (*ss
));
241 ss
->ptail
= &ss
->head
;
246 last_subseg
= subseg
;
247 last_line_subseg
= ss
;
252 /* Record an entry for LOC occurring at LABEL. */
255 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
257 struct line_subseg
*ss
;
258 struct line_entry
*e
;
260 e
= (struct line_entry
*) xmalloc (sizeof (*e
));
265 ss
= get_line_subseg (now_seg
, now_subseg
);
267 ss
->ptail
= &e
->next
;
270 /* Record an entry for LOC occurring at OFS within the current fragment. */
273 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
275 static unsigned int line
= -1;
276 static unsigned int filenum
= -1;
280 /* Early out for as-yet incomplete location information. */
281 if (loc
->filenum
== 0 || loc
->line
== 0)
284 /* Don't emit sequences of line symbols for the same line when the
285 symbols apply to assembler code. It is necessary to emit
286 duplicate line symbols when a compiler asks for them, because GDB
287 uses them to determine the end of the prologue. */
288 if (debug_type
== DEBUG_DWARF2
289 && line
== loc
->line
&& filenum
== loc
->filenum
)
293 filenum
= loc
->filenum
;
295 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
296 dwarf2_gen_line_info_1 (sym
, loc
);
299 /* Returns the current source information. If .file directives have
300 been encountered, the info for the corresponding source file is
301 returned. Otherwise, the info for the assembly source file is
305 dwarf2_where (struct dwarf2_line_info
*line
)
307 if (debug_type
== DEBUG_DWARF2
)
310 as_where (&filename
, &line
->line
);
311 line
->filenum
= get_filenum (filename
, 0);
313 line
->flags
= DWARF2_FLAG_IS_STMT
;
314 line
->isa
= current
.isa
;
320 /* A hook to allow the target backend to inform the line number state
321 machine of isa changes when assembler debug info is enabled. */
324 dwarf2_set_isa (unsigned int isa
)
329 /* Called for each machine instruction, or relatively atomic group of
330 machine instructions (ie built-in macro). The instruction or group
331 is SIZE bytes in length. If dwarf2 line number generation is called
332 for, emit a line statement appropriately. */
335 dwarf2_emit_insn (int size
)
337 struct dwarf2_line_info loc
;
339 if (loc_directive_seen
)
341 /* Use the last location established by a .loc directive, not
342 the value returned by dwarf2_where(). That calls as_where()
343 which will return either the logical input file name (foo.c)
344 or the physical input file name (foo.s) and not the file name
345 specified in the most recent .loc directive (eg foo.h). */
348 /* Unless we generate DWARF2 debugging information for each
349 assembler line, we only emit one line symbol for one LOC. */
350 if (debug_type
!= DEBUG_DWARF2
)
351 loc_directive_seen
= FALSE
;
353 else if (debug_type
!= DEBUG_DWARF2
)
358 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
360 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
361 | DWARF2_FLAG_PROLOGUE_END
362 | DWARF2_FLAG_EPILOGUE_BEGIN
);
365 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
366 is enabled, emit a basic block marker. */
369 dwarf2_emit_label (symbolS
*label
)
371 struct dwarf2_line_info loc
;
373 if (!dwarf2_loc_mark_labels
)
375 if (S_GET_SEGMENT (label
) != now_seg
)
377 if (!(bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
))
380 if (debug_type
== DEBUG_DWARF2
)
385 loc_directive_seen
= FALSE
;
388 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
390 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
391 | DWARF2_FLAG_PROLOGUE_END
392 | DWARF2_FLAG_EPILOGUE_BEGIN
);
394 dwarf2_gen_line_info_1 (label
, &loc
);
397 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
398 allocate it on that file table slot, otherwise return the first
402 get_filenum (const char *filename
, unsigned int num
)
404 static unsigned int last_used
, last_used_dir_len
;
409 if (num
== 0 && last_used
)
411 if (! files
[last_used
].dir
412 && strcmp (filename
, files
[last_used
].filename
) == 0)
414 if (files
[last_used
].dir
415 && strncmp (filename
, dirs
[files
[last_used
].dir
],
416 last_used_dir_len
) == 0
417 && IS_DIR_SEPARATOR (filename
[last_used_dir_len
])
418 && strcmp (filename
+ last_used_dir_len
+ 1,
419 files
[last_used
].filename
) == 0)
423 file
= lbasename (filename
);
424 /* Don't make empty string from / or A: from A:/ . */
425 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
426 if (file
<= filename
+ 3)
429 if (file
== filename
+ 1)
432 dir_len
= file
- filename
;
438 for (dir
= 1; dir
< dirs_in_use
; ++dir
)
439 if (strncmp (filename
, dirs
[dir
], dir_len
) == 0
440 && dirs
[dir
][dir_len
] == '\0')
443 if (dir
>= dirs_in_use
)
445 if (dir
>= dirs_allocated
)
447 dirs_allocated
= dir
+ 32;
449 xrealloc (dirs
, (dir
+ 32) * sizeof (const char *));
452 dirs
[dir
] = xmalloc (dir_len
+ 1);
453 memcpy (dirs
[dir
], filename
, dir_len
);
454 dirs
[dir
][dir_len
] = '\0';
455 dirs_in_use
= dir
+ 1;
461 for (i
= 1; i
< files_in_use
; ++i
)
462 if (files
[i
].dir
== dir
464 && strcmp (file
, files
[i
].filename
) == 0)
467 last_used_dir_len
= dir_len
;
474 if (i
>= files_allocated
)
476 unsigned int old
= files_allocated
;
478 files_allocated
= i
+ 32;
479 files
= (struct file_entry
*)
480 xrealloc (files
, (i
+ 32) * sizeof (struct file_entry
));
482 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
485 files
[i
].filename
= num
? file
: xstrdup (file
);
487 files_in_use
= i
+ 1;
489 last_used_dir_len
= dir_len
;
494 /* Handle two forms of .file directive:
495 - Pass .file "source.c" to s_app_file
496 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
498 If an entry is added to the file table, return a pointer to the filename. */
501 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
507 /* Continue to accept a bare string and pass it off. */
509 if (*input_line_pointer
== '"')
515 num
= get_absolute_expression ();
516 filename
= demand_copy_C_string (&filename_len
);
517 if (filename
== NULL
)
519 demand_empty_rest_of_line ();
523 as_bad (_("file number less than one"));
527 if (num
< (int) files_in_use
&& files
[num
].filename
!= 0)
529 as_bad (_("file number %ld already allocated"), (long) num
);
533 get_filenum (filename
, num
);
539 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
541 offsetT filenum
, line
;
543 filenum
= get_absolute_expression ();
545 line
= get_absolute_expression ();
549 as_bad (_("file number less than one"));
552 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== 0)
554 as_bad (_("unassigned file number %ld"), (long) filenum
);
558 current
.filenum
= filenum
;
564 if (files
[filenum
].dir
)
566 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
567 size_t file_len
= strlen (files
[filenum
].filename
);
568 char *cp
= (char *) alloca (dir_len
+ 1 + file_len
+ 1);
570 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
572 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
573 cp
[dir_len
+ file_len
+ 1] = '\0';
574 listing_source_file (cp
);
577 listing_source_file (files
[filenum
].filename
);
578 listing_source_line (line
);
583 if (ISDIGIT (*input_line_pointer
))
585 current
.column
= get_absolute_expression ();
589 while (ISALPHA (*input_line_pointer
))
594 p
= input_line_pointer
;
595 c
= get_symbol_end ();
597 if (strcmp (p
, "basic_block") == 0)
599 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
600 *input_line_pointer
= c
;
602 else if (strcmp (p
, "prologue_end") == 0)
604 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
605 *input_line_pointer
= c
;
607 else if (strcmp (p
, "epilogue_begin") == 0)
609 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
610 *input_line_pointer
= c
;
612 else if (strcmp (p
, "is_stmt") == 0)
614 *input_line_pointer
= c
;
615 value
= get_absolute_expression ();
617 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
619 current
.flags
|= DWARF2_FLAG_IS_STMT
;
622 as_bad (_("is_stmt value not 0 or 1"));
626 else if (strcmp (p
, "isa") == 0)
628 *input_line_pointer
= c
;
629 value
= get_absolute_expression ();
634 as_bad (_("isa number less than zero"));
640 as_bad (_("unknown .loc sub-directive `%s'"), p
);
641 *input_line_pointer
= c
;
648 demand_empty_rest_of_line ();
649 loc_directive_seen
= TRUE
;
653 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
655 offsetT value
= get_absolute_expression ();
657 if (value
!= 0 && value
!= 1)
659 as_bad (_("expected 0 or 1"));
660 ignore_rest_of_line ();
664 dwarf2_loc_mark_labels
= value
!= 0;
665 demand_empty_rest_of_line ();
670 first_frag_for_seg (segT seg
)
672 frchainS
*f
, *first
= NULL
;
674 for (f
= frchain_root
; f
; f
= f
->frch_next
)
675 if (f
->frch_seg
== seg
676 && (! first
|| first
->frch_subseg
> f
->frch_subseg
))
679 return first
? first
->frch_root
: NULL
;
683 last_frag_for_seg (segT seg
)
685 frchainS
*f
, *last
= NULL
;
687 for (f
= frchain_root
; f
; f
= f
->frch_next
)
688 if (f
->frch_seg
== seg
689 && (! last
|| last
->frch_subseg
< f
->frch_subseg
))
692 return last
? last
->frch_last
: NULL
;
695 /* Emit a single byte into the current segment. */
700 FRAG_APPEND_1_CHAR (byte
);
703 /* Emit a statement program opcode into the current segment. */
711 /* Emit a two-byte word into the current segment. */
716 md_number_to_chars (frag_more (2), data
, 2);
719 /* Emit a four byte word into the current segment. */
724 md_number_to_chars (frag_more (4), data
, 4);
727 /* Emit an unsigned "little-endian base 128" number. */
730 out_uleb128 (addressT value
)
732 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
735 /* Emit a tuple for .debug_abbrev. */
738 out_abbrev (int name
, int form
)
744 /* Get the size of a fragment. */
747 get_frag_fix (fragS
*frag
)
754 /* If a fragment is the last in the chain, special measures must be
755 taken to find its size before relaxation, since it may be pending
756 on some subsegment chain. */
757 for (fr
= frchain_root
; fr
; fr
= fr
->frch_next
)
758 if (fr
->frch_last
== frag
)
759 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
764 /* Set an absolute address (may result in a relocation entry). */
767 out_set_addr (symbolS
*sym
)
771 out_opcode (DW_LNS_extended_op
);
772 out_uleb128 (sizeof_address
+ 1);
774 out_opcode (DW_LNE_set_address
);
775 expr
.X_op
= O_symbol
;
776 expr
.X_add_symbol
= sym
;
777 expr
.X_add_number
= 0;
778 emit_expr (&expr
, sizeof_address
);
781 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
782 static void scale_addr_delta (addressT
*);
785 scale_addr_delta (addressT
*addr_delta
)
787 static int printed_this
= 0;
788 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0)
791 as_bad("unaligned opcodes detected in executable segment");
794 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
797 #define scale_addr_delta(A)
800 /* Encode a pair of line and address skips as efficiently as possible.
801 Note that the line skip is signed, whereas the address skip is unsigned.
803 The following two routines *must* be kept in sync. This is
804 enforced by making emit_inc_line_addr abort if we do not emit
805 exactly the expected number of bytes. */
808 size_inc_line_addr (int line_delta
, addressT addr_delta
)
810 unsigned int tmp
, opcode
;
813 /* Scale the address delta by the minimum instruction length. */
814 scale_addr_delta (&addr_delta
);
816 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
817 We cannot use special opcodes here, since we want the end_sequence
818 to emit the matrix entry. */
819 if (line_delta
== INT_MAX
)
821 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
824 len
= 1 + sizeof_leb128 (addr_delta
, 0);
828 /* Bias the line delta by the base. */
829 tmp
= line_delta
- DWARF2_LINE_BASE
;
831 /* If the line increment is out of range of a special opcode, we
832 must encode it with DW_LNS_advance_line. */
833 if (tmp
>= DWARF2_LINE_RANGE
)
835 len
= 1 + sizeof_leb128 (line_delta
, 1);
837 tmp
= 0 - DWARF2_LINE_BASE
;
840 /* Bias the opcode by the special opcode base. */
841 tmp
+= DWARF2_LINE_OPCODE_BASE
;
843 /* Avoid overflow when addr_delta is large. */
844 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
846 /* Try using a special opcode. */
847 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
851 /* Try using DW_LNS_const_add_pc followed by special op. */
852 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
857 /* Otherwise use DW_LNS_advance_pc. */
858 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
860 /* DW_LNS_copy or special opcode. */
867 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
869 unsigned int tmp
, opcode
;
873 /* Line number sequences cannot go backward in addresses. This means
874 we've incorrectly ordered the statements in the sequence. */
875 assert ((offsetT
) addr_delta
>= 0);
877 /* Scale the address delta by the minimum instruction length. */
878 scale_addr_delta (&addr_delta
);
880 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
881 We cannot use special opcodes here, since we want the end_sequence
882 to emit the matrix entry. */
883 if (line_delta
== INT_MAX
)
885 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
886 *p
++ = DW_LNS_const_add_pc
;
889 *p
++ = DW_LNS_advance_pc
;
890 p
+= output_leb128 (p
, addr_delta
, 0);
893 *p
++ = DW_LNS_extended_op
;
895 *p
++ = DW_LNE_end_sequence
;
899 /* Bias the line delta by the base. */
900 tmp
= line_delta
- DWARF2_LINE_BASE
;
902 /* If the line increment is out of range of a special opcode, we
903 must encode it with DW_LNS_advance_line. */
904 if (tmp
>= DWARF2_LINE_RANGE
)
906 *p
++ = DW_LNS_advance_line
;
907 p
+= output_leb128 (p
, line_delta
, 1);
910 tmp
= 0 - DWARF2_LINE_BASE
;
914 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
916 if (line_delta
== 0 && addr_delta
== 0)
922 /* Bias the opcode by the special opcode base. */
923 tmp
+= DWARF2_LINE_OPCODE_BASE
;
925 /* Avoid overflow when addr_delta is large. */
926 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
928 /* Try using a special opcode. */
929 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
936 /* Try using DW_LNS_const_add_pc followed by special op. */
937 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
940 *p
++ = DW_LNS_const_add_pc
;
946 /* Otherwise use DW_LNS_advance_pc. */
947 *p
++ = DW_LNS_advance_pc
;
948 p
+= output_leb128 (p
, addr_delta
, 0);
959 /* Handy routine to combine calls to the above two routines. */
962 out_inc_line_addr (int line_delta
, addressT addr_delta
)
964 int len
= size_inc_line_addr (line_delta
, addr_delta
);
965 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
968 /* Generate a variant frag that we can use to relax address/line
969 increments between fragments of the target segment. */
972 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
977 expr
.X_op
= O_subtract
;
978 expr
.X_add_symbol
= to_sym
;
979 expr
.X_op_symbol
= from_sym
;
980 expr
.X_add_number
= 0;
982 /* The maximum size of the frag is the line delta with a maximum
983 sized address delta. */
984 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
986 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
987 make_expr_symbol (&expr
), line_delta
, NULL
);
990 /* The function estimates the size of a rs_dwarf2dbg variant frag
991 based on the current values of the symbols. It is called before
992 the relaxation loop. We set fr_subtype to the expected length. */
995 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1000 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1001 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1003 frag
->fr_subtype
= size
;
1008 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1009 current values of the symbols. fr_subtype is the current length
1010 of the frag. This returns the change in frag length. */
1013 dwarf2dbg_relax_frag (fragS
*frag
)
1015 int old_size
, new_size
;
1017 old_size
= frag
->fr_subtype
;
1018 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1020 return new_size
- old_size
;
1023 /* This function converts a rs_dwarf2dbg variant frag into a normal
1024 fill frag. This is called after all relaxation has been done.
1025 fr_subtype will be the desired length of the frag. */
1028 dwarf2dbg_convert_frag (fragS
*frag
)
1032 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1034 /* fr_var carries the max_chars that we created the fragment with.
1035 fr_subtype carries the current expected length. We must, of
1036 course, have allocated enough memory earlier. */
1037 assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1039 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1040 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1042 frag
->fr_fix
+= frag
->fr_subtype
;
1043 frag
->fr_type
= rs_fill
;
1045 frag
->fr_offset
= 0;
1048 /* Generate .debug_line content for the chain of line number entries
1049 beginning at E, for segment SEG. */
1052 process_entries (segT seg
, struct line_entry
*e
)
1054 unsigned filenum
= 1;
1056 unsigned column
= 0;
1058 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1059 fragS
*last_frag
= NULL
, *frag
;
1060 addressT last_frag_ofs
= 0, frag_ofs
;
1061 symbolS
*last_lab
, *lab
;
1062 struct line_entry
*next
;
1068 if (filenum
!= e
->loc
.filenum
)
1070 filenum
= e
->loc
.filenum
;
1071 out_opcode (DW_LNS_set_file
);
1072 out_uleb128 (filenum
);
1075 if (column
!= e
->loc
.column
)
1077 column
= e
->loc
.column
;
1078 out_opcode (DW_LNS_set_column
);
1079 out_uleb128 (column
);
1082 if (isa
!= e
->loc
.isa
)
1085 out_opcode (DW_LNS_set_isa
);
1089 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1091 flags
= e
->loc
.flags
;
1092 out_opcode (DW_LNS_negate_stmt
);
1095 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1096 out_opcode (DW_LNS_set_basic_block
);
1098 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1099 out_opcode (DW_LNS_set_prologue_end
);
1101 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1102 out_opcode (DW_LNS_set_epilogue_begin
);
1104 /* Don't try to optimize away redundant entries; gdb wants two
1105 entries for a function where the code starts on the same line as
1106 the {, and there's no way to identify that case here. Trust gcc
1107 to optimize appropriately. */
1108 line_delta
= e
->loc
.line
- line
;
1110 frag
= symbol_get_frag (lab
);
1111 frag_ofs
= S_GET_VALUE (lab
);
1113 if (last_frag
== NULL
)
1116 out_inc_line_addr (line_delta
, 0);
1118 else if (frag
== last_frag
)
1119 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1121 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1126 last_frag_ofs
= frag_ofs
;
1133 /* Emit a DW_LNE_end_sequence for the end of the section. */
1134 frag
= last_frag_for_seg (seg
);
1135 frag_ofs
= get_frag_fix (frag
);
1136 if (frag
== last_frag
)
1137 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1140 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1141 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1145 /* Emit the directory and file tables for .debug_line. */
1148 out_file_list (void)
1154 /* Emit directory list. */
1155 for (i
= 1; i
< dirs_in_use
; ++i
)
1157 size
= strlen (dirs
[i
]) + 1;
1158 cp
= frag_more (size
);
1159 memcpy (cp
, dirs
[i
], size
);
1164 for (i
= 1; i
< files_in_use
; ++i
)
1166 if (files
[i
].filename
== NULL
)
1168 as_bad (_("unassigned file number %ld"), (long) i
);
1169 /* Prevent a crash later, particularly for file 1. */
1170 files
[i
].filename
= "";
1174 size
= strlen (files
[i
].filename
) + 1;
1175 cp
= frag_more (size
);
1176 memcpy (cp
, files
[i
].filename
, size
);
1178 out_uleb128 (files
[i
].dir
); /* directory number */
1179 out_uleb128 (0); /* last modification timestamp */
1180 out_uleb128 (0); /* filesize */
1183 /* Terminate filename list. */
1187 /* Emit the collected .debug_line data. */
1190 out_debug_line (segT line_seg
)
1193 symbolS
*line_start
;
1194 symbolS
*prologue_end
;
1197 enum dwarf2_format d2f
;
1200 subseg_set (line_seg
, 0);
1202 line_start
= symbol_temp_new_now ();
1203 prologue_end
= symbol_temp_make ();
1204 line_end
= symbol_temp_make ();
1206 /* Total length of the information for this compilation unit. */
1207 expr
.X_op
= O_subtract
;
1208 expr
.X_add_symbol
= line_end
;
1209 expr
.X_op_symbol
= line_start
;
1211 d2f
= DWARF2_FORMAT ();
1212 if (d2f
== dwarf2_format_32bit
)
1214 expr
.X_add_number
= -4;
1215 emit_expr (&expr
, 4);
1218 else if (d2f
== dwarf2_format_64bit
)
1220 expr
.X_add_number
= -12;
1222 emit_expr (&expr
, 8);
1225 else if (d2f
== dwarf2_format_64bit_irix
)
1227 expr
.X_add_number
= -8;
1228 emit_expr (&expr
, 8);
1233 as_fatal (_("internal error: unknown dwarf2 format"));
1239 /* Length of the prologue following this length. */
1240 expr
.X_op
= O_subtract
;
1241 expr
.X_add_symbol
= prologue_end
;
1242 expr
.X_op_symbol
= line_start
;
1243 expr
.X_add_number
= - (4 + 2 + 4);
1244 emit_expr (&expr
, sizeof_offset
);
1246 /* Parameters of the state machine. */
1247 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
1248 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
1249 out_byte (DWARF2_LINE_BASE
);
1250 out_byte (DWARF2_LINE_RANGE
);
1251 out_byte (DWARF2_LINE_OPCODE_BASE
);
1253 /* Standard opcode lengths. */
1254 out_byte (0); /* DW_LNS_copy */
1255 out_byte (1); /* DW_LNS_advance_pc */
1256 out_byte (1); /* DW_LNS_advance_line */
1257 out_byte (1); /* DW_LNS_set_file */
1258 out_byte (1); /* DW_LNS_set_column */
1259 out_byte (0); /* DW_LNS_negate_stmt */
1260 out_byte (0); /* DW_LNS_set_basic_block */
1261 out_byte (0); /* DW_LNS_const_add_pc */
1262 out_byte (1); /* DW_LNS_fixed_advance_pc */
1263 out_byte (0); /* DW_LNS_set_prologue_end */
1264 out_byte (0); /* DW_LNS_set_epilogue_begin */
1265 out_byte (1); /* DW_LNS_set_isa */
1269 symbol_set_value_now (prologue_end
);
1271 /* For each section, emit a statement program. */
1272 for (s
= all_segs
; s
; s
= s
->next
)
1273 process_entries (s
->seg
, s
->head
->head
);
1275 symbol_set_value_now (line_end
);
1278 /* Emit data for .debug_aranges. */
1281 out_debug_aranges (segT aranges_seg
, segT info_seg
)
1283 unsigned int addr_size
= sizeof_address
;
1284 addressT size
, skip
;
1289 size
= 4 + 2 + 4 + 1 + 1;
1291 skip
= 2 * addr_size
- (size
& (2 * addr_size
- 1));
1292 if (skip
== 2 * addr_size
)
1296 for (s
= all_segs
; s
; s
= s
->next
)
1297 size
+= 2 * addr_size
;
1299 size
+= 2 * addr_size
;
1301 subseg_set (aranges_seg
, 0);
1303 /* Length of the compilation unit. */
1304 out_four (size
- 4);
1309 /* Offset to .debug_info. */
1310 /* ??? sizeof_offset */
1311 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), 4);
1313 /* Size of an address (offset portion). */
1314 out_byte (addr_size
);
1316 /* Size of a segment descriptor. */
1319 /* Align the header. */
1321 frag_align (ffs (2 * addr_size
) - 1, 0, 0);
1323 for (s
= all_segs
; s
; s
= s
->next
)
1328 frag
= first_frag_for_seg (s
->seg
);
1329 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1330 s
->text_start
= beg
;
1332 frag
= last_frag_for_seg (s
->seg
);
1333 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
), frag
);
1336 expr
.X_op
= O_symbol
;
1337 expr
.X_add_symbol
= beg
;
1338 expr
.X_add_number
= 0;
1339 emit_expr (&expr
, addr_size
);
1341 expr
.X_op
= O_subtract
;
1342 expr
.X_add_symbol
= end
;
1343 expr
.X_op_symbol
= beg
;
1344 expr
.X_add_number
= 0;
1345 emit_expr (&expr
, addr_size
);
1348 p
= frag_more (2 * addr_size
);
1349 md_number_to_chars (p
, 0, addr_size
);
1350 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1353 /* Emit data for .debug_abbrev. Note that this must be kept in
1354 sync with out_debug_info below. */
1357 out_debug_abbrev (segT abbrev_seg
)
1359 subseg_set (abbrev_seg
, 0);
1362 out_uleb128 (DW_TAG_compile_unit
);
1363 out_byte (DW_CHILDREN_no
);
1364 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1365 if (all_segs
->next
== NULL
)
1367 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1368 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1370 out_abbrev (DW_AT_name
, DW_FORM_string
);
1371 out_abbrev (DW_AT_comp_dir
, DW_FORM_string
);
1372 out_abbrev (DW_AT_producer
, DW_FORM_string
);
1373 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1376 /* Terminate the abbreviations for this compilation unit. */
1380 /* Emit a description of this compilation unit for .debug_info. */
1383 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
)
1388 symbolS
*info_start
;
1392 enum dwarf2_format d2f
;
1395 subseg_set (info_seg
, 0);
1397 info_start
= symbol_temp_new_now ();
1398 info_end
= symbol_temp_make ();
1400 /* Compilation Unit length. */
1401 expr
.X_op
= O_subtract
;
1402 expr
.X_add_symbol
= info_end
;
1403 expr
.X_op_symbol
= info_start
;
1405 d2f
= DWARF2_FORMAT ();
1406 if (d2f
== dwarf2_format_32bit
)
1408 expr
.X_add_number
= -4;
1409 emit_expr (&expr
, 4);
1412 else if (d2f
== dwarf2_format_64bit
)
1414 expr
.X_add_number
= -12;
1416 emit_expr (&expr
, 8);
1419 else if (d2f
== dwarf2_format_64bit_irix
)
1421 expr
.X_add_number
= -8;
1422 emit_expr (&expr
, 8);
1427 as_fatal (_("internal error: unknown dwarf2 format"));
1430 /* DWARF version. */
1433 /* .debug_abbrev offset */
1434 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
1436 /* Target address size. */
1437 out_byte (sizeof_address
);
1439 /* DW_TAG_compile_unit DIE abbrev */
1442 /* DW_AT_stmt_list */
1443 /* ??? sizeof_offset */
1444 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
), 4);
1446 /* These two attributes may only be emitted if all of the code is
1447 contiguous. Multiple sections are not that. */
1448 if (all_segs
->next
== NULL
)
1451 expr
.X_op
= O_symbol
;
1452 expr
.X_add_symbol
= all_segs
->text_start
;
1453 expr
.X_add_number
= 0;
1454 emit_expr (&expr
, sizeof_address
);
1457 expr
.X_op
= O_symbol
;
1458 expr
.X_add_symbol
= all_segs
->text_end
;
1459 expr
.X_add_number
= 0;
1460 emit_expr (&expr
, sizeof_address
);
1463 /* DW_AT_name. We don't have the actual file name that was present
1464 on the command line, so assume files[1] is the main input file.
1465 We're not supposed to get called unless at least one line number
1466 entry was emitted, so this should always be defined. */
1467 if (!files
|| files_in_use
< 1)
1471 len
= strlen (dirs
[files
[1].dir
]);
1472 p
= frag_more (len
+ 1);
1473 memcpy (p
, dirs
[files
[1].dir
], len
);
1476 len
= strlen (files
[1].filename
) + 1;
1477 p
= frag_more (len
);
1478 memcpy (p
, files
[1].filename
, len
);
1480 /* DW_AT_comp_dir */
1481 comp_dir
= getpwd ();
1482 len
= strlen (comp_dir
) + 1;
1483 p
= frag_more (len
);
1484 memcpy (p
, comp_dir
, len
);
1486 /* DW_AT_producer */
1487 sprintf (producer
, "GNU AS %s", VERSION
);
1488 len
= strlen (producer
) + 1;
1489 p
= frag_more (len
);
1490 memcpy (p
, producer
, len
);
1492 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1493 dwarf2 draft has no standard code for assembler. */
1494 out_two (DW_LANG_Mips_Assembler
);
1496 symbol_set_value_now (info_end
);
1499 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1500 were any .file/.loc directives, or --gdwarf2 was given, or if the
1501 file has a non-empty .debug_info section. If we emit .debug_line,
1502 and the .debug_info section is empty, we also emit .debug_info,
1503 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1504 there were any .file/.loc directives, or --gdwarf2 was given and
1505 there were any located instructions emitted. */
1508 dwarf2_finish (void)
1513 int emit_other_sections
= 0;
1515 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
1516 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
1518 if (!all_segs
&& emit_other_sections
)
1519 /* There is no line information and no non-empty .debug_info
1523 /* Calculate the size of an address for the target machine. */
1524 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
1526 /* Create and switch to the line number section. */
1527 line_seg
= subseg_new (".debug_line", 0);
1528 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
| SEC_DEBUGGING
);
1530 /* For each subsection, chain the debug entries together. */
1531 for (s
= all_segs
; s
; s
= s
->next
)
1533 struct line_subseg
*ss
= s
->head
;
1534 struct line_entry
**ptail
= ss
->ptail
;
1536 while ((ss
= ss
->next
) != NULL
)
1543 out_debug_line (line_seg
);
1545 /* If this is assembler generated line info, and there is no
1546 debug_info already, we need .debug_info and .debug_abbrev
1547 sections as well. */
1548 if (emit_other_sections
)
1555 info_seg
= subseg_new (".debug_info", 0);
1556 abbrev_seg
= subseg_new (".debug_abbrev", 0);
1557 aranges_seg
= subseg_new (".debug_aranges", 0);
1559 bfd_set_section_flags (stdoutput
, info_seg
,
1560 SEC_READONLY
| SEC_DEBUGGING
);
1561 bfd_set_section_flags (stdoutput
, abbrev_seg
,
1562 SEC_READONLY
| SEC_DEBUGGING
);
1563 bfd_set_section_flags (stdoutput
, aranges_seg
,
1564 SEC_READONLY
| SEC_DEBUGGING
);
1566 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
1568 out_debug_aranges (aranges_seg
, info_seg
);
1569 out_debug_abbrev (abbrev_seg
);
1570 out_debug_info (info_seg
, abbrev_seg
, line_seg
);