1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999-2013 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)
162 struct line_entry
*next
;
164 struct dwarf2_line_info loc
;
168 struct line_subseg
*next
;
170 struct line_entry
*head
;
171 struct line_entry
**ptail
;
175 struct line_seg
*next
;
177 struct line_subseg
*head
;
182 /* Collects data for all line table entries during assembly. */
183 static struct line_seg
*all_segs
;
184 /* Hash used to quickly lookup a segment by name, avoiding the need to search
185 through the all_segs list. */
186 static struct hash_control
*all_segs_hash
;
187 static struct line_seg
**last_seg_ptr
;
190 const char *filename
;
194 /* Table of files used by .debug_line. */
195 static struct file_entry
*files
;
196 static unsigned int files_in_use
;
197 static unsigned int files_allocated
;
199 /* Table of directories used by .debug_line. */
201 static unsigned int dirs_in_use
;
202 static unsigned int dirs_allocated
;
204 /* TRUE when we've seen a .loc directive recently. Used to avoid
205 doing work when there's nothing to do. */
206 bfd_boolean dwarf2_loc_directive_seen
;
208 /* TRUE when we're supposed to set the basic block mark whenever a
210 bfd_boolean dwarf2_loc_mark_labels
;
212 /* Current location as indicated by the most recent .loc directive. */
213 static struct dwarf2_line_info current
= {
215 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
219 /* The size of an address on the target. */
220 static unsigned int sizeof_address
;
222 static unsigned int get_filenum (const char *, unsigned int);
224 #ifndef TC_DWARF2_EMIT_OFFSET
225 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
227 /* Create an offset to .dwarf2_*. */
230 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
235 exp
.X_add_symbol
= symbol
;
236 exp
.X_add_number
= 0;
237 emit_expr (&exp
, size
);
241 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
243 static struct line_subseg
*
244 get_line_subseg (segT seg
, subsegT subseg
)
246 static segT last_seg
;
247 static subsegT last_subseg
;
248 static struct line_subseg
*last_line_subseg
;
251 struct line_subseg
**pss
, *lss
;
253 if (seg
== last_seg
&& subseg
== last_subseg
)
254 return last_line_subseg
;
256 s
= (struct line_seg
*) hash_find (all_segs_hash
, seg
->name
);
259 s
= (struct line_seg
*) xmalloc (sizeof (*s
));
264 last_seg_ptr
= &s
->next
;
265 hash_insert (all_segs_hash
, seg
->name
, s
);
267 gas_assert (seg
== s
->seg
);
269 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
271 if (lss
->subseg
== subseg
)
273 if (lss
->subseg
> subseg
)
277 lss
= (struct line_subseg
*) xmalloc (sizeof (*lss
));
279 lss
->subseg
= subseg
;
281 lss
->ptail
= &lss
->head
;
286 last_subseg
= subseg
;
287 last_line_subseg
= lss
;
292 /* Record an entry for LOC occurring at LABEL. */
295 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
297 struct line_subseg
*lss
;
298 struct line_entry
*e
;
300 e
= (struct line_entry
*) xmalloc (sizeof (*e
));
305 lss
= get_line_subseg (now_seg
, now_subseg
);
307 lss
->ptail
= &e
->next
;
310 /* Record an entry for LOC occurring at OFS within the current fragment. */
313 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
315 static unsigned int line
= -1;
316 static unsigned int filenum
= -1;
320 /* Early out for as-yet incomplete location information. */
321 if (loc
->filenum
== 0 || loc
->line
== 0)
324 /* Don't emit sequences of line symbols for the same line when the
325 symbols apply to assembler code. It is necessary to emit
326 duplicate line symbols when a compiler asks for them, because GDB
327 uses them to determine the end of the prologue. */
328 if (debug_type
== DEBUG_DWARF2
329 && line
== loc
->line
&& filenum
== loc
->filenum
)
333 filenum
= loc
->filenum
;
339 /* Use a non-fake name for the line number location,
340 so that it can be referred to by relocations. */
341 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
342 sym
= symbol_new (name
, now_seg
, ofs
, frag_now
);
345 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
346 dwarf2_gen_line_info_1 (sym
, loc
);
349 /* Returns the current source information. If .file directives have
350 been encountered, the info for the corresponding source file is
351 returned. Otherwise, the info for the assembly source file is
355 dwarf2_where (struct dwarf2_line_info
*line
)
357 if (debug_type
== DEBUG_DWARF2
)
360 as_where (&filename
, &line
->line
);
361 line
->filenum
= get_filenum (filename
, 0);
363 line
->flags
= DWARF2_FLAG_IS_STMT
;
364 line
->isa
= current
.isa
;
365 line
->discriminator
= current
.discriminator
;
371 /* A hook to allow the target backend to inform the line number state
372 machine of isa changes when assembler debug info is enabled. */
375 dwarf2_set_isa (unsigned int isa
)
380 /* Called for each machine instruction, or relatively atomic group of
381 machine instructions (ie built-in macro). The instruction or group
382 is SIZE bytes in length. If dwarf2 line number generation is called
383 for, emit a line statement appropriately. */
386 dwarf2_emit_insn (int size
)
388 struct dwarf2_line_info loc
;
390 if (!dwarf2_loc_directive_seen
&& debug_type
!= DEBUG_DWARF2
)
395 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
396 dwarf2_consume_line_info ();
399 /* Called after the current line information has been either used with
400 dwarf2_gen_line_info or saved with a machine instruction for later use.
401 This resets the state of the line number information to reflect that
405 dwarf2_consume_line_info (void)
407 /* Unless we generate DWARF2 debugging information for each
408 assembler line, we only emit one line symbol for one LOC. */
409 dwarf2_loc_directive_seen
= FALSE
;
411 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
412 | DWARF2_FLAG_PROLOGUE_END
413 | DWARF2_FLAG_EPILOGUE_BEGIN
);
414 current
.discriminator
= 0;
417 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
418 is enabled, emit a basic block marker. */
421 dwarf2_emit_label (symbolS
*label
)
423 struct dwarf2_line_info loc
;
425 if (!dwarf2_loc_mark_labels
)
427 if (S_GET_SEGMENT (label
) != now_seg
)
429 if (!(bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
))
431 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
436 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
438 dwarf2_gen_line_info_1 (label
, &loc
);
439 dwarf2_consume_line_info ();
442 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
443 allocate it on that file table slot, otherwise return the first
447 get_filenum (const char *filename
, unsigned int num
)
449 static unsigned int last_used
, last_used_dir_len
;
454 if (num
== 0 && last_used
)
456 if (! files
[last_used
].dir
457 && filename_cmp (filename
, files
[last_used
].filename
) == 0)
459 if (files
[last_used
].dir
460 && filename_ncmp (filename
, dirs
[files
[last_used
].dir
],
461 last_used_dir_len
) == 0
462 && IS_DIR_SEPARATOR (filename
[last_used_dir_len
])
463 && filename_cmp (filename
+ last_used_dir_len
+ 1,
464 files
[last_used
].filename
) == 0)
468 file
= lbasename (filename
);
469 /* Don't make empty string from / or A: from A:/ . */
470 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
471 if (file
<= filename
+ 3)
474 if (file
== filename
+ 1)
477 dir_len
= file
- filename
;
482 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
485 for (dir
= 1; dir
< dirs_in_use
; ++dir
)
486 if (filename_ncmp (filename
, dirs
[dir
], dir_len
) == 0
487 && dirs
[dir
][dir_len
] == '\0')
490 if (dir
>= dirs_in_use
)
492 if (dir
>= dirs_allocated
)
494 dirs_allocated
= dir
+ 32;
496 xrealloc (dirs
, (dir
+ 32) * sizeof (const char *));
499 dirs
[dir
] = (char *) xmalloc (dir_len
+ 1);
500 memcpy (dirs
[dir
], filename
, dir_len
);
501 dirs
[dir
][dir_len
] = '\0';
502 dirs_in_use
= dir
+ 1;
508 for (i
= 1; i
< files_in_use
; ++i
)
509 if (files
[i
].dir
== dir
511 && filename_cmp (file
, files
[i
].filename
) == 0)
514 last_used_dir_len
= dir_len
;
521 if (i
>= files_allocated
)
523 unsigned int old
= files_allocated
;
525 files_allocated
= i
+ 32;
526 files
= (struct file_entry
*)
527 xrealloc (files
, (i
+ 32) * sizeof (struct file_entry
));
529 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
532 files
[i
].filename
= num
? file
: xstrdup (file
);
534 if (files_in_use
< i
+ 1)
535 files_in_use
= i
+ 1;
537 last_used_dir_len
= dir_len
;
542 /* Handle two forms of .file directive:
543 - Pass .file "source.c" to s_app_file
544 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
546 If an entry is added to the file table, return a pointer to the filename. */
549 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
555 /* Continue to accept a bare string and pass it off. */
557 if (*input_line_pointer
== '"')
563 num
= get_absolute_expression ();
564 filename
= demand_copy_C_string (&filename_len
);
565 if (filename
== NULL
)
567 demand_empty_rest_of_line ();
571 as_bad (_("file number less than one"));
575 /* A .file directive implies compiler generated debug information is
576 being supplied. Turn off gas generated debug info. */
577 debug_type
= DEBUG_NONE
;
579 if (num
< (int) files_in_use
&& files
[num
].filename
!= 0)
581 as_bad (_("file number %ld already allocated"), (long) num
);
585 get_filenum (filename
, num
);
591 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
593 offsetT filenum
, line
;
595 /* If we see two .loc directives in a row, force the first one to be
597 if (dwarf2_loc_directive_seen
)
598 dwarf2_emit_insn (0);
600 filenum
= get_absolute_expression ();
602 line
= get_absolute_expression ();
606 as_bad (_("file number less than one"));
609 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== 0)
611 as_bad (_("unassigned file number %ld"), (long) filenum
);
615 current
.filenum
= filenum
;
617 current
.discriminator
= 0;
622 if (files
[filenum
].dir
)
624 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
625 size_t file_len
= strlen (files
[filenum
].filename
);
626 char *cp
= (char *) alloca (dir_len
+ 1 + file_len
+ 1);
628 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
629 INSERT_DIR_SEPARATOR (cp
, dir_len
);
630 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
631 cp
[dir_len
+ file_len
+ 1] = '\0';
632 listing_source_file (cp
);
635 listing_source_file (files
[filenum
].filename
);
636 listing_source_line (line
);
641 if (ISDIGIT (*input_line_pointer
))
643 current
.column
= get_absolute_expression ();
647 while (ISALPHA (*input_line_pointer
))
652 p
= input_line_pointer
;
653 c
= get_symbol_end ();
655 if (strcmp (p
, "basic_block") == 0)
657 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
658 *input_line_pointer
= c
;
660 else if (strcmp (p
, "prologue_end") == 0)
662 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
663 *input_line_pointer
= c
;
665 else if (strcmp (p
, "epilogue_begin") == 0)
667 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
668 *input_line_pointer
= c
;
670 else if (strcmp (p
, "is_stmt") == 0)
672 *input_line_pointer
= c
;
673 value
= get_absolute_expression ();
675 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
677 current
.flags
|= DWARF2_FLAG_IS_STMT
;
680 as_bad (_("is_stmt value not 0 or 1"));
684 else if (strcmp (p
, "isa") == 0)
686 *input_line_pointer
= c
;
687 value
= get_absolute_expression ();
692 as_bad (_("isa number less than zero"));
696 else if (strcmp (p
, "discriminator") == 0)
698 *input_line_pointer
= c
;
699 value
= get_absolute_expression ();
701 current
.discriminator
= value
;
704 as_bad (_("discriminator less than zero"));
710 as_bad (_("unknown .loc sub-directive `%s'"), p
);
711 *input_line_pointer
= c
;
718 demand_empty_rest_of_line ();
719 dwarf2_loc_directive_seen
= TRUE
;
720 debug_type
= DEBUG_NONE
;
724 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
726 offsetT value
= get_absolute_expression ();
728 if (value
!= 0 && value
!= 1)
730 as_bad (_("expected 0 or 1"));
731 ignore_rest_of_line ();
735 dwarf2_loc_mark_labels
= value
!= 0;
736 demand_empty_rest_of_line ();
741 first_frag_for_seg (segT seg
)
743 return seg_info (seg
)->frchainP
->frch_root
;
747 last_frag_for_seg (segT seg
)
749 frchainS
*f
= seg_info (seg
)->frchainP
;
751 while (f
->frch_next
!= NULL
)
757 /* Emit a single byte into the current segment. */
762 FRAG_APPEND_1_CHAR (byte
);
765 /* Emit a statement program opcode into the current segment. */
773 /* Emit a two-byte word into the current segment. */
778 md_number_to_chars (frag_more (2), data
, 2);
781 /* Emit a four byte word into the current segment. */
786 md_number_to_chars (frag_more (4), data
, 4);
789 /* Emit an unsigned "little-endian base 128" number. */
792 out_uleb128 (addressT value
)
794 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
797 /* Emit a signed "little-endian base 128" number. */
800 out_leb128 (addressT value
)
802 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
805 /* Emit a tuple for .debug_abbrev. */
808 out_abbrev (int name
, int form
)
814 /* Get the size of a fragment. */
817 get_frag_fix (fragS
*frag
, segT seg
)
824 /* If a fragment is the last in the chain, special measures must be
825 taken to find its size before relaxation, since it may be pending
826 on some subsegment chain. */
827 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
828 if (fr
->frch_last
== frag
)
829 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
834 /* Set an absolute address (may result in a relocation entry). */
837 out_set_addr (symbolS
*sym
)
841 out_opcode (DW_LNS_extended_op
);
842 out_uleb128 (sizeof_address
+ 1);
844 out_opcode (DW_LNE_set_address
);
846 exp
.X_add_symbol
= sym
;
847 exp
.X_add_number
= 0;
848 emit_expr (&exp
, sizeof_address
);
851 static void scale_addr_delta (addressT
*);
854 scale_addr_delta (addressT
*addr_delta
)
856 static int printed_this
= 0;
857 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
859 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
861 as_bad("unaligned opcodes detected in executable segment");
864 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
868 /* Encode a pair of line and address skips as efficiently as possible.
869 Note that the line skip is signed, whereas the address skip is unsigned.
871 The following two routines *must* be kept in sync. This is
872 enforced by making emit_inc_line_addr abort if we do not emit
873 exactly the expected number of bytes. */
876 size_inc_line_addr (int line_delta
, addressT addr_delta
)
878 unsigned int tmp
, opcode
;
881 /* Scale the address delta by the minimum instruction length. */
882 scale_addr_delta (&addr_delta
);
884 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
885 We cannot use special opcodes here, since we want the end_sequence
886 to emit the matrix entry. */
887 if (line_delta
== INT_MAX
)
889 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
892 len
= 1 + sizeof_leb128 (addr_delta
, 0);
896 /* Bias the line delta by the base. */
897 tmp
= line_delta
- DWARF2_LINE_BASE
;
899 /* If the line increment is out of range of a special opcode, we
900 must encode it with DW_LNS_advance_line. */
901 if (tmp
>= DWARF2_LINE_RANGE
)
903 len
= 1 + sizeof_leb128 (line_delta
, 1);
905 tmp
= 0 - DWARF2_LINE_BASE
;
908 /* Bias the opcode by the special opcode base. */
909 tmp
+= DWARF2_LINE_OPCODE_BASE
;
911 /* Avoid overflow when addr_delta is large. */
912 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
914 /* Try using a special opcode. */
915 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
919 /* Try using DW_LNS_const_add_pc followed by special op. */
920 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
925 /* Otherwise use DW_LNS_advance_pc. */
926 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
928 /* DW_LNS_copy or special opcode. */
935 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
937 unsigned int tmp
, opcode
;
941 /* Line number sequences cannot go backward in addresses. This means
942 we've incorrectly ordered the statements in the sequence. */
943 gas_assert ((offsetT
) addr_delta
>= 0);
945 /* Scale the address delta by the minimum instruction length. */
946 scale_addr_delta (&addr_delta
);
948 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
949 We cannot use special opcodes here, since we want the end_sequence
950 to emit the matrix entry. */
951 if (line_delta
== INT_MAX
)
953 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
954 *p
++ = DW_LNS_const_add_pc
;
957 *p
++ = DW_LNS_advance_pc
;
958 p
+= output_leb128 (p
, addr_delta
, 0);
961 *p
++ = DW_LNS_extended_op
;
963 *p
++ = DW_LNE_end_sequence
;
967 /* Bias the line delta by the base. */
968 tmp
= line_delta
- DWARF2_LINE_BASE
;
970 /* If the line increment is out of range of a special opcode, we
971 must encode it with DW_LNS_advance_line. */
972 if (tmp
>= DWARF2_LINE_RANGE
)
974 *p
++ = DW_LNS_advance_line
;
975 p
+= output_leb128 (p
, line_delta
, 1);
978 tmp
= 0 - DWARF2_LINE_BASE
;
982 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
984 if (line_delta
== 0 && addr_delta
== 0)
990 /* Bias the opcode by the special opcode base. */
991 tmp
+= DWARF2_LINE_OPCODE_BASE
;
993 /* Avoid overflow when addr_delta is large. */
994 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
996 /* Try using a special opcode. */
997 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1004 /* Try using DW_LNS_const_add_pc followed by special op. */
1005 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1008 *p
++ = DW_LNS_const_add_pc
;
1014 /* Otherwise use DW_LNS_advance_pc. */
1015 *p
++ = DW_LNS_advance_pc
;
1016 p
+= output_leb128 (p
, addr_delta
, 0);
1024 gas_assert (p
== end
);
1027 /* Handy routine to combine calls to the above two routines. */
1030 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1032 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1033 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1036 /* Write out an alternative form of line and address skips using
1037 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1038 line and address information, but it is required if linker relaxation
1039 could change the code offsets. The following two routines *must* be
1041 #define ADDR_DELTA_LIMIT 50000
1044 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1048 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1049 if (line_delta
!= INT_MAX
)
1050 len
= 1 + sizeof_leb128 (line_delta
, 1);
1052 if (addr_delta
> ADDR_DELTA_LIMIT
)
1054 /* DW_LNS_extended_op */
1055 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1056 /* DW_LNE_set_address */
1057 len
+= 1 + sizeof_address
;
1060 /* DW_LNS_fixed_advance_pc */
1063 if (line_delta
== INT_MAX
)
1064 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1074 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1078 char *end
= p
+ len
;
1080 /* Line number sequences cannot go backward in addresses. This means
1081 we've incorrectly ordered the statements in the sequence. */
1082 gas_assert ((offsetT
) addr_delta
>= 0);
1084 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1085 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1087 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1088 if (line_delta
!= INT_MAX
)
1090 *p
++ = DW_LNS_advance_line
;
1091 p
+= output_leb128 (p
, line_delta
, 1);
1094 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1096 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1097 advance the address by at most 64K. Linker relaxation (without
1098 which this function would not be used) could change the operand by
1099 an unknown amount. If the address increment is getting close to
1100 the limit, just reset the address. */
1101 if (addr_delta
> ADDR_DELTA_LIMIT
)
1106 gas_assert (pexp
->X_op
== O_subtract
);
1107 to_sym
= pexp
->X_add_symbol
;
1109 *p
++ = DW_LNS_extended_op
;
1110 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1111 *p
++ = DW_LNE_set_address
;
1112 exp
.X_op
= O_symbol
;
1113 exp
.X_add_symbol
= to_sym
;
1114 exp
.X_add_number
= 0;
1115 emit_expr_fix (&exp
, sizeof_address
, frag
, p
);
1116 p
+= sizeof_address
;
1120 *p
++ = DW_LNS_fixed_advance_pc
;
1121 emit_expr_fix (pexp
, 2, frag
, p
);
1125 if (line_delta
== INT_MAX
)
1127 *p
++ = DW_LNS_extended_op
;
1129 *p
++ = DW_LNE_end_sequence
;
1134 gas_assert (p
== end
);
1137 /* Generate a variant frag that we can use to relax address/line
1138 increments between fragments of the target segment. */
1141 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1146 exp
.X_op
= O_subtract
;
1147 exp
.X_add_symbol
= to_sym
;
1148 exp
.X_op_symbol
= from_sym
;
1149 exp
.X_add_number
= 0;
1151 /* The maximum size of the frag is the line delta with a maximum
1152 sized address delta. */
1153 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1154 max_chars
= size_fixed_inc_line_addr (line_delta
,
1155 -DWARF2_LINE_MIN_INSN_LENGTH
);
1157 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1159 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1160 make_expr_symbol (&exp
), line_delta
, NULL
);
1163 /* The function estimates the size of a rs_dwarf2dbg variant frag
1164 based on the current values of the symbols. It is called before
1165 the relaxation loop. We set fr_subtype to the expected length. */
1168 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1173 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1174 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1175 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1177 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1179 frag
->fr_subtype
= size
;
1184 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1185 current values of the symbols. fr_subtype is the current length
1186 of the frag. This returns the change in frag length. */
1189 dwarf2dbg_relax_frag (fragS
*frag
)
1191 int old_size
, new_size
;
1193 old_size
= frag
->fr_subtype
;
1194 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1196 return new_size
- old_size
;
1199 /* This function converts a rs_dwarf2dbg variant frag into a normal
1200 fill frag. This is called after all relaxation has been done.
1201 fr_subtype will be the desired length of the frag. */
1204 dwarf2dbg_convert_frag (fragS
*frag
)
1208 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1210 /* If linker relaxation is enabled then the distance bewteen the two
1211 symbols in the frag->fr_symbol expression might change. Hence we
1212 cannot rely upon the value computed by resolve_symbol_value.
1213 Instead we leave the expression unfinalized and allow
1214 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1215 relocation) that will allow the linker to correctly compute the
1216 actual address difference. We have to use a fixed line advance for
1217 this as we cannot (easily) relocate leb128 encoded values. */
1218 int saved_finalize_syms
= finalize_syms
;
1221 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1222 finalize_syms
= saved_finalize_syms
;
1225 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1227 /* fr_var carries the max_chars that we created the fragment with.
1228 fr_subtype carries the current expected length. We must, of
1229 course, have allocated enough memory earlier. */
1230 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1232 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1233 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1234 frag
->fr_literal
+ frag
->fr_fix
,
1237 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1238 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1240 frag
->fr_fix
+= frag
->fr_subtype
;
1241 frag
->fr_type
= rs_fill
;
1243 frag
->fr_offset
= 0;
1246 /* Generate .debug_line content for the chain of line number entries
1247 beginning at E, for segment SEG. */
1250 process_entries (segT seg
, struct line_entry
*e
)
1252 unsigned filenum
= 1;
1254 unsigned column
= 0;
1256 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1257 fragS
*last_frag
= NULL
, *frag
;
1258 addressT last_frag_ofs
= 0, frag_ofs
;
1259 symbolS
*last_lab
= NULL
, *lab
;
1260 struct line_entry
*next
;
1262 if (flag_dwarf_sections
)
1265 const char * sec_name
;
1267 /* Switch to the relevent sub-section before we start to emit
1268 the line number table.
1270 FIXME: These sub-sections do not have a normal Line Number
1271 Program Header, thus strictly speaking they are not valid
1272 DWARF sections. Unfortunately the DWARF standard assumes
1273 a one-to-one relationship between compilation units and
1274 line number tables. Thus we have to have a .debug_line
1275 section, as well as our sub-sections, and we have to ensure
1276 that all of the sub-sections are merged into a proper
1277 .debug_line section before a debugger sees them. */
1279 sec_name
= bfd_get_section_name (stdoutput
, seg
);
1280 if (strcmp (sec_name
, ".text") != 0)
1284 len
= strlen (sec_name
);
1285 name
= xmalloc (len
+ 11 + 2);
1286 sprintf (name
, ".debug_line%s", sec_name
);
1287 subseg_set (subseg_get (name
, FALSE
), 0);
1290 /* Don't create a .debug_line.text section -
1291 that is redundant. Instead just switch back to the
1292 normal .debug_line section. */
1293 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1300 if (filenum
!= e
->loc
.filenum
)
1302 filenum
= e
->loc
.filenum
;
1303 out_opcode (DW_LNS_set_file
);
1304 out_uleb128 (filenum
);
1307 if (column
!= e
->loc
.column
)
1309 column
= e
->loc
.column
;
1310 out_opcode (DW_LNS_set_column
);
1311 out_uleb128 (column
);
1314 if (e
->loc
.discriminator
!= 0)
1316 out_opcode (DW_LNS_extended_op
);
1317 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1318 out_opcode (DW_LNE_set_discriminator
);
1319 out_uleb128 (e
->loc
.discriminator
);
1322 if (isa
!= e
->loc
.isa
)
1325 out_opcode (DW_LNS_set_isa
);
1329 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1331 flags
= e
->loc
.flags
;
1332 out_opcode (DW_LNS_negate_stmt
);
1335 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1336 out_opcode (DW_LNS_set_basic_block
);
1338 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1339 out_opcode (DW_LNS_set_prologue_end
);
1341 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1342 out_opcode (DW_LNS_set_epilogue_begin
);
1344 /* Don't try to optimize away redundant entries; gdb wants two
1345 entries for a function where the code starts on the same line as
1346 the {, and there's no way to identify that case here. Trust gcc
1347 to optimize appropriately. */
1348 line_delta
= e
->loc
.line
- line
;
1350 frag
= symbol_get_frag (lab
);
1351 frag_ofs
= S_GET_VALUE (lab
);
1353 if (last_frag
== NULL
)
1356 out_inc_line_addr (line_delta
, 0);
1358 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1359 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1361 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1366 last_frag_ofs
= frag_ofs
;
1374 /* Emit a DW_LNE_end_sequence for the end of the section. */
1375 frag
= last_frag_for_seg (seg
);
1376 frag_ofs
= get_frag_fix (frag
, seg
);
1377 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1378 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1381 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1382 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1386 /* Emit the directory and file tables for .debug_line. */
1389 out_file_list (void)
1396 /* Emit directory list. */
1397 for (i
= 1; i
< dirs_in_use
; ++i
)
1399 dir
= remap_debug_filename (dirs
[i
]);
1400 size
= strlen (dir
) + 1;
1401 cp
= frag_more (size
);
1402 memcpy (cp
, dir
, size
);
1407 for (i
= 1; i
< files_in_use
; ++i
)
1409 const char *fullfilename
;
1411 if (files
[i
].filename
== NULL
)
1413 as_bad (_("unassigned file number %ld"), (long) i
);
1414 /* Prevent a crash later, particularly for file 1. */
1415 files
[i
].filename
= "";
1419 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
1420 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
1421 size
= strlen (fullfilename
) + 1;
1422 cp
= frag_more (size
);
1423 memcpy (cp
, fullfilename
, size
);
1425 out_uleb128 (files
[i
].dir
); /* directory number */
1426 /* Output the last modification timestamp. */
1427 out_uleb128 (DWARF2_FILE_TIME_NAME (files
[i
].filename
,
1428 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1429 /* Output the filesize. */
1430 out_uleb128 (DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
1431 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1434 /* Terminate filename list. */
1438 /* Switch to SEC and output a header length field. Return the size of
1439 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1440 to the end of the section. */
1443 out_header (asection
*sec
, expressionS
*exp
)
1448 subseg_set (sec
, 0);
1449 start_sym
= symbol_temp_new_now ();
1450 end_sym
= symbol_temp_make ();
1452 /* Total length of the information. */
1453 exp
->X_op
= O_subtract
;
1454 exp
->X_add_symbol
= end_sym
;
1455 exp
->X_op_symbol
= start_sym
;
1457 switch (DWARF2_FORMAT (sec
))
1459 case dwarf2_format_32bit
:
1460 exp
->X_add_number
= -4;
1464 case dwarf2_format_64bit
:
1465 exp
->X_add_number
= -12;
1470 case dwarf2_format_64bit_irix
:
1471 exp
->X_add_number
= -8;
1476 as_fatal (_("internal error: unknown dwarf2 format"));
1480 /* Emit the collected .debug_line data. */
1483 out_debug_line (segT line_seg
)
1486 symbolS
*prologue_end
;
1491 sizeof_offset
= out_header (line_seg
, &exp
);
1492 line_end
= exp
.X_add_symbol
;
1495 out_two (DWARF2_LINE_VERSION
);
1497 /* Length of the prologue following this length. */
1498 prologue_end
= symbol_temp_make ();
1499 exp
.X_add_symbol
= prologue_end
;
1500 exp
.X_add_number
= - (4 + 2 + 4);
1501 emit_expr (&exp
, sizeof_offset
);
1503 /* Parameters of the state machine. */
1504 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
1505 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
1506 out_byte (DWARF2_LINE_BASE
);
1507 out_byte (DWARF2_LINE_RANGE
);
1508 out_byte (DWARF2_LINE_OPCODE_BASE
);
1510 /* Standard opcode lengths. */
1511 out_byte (0); /* DW_LNS_copy */
1512 out_byte (1); /* DW_LNS_advance_pc */
1513 out_byte (1); /* DW_LNS_advance_line */
1514 out_byte (1); /* DW_LNS_set_file */
1515 out_byte (1); /* DW_LNS_set_column */
1516 out_byte (0); /* DW_LNS_negate_stmt */
1517 out_byte (0); /* DW_LNS_set_basic_block */
1518 out_byte (0); /* DW_LNS_const_add_pc */
1519 out_byte (1); /* DW_LNS_fixed_advance_pc */
1520 out_byte (0); /* DW_LNS_set_prologue_end */
1521 out_byte (0); /* DW_LNS_set_epilogue_begin */
1522 out_byte (1); /* DW_LNS_set_isa */
1526 symbol_set_value_now (prologue_end
);
1528 /* For each section, emit a statement program. */
1529 for (s
= all_segs
; s
; s
= s
->next
)
1530 if (SEG_NORMAL (s
->seg
))
1531 process_entries (s
->seg
, s
->head
->head
);
1533 as_warn ("dwarf line number information for %s ignored",
1534 segment_name (s
->seg
));
1536 if (flag_dwarf_sections
)
1537 /* We have to switch to the special .debug_line_end section
1538 before emitting the end-of-debug_line symbol. The linker
1539 script arranges for this section to be placed after all the
1540 (potentially garbage collected) .debug_line.<foo> sections.
1541 This section contains the line_end symbol which is used to
1542 compute the size of the linked .debug_line section, as seen
1543 in the DWARF Line Number header. */
1544 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
1546 symbol_set_value_now (line_end
);
1550 out_debug_ranges (segT ranges_seg
)
1552 unsigned int addr_size
= sizeof_address
;
1557 subseg_set (ranges_seg
, 0);
1559 /* Base Address Entry. */
1560 for (i
= 0; i
< addr_size
; i
++)
1562 for (i
= 0; i
< addr_size
; i
++)
1565 /* Range List Entry. */
1566 for (s
= all_segs
; s
; s
= s
->next
)
1571 frag
= first_frag_for_seg (s
->seg
);
1572 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1573 s
->text_start
= beg
;
1575 frag
= last_frag_for_seg (s
->seg
);
1576 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1579 exp
.X_op
= O_symbol
;
1580 exp
.X_add_symbol
= beg
;
1581 exp
.X_add_number
= 0;
1582 emit_expr (&exp
, addr_size
);
1584 exp
.X_op
= O_symbol
;
1585 exp
.X_add_symbol
= end
;
1586 exp
.X_add_number
= 0;
1587 emit_expr (&exp
, addr_size
);
1590 /* End of Range Entry. */
1591 for (i
= 0; i
< addr_size
; i
++)
1593 for (i
= 0; i
< addr_size
; i
++)
1597 /* Emit data for .debug_aranges. */
1600 out_debug_aranges (segT aranges_seg
, segT info_seg
)
1602 unsigned int addr_size
= sizeof_address
;
1605 symbolS
*aranges_end
;
1609 sizeof_offset
= out_header (aranges_seg
, &exp
);
1610 aranges_end
= exp
.X_add_symbol
;
1613 out_two (DWARF2_ARANGES_VERSION
);
1615 /* Offset to .debug_info. */
1616 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
1618 /* Size of an address (offset portion). */
1619 out_byte (addr_size
);
1621 /* Size of a segment descriptor. */
1624 /* Align the header. */
1625 frag_align (ffs (2 * addr_size
) - 1, 0, 0);
1627 for (s
= all_segs
; s
; s
= s
->next
)
1632 frag
= first_frag_for_seg (s
->seg
);
1633 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1634 s
->text_start
= beg
;
1636 frag
= last_frag_for_seg (s
->seg
);
1637 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1640 exp
.X_op
= O_symbol
;
1641 exp
.X_add_symbol
= beg
;
1642 exp
.X_add_number
= 0;
1643 emit_expr (&exp
, addr_size
);
1645 exp
.X_op
= O_subtract
;
1646 exp
.X_add_symbol
= end
;
1647 exp
.X_op_symbol
= beg
;
1648 exp
.X_add_number
= 0;
1649 emit_expr (&exp
, addr_size
);
1652 p
= frag_more (2 * addr_size
);
1653 md_number_to_chars (p
, 0, addr_size
);
1654 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1656 symbol_set_value_now (aranges_end
);
1659 /* Emit data for .debug_abbrev. Note that this must be kept in
1660 sync with out_debug_info below. */
1663 out_debug_abbrev (segT abbrev_seg
,
1664 segT info_seg ATTRIBUTE_UNUSED
,
1665 segT line_seg ATTRIBUTE_UNUSED
)
1667 subseg_set (abbrev_seg
, 0);
1670 out_uleb128 (DW_TAG_compile_unit
);
1671 out_byte (DW_CHILDREN_no
);
1672 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
1673 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1675 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
1676 if (all_segs
->next
== NULL
)
1678 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1679 if (DWARF2_VERSION
< 4)
1680 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1682 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
1683 ? DW_FORM_data4
: DW_FORM_data8
));
1687 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
1688 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
1690 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
1692 out_abbrev (DW_AT_name
, DW_FORM_string
);
1693 out_abbrev (DW_AT_comp_dir
, DW_FORM_string
);
1694 out_abbrev (DW_AT_producer
, DW_FORM_string
);
1695 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1698 /* Terminate the abbreviations for this compilation unit. */
1702 /* Emit a description of this compilation unit for .debug_info. */
1705 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
)
1708 const char *comp_dir
;
1709 const char *dirname
;
1716 sizeof_offset
= out_header (info_seg
, &exp
);
1717 info_end
= exp
.X_add_symbol
;
1719 /* DWARF version. */
1720 out_two (DWARF2_VERSION
);
1722 /* .debug_abbrev offset */
1723 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
1725 /* Target address size. */
1726 out_byte (sizeof_address
);
1728 /* DW_TAG_compile_unit DIE abbrev */
1731 /* DW_AT_stmt_list */
1732 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
1733 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
1736 /* These two attributes are emitted if all of the code is contiguous. */
1737 if (all_segs
->next
== NULL
)
1740 exp
.X_op
= O_symbol
;
1741 exp
.X_add_symbol
= all_segs
->text_start
;
1742 exp
.X_add_number
= 0;
1743 emit_expr (&exp
, sizeof_address
);
1746 if (DWARF2_VERSION
< 4)
1747 exp
.X_op
= O_symbol
;
1750 exp
.X_op
= O_subtract
;
1751 exp
.X_op_symbol
= all_segs
->text_start
;
1753 exp
.X_add_symbol
= all_segs
->text_end
;
1754 exp
.X_add_number
= 0;
1755 emit_expr (&exp
, sizeof_address
);
1759 /* This attribute is emitted if the code is disjoint. */
1761 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
1764 /* DW_AT_name. We don't have the actual file name that was present
1765 on the command line, so assume files[1] is the main input file.
1766 We're not supposed to get called unless at least one line number
1767 entry was emitted, so this should always be defined. */
1768 if (files_in_use
== 0)
1772 dirname
= remap_debug_filename (dirs
[files
[1].dir
]);
1773 len
= strlen (dirname
);
1775 /* Already has trailing slash. */
1776 p
= frag_more (len
);
1777 memcpy (p
, dirname
, len
);
1779 p
= frag_more (len
+ 1);
1780 memcpy (p
, dirname
, len
);
1781 INSERT_DIR_SEPARATOR (p
, len
);
1784 len
= strlen (files
[1].filename
) + 1;
1785 p
= frag_more (len
);
1786 memcpy (p
, files
[1].filename
, len
);
1788 /* DW_AT_comp_dir */
1789 comp_dir
= remap_debug_filename (getpwd ());
1790 len
= strlen (comp_dir
) + 1;
1791 p
= frag_more (len
);
1792 memcpy (p
, comp_dir
, len
);
1794 /* DW_AT_producer */
1795 sprintf (producer
, "GNU AS %s", VERSION
);
1796 len
= strlen (producer
) + 1;
1797 p
= frag_more (len
);
1798 memcpy (p
, producer
, len
);
1800 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1801 dwarf2 draft has no standard code for assembler. */
1802 out_two (DW_LANG_Mips_Assembler
);
1804 symbol_set_value_now (info_end
);
1810 all_segs_hash
= hash_new ();
1811 last_seg_ptr
= &all_segs
;
1815 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1816 were any .file/.loc directives, or --gdwarf2 was given, or if the
1817 file has a non-empty .debug_info section and an empty .debug_line
1818 section. If we emit .debug_line, and the .debug_info section is
1819 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1820 ALL_SEGS will be non-null if there were any .file/.loc directives,
1821 or --gdwarf2 was given and there were any located instructions
1825 dwarf2_finish (void)
1830 int emit_other_sections
= 0;
1831 int empty_debug_line
= 0;
1833 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
1834 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
1836 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
1837 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
1839 /* We can't construct a new debug_line section if we already have one.
1841 if (all_segs
&& !empty_debug_line
)
1842 as_fatal ("duplicate .debug_line sections");
1844 if ((!all_segs
&& emit_other_sections
)
1845 || (!emit_other_sections
&& !empty_debug_line
))
1846 /* If there is no line information and no non-empty .debug_info
1847 section, or if there is both a non-empty .debug_info and a non-empty
1848 .debug_line, then we do nothing. */
1851 /* Calculate the size of an address for the target machine. */
1852 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
1854 /* Create and switch to the line number section. */
1855 line_seg
= subseg_new (".debug_line", 0);
1856 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
| SEC_DEBUGGING
);
1858 /* For each subsection, chain the debug entries together. */
1859 for (s
= all_segs
; s
; s
= s
->next
)
1861 struct line_subseg
*lss
= s
->head
;
1862 struct line_entry
**ptail
= lss
->ptail
;
1864 while ((lss
= lss
->next
) != NULL
)
1871 out_debug_line (line_seg
);
1873 /* If this is assembler generated line info, and there is no
1874 debug_info already, we need .debug_info and .debug_abbrev
1875 sections as well. */
1876 if (emit_other_sections
)
1882 gas_assert (all_segs
);
1884 info_seg
= subseg_new (".debug_info", 0);
1885 abbrev_seg
= subseg_new (".debug_abbrev", 0);
1886 aranges_seg
= subseg_new (".debug_aranges", 0);
1888 bfd_set_section_flags (stdoutput
, info_seg
,
1889 SEC_READONLY
| SEC_DEBUGGING
);
1890 bfd_set_section_flags (stdoutput
, abbrev_seg
,
1891 SEC_READONLY
| SEC_DEBUGGING
);
1892 bfd_set_section_flags (stdoutput
, aranges_seg
,
1893 SEC_READONLY
| SEC_DEBUGGING
);
1895 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
1897 if (all_segs
->next
== NULL
)
1901 ranges_seg
= subseg_new (".debug_ranges", 0);
1902 bfd_set_section_flags (stdoutput
, ranges_seg
,
1903 SEC_READONLY
| SEC_DEBUGGING
);
1904 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
1905 out_debug_ranges (ranges_seg
);
1908 out_debug_aranges (aranges_seg
, info_seg
);
1909 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
1910 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
);