1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2015 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
= (struct line_seg
*) xmalloc (sizeof (*s
));
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
= (struct line_subseg
*) xmalloc (sizeof (*lss
));
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
= (struct line_entry
*) xmalloc (sizeof (*e
));
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
)
354 as_where (&filename
, &line
->line
);
355 line
->filenum
= get_filenum (filename
, 0);
357 line
->flags
= DWARF2_FLAG_IS_STMT
;
358 line
->isa
= current
.isa
;
359 line
->discriminator
= current
.discriminator
;
365 /* A hook to allow the target backend to inform the line number state
366 machine of isa changes when assembler debug info is enabled. */
369 dwarf2_set_isa (unsigned int isa
)
374 /* Called for each machine instruction, or relatively atomic group of
375 machine instructions (ie built-in macro). The instruction or group
376 is SIZE bytes in length. If dwarf2 line number generation is called
377 for, emit a line statement appropriately. */
380 dwarf2_emit_insn (int size
)
382 struct dwarf2_line_info loc
;
384 if (!dwarf2_loc_directive_seen
&& debug_type
!= DEBUG_DWARF2
)
389 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
390 dwarf2_consume_line_info ();
393 /* Move all previously-emitted line entries for the current position by
394 DELTA bytes. This function cannot be used to move the same entries
398 dwarf2_move_insn (int delta
)
400 struct line_subseg
*lss
;
401 struct line_entry
*e
;
407 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
411 now
= frag_now_fix ();
412 while ((e
= *lss
->pmove_tail
))
414 if (S_GET_VALUE (e
->label
) == now
)
415 S_SET_VALUE (e
->label
, now
+ delta
);
416 lss
->pmove_tail
= &e
->next
;
420 /* Called after the current line information has been either used with
421 dwarf2_gen_line_info or saved with a machine instruction for later use.
422 This resets the state of the line number information to reflect that
426 dwarf2_consume_line_info (void)
428 /* Unless we generate DWARF2 debugging information for each
429 assembler line, we only emit one line symbol for one LOC. */
430 dwarf2_loc_directive_seen
= FALSE
;
432 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
433 | DWARF2_FLAG_PROLOGUE_END
434 | DWARF2_FLAG_EPILOGUE_BEGIN
);
435 current
.discriminator
= 0;
438 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
439 is enabled, emit a basic block marker. */
442 dwarf2_emit_label (symbolS
*label
)
444 struct dwarf2_line_info loc
;
446 if (!dwarf2_loc_mark_labels
)
448 if (S_GET_SEGMENT (label
) != now_seg
)
450 if (!(bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
))
452 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
457 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
459 dwarf2_gen_line_info_1 (label
, &loc
);
460 dwarf2_consume_line_info ();
463 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
464 allocate it on that file table slot, otherwise return the first
468 get_filenum (const char *filename
, unsigned int num
)
470 static unsigned int last_used
, last_used_dir_len
;
475 if (num
== 0 && last_used
)
477 if (! files
[last_used
].dir
478 && filename_cmp (filename
, files
[last_used
].filename
) == 0)
480 if (files
[last_used
].dir
481 && filename_ncmp (filename
, dirs
[files
[last_used
].dir
],
482 last_used_dir_len
) == 0
483 && IS_DIR_SEPARATOR (filename
[last_used_dir_len
])
484 && filename_cmp (filename
+ last_used_dir_len
+ 1,
485 files
[last_used
].filename
) == 0)
489 file
= lbasename (filename
);
490 /* Don't make empty string from / or A: from A:/ . */
491 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
492 if (file
<= filename
+ 3)
495 if (file
== filename
+ 1)
498 dir_len
= file
- filename
;
503 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
506 for (dir
= 1; dir
< dirs_in_use
; ++dir
)
507 if (filename_ncmp (filename
, dirs
[dir
], dir_len
) == 0
508 && dirs
[dir
][dir_len
] == '\0')
511 if (dir
>= dirs_in_use
)
513 if (dir
>= dirs_allocated
)
515 dirs_allocated
= dir
+ 32;
517 xrealloc (dirs
, (dir
+ 32) * sizeof (const char *));
520 dirs
[dir
] = (char *) xmalloc (dir_len
+ 1);
521 memcpy (dirs
[dir
], filename
, dir_len
);
522 dirs
[dir
][dir_len
] = '\0';
523 dirs_in_use
= dir
+ 1;
529 for (i
= 1; i
< files_in_use
; ++i
)
530 if (files
[i
].dir
== dir
532 && filename_cmp (file
, files
[i
].filename
) == 0)
535 last_used_dir_len
= dir_len
;
542 if (i
>= files_allocated
)
544 unsigned int old
= files_allocated
;
546 files_allocated
= i
+ 32;
547 files
= (struct file_entry
*)
548 xrealloc (files
, (i
+ 32) * sizeof (struct file_entry
));
550 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
553 files
[i
].filename
= num
? file
: xstrdup (file
);
555 if (files_in_use
< i
+ 1)
556 files_in_use
= i
+ 1;
558 last_used_dir_len
= dir_len
;
563 /* Handle two forms of .file directive:
564 - Pass .file "source.c" to s_app_file
565 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
567 If an entry is added to the file table, return a pointer to the filename. */
570 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
576 /* Continue to accept a bare string and pass it off. */
578 if (*input_line_pointer
== '"')
584 num
= get_absolute_expression ();
585 filename
= demand_copy_C_string (&filename_len
);
586 if (filename
== NULL
)
588 demand_empty_rest_of_line ();
592 as_bad (_("file number less than one"));
596 /* A .file directive implies compiler generated debug information is
597 being supplied. Turn off gas generated debug info. */
598 debug_type
= DEBUG_NONE
;
600 if (num
< (int) files_in_use
&& files
[num
].filename
!= 0)
602 as_bad (_("file number %ld already allocated"), (long) num
);
606 get_filenum (filename
, num
);
612 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
614 offsetT filenum
, line
;
616 /* If we see two .loc directives in a row, force the first one to be
618 if (dwarf2_loc_directive_seen
)
619 dwarf2_emit_insn (0);
621 filenum
= get_absolute_expression ();
623 line
= get_absolute_expression ();
627 as_bad (_("file number less than one"));
630 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== 0)
632 as_bad (_("unassigned file number %ld"), (long) filenum
);
636 current
.filenum
= filenum
;
638 current
.discriminator
= 0;
643 if (files
[filenum
].dir
)
645 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
646 size_t file_len
= strlen (files
[filenum
].filename
);
647 char *cp
= (char *) alloca (dir_len
+ 1 + file_len
+ 1);
649 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
650 INSERT_DIR_SEPARATOR (cp
, dir_len
);
651 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
652 cp
[dir_len
+ file_len
+ 1] = '\0';
653 listing_source_file (cp
);
656 listing_source_file (files
[filenum
].filename
);
657 listing_source_line (line
);
662 if (ISDIGIT (*input_line_pointer
))
664 current
.column
= get_absolute_expression ();
668 while (ISALPHA (*input_line_pointer
))
673 c
= get_symbol_name (& p
);
675 if (strcmp (p
, "basic_block") == 0)
677 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
678 *input_line_pointer
= c
;
680 else if (strcmp (p
, "prologue_end") == 0)
682 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
683 *input_line_pointer
= c
;
685 else if (strcmp (p
, "epilogue_begin") == 0)
687 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
688 *input_line_pointer
= c
;
690 else if (strcmp (p
, "is_stmt") == 0)
692 (void) restore_line_pointer (c
);
693 value
= get_absolute_expression ();
695 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
697 current
.flags
|= DWARF2_FLAG_IS_STMT
;
700 as_bad (_("is_stmt value not 0 or 1"));
704 else if (strcmp (p
, "isa") == 0)
706 (void) restore_line_pointer (c
);
707 value
= get_absolute_expression ();
712 as_bad (_("isa number less than zero"));
716 else if (strcmp (p
, "discriminator") == 0)
718 (void) restore_line_pointer (c
);
719 value
= get_absolute_expression ();
721 current
.discriminator
= value
;
724 as_bad (_("discriminator less than zero"));
730 as_bad (_("unknown .loc sub-directive `%s'"), p
);
731 (void) restore_line_pointer (c
);
735 SKIP_WHITESPACE_AFTER_NAME ();
738 demand_empty_rest_of_line ();
739 dwarf2_loc_directive_seen
= TRUE
;
740 debug_type
= DEBUG_NONE
;
744 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
746 offsetT value
= get_absolute_expression ();
748 if (value
!= 0 && value
!= 1)
750 as_bad (_("expected 0 or 1"));
751 ignore_rest_of_line ();
755 dwarf2_loc_mark_labels
= value
!= 0;
756 demand_empty_rest_of_line ();
761 first_frag_for_seg (segT seg
)
763 return seg_info (seg
)->frchainP
->frch_root
;
767 last_frag_for_seg (segT seg
)
769 frchainS
*f
= seg_info (seg
)->frchainP
;
771 while (f
->frch_next
!= NULL
)
777 /* Emit a single byte into the current segment. */
782 FRAG_APPEND_1_CHAR (byte
);
785 /* Emit a statement program opcode into the current segment. */
793 /* Emit a two-byte word into the current segment. */
798 md_number_to_chars (frag_more (2), data
, 2);
801 /* Emit a four byte word into the current segment. */
806 md_number_to_chars (frag_more (4), data
, 4);
809 /* Emit an unsigned "little-endian base 128" number. */
812 out_uleb128 (addressT value
)
814 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
817 /* Emit a signed "little-endian base 128" number. */
820 out_leb128 (addressT value
)
822 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
825 /* Emit a tuple for .debug_abbrev. */
828 out_abbrev (int name
, int form
)
834 /* Get the size of a fragment. */
837 get_frag_fix (fragS
*frag
, segT seg
)
844 /* If a fragment is the last in the chain, special measures must be
845 taken to find its size before relaxation, since it may be pending
846 on some subsegment chain. */
847 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
848 if (fr
->frch_last
== frag
)
849 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
854 /* Set an absolute address (may result in a relocation entry). */
857 out_set_addr (symbolS
*sym
)
861 out_opcode (DW_LNS_extended_op
);
862 out_uleb128 (sizeof_address
+ 1);
864 out_opcode (DW_LNE_set_address
);
866 exp
.X_add_symbol
= sym
;
867 exp
.X_add_number
= 0;
868 emit_expr (&exp
, sizeof_address
);
871 static void scale_addr_delta (addressT
*);
874 scale_addr_delta (addressT
*addr_delta
)
876 static int printed_this
= 0;
877 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
879 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
881 as_bad("unaligned opcodes detected in executable segment");
884 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
888 /* Encode a pair of line and address skips as efficiently as possible.
889 Note that the line skip is signed, whereas the address skip is unsigned.
891 The following two routines *must* be kept in sync. This is
892 enforced by making emit_inc_line_addr abort if we do not emit
893 exactly the expected number of bytes. */
896 size_inc_line_addr (int line_delta
, addressT addr_delta
)
898 unsigned int tmp
, opcode
;
901 /* Scale the address delta by the minimum instruction length. */
902 scale_addr_delta (&addr_delta
);
904 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
905 We cannot use special opcodes here, since we want the end_sequence
906 to emit the matrix entry. */
907 if (line_delta
== INT_MAX
)
909 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
912 len
= 1 + sizeof_leb128 (addr_delta
, 0);
916 /* Bias the line delta by the base. */
917 tmp
= line_delta
- DWARF2_LINE_BASE
;
919 /* If the line increment is out of range of a special opcode, we
920 must encode it with DW_LNS_advance_line. */
921 if (tmp
>= DWARF2_LINE_RANGE
)
923 len
= 1 + sizeof_leb128 (line_delta
, 1);
925 tmp
= 0 - DWARF2_LINE_BASE
;
928 /* Bias the opcode by the special opcode base. */
929 tmp
+= DWARF2_LINE_OPCODE_BASE
;
931 /* Avoid overflow when addr_delta is large. */
932 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
934 /* Try using a special opcode. */
935 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
939 /* Try using DW_LNS_const_add_pc followed by special op. */
940 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
945 /* Otherwise use DW_LNS_advance_pc. */
946 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
948 /* DW_LNS_copy or special opcode. */
955 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
957 unsigned int tmp
, opcode
;
961 /* Line number sequences cannot go backward in addresses. This means
962 we've incorrectly ordered the statements in the sequence. */
963 gas_assert ((offsetT
) addr_delta
>= 0);
965 /* Scale the address delta by the minimum instruction length. */
966 scale_addr_delta (&addr_delta
);
968 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
969 We cannot use special opcodes here, since we want the end_sequence
970 to emit the matrix entry. */
971 if (line_delta
== INT_MAX
)
973 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
974 *p
++ = DW_LNS_const_add_pc
;
977 *p
++ = DW_LNS_advance_pc
;
978 p
+= output_leb128 (p
, addr_delta
, 0);
981 *p
++ = DW_LNS_extended_op
;
983 *p
++ = DW_LNE_end_sequence
;
987 /* Bias the line delta by the base. */
988 tmp
= line_delta
- DWARF2_LINE_BASE
;
990 /* If the line increment is out of range of a special opcode, we
991 must encode it with DW_LNS_advance_line. */
992 if (tmp
>= DWARF2_LINE_RANGE
)
994 *p
++ = DW_LNS_advance_line
;
995 p
+= output_leb128 (p
, line_delta
, 1);
998 tmp
= 0 - DWARF2_LINE_BASE
;
1002 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1004 if (line_delta
== 0 && addr_delta
== 0)
1010 /* Bias the opcode by the special opcode base. */
1011 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1013 /* Avoid overflow when addr_delta is large. */
1014 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1016 /* Try using a special opcode. */
1017 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1024 /* Try using DW_LNS_const_add_pc followed by special op. */
1025 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1028 *p
++ = DW_LNS_const_add_pc
;
1034 /* Otherwise use DW_LNS_advance_pc. */
1035 *p
++ = DW_LNS_advance_pc
;
1036 p
+= output_leb128 (p
, addr_delta
, 0);
1044 gas_assert (p
== end
);
1047 /* Handy routine to combine calls to the above two routines. */
1050 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1052 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1053 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1056 /* Write out an alternative form of line and address skips using
1057 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1058 line and address information, but it is required if linker relaxation
1059 could change the code offsets. The following two routines *must* be
1061 #define ADDR_DELTA_LIMIT 50000
1064 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1068 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1069 if (line_delta
!= INT_MAX
)
1070 len
= 1 + sizeof_leb128 (line_delta
, 1);
1072 if (addr_delta
> ADDR_DELTA_LIMIT
)
1074 /* DW_LNS_extended_op */
1075 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1076 /* DW_LNE_set_address */
1077 len
+= 1 + sizeof_address
;
1080 /* DW_LNS_fixed_advance_pc */
1083 if (line_delta
== INT_MAX
)
1084 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1094 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1098 char *end
= p
+ len
;
1100 /* Line number sequences cannot go backward in addresses. This means
1101 we've incorrectly ordered the statements in the sequence. */
1102 gas_assert ((offsetT
) addr_delta
>= 0);
1104 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1105 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1107 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1108 if (line_delta
!= INT_MAX
)
1110 *p
++ = DW_LNS_advance_line
;
1111 p
+= output_leb128 (p
, line_delta
, 1);
1114 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1116 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1117 advance the address by at most 64K. Linker relaxation (without
1118 which this function would not be used) could change the operand by
1119 an unknown amount. If the address increment is getting close to
1120 the limit, just reset the address. */
1121 if (addr_delta
> ADDR_DELTA_LIMIT
)
1126 gas_assert (pexp
->X_op
== O_subtract
);
1127 to_sym
= pexp
->X_add_symbol
;
1129 *p
++ = DW_LNS_extended_op
;
1130 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1131 *p
++ = DW_LNE_set_address
;
1132 exp
.X_op
= O_symbol
;
1133 exp
.X_add_symbol
= to_sym
;
1134 exp
.X_add_number
= 0;
1135 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1136 p
+= sizeof_address
;
1140 *p
++ = DW_LNS_fixed_advance_pc
;
1141 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1145 if (line_delta
== INT_MAX
)
1147 *p
++ = DW_LNS_extended_op
;
1149 *p
++ = DW_LNE_end_sequence
;
1154 gas_assert (p
== end
);
1157 /* Generate a variant frag that we can use to relax address/line
1158 increments between fragments of the target segment. */
1161 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1166 exp
.X_op
= O_subtract
;
1167 exp
.X_add_symbol
= to_sym
;
1168 exp
.X_op_symbol
= from_sym
;
1169 exp
.X_add_number
= 0;
1171 /* The maximum size of the frag is the line delta with a maximum
1172 sized address delta. */
1173 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1174 max_chars
= size_fixed_inc_line_addr (line_delta
,
1175 -DWARF2_LINE_MIN_INSN_LENGTH
);
1177 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1179 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1180 make_expr_symbol (&exp
), line_delta
, NULL
);
1183 /* The function estimates the size of a rs_dwarf2dbg variant frag
1184 based on the current values of the symbols. It is called before
1185 the relaxation loop. We set fr_subtype to the expected length. */
1188 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1193 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1194 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1195 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1197 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1199 frag
->fr_subtype
= size
;
1204 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1205 current values of the symbols. fr_subtype is the current length
1206 of the frag. This returns the change in frag length. */
1209 dwarf2dbg_relax_frag (fragS
*frag
)
1211 int old_size
, new_size
;
1213 old_size
= frag
->fr_subtype
;
1214 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1216 return new_size
- old_size
;
1219 /* This function converts a rs_dwarf2dbg variant frag into a normal
1220 fill frag. This is called after all relaxation has been done.
1221 fr_subtype will be the desired length of the frag. */
1224 dwarf2dbg_convert_frag (fragS
*frag
)
1228 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1230 /* If linker relaxation is enabled then the distance bewteen the two
1231 symbols in the frag->fr_symbol expression might change. Hence we
1232 cannot rely upon the value computed by resolve_symbol_value.
1233 Instead we leave the expression unfinalized and allow
1234 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1235 relocation) that will allow the linker to correctly compute the
1236 actual address difference. We have to use a fixed line advance for
1237 this as we cannot (easily) relocate leb128 encoded values. */
1238 int saved_finalize_syms
= finalize_syms
;
1241 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1242 finalize_syms
= saved_finalize_syms
;
1245 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1247 /* fr_var carries the max_chars that we created the fragment with.
1248 fr_subtype carries the current expected length. We must, of
1249 course, have allocated enough memory earlier. */
1250 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1252 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1253 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1254 frag
->fr_literal
+ frag
->fr_fix
,
1257 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1258 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1260 frag
->fr_fix
+= frag
->fr_subtype
;
1261 frag
->fr_type
= rs_fill
;
1263 frag
->fr_offset
= 0;
1266 /* Generate .debug_line content for the chain of line number entries
1267 beginning at E, for segment SEG. */
1270 process_entries (segT seg
, struct line_entry
*e
)
1272 unsigned filenum
= 1;
1274 unsigned column
= 0;
1276 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1277 fragS
*last_frag
= NULL
, *frag
;
1278 addressT last_frag_ofs
= 0, frag_ofs
;
1279 symbolS
*last_lab
= NULL
, *lab
;
1280 struct line_entry
*next
;
1282 if (flag_dwarf_sections
)
1285 const char * sec_name
;
1287 /* Switch to the relevent sub-section before we start to emit
1288 the line number table.
1290 FIXME: These sub-sections do not have a normal Line Number
1291 Program Header, thus strictly speaking they are not valid
1292 DWARF sections. Unfortunately the DWARF standard assumes
1293 a one-to-one relationship between compilation units and
1294 line number tables. Thus we have to have a .debug_line
1295 section, as well as our sub-sections, and we have to ensure
1296 that all of the sub-sections are merged into a proper
1297 .debug_line section before a debugger sees them. */
1299 sec_name
= bfd_get_section_name (stdoutput
, seg
);
1300 if (strcmp (sec_name
, ".text") != 0)
1304 len
= strlen (sec_name
);
1305 name
= xmalloc (len
+ 11 + 2);
1306 sprintf (name
, ".debug_line%s", sec_name
);
1307 subseg_set (subseg_get (name
, FALSE
), 0);
1310 /* Don't create a .debug_line.text section -
1311 that is redundant. Instead just switch back to the
1312 normal .debug_line section. */
1313 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1320 if (filenum
!= e
->loc
.filenum
)
1322 filenum
= e
->loc
.filenum
;
1323 out_opcode (DW_LNS_set_file
);
1324 out_uleb128 (filenum
);
1327 if (column
!= e
->loc
.column
)
1329 column
= e
->loc
.column
;
1330 out_opcode (DW_LNS_set_column
);
1331 out_uleb128 (column
);
1334 if (e
->loc
.discriminator
!= 0)
1336 out_opcode (DW_LNS_extended_op
);
1337 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1338 out_opcode (DW_LNE_set_discriminator
);
1339 out_uleb128 (e
->loc
.discriminator
);
1342 if (isa
!= e
->loc
.isa
)
1345 out_opcode (DW_LNS_set_isa
);
1349 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1351 flags
= e
->loc
.flags
;
1352 out_opcode (DW_LNS_negate_stmt
);
1355 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1356 out_opcode (DW_LNS_set_basic_block
);
1358 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1359 out_opcode (DW_LNS_set_prologue_end
);
1361 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1362 out_opcode (DW_LNS_set_epilogue_begin
);
1364 /* Don't try to optimize away redundant entries; gdb wants two
1365 entries for a function where the code starts on the same line as
1366 the {, and there's no way to identify that case here. Trust gcc
1367 to optimize appropriately. */
1368 line_delta
= e
->loc
.line
- line
;
1370 frag
= symbol_get_frag (lab
);
1371 frag_ofs
= S_GET_VALUE (lab
);
1373 if (last_frag
== NULL
)
1376 out_inc_line_addr (line_delta
, 0);
1378 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1379 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1381 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1386 last_frag_ofs
= frag_ofs
;
1394 /* Emit a DW_LNE_end_sequence for the end of the section. */
1395 frag
= last_frag_for_seg (seg
);
1396 frag_ofs
= get_frag_fix (frag
, seg
);
1397 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1398 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1401 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1402 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1406 /* Emit the directory and file tables for .debug_line. */
1409 out_file_list (void)
1416 /* Emit directory list. */
1417 for (i
= 1; i
< dirs_in_use
; ++i
)
1419 dir
= remap_debug_filename (dirs
[i
]);
1420 size
= strlen (dir
) + 1;
1421 cp
= frag_more (size
);
1422 memcpy (cp
, dir
, size
);
1427 for (i
= 1; i
< files_in_use
; ++i
)
1429 const char *fullfilename
;
1431 if (files
[i
].filename
== NULL
)
1433 as_bad (_("unassigned file number %ld"), (long) i
);
1434 /* Prevent a crash later, particularly for file 1. */
1435 files
[i
].filename
= "";
1439 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
1440 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
1441 size
= strlen (fullfilename
) + 1;
1442 cp
= frag_more (size
);
1443 memcpy (cp
, fullfilename
, size
);
1445 out_uleb128 (files
[i
].dir
); /* directory number */
1446 /* Output the last modification timestamp. */
1447 out_uleb128 (DWARF2_FILE_TIME_NAME (files
[i
].filename
,
1448 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1449 /* Output the filesize. */
1450 out_uleb128 (DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
1451 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1454 /* Terminate filename list. */
1458 /* Switch to SEC and output a header length field. Return the size of
1459 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1460 to the end of the section. EXPR->X_add_number will be set to the
1461 negative size of the header. */
1464 out_header (asection
*sec
, expressionS
*exp
)
1469 subseg_set (sec
, 0);
1471 if (flag_dwarf_sections
)
1473 /* If we are going to put the start and end symbols in different
1474 sections, then we need real symbols, not just fake, local ones. */
1476 start_sym
= symbol_make (".Ldebug_line_start");
1477 end_sym
= symbol_make (".Ldebug_line_end");
1478 symbol_set_value_now (start_sym
);
1482 start_sym
= symbol_temp_new_now ();
1483 end_sym
= symbol_temp_make ();
1486 /* Total length of the information. */
1487 exp
->X_op
= O_subtract
;
1488 exp
->X_add_symbol
= end_sym
;
1489 exp
->X_op_symbol
= start_sym
;
1491 switch (DWARF2_FORMAT (sec
))
1493 case dwarf2_format_32bit
:
1494 exp
->X_add_number
= -4;
1498 case dwarf2_format_64bit
:
1499 exp
->X_add_number
= -12;
1504 case dwarf2_format_64bit_irix
:
1505 exp
->X_add_number
= -8;
1510 as_fatal (_("internal error: unknown dwarf2 format"));
1514 /* Emit the collected .debug_line data. */
1517 out_debug_line (segT line_seg
)
1520 symbolS
*prologue_start
, *prologue_end
;
1525 sizeof_offset
= out_header (line_seg
, &exp
);
1526 line_end
= exp
.X_add_symbol
;
1529 out_two (DWARF2_LINE_VERSION
);
1531 /* Length of the prologue following this length. */
1532 prologue_start
= symbol_temp_make ();
1533 prologue_end
= symbol_temp_make ();
1534 exp
.X_op
= O_subtract
;
1535 exp
.X_add_symbol
= prologue_end
;
1536 exp
.X_op_symbol
= prologue_start
;
1537 exp
.X_add_number
= 0;
1538 emit_expr (&exp
, sizeof_offset
);
1539 symbol_set_value_now (prologue_start
);
1541 /* Parameters of the state machine. */
1542 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
1543 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
1544 out_byte (DWARF2_LINE_BASE
);
1545 out_byte (DWARF2_LINE_RANGE
);
1546 out_byte (DWARF2_LINE_OPCODE_BASE
);
1548 /* Standard opcode lengths. */
1549 out_byte (0); /* DW_LNS_copy */
1550 out_byte (1); /* DW_LNS_advance_pc */
1551 out_byte (1); /* DW_LNS_advance_line */
1552 out_byte (1); /* DW_LNS_set_file */
1553 out_byte (1); /* DW_LNS_set_column */
1554 out_byte (0); /* DW_LNS_negate_stmt */
1555 out_byte (0); /* DW_LNS_set_basic_block */
1556 out_byte (0); /* DW_LNS_const_add_pc */
1557 out_byte (1); /* DW_LNS_fixed_advance_pc */
1558 out_byte (0); /* DW_LNS_set_prologue_end */
1559 out_byte (0); /* DW_LNS_set_epilogue_begin */
1560 out_byte (1); /* DW_LNS_set_isa */
1564 symbol_set_value_now (prologue_end
);
1566 /* For each section, emit a statement program. */
1567 for (s
= all_segs
; s
; s
= s
->next
)
1568 if (SEG_NORMAL (s
->seg
))
1569 process_entries (s
->seg
, s
->head
->head
);
1571 as_warn ("dwarf line number information for %s ignored",
1572 segment_name (s
->seg
));
1574 if (flag_dwarf_sections
)
1575 /* We have to switch to the special .debug_line_end section
1576 before emitting the end-of-debug_line symbol. The linker
1577 script arranges for this section to be placed after all the
1578 (potentially garbage collected) .debug_line.<foo> sections.
1579 This section contains the line_end symbol which is used to
1580 compute the size of the linked .debug_line section, as seen
1581 in the DWARF Line Number header. */
1582 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
1584 symbol_set_value_now (line_end
);
1588 out_debug_ranges (segT ranges_seg
)
1590 unsigned int addr_size
= sizeof_address
;
1595 subseg_set (ranges_seg
, 0);
1597 /* Base Address Entry. */
1598 for (i
= 0; i
< addr_size
; i
++)
1600 for (i
= 0; i
< addr_size
; i
++)
1603 /* Range List Entry. */
1604 for (s
= all_segs
; s
; s
= s
->next
)
1609 frag
= first_frag_for_seg (s
->seg
);
1610 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1611 s
->text_start
= beg
;
1613 frag
= last_frag_for_seg (s
->seg
);
1614 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1617 exp
.X_op
= O_symbol
;
1618 exp
.X_add_symbol
= beg
;
1619 exp
.X_add_number
= 0;
1620 emit_expr (&exp
, addr_size
);
1622 exp
.X_op
= O_symbol
;
1623 exp
.X_add_symbol
= end
;
1624 exp
.X_add_number
= 0;
1625 emit_expr (&exp
, addr_size
);
1628 /* End of Range Entry. */
1629 for (i
= 0; i
< addr_size
; i
++)
1631 for (i
= 0; i
< addr_size
; i
++)
1635 /* Emit data for .debug_aranges. */
1638 out_debug_aranges (segT aranges_seg
, segT info_seg
)
1640 unsigned int addr_size
= sizeof_address
;
1644 symbolS
*aranges_end
;
1648 sizeof_offset
= out_header (aranges_seg
, &exp
);
1649 aranges_end
= exp
.X_add_symbol
;
1650 size
= -exp
.X_add_number
;
1653 out_two (DWARF2_ARANGES_VERSION
);
1656 /* Offset to .debug_info. */
1657 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
1658 size
+= sizeof_offset
;
1660 /* Size of an address (offset portion). */
1661 out_byte (addr_size
);
1664 /* Size of a segment descriptor. */
1668 /* Align the header. */
1669 while ((size
++ % (2 * addr_size
)) > 0)
1672 for (s
= all_segs
; s
; s
= s
->next
)
1677 frag
= first_frag_for_seg (s
->seg
);
1678 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1679 s
->text_start
= beg
;
1681 frag
= last_frag_for_seg (s
->seg
);
1682 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1685 exp
.X_op
= O_symbol
;
1686 exp
.X_add_symbol
= beg
;
1687 exp
.X_add_number
= 0;
1688 emit_expr (&exp
, addr_size
);
1690 exp
.X_op
= O_subtract
;
1691 exp
.X_add_symbol
= end
;
1692 exp
.X_op_symbol
= beg
;
1693 exp
.X_add_number
= 0;
1694 emit_expr (&exp
, addr_size
);
1697 p
= frag_more (2 * addr_size
);
1698 md_number_to_chars (p
, 0, addr_size
);
1699 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1701 symbol_set_value_now (aranges_end
);
1704 /* Emit data for .debug_abbrev. Note that this must be kept in
1705 sync with out_debug_info below. */
1708 out_debug_abbrev (segT abbrev_seg
,
1709 segT info_seg ATTRIBUTE_UNUSED
,
1710 segT line_seg ATTRIBUTE_UNUSED
)
1712 subseg_set (abbrev_seg
, 0);
1715 out_uleb128 (DW_TAG_compile_unit
);
1716 out_byte (DW_CHILDREN_no
);
1717 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
1718 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1720 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
1721 if (all_segs
->next
== NULL
)
1723 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1724 if (DWARF2_VERSION
< 4)
1725 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1727 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
1728 ? DW_FORM_data4
: DW_FORM_data8
));
1732 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
1733 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
1735 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
1737 out_abbrev (DW_AT_name
, DW_FORM_string
);
1738 out_abbrev (DW_AT_comp_dir
, DW_FORM_string
);
1739 out_abbrev (DW_AT_producer
, DW_FORM_string
);
1740 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1743 /* Terminate the abbreviations for this compilation unit. */
1747 /* Emit a description of this compilation unit for .debug_info. */
1750 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
)
1753 const char *comp_dir
;
1754 const char *dirname
;
1761 sizeof_offset
= out_header (info_seg
, &exp
);
1762 info_end
= exp
.X_add_symbol
;
1764 /* DWARF version. */
1765 out_two (DWARF2_VERSION
);
1767 /* .debug_abbrev offset */
1768 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
1770 /* Target address size. */
1771 out_byte (sizeof_address
);
1773 /* DW_TAG_compile_unit DIE abbrev */
1776 /* DW_AT_stmt_list */
1777 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
1778 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
1781 /* These two attributes are emitted if all of the code is contiguous. */
1782 if (all_segs
->next
== NULL
)
1785 exp
.X_op
= O_symbol
;
1786 exp
.X_add_symbol
= all_segs
->text_start
;
1787 exp
.X_add_number
= 0;
1788 emit_expr (&exp
, sizeof_address
);
1791 if (DWARF2_VERSION
< 4)
1792 exp
.X_op
= O_symbol
;
1795 exp
.X_op
= O_subtract
;
1796 exp
.X_op_symbol
= all_segs
->text_start
;
1798 exp
.X_add_symbol
= all_segs
->text_end
;
1799 exp
.X_add_number
= 0;
1800 emit_expr (&exp
, sizeof_address
);
1804 /* This attribute is emitted if the code is disjoint. */
1806 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
1809 /* DW_AT_name. We don't have the actual file name that was present
1810 on the command line, so assume files[1] is the main input file.
1811 We're not supposed to get called unless at least one line number
1812 entry was emitted, so this should always be defined. */
1813 if (files_in_use
== 0)
1817 dirname
= remap_debug_filename (dirs
[files
[1].dir
]);
1818 len
= strlen (dirname
);
1820 /* Already has trailing slash. */
1821 p
= frag_more (len
);
1822 memcpy (p
, dirname
, len
);
1824 p
= frag_more (len
+ 1);
1825 memcpy (p
, dirname
, len
);
1826 INSERT_DIR_SEPARATOR (p
, len
);
1829 len
= strlen (files
[1].filename
) + 1;
1830 p
= frag_more (len
);
1831 memcpy (p
, files
[1].filename
, len
);
1833 /* DW_AT_comp_dir */
1834 comp_dir
= remap_debug_filename (getpwd ());
1835 len
= strlen (comp_dir
) + 1;
1836 p
= frag_more (len
);
1837 memcpy (p
, comp_dir
, len
);
1839 /* DW_AT_producer */
1840 sprintf (producer
, "GNU AS %s", VERSION
);
1841 len
= strlen (producer
) + 1;
1842 p
= frag_more (len
);
1843 memcpy (p
, producer
, len
);
1845 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1846 dwarf2 draft has no standard code for assembler. */
1847 out_two (DW_LANG_Mips_Assembler
);
1849 symbol_set_value_now (info_end
);
1855 last_seg_ptr
= &all_segs
;
1859 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1860 were any .file/.loc directives, or --gdwarf2 was given, or if the
1861 file has a non-empty .debug_info section and an empty .debug_line
1862 section. If we emit .debug_line, and the .debug_info section is
1863 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1864 ALL_SEGS will be non-null if there were any .file/.loc directives,
1865 or --gdwarf2 was given and there were any located instructions
1869 dwarf2_finish (void)
1874 int emit_other_sections
= 0;
1875 int empty_debug_line
= 0;
1877 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
1878 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
1880 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
1881 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
1883 /* We can't construct a new debug_line section if we already have one.
1885 if (all_segs
&& !empty_debug_line
)
1886 as_fatal ("duplicate .debug_line sections");
1888 if ((!all_segs
&& emit_other_sections
)
1889 || (!emit_other_sections
&& !empty_debug_line
))
1890 /* If there is no line information and no non-empty .debug_info
1891 section, or if there is both a non-empty .debug_info and a non-empty
1892 .debug_line, then we do nothing. */
1895 /* Calculate the size of an address for the target machine. */
1896 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
1898 /* Create and switch to the line number section. */
1899 line_seg
= subseg_new (".debug_line", 0);
1900 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
| SEC_DEBUGGING
);
1902 /* For each subsection, chain the debug entries together. */
1903 for (s
= all_segs
; s
; s
= s
->next
)
1905 struct line_subseg
*lss
= s
->head
;
1906 struct line_entry
**ptail
= lss
->ptail
;
1908 while ((lss
= lss
->next
) != NULL
)
1915 out_debug_line (line_seg
);
1917 /* If this is assembler generated line info, and there is no
1918 debug_info already, we need .debug_info and .debug_abbrev
1919 sections as well. */
1920 if (emit_other_sections
)
1926 gas_assert (all_segs
);
1928 info_seg
= subseg_new (".debug_info", 0);
1929 abbrev_seg
= subseg_new (".debug_abbrev", 0);
1930 aranges_seg
= subseg_new (".debug_aranges", 0);
1932 bfd_set_section_flags (stdoutput
, info_seg
,
1933 SEC_READONLY
| SEC_DEBUGGING
);
1934 bfd_set_section_flags (stdoutput
, abbrev_seg
,
1935 SEC_READONLY
| SEC_DEBUGGING
);
1936 bfd_set_section_flags (stdoutput
, aranges_seg
,
1937 SEC_READONLY
| SEC_DEBUGGING
);
1939 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
1941 if (all_segs
->next
== NULL
)
1945 ranges_seg
= subseg_new (".debug_ranges", 0);
1946 bfd_set_section_flags (stdoutput
, ranges_seg
,
1947 SEC_READONLY
| SEC_DEBUGGING
);
1948 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
1949 out_debug_ranges (ranges_seg
);
1952 out_debug_aranges (aranges_seg
, info_seg
);
1953 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
1954 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
);