1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2016 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION 2
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation output version 2 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION 2
109 /* Since we can't generate the prolog until the body is complete, we
110 use three different subsegments for .debug_line: one holding the
111 prolog, one for the directory and filename info, and one for the
112 body ("statement program"). */
117 /* If linker relaxation might change offsets in the code, the DWARF special
118 opcodes and variable-length operands cannot be used. If this macro is
119 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
120 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
121 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
124 /* First special line opcde - leave room for the standard opcodes.
125 Note: If you want to change this, you'll have to update the
126 "standard_opcode_lengths" table that is emitted below in
128 #define DWARF2_LINE_OPCODE_BASE 13
130 #ifndef DWARF2_LINE_BASE
131 /* Minimum line offset in a special line info. opcode. This value
132 was chosen to give a reasonable range of values. */
133 # define DWARF2_LINE_BASE -5
136 /* Range of line offsets in a special line info. opcode. */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE 14
141 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
142 /* Define the architecture-dependent minimum instruction length (in
143 bytes). This value should be rather too small than too big. */
144 # define DWARF2_LINE_MIN_INSN_LENGTH 1
147 /* Flag that indicates the initial value of the is_stmt_start flag. */
148 #define DWARF2_LINE_DEFAULT_IS_STMT 1
150 /* Given a special op, return the line skip amount. */
151 #define SPECIAL_LINE(op) \
152 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
154 /* Given a special op, return the address skip amount (in units of
155 DWARF2_LINE_MIN_INSN_LENGTH. */
156 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
158 /* The maximum address skip amount that can be encoded with a special op. */
159 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
161 #ifndef TC_PARSE_CONS_RETURN_NONE
162 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
166 struct line_entry
*next
;
168 struct dwarf2_line_info loc
;
172 struct line_subseg
*next
;
174 struct line_entry
*head
;
175 struct line_entry
**ptail
;
176 struct line_entry
**pmove_tail
;
180 struct line_seg
*next
;
182 struct line_subseg
*head
;
187 /* Collects data for all line table entries during assembly. */
188 static struct line_seg
*all_segs
;
189 static struct line_seg
**last_seg_ptr
;
192 const char *filename
;
196 /* Table of files used by .debug_line. */
197 static struct file_entry
*files
;
198 static unsigned int files_in_use
;
199 static unsigned int files_allocated
;
201 /* Table of directories used by .debug_line. */
203 static unsigned int dirs_in_use
;
204 static unsigned int dirs_allocated
;
206 /* TRUE when we've seen a .loc directive recently. Used to avoid
207 doing work when there's nothing to do. */
208 bfd_boolean dwarf2_loc_directive_seen
;
210 /* TRUE when we're supposed to set the basic block mark whenever a
212 bfd_boolean dwarf2_loc_mark_labels
;
214 /* Current location as indicated by the most recent .loc directive. */
215 static struct dwarf2_line_info current
= {
217 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
221 /* The size of an address on the target. */
222 static unsigned int sizeof_address
;
224 static unsigned int get_filenum (const char *, unsigned int);
226 #ifndef TC_DWARF2_EMIT_OFFSET
227 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
229 /* Create an offset to .dwarf2_*. */
232 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
237 exp
.X_add_symbol
= symbol
;
238 exp
.X_add_number
= 0;
239 emit_expr (&exp
, size
);
243 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
245 static struct line_subseg
*
246 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
248 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
249 struct line_subseg
**pss
, *lss
;
256 s
= XNEW (struct line_seg
);
261 last_seg_ptr
= &s
->next
;
262 seg_info (seg
)->dwarf2_line_seg
= s
;
264 gas_assert (seg
== s
->seg
);
266 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
268 if (lss
->subseg
== subseg
)
270 if (lss
->subseg
> subseg
)
274 lss
= XNEW (struct line_subseg
);
276 lss
->subseg
= subseg
;
278 lss
->ptail
= &lss
->head
;
279 lss
->pmove_tail
= &lss
->head
;
286 /* Record an entry for LOC occurring at LABEL. */
289 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
291 struct line_subseg
*lss
;
292 struct line_entry
*e
;
294 e
= XNEW (struct line_entry
);
299 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
301 lss
->ptail
= &e
->next
;
304 /* Record an entry for LOC occurring at OFS within the current fragment. */
307 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
309 static unsigned int line
= -1;
310 static unsigned int filenum
= -1;
314 /* Early out for as-yet incomplete location information. */
315 if (loc
->filenum
== 0 || loc
->line
== 0)
318 /* Don't emit sequences of line symbols for the same line when the
319 symbols apply to assembler code. It is necessary to emit
320 duplicate line symbols when a compiler asks for them, because GDB
321 uses them to determine the end of the prologue. */
322 if (debug_type
== DEBUG_DWARF2
323 && line
== loc
->line
&& filenum
== loc
->filenum
)
327 filenum
= loc
->filenum
;
333 /* Use a non-fake name for the line number location,
334 so that it can be referred to by relocations. */
335 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
336 sym
= symbol_new (name
, now_seg
, ofs
, frag_now
);
339 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
340 dwarf2_gen_line_info_1 (sym
, loc
);
343 /* Returns the current source information. If .file directives have
344 been encountered, the info for the corresponding source file is
345 returned. Otherwise, the info for the assembly source file is
349 dwarf2_where (struct dwarf2_line_info
*line
)
351 if (debug_type
== DEBUG_DWARF2
)
353 const char *filename
= as_where (&line
->line
);
354 line
->filenum
= get_filenum (filename
, 0);
356 line
->flags
= DWARF2_FLAG_IS_STMT
;
357 line
->isa
= current
.isa
;
358 line
->discriminator
= current
.discriminator
;
364 /* A hook to allow the target backend to inform the line number state
365 machine of isa changes when assembler debug info is enabled. */
368 dwarf2_set_isa (unsigned int isa
)
373 /* Called for each machine instruction, or relatively atomic group of
374 machine instructions (ie built-in macro). The instruction or group
375 is SIZE bytes in length. If dwarf2 line number generation is called
376 for, emit a line statement appropriately. */
379 dwarf2_emit_insn (int size
)
381 struct dwarf2_line_info loc
;
383 if (!dwarf2_loc_directive_seen
&& debug_type
!= DEBUG_DWARF2
)
388 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
389 dwarf2_consume_line_info ();
392 /* Move all previously-emitted line entries for the current position by
393 DELTA bytes. This function cannot be used to move the same entries
397 dwarf2_move_insn (int delta
)
399 struct line_subseg
*lss
;
400 struct line_entry
*e
;
406 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
410 now
= frag_now_fix ();
411 while ((e
= *lss
->pmove_tail
))
413 if (S_GET_VALUE (e
->label
) == now
)
414 S_SET_VALUE (e
->label
, now
+ delta
);
415 lss
->pmove_tail
= &e
->next
;
419 /* Called after the current line information has been either used with
420 dwarf2_gen_line_info or saved with a machine instruction for later use.
421 This resets the state of the line number information to reflect that
425 dwarf2_consume_line_info (void)
427 /* Unless we generate DWARF2 debugging information for each
428 assembler line, we only emit one line symbol for one LOC. */
429 dwarf2_loc_directive_seen
= FALSE
;
431 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
432 | DWARF2_FLAG_PROLOGUE_END
433 | DWARF2_FLAG_EPILOGUE_BEGIN
);
434 current
.discriminator
= 0;
437 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
438 is enabled, emit a basic block marker. */
441 dwarf2_emit_label (symbolS
*label
)
443 struct dwarf2_line_info loc
;
445 if (!dwarf2_loc_mark_labels
)
447 if (S_GET_SEGMENT (label
) != now_seg
)
449 if (!(bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
))
451 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
456 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
458 dwarf2_gen_line_info_1 (label
, &loc
);
459 dwarf2_consume_line_info ();
462 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
463 allocate it on that file table slot, otherwise return the first
467 get_filenum (const char *filename
, unsigned int num
)
469 static unsigned int last_used
, last_used_dir_len
;
474 if (num
== 0 && last_used
)
476 if (! files
[last_used
].dir
477 && filename_cmp (filename
, files
[last_used
].filename
) == 0)
479 if (files
[last_used
].dir
480 && filename_ncmp (filename
, dirs
[files
[last_used
].dir
],
481 last_used_dir_len
) == 0
482 && IS_DIR_SEPARATOR (filename
[last_used_dir_len
])
483 && filename_cmp (filename
+ last_used_dir_len
+ 1,
484 files
[last_used
].filename
) == 0)
488 file
= lbasename (filename
);
489 /* Don't make empty string from / or A: from A:/ . */
490 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
491 if (file
<= filename
+ 3)
494 if (file
== filename
+ 1)
497 dir_len
= file
- filename
;
502 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
505 for (dir
= 1; dir
< dirs_in_use
; ++dir
)
506 if (filename_ncmp (filename
, dirs
[dir
], dir_len
) == 0
507 && dirs
[dir
][dir_len
] == '\0')
510 if (dir
>= dirs_in_use
)
512 if (dir
>= dirs_allocated
)
514 dirs_allocated
= dir
+ 32;
515 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
518 dirs
[dir
] = (char *) xmalloc (dir_len
+ 1);
519 memcpy (dirs
[dir
], filename
, dir_len
);
520 dirs
[dir
][dir_len
] = '\0';
521 dirs_in_use
= dir
+ 1;
527 for (i
= 1; i
< files_in_use
; ++i
)
528 if (files
[i
].dir
== dir
530 && filename_cmp (file
, files
[i
].filename
) == 0)
533 last_used_dir_len
= dir_len
;
540 if (i
>= files_allocated
)
542 unsigned int old
= files_allocated
;
544 files_allocated
= i
+ 32;
545 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
547 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
550 files
[i
].filename
= num
? file
: xstrdup (file
);
552 if (files_in_use
< i
+ 1)
553 files_in_use
= i
+ 1;
555 last_used_dir_len
= dir_len
;
560 /* Handle two forms of .file directive:
561 - Pass .file "source.c" to s_app_file
562 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
564 If an entry is added to the file table, return a pointer to the filename. */
567 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
573 /* Continue to accept a bare string and pass it off. */
575 if (*input_line_pointer
== '"')
581 num
= get_absolute_expression ();
582 filename
= demand_copy_C_string (&filename_len
);
583 if (filename
== NULL
)
585 demand_empty_rest_of_line ();
589 as_bad (_("file number less than one"));
593 /* A .file directive implies compiler generated debug information is
594 being supplied. Turn off gas generated debug info. */
595 debug_type
= DEBUG_NONE
;
597 if (num
< (int) files_in_use
&& files
[num
].filename
!= 0)
599 as_bad (_("file number %ld already allocated"), (long) num
);
603 get_filenum (filename
, num
);
609 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
611 offsetT filenum
, line
;
613 /* If we see two .loc directives in a row, force the first one to be
615 if (dwarf2_loc_directive_seen
)
616 dwarf2_emit_insn (0);
618 filenum
= get_absolute_expression ();
620 line
= get_absolute_expression ();
624 as_bad (_("file number less than one"));
627 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== 0)
629 as_bad (_("unassigned file number %ld"), (long) filenum
);
633 current
.filenum
= filenum
;
635 current
.discriminator
= 0;
640 if (files
[filenum
].dir
)
642 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
643 size_t file_len
= strlen (files
[filenum
].filename
);
644 char *cp
= (char *) xmalloc (dir_len
+ 1 + file_len
+ 1);
646 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
647 INSERT_DIR_SEPARATOR (cp
, dir_len
);
648 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
649 cp
[dir_len
+ file_len
+ 1] = '\0';
650 listing_source_file (cp
);
654 listing_source_file (files
[filenum
].filename
);
655 listing_source_line (line
);
660 if (ISDIGIT (*input_line_pointer
))
662 current
.column
= get_absolute_expression ();
666 while (ISALPHA (*input_line_pointer
))
671 c
= get_symbol_name (& p
);
673 if (strcmp (p
, "basic_block") == 0)
675 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
676 *input_line_pointer
= c
;
678 else if (strcmp (p
, "prologue_end") == 0)
680 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
681 *input_line_pointer
= c
;
683 else if (strcmp (p
, "epilogue_begin") == 0)
685 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
686 *input_line_pointer
= c
;
688 else if (strcmp (p
, "is_stmt") == 0)
690 (void) restore_line_pointer (c
);
691 value
= get_absolute_expression ();
693 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
695 current
.flags
|= DWARF2_FLAG_IS_STMT
;
698 as_bad (_("is_stmt value not 0 or 1"));
702 else if (strcmp (p
, "isa") == 0)
704 (void) restore_line_pointer (c
);
705 value
= get_absolute_expression ();
710 as_bad (_("isa number less than zero"));
714 else if (strcmp (p
, "discriminator") == 0)
716 (void) restore_line_pointer (c
);
717 value
= get_absolute_expression ();
719 current
.discriminator
= value
;
722 as_bad (_("discriminator less than zero"));
728 as_bad (_("unknown .loc sub-directive `%s'"), p
);
729 (void) restore_line_pointer (c
);
733 SKIP_WHITESPACE_AFTER_NAME ();
736 demand_empty_rest_of_line ();
737 dwarf2_loc_directive_seen
= TRUE
;
738 debug_type
= DEBUG_NONE
;
742 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
744 offsetT value
= get_absolute_expression ();
746 if (value
!= 0 && value
!= 1)
748 as_bad (_("expected 0 or 1"));
749 ignore_rest_of_line ();
753 dwarf2_loc_mark_labels
= value
!= 0;
754 demand_empty_rest_of_line ();
759 first_frag_for_seg (segT seg
)
761 return seg_info (seg
)->frchainP
->frch_root
;
765 last_frag_for_seg (segT seg
)
767 frchainS
*f
= seg_info (seg
)->frchainP
;
769 while (f
->frch_next
!= NULL
)
775 /* Emit a single byte into the current segment. */
780 FRAG_APPEND_1_CHAR (byte
);
783 /* Emit a statement program opcode into the current segment. */
791 /* Emit a two-byte word into the current segment. */
796 md_number_to_chars (frag_more (2), data
, 2);
799 /* Emit a four byte word into the current segment. */
804 md_number_to_chars (frag_more (4), data
, 4);
807 /* Emit an unsigned "little-endian base 128" number. */
810 out_uleb128 (addressT value
)
812 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
815 /* Emit a signed "little-endian base 128" number. */
818 out_leb128 (addressT value
)
820 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
823 /* Emit a tuple for .debug_abbrev. */
826 out_abbrev (int name
, int form
)
832 /* Get the size of a fragment. */
835 get_frag_fix (fragS
*frag
, segT seg
)
842 /* If a fragment is the last in the chain, special measures must be
843 taken to find its size before relaxation, since it may be pending
844 on some subsegment chain. */
845 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
846 if (fr
->frch_last
== frag
)
847 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
852 /* Set an absolute address (may result in a relocation entry). */
855 out_set_addr (symbolS
*sym
)
859 out_opcode (DW_LNS_extended_op
);
860 out_uleb128 (sizeof_address
+ 1);
862 out_opcode (DW_LNE_set_address
);
864 exp
.X_add_symbol
= sym
;
865 exp
.X_add_number
= 0;
866 emit_expr (&exp
, sizeof_address
);
869 static void scale_addr_delta (addressT
*);
872 scale_addr_delta (addressT
*addr_delta
)
874 static int printed_this
= 0;
875 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
877 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
879 as_bad("unaligned opcodes detected in executable segment");
882 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
886 /* Encode a pair of line and address skips as efficiently as possible.
887 Note that the line skip is signed, whereas the address skip is unsigned.
889 The following two routines *must* be kept in sync. This is
890 enforced by making emit_inc_line_addr abort if we do not emit
891 exactly the expected number of bytes. */
894 size_inc_line_addr (int line_delta
, addressT addr_delta
)
896 unsigned int tmp
, opcode
;
899 /* Scale the address delta by the minimum instruction length. */
900 scale_addr_delta (&addr_delta
);
902 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
903 We cannot use special opcodes here, since we want the end_sequence
904 to emit the matrix entry. */
905 if (line_delta
== INT_MAX
)
907 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
910 len
= 1 + sizeof_leb128 (addr_delta
, 0);
914 /* Bias the line delta by the base. */
915 tmp
= line_delta
- DWARF2_LINE_BASE
;
917 /* If the line increment is out of range of a special opcode, we
918 must encode it with DW_LNS_advance_line. */
919 if (tmp
>= DWARF2_LINE_RANGE
)
921 len
= 1 + sizeof_leb128 (line_delta
, 1);
923 tmp
= 0 - DWARF2_LINE_BASE
;
926 /* Bias the opcode by the special opcode base. */
927 tmp
+= DWARF2_LINE_OPCODE_BASE
;
929 /* Avoid overflow when addr_delta is large. */
930 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
932 /* Try using a special opcode. */
933 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
937 /* Try using DW_LNS_const_add_pc followed by special op. */
938 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
943 /* Otherwise use DW_LNS_advance_pc. */
944 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
946 /* DW_LNS_copy or special opcode. */
953 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
955 unsigned int tmp
, opcode
;
959 /* Line number sequences cannot go backward in addresses. This means
960 we've incorrectly ordered the statements in the sequence. */
961 gas_assert ((offsetT
) addr_delta
>= 0);
963 /* Scale the address delta by the minimum instruction length. */
964 scale_addr_delta (&addr_delta
);
966 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
967 We cannot use special opcodes here, since we want the end_sequence
968 to emit the matrix entry. */
969 if (line_delta
== INT_MAX
)
971 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
972 *p
++ = DW_LNS_const_add_pc
;
975 *p
++ = DW_LNS_advance_pc
;
976 p
+= output_leb128 (p
, addr_delta
, 0);
979 *p
++ = DW_LNS_extended_op
;
981 *p
++ = DW_LNE_end_sequence
;
985 /* Bias the line delta by the base. */
986 tmp
= line_delta
- DWARF2_LINE_BASE
;
988 /* If the line increment is out of range of a special opcode, we
989 must encode it with DW_LNS_advance_line. */
990 if (tmp
>= DWARF2_LINE_RANGE
)
992 *p
++ = DW_LNS_advance_line
;
993 p
+= output_leb128 (p
, line_delta
, 1);
996 tmp
= 0 - DWARF2_LINE_BASE
;
1000 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1002 if (line_delta
== 0 && addr_delta
== 0)
1008 /* Bias the opcode by the special opcode base. */
1009 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1011 /* Avoid overflow when addr_delta is large. */
1012 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1014 /* Try using a special opcode. */
1015 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1022 /* Try using DW_LNS_const_add_pc followed by special op. */
1023 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1026 *p
++ = DW_LNS_const_add_pc
;
1032 /* Otherwise use DW_LNS_advance_pc. */
1033 *p
++ = DW_LNS_advance_pc
;
1034 p
+= output_leb128 (p
, addr_delta
, 0);
1042 gas_assert (p
== end
);
1045 /* Handy routine to combine calls to the above two routines. */
1048 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1050 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1051 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1054 /* Write out an alternative form of line and address skips using
1055 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1056 line and address information, but it is required if linker relaxation
1057 could change the code offsets. The following two routines *must* be
1059 #define ADDR_DELTA_LIMIT 50000
1062 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1066 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1067 if (line_delta
!= INT_MAX
)
1068 len
= 1 + sizeof_leb128 (line_delta
, 1);
1070 if (addr_delta
> ADDR_DELTA_LIMIT
)
1072 /* DW_LNS_extended_op */
1073 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1074 /* DW_LNE_set_address */
1075 len
+= 1 + sizeof_address
;
1078 /* DW_LNS_fixed_advance_pc */
1081 if (line_delta
== INT_MAX
)
1082 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1092 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1096 char *end
= p
+ len
;
1098 /* Line number sequences cannot go backward in addresses. This means
1099 we've incorrectly ordered the statements in the sequence. */
1100 gas_assert ((offsetT
) addr_delta
>= 0);
1102 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1103 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1105 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1106 if (line_delta
!= INT_MAX
)
1108 *p
++ = DW_LNS_advance_line
;
1109 p
+= output_leb128 (p
, line_delta
, 1);
1112 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1114 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1115 advance the address by at most 64K. Linker relaxation (without
1116 which this function would not be used) could change the operand by
1117 an unknown amount. If the address increment is getting close to
1118 the limit, just reset the address. */
1119 if (addr_delta
> ADDR_DELTA_LIMIT
)
1124 gas_assert (pexp
->X_op
== O_subtract
);
1125 to_sym
= pexp
->X_add_symbol
;
1127 *p
++ = DW_LNS_extended_op
;
1128 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1129 *p
++ = DW_LNE_set_address
;
1130 exp
.X_op
= O_symbol
;
1131 exp
.X_add_symbol
= to_sym
;
1132 exp
.X_add_number
= 0;
1133 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1134 p
+= sizeof_address
;
1138 *p
++ = DW_LNS_fixed_advance_pc
;
1139 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1143 if (line_delta
== INT_MAX
)
1145 *p
++ = DW_LNS_extended_op
;
1147 *p
++ = DW_LNE_end_sequence
;
1152 gas_assert (p
== end
);
1155 /* Generate a variant frag that we can use to relax address/line
1156 increments between fragments of the target segment. */
1159 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1164 exp
.X_op
= O_subtract
;
1165 exp
.X_add_symbol
= to_sym
;
1166 exp
.X_op_symbol
= from_sym
;
1167 exp
.X_add_number
= 0;
1169 /* The maximum size of the frag is the line delta with a maximum
1170 sized address delta. */
1171 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1172 max_chars
= size_fixed_inc_line_addr (line_delta
,
1173 -DWARF2_LINE_MIN_INSN_LENGTH
);
1175 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1177 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1178 make_expr_symbol (&exp
), line_delta
, NULL
);
1181 /* The function estimates the size of a rs_dwarf2dbg variant frag
1182 based on the current values of the symbols. It is called before
1183 the relaxation loop. We set fr_subtype to the expected length. */
1186 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1191 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1192 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1193 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1195 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1197 frag
->fr_subtype
= size
;
1202 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1203 current values of the symbols. fr_subtype is the current length
1204 of the frag. This returns the change in frag length. */
1207 dwarf2dbg_relax_frag (fragS
*frag
)
1209 int old_size
, new_size
;
1211 old_size
= frag
->fr_subtype
;
1212 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1214 return new_size
- old_size
;
1217 /* This function converts a rs_dwarf2dbg variant frag into a normal
1218 fill frag. This is called after all relaxation has been done.
1219 fr_subtype will be the desired length of the frag. */
1222 dwarf2dbg_convert_frag (fragS
*frag
)
1226 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1228 /* If linker relaxation is enabled then the distance bewteen the two
1229 symbols in the frag->fr_symbol expression might change. Hence we
1230 cannot rely upon the value computed by resolve_symbol_value.
1231 Instead we leave the expression unfinalized and allow
1232 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1233 relocation) that will allow the linker to correctly compute the
1234 actual address difference. We have to use a fixed line advance for
1235 this as we cannot (easily) relocate leb128 encoded values. */
1236 int saved_finalize_syms
= finalize_syms
;
1239 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1240 finalize_syms
= saved_finalize_syms
;
1243 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1245 /* fr_var carries the max_chars that we created the fragment with.
1246 fr_subtype carries the current expected length. We must, of
1247 course, have allocated enough memory earlier. */
1248 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1250 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1251 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1252 frag
->fr_literal
+ frag
->fr_fix
,
1255 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1256 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1258 frag
->fr_fix
+= frag
->fr_subtype
;
1259 frag
->fr_type
= rs_fill
;
1261 frag
->fr_offset
= 0;
1264 /* Generate .debug_line content for the chain of line number entries
1265 beginning at E, for segment SEG. */
1268 process_entries (segT seg
, struct line_entry
*e
)
1270 unsigned filenum
= 1;
1272 unsigned column
= 0;
1274 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1275 fragS
*last_frag
= NULL
, *frag
;
1276 addressT last_frag_ofs
= 0, frag_ofs
;
1277 symbolS
*last_lab
= NULL
, *lab
;
1278 struct line_entry
*next
;
1280 if (flag_dwarf_sections
)
1283 const char * sec_name
;
1285 /* Switch to the relevent sub-section before we start to emit
1286 the line number table.
1288 FIXME: These sub-sections do not have a normal Line Number
1289 Program Header, thus strictly speaking they are not valid
1290 DWARF sections. Unfortunately the DWARF standard assumes
1291 a one-to-one relationship between compilation units and
1292 line number tables. Thus we have to have a .debug_line
1293 section, as well as our sub-sections, and we have to ensure
1294 that all of the sub-sections are merged into a proper
1295 .debug_line section before a debugger sees them. */
1297 sec_name
= bfd_get_section_name (stdoutput
, seg
);
1298 if (strcmp (sec_name
, ".text") != 0)
1302 len
= strlen (sec_name
);
1303 name
= xmalloc (len
+ 11 + 2);
1304 sprintf (name
, ".debug_line%s", sec_name
);
1305 subseg_set (subseg_get (name
, FALSE
), 0);
1308 /* Don't create a .debug_line.text section -
1309 that is redundant. Instead just switch back to the
1310 normal .debug_line section. */
1311 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1318 if (filenum
!= e
->loc
.filenum
)
1320 filenum
= e
->loc
.filenum
;
1321 out_opcode (DW_LNS_set_file
);
1322 out_uleb128 (filenum
);
1325 if (column
!= e
->loc
.column
)
1327 column
= e
->loc
.column
;
1328 out_opcode (DW_LNS_set_column
);
1329 out_uleb128 (column
);
1332 if (e
->loc
.discriminator
!= 0)
1334 out_opcode (DW_LNS_extended_op
);
1335 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1336 out_opcode (DW_LNE_set_discriminator
);
1337 out_uleb128 (e
->loc
.discriminator
);
1340 if (isa
!= e
->loc
.isa
)
1343 out_opcode (DW_LNS_set_isa
);
1347 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1349 flags
= e
->loc
.flags
;
1350 out_opcode (DW_LNS_negate_stmt
);
1353 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1354 out_opcode (DW_LNS_set_basic_block
);
1356 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1357 out_opcode (DW_LNS_set_prologue_end
);
1359 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1360 out_opcode (DW_LNS_set_epilogue_begin
);
1362 /* Don't try to optimize away redundant entries; gdb wants two
1363 entries for a function where the code starts on the same line as
1364 the {, and there's no way to identify that case here. Trust gcc
1365 to optimize appropriately. */
1366 line_delta
= e
->loc
.line
- line
;
1368 frag
= symbol_get_frag (lab
);
1369 frag_ofs
= S_GET_VALUE (lab
);
1371 if (last_frag
== NULL
)
1374 out_inc_line_addr (line_delta
, 0);
1376 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1377 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1379 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1384 last_frag_ofs
= frag_ofs
;
1392 /* Emit a DW_LNE_end_sequence for the end of the section. */
1393 frag
= last_frag_for_seg (seg
);
1394 frag_ofs
= get_frag_fix (frag
, seg
);
1395 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1396 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1399 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1400 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1404 /* Emit the directory and file tables for .debug_line. */
1407 out_file_list (void)
1414 /* Emit directory list. */
1415 for (i
= 1; i
< dirs_in_use
; ++i
)
1417 dir
= remap_debug_filename (dirs
[i
]);
1418 size
= strlen (dir
) + 1;
1419 cp
= frag_more (size
);
1420 memcpy (cp
, dir
, size
);
1425 for (i
= 1; i
< files_in_use
; ++i
)
1427 const char *fullfilename
;
1429 if (files
[i
].filename
== NULL
)
1431 as_bad (_("unassigned file number %ld"), (long) i
);
1432 /* Prevent a crash later, particularly for file 1. */
1433 files
[i
].filename
= "";
1437 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
1438 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
1439 size
= strlen (fullfilename
) + 1;
1440 cp
= frag_more (size
);
1441 memcpy (cp
, fullfilename
, size
);
1443 out_uleb128 (files
[i
].dir
); /* directory number */
1444 /* Output the last modification timestamp. */
1445 out_uleb128 (DWARF2_FILE_TIME_NAME (files
[i
].filename
,
1446 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1447 /* Output the filesize. */
1448 out_uleb128 (DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
1449 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1452 /* Terminate filename list. */
1456 /* Switch to SEC and output a header length field. Return the size of
1457 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1458 to the end of the section. EXPR->X_add_number will be set to the
1459 negative size of the header. */
1462 out_header (asection
*sec
, expressionS
*exp
)
1467 subseg_set (sec
, 0);
1469 if (flag_dwarf_sections
)
1471 /* If we are going to put the start and end symbols in different
1472 sections, then we need real symbols, not just fake, local ones. */
1474 start_sym
= symbol_make (".Ldebug_line_start");
1475 end_sym
= symbol_make (".Ldebug_line_end");
1476 symbol_set_value_now (start_sym
);
1480 start_sym
= symbol_temp_new_now ();
1481 end_sym
= symbol_temp_make ();
1484 /* Total length of the information. */
1485 exp
->X_op
= O_subtract
;
1486 exp
->X_add_symbol
= end_sym
;
1487 exp
->X_op_symbol
= start_sym
;
1489 switch (DWARF2_FORMAT (sec
))
1491 case dwarf2_format_32bit
:
1492 exp
->X_add_number
= -4;
1496 case dwarf2_format_64bit
:
1497 exp
->X_add_number
= -12;
1502 case dwarf2_format_64bit_irix
:
1503 exp
->X_add_number
= -8;
1508 as_fatal (_("internal error: unknown dwarf2 format"));
1512 /* Emit the collected .debug_line data. */
1515 out_debug_line (segT line_seg
)
1518 symbolS
*prologue_start
, *prologue_end
;
1523 sizeof_offset
= out_header (line_seg
, &exp
);
1524 line_end
= exp
.X_add_symbol
;
1527 out_two (DWARF2_LINE_VERSION
);
1529 /* Length of the prologue following this length. */
1530 prologue_start
= symbol_temp_make ();
1531 prologue_end
= symbol_temp_make ();
1532 exp
.X_op
= O_subtract
;
1533 exp
.X_add_symbol
= prologue_end
;
1534 exp
.X_op_symbol
= prologue_start
;
1535 exp
.X_add_number
= 0;
1536 emit_expr (&exp
, sizeof_offset
);
1537 symbol_set_value_now (prologue_start
);
1539 /* Parameters of the state machine. */
1540 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
1541 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
1542 out_byte (DWARF2_LINE_BASE
);
1543 out_byte (DWARF2_LINE_RANGE
);
1544 out_byte (DWARF2_LINE_OPCODE_BASE
);
1546 /* Standard opcode lengths. */
1547 out_byte (0); /* DW_LNS_copy */
1548 out_byte (1); /* DW_LNS_advance_pc */
1549 out_byte (1); /* DW_LNS_advance_line */
1550 out_byte (1); /* DW_LNS_set_file */
1551 out_byte (1); /* DW_LNS_set_column */
1552 out_byte (0); /* DW_LNS_negate_stmt */
1553 out_byte (0); /* DW_LNS_set_basic_block */
1554 out_byte (0); /* DW_LNS_const_add_pc */
1555 out_byte (1); /* DW_LNS_fixed_advance_pc */
1556 out_byte (0); /* DW_LNS_set_prologue_end */
1557 out_byte (0); /* DW_LNS_set_epilogue_begin */
1558 out_byte (1); /* DW_LNS_set_isa */
1562 symbol_set_value_now (prologue_end
);
1564 /* For each section, emit a statement program. */
1565 for (s
= all_segs
; s
; s
= s
->next
)
1566 if (SEG_NORMAL (s
->seg
))
1567 process_entries (s
->seg
, s
->head
->head
);
1569 as_warn ("dwarf line number information for %s ignored",
1570 segment_name (s
->seg
));
1572 if (flag_dwarf_sections
)
1573 /* We have to switch to the special .debug_line_end section
1574 before emitting the end-of-debug_line symbol. The linker
1575 script arranges for this section to be placed after all the
1576 (potentially garbage collected) .debug_line.<foo> sections.
1577 This section contains the line_end symbol which is used to
1578 compute the size of the linked .debug_line section, as seen
1579 in the DWARF Line Number header. */
1580 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
1582 symbol_set_value_now (line_end
);
1586 out_debug_ranges (segT ranges_seg
)
1588 unsigned int addr_size
= sizeof_address
;
1593 subseg_set (ranges_seg
, 0);
1595 /* Base Address Entry. */
1596 for (i
= 0; i
< addr_size
; i
++)
1598 for (i
= 0; i
< addr_size
; i
++)
1601 /* Range List Entry. */
1602 for (s
= all_segs
; s
; s
= s
->next
)
1607 frag
= first_frag_for_seg (s
->seg
);
1608 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1609 s
->text_start
= beg
;
1611 frag
= last_frag_for_seg (s
->seg
);
1612 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1615 exp
.X_op
= O_symbol
;
1616 exp
.X_add_symbol
= beg
;
1617 exp
.X_add_number
= 0;
1618 emit_expr (&exp
, addr_size
);
1620 exp
.X_op
= O_symbol
;
1621 exp
.X_add_symbol
= end
;
1622 exp
.X_add_number
= 0;
1623 emit_expr (&exp
, addr_size
);
1626 /* End of Range Entry. */
1627 for (i
= 0; i
< addr_size
; i
++)
1629 for (i
= 0; i
< addr_size
; i
++)
1633 /* Emit data for .debug_aranges. */
1636 out_debug_aranges (segT aranges_seg
, segT info_seg
)
1638 unsigned int addr_size
= sizeof_address
;
1642 symbolS
*aranges_end
;
1646 sizeof_offset
= out_header (aranges_seg
, &exp
);
1647 aranges_end
= exp
.X_add_symbol
;
1648 size
= -exp
.X_add_number
;
1651 out_two (DWARF2_ARANGES_VERSION
);
1654 /* Offset to .debug_info. */
1655 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
1656 size
+= sizeof_offset
;
1658 /* Size of an address (offset portion). */
1659 out_byte (addr_size
);
1662 /* Size of a segment descriptor. */
1666 /* Align the header. */
1667 while ((size
++ % (2 * addr_size
)) > 0)
1670 for (s
= all_segs
; s
; s
= s
->next
)
1675 frag
= first_frag_for_seg (s
->seg
);
1676 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1677 s
->text_start
= beg
;
1679 frag
= last_frag_for_seg (s
->seg
);
1680 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1683 exp
.X_op
= O_symbol
;
1684 exp
.X_add_symbol
= beg
;
1685 exp
.X_add_number
= 0;
1686 emit_expr (&exp
, addr_size
);
1688 exp
.X_op
= O_subtract
;
1689 exp
.X_add_symbol
= end
;
1690 exp
.X_op_symbol
= beg
;
1691 exp
.X_add_number
= 0;
1692 emit_expr (&exp
, addr_size
);
1695 p
= frag_more (2 * addr_size
);
1696 md_number_to_chars (p
, 0, addr_size
);
1697 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1699 symbol_set_value_now (aranges_end
);
1702 /* Emit data for .debug_abbrev. Note that this must be kept in
1703 sync with out_debug_info below. */
1706 out_debug_abbrev (segT abbrev_seg
,
1707 segT info_seg ATTRIBUTE_UNUSED
,
1708 segT line_seg ATTRIBUTE_UNUSED
)
1710 subseg_set (abbrev_seg
, 0);
1713 out_uleb128 (DW_TAG_compile_unit
);
1714 out_byte (DW_CHILDREN_no
);
1715 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
1716 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1718 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
1719 if (all_segs
->next
== NULL
)
1721 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1722 if (DWARF2_VERSION
< 4)
1723 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1725 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
1726 ? DW_FORM_data4
: DW_FORM_data8
));
1730 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
1731 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
1733 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
1735 out_abbrev (DW_AT_name
, DW_FORM_string
);
1736 out_abbrev (DW_AT_comp_dir
, DW_FORM_string
);
1737 out_abbrev (DW_AT_producer
, DW_FORM_string
);
1738 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1741 /* Terminate the abbreviations for this compilation unit. */
1745 /* Emit a description of this compilation unit for .debug_info. */
1748 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
)
1751 const char *comp_dir
;
1752 const char *dirname
;
1759 sizeof_offset
= out_header (info_seg
, &exp
);
1760 info_end
= exp
.X_add_symbol
;
1762 /* DWARF version. */
1763 out_two (DWARF2_VERSION
);
1765 /* .debug_abbrev offset */
1766 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
1768 /* Target address size. */
1769 out_byte (sizeof_address
);
1771 /* DW_TAG_compile_unit DIE abbrev */
1774 /* DW_AT_stmt_list */
1775 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
1776 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
1779 /* These two attributes are emitted if all of the code is contiguous. */
1780 if (all_segs
->next
== NULL
)
1783 exp
.X_op
= O_symbol
;
1784 exp
.X_add_symbol
= all_segs
->text_start
;
1785 exp
.X_add_number
= 0;
1786 emit_expr (&exp
, sizeof_address
);
1789 if (DWARF2_VERSION
< 4)
1790 exp
.X_op
= O_symbol
;
1793 exp
.X_op
= O_subtract
;
1794 exp
.X_op_symbol
= all_segs
->text_start
;
1796 exp
.X_add_symbol
= all_segs
->text_end
;
1797 exp
.X_add_number
= 0;
1798 emit_expr (&exp
, sizeof_address
);
1802 /* This attribute is emitted if the code is disjoint. */
1804 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
1807 /* DW_AT_name. We don't have the actual file name that was present
1808 on the command line, so assume files[1] is the main input file.
1809 We're not supposed to get called unless at least one line number
1810 entry was emitted, so this should always be defined. */
1811 if (files_in_use
== 0)
1815 dirname
= remap_debug_filename (dirs
[files
[1].dir
]);
1816 len
= strlen (dirname
);
1818 /* Already has trailing slash. */
1819 p
= frag_more (len
);
1820 memcpy (p
, dirname
, len
);
1822 p
= frag_more (len
+ 1);
1823 memcpy (p
, dirname
, len
);
1824 INSERT_DIR_SEPARATOR (p
, len
);
1827 len
= strlen (files
[1].filename
) + 1;
1828 p
= frag_more (len
);
1829 memcpy (p
, files
[1].filename
, len
);
1831 /* DW_AT_comp_dir */
1832 comp_dir
= remap_debug_filename (getpwd ());
1833 len
= strlen (comp_dir
) + 1;
1834 p
= frag_more (len
);
1835 memcpy (p
, comp_dir
, len
);
1837 /* DW_AT_producer */
1838 sprintf (producer
, "GNU AS %s", VERSION
);
1839 len
= strlen (producer
) + 1;
1840 p
= frag_more (len
);
1841 memcpy (p
, producer
, len
);
1843 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1844 dwarf2 draft has no standard code for assembler. */
1845 out_two (DW_LANG_Mips_Assembler
);
1847 symbol_set_value_now (info_end
);
1853 last_seg_ptr
= &all_segs
;
1857 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1858 were any .file/.loc directives, or --gdwarf2 was given, or if the
1859 file has a non-empty .debug_info section and an empty .debug_line
1860 section. If we emit .debug_line, and the .debug_info section is
1861 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1862 ALL_SEGS will be non-null if there were any .file/.loc directives,
1863 or --gdwarf2 was given and there were any located instructions
1867 dwarf2_finish (void)
1872 int emit_other_sections
= 0;
1873 int empty_debug_line
= 0;
1875 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
1876 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
1878 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
1879 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
1881 /* We can't construct a new debug_line section if we already have one.
1883 if (all_segs
&& !empty_debug_line
)
1884 as_fatal ("duplicate .debug_line sections");
1886 if ((!all_segs
&& emit_other_sections
)
1887 || (!emit_other_sections
&& !empty_debug_line
))
1888 /* If there is no line information and no non-empty .debug_info
1889 section, or if there is both a non-empty .debug_info and a non-empty
1890 .debug_line, then we do nothing. */
1893 /* Calculate the size of an address for the target machine. */
1894 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
1896 /* Create and switch to the line number section. */
1897 line_seg
= subseg_new (".debug_line", 0);
1898 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
| SEC_DEBUGGING
);
1900 /* For each subsection, chain the debug entries together. */
1901 for (s
= all_segs
; s
; s
= s
->next
)
1903 struct line_subseg
*lss
= s
->head
;
1904 struct line_entry
**ptail
= lss
->ptail
;
1906 while ((lss
= lss
->next
) != NULL
)
1913 out_debug_line (line_seg
);
1915 /* If this is assembler generated line info, and there is no
1916 debug_info already, we need .debug_info and .debug_abbrev
1917 sections as well. */
1918 if (emit_other_sections
)
1924 gas_assert (all_segs
);
1926 info_seg
= subseg_new (".debug_info", 0);
1927 abbrev_seg
= subseg_new (".debug_abbrev", 0);
1928 aranges_seg
= subseg_new (".debug_aranges", 0);
1930 bfd_set_section_flags (stdoutput
, info_seg
,
1931 SEC_READONLY
| SEC_DEBUGGING
);
1932 bfd_set_section_flags (stdoutput
, abbrev_seg
,
1933 SEC_READONLY
| SEC_DEBUGGING
);
1934 bfd_set_section_flags (stdoutput
, aranges_seg
,
1935 SEC_READONLY
| SEC_DEBUGGING
);
1937 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
1939 if (all_segs
->next
== NULL
)
1943 ranges_seg
= subseg_new (".debug_ranges", 0);
1944 bfd_set_section_flags (stdoutput
, ranges_seg
,
1945 SEC_READONLY
| SEC_DEBUGGING
);
1946 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
1947 out_debug_ranges (ranges_seg
);
1950 out_debug_aranges (aranges_seg
, info_seg
);
1951 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
1952 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
);