1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2021 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"
34 #include "dwarf2dbg.h"
35 #include <filenames.h>
37 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
38 /* We need to decide which character to use as a directory separator.
39 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
40 necessarily mean that the backslash character is the one to use.
41 Some environments, eg Cygwin, can support both naming conventions.
42 So we use the heuristic that we only need to use the backslash if
43 the path is an absolute path starting with a DOS style drive
44 selector. eg C: or D: */
45 # define INSERT_DIR_SEPARATOR(string, offset) \
50 && string[1] == ':') \
51 string [offset] = '\\'; \
53 string [offset] = '/'; \
57 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
61 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
64 #ifndef DWARF2_ADDR_SIZE
65 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
68 #ifndef DWARF2_FILE_NAME
69 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
72 #ifndef DWARF2_FILE_TIME_NAME
73 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
76 #ifndef DWARF2_FILE_SIZE_NAME
77 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
80 #ifndef DWARF2_VERSION
81 #define DWARF2_VERSION dwarf_level
84 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
85 #ifndef DWARF2_ARANGES_VERSION
86 #define DWARF2_ARANGES_VERSION 2
89 /* This implementation outputs version 3 .debug_line information. */
90 #ifndef DWARF2_LINE_VERSION
91 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
94 /* The .debug_rnglists has only been in DWARF version 5. */
95 #ifndef DWARF2_RNGLISTS_VERSION
96 #define DWARF2_RNGLISTS_VERSION 5
103 /* Since we can't generate the prolog until the body is complete, we
104 use three different subsegments for .debug_line: one holding the
105 prolog, one for the directory and filename info, and one for the
106 body ("statement program"). */
111 /* If linker relaxation might change offsets in the code, the DWARF special
112 opcodes and variable-length operands cannot be used. If this macro is
113 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
114 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
115 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
118 /* First special line opcode - leave room for the standard opcodes.
119 Note: If you want to change this, you'll have to update the
120 "standard_opcode_lengths" table that is emitted below in
122 #define DWARF2_LINE_OPCODE_BASE 13
124 #ifndef DWARF2_LINE_BASE
125 /* Minimum line offset in a special line info. opcode. This value
126 was chosen to give a reasonable range of values. */
127 # define DWARF2_LINE_BASE -5
130 /* Range of line offsets in a special line info. opcode. */
131 #ifndef DWARF2_LINE_RANGE
132 # define DWARF2_LINE_RANGE 14
135 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
136 /* Define the architecture-dependent minimum instruction length (in
137 bytes). This value should be rather too small than too big. */
138 # define DWARF2_LINE_MIN_INSN_LENGTH 1
141 /* Flag that indicates the initial value of the is_stmt_start flag. */
142 #define DWARF2_LINE_DEFAULT_IS_STMT 1
144 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
145 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
148 /* Given a special op, return the line skip amount. */
149 #define SPECIAL_LINE(op) \
150 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
152 /* Given a special op, return the address skip amount (in units of
153 DWARF2_LINE_MIN_INSN_LENGTH. */
154 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
156 /* The maximum address skip amount that can be encoded with a special op. */
157 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
159 #ifndef TC_PARSE_CONS_RETURN_NONE
160 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
165 struct line_entry
*next
;
167 struct dwarf2_line_info loc
;
170 /* Don't change the offset of next in line_entry. set_or_check_view
171 calls in dwarf2_gen_line_info_1 depend on it. */
172 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
177 struct line_subseg
*next
;
179 struct line_entry
*head
;
180 struct line_entry
**ptail
;
181 struct line_entry
**pmove_tail
;
186 struct line_seg
*next
;
188 struct line_subseg
*head
;
193 /* Collects data for all line table entries during assembly. */
194 static struct line_seg
*all_segs
;
195 static struct line_seg
**last_seg_ptr
;
197 #define NUM_MD5_BYTES 16
201 const char * filename
;
203 unsigned char md5
[NUM_MD5_BYTES
];
206 /* Table of files used by .debug_line. */
207 static struct file_entry
*files
;
208 static unsigned int files_in_use
;
209 static unsigned int files_allocated
;
211 /* Table of directories used by .debug_line. */
212 static char ** dirs
= NULL
;
213 static unsigned int dirs_in_use
= 0;
214 static unsigned int dirs_allocated
= 0;
216 /* TRUE when we've seen a .loc directive recently. Used to avoid
217 doing work when there's nothing to do. Will be reset by
218 dwarf2_consume_line_info. */
219 bool dwarf2_loc_directive_seen
;
221 /* TRUE when we've seen any .loc directive at any time during parsing.
222 Indicates the user wants us to generate a .debug_line section.
223 Used in dwarf2_finish as sanity check. */
224 static bool dwarf2_any_loc_directive_seen
;
226 /* TRUE when we're supposed to set the basic block mark whenever a
228 bool dwarf2_loc_mark_labels
;
230 /* Current location as indicated by the most recent .loc directive. */
231 static struct dwarf2_line_info current
=
234 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
238 /* This symbol is used to recognize view number forced resets in loc
240 static symbolS
*force_reset_view
;
242 /* This symbol evaluates to an expression that, if nonzero, indicates
243 some view assert check failed. */
244 static symbolS
*view_assert_failed
;
246 /* The size of an address on the target. */
247 static unsigned int sizeof_address
;
249 #ifndef TC_DWARF2_EMIT_OFFSET
250 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
252 /* Create an offset to .dwarf2_*. */
255 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
259 memset (&exp
, 0, sizeof exp
);
261 exp
.X_add_symbol
= symbol
;
262 exp
.X_add_number
= 0;
263 emit_expr (&exp
, size
);
267 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
269 static struct line_subseg
*
270 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
272 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
273 struct line_subseg
**pss
, *lss
;
280 s
= XNEW (struct line_seg
);
285 last_seg_ptr
= &s
->next
;
286 seg_info (seg
)->dwarf2_line_seg
= s
;
289 gas_assert (seg
== s
->seg
);
291 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
293 if (lss
->subseg
== subseg
)
295 if (lss
->subseg
> subseg
)
299 lss
= XNEW (struct line_subseg
);
301 lss
->subseg
= subseg
;
303 lss
->ptail
= &lss
->head
;
304 lss
->pmove_tail
= &lss
->head
;
311 /* (Un)reverse the line_entry list starting from H. */
313 static struct line_entry
*
314 reverse_line_entry_list (struct line_entry
*h
)
316 struct line_entry
*p
= NULL
, *e
, *n
;
318 for (e
= h
; e
; e
= n
)
327 /* Compute the view for E based on the previous entry P. If we
328 introduce an (undefined) view symbol for P, and H is given (P must
329 be the tail in this case), introduce view symbols for earlier list
330 entries as well, until one of them is constant. */
333 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
334 struct line_entry
*h
)
338 memset (&viewx
, 0, sizeof (viewx
));
339 viewx
.X_unsigned
= 1;
341 /* First, compute !(E->label > P->label), to tell whether or not
342 we're to reset the view number. If we can't resolve it to a
343 constant, keep it symbolic. */
344 if (!p
|| (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
))
346 viewx
.X_op
= O_constant
;
347 viewx
.X_add_number
= 0;
348 viewx
.X_add_symbol
= NULL
;
349 viewx
.X_op_symbol
= NULL
;
354 viewx
.X_add_number
= 0;
355 viewx
.X_add_symbol
= e
->label
;
356 viewx
.X_op_symbol
= p
->label
;
357 resolve_expression (&viewx
);
358 if (viewx
.X_op
== O_constant
)
359 viewx
.X_add_number
= !viewx
.X_add_number
;
362 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
363 viewx
.X_add_number
= 0;
364 viewx
.X_op_symbol
= NULL
;
365 viewx
.X_op
= O_logical_not
;
369 if (S_IS_DEFINED (e
->loc
.u
.view
) && symbol_constant_p (e
->loc
.u
.view
))
371 expressionS
*value
= symbol_get_value_expression (e
->loc
.u
.view
);
372 /* We can't compare the view numbers at this point, because in
373 VIEWX we've only determined whether we're to reset it so
375 if (viewx
.X_op
== O_constant
)
377 if (!value
->X_add_number
!= !viewx
.X_add_number
)
378 as_bad (_("view number mismatch"));
380 /* Record the expression to check it later. It is the result of
381 a logical not, thus 0 or 1. We just add up all such deferred
382 expressions, and resolve it at the end. */
383 else if (!value
->X_add_number
)
385 symbolS
*deferred
= make_expr_symbol (&viewx
);
386 if (view_assert_failed
)
390 memset (&chk
, 0, sizeof (chk
));
393 chk
.X_add_number
= 0;
394 chk
.X_add_symbol
= view_assert_failed
;
395 chk
.X_op_symbol
= deferred
;
396 deferred
= make_expr_symbol (&chk
);
398 view_assert_failed
= deferred
;
402 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
408 p
->loc
.u
.view
= symbol_temp_make ();
409 gas_assert (!S_IS_DEFINED (p
->loc
.u
.view
));
412 memset (&incv
, 0, sizeof (incv
));
414 incv
.X_op
= O_symbol
;
415 incv
.X_add_symbol
= p
->loc
.u
.view
;
416 incv
.X_add_number
= 1;
418 if (viewx
.X_op
== O_constant
)
420 gas_assert (viewx
.X_add_number
== 1);
425 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
426 viewx
.X_add_number
= 0;
427 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
428 viewx
.X_op
= O_multiply
;
432 if (!S_IS_DEFINED (e
->loc
.u
.view
))
434 symbol_set_value_expression (e
->loc
.u
.view
, &viewx
);
435 S_SET_SEGMENT (e
->loc
.u
.view
, expr_section
);
436 symbol_set_frag (e
->loc
.u
.view
, &zero_address_frag
);
439 /* Define and attempt to simplify any earlier views needed to
441 if (h
&& p
&& p
->loc
.u
.view
&& !S_IS_DEFINED (p
->loc
.u
.view
))
443 struct line_entry
*h2
;
444 /* Reverse the list to avoid quadratic behavior going backwards
445 in a single-linked list. */
446 struct line_entry
*r
= reverse_line_entry_list (h
);
449 /* Set or check views until we find a defined or absent view. */
452 /* Do not define the head of a (sub?)segment view while
453 handling others. It would be defined too early, without
454 regard to the last view of other subsegments.
455 set_or_check_view will be called for every head segment
459 set_or_check_view (r
, r
->next
, NULL
);
462 && r
->next
->loc
.u
.view
463 && !S_IS_DEFINED (r
->next
->loc
.u
.view
)
466 /* Unreverse the list, so that we can go forward again. */
467 h2
= reverse_line_entry_list (p
);
468 gas_assert (h2
== h
);
470 /* Starting from the last view we just defined, attempt to
471 simplify the view expressions, until we do so to P. */
474 /* The head view of a subsegment may remain undefined while
475 handling other elements, before it is linked to the last
476 view of the previous subsegment. */
479 gas_assert (S_IS_DEFINED (r
->loc
.u
.view
));
480 resolve_expression (symbol_get_value_expression (r
->loc
.u
.view
));
482 while (r
!= p
&& (r
= r
->next
));
484 /* Now that we've defined and computed all earlier views that might
485 be needed to compute E's, attempt to simplify it. */
486 resolve_expression (symbol_get_value_expression (e
->loc
.u
.view
));
490 /* Record an entry for LOC occurring at LABEL. */
493 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
495 struct line_subseg
*lss
;
496 struct line_entry
*e
;
497 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
499 /* PR 26850: Do not record LOCs in non-executable or non-loaded
500 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
501 obj_coff_section is careless in setting SEC_ALLOC. */
503 need_flags
|= SEC_ALLOC
;
504 if ((now_seg
->flags
& need_flags
) != need_flags
)
506 /* FIXME: Add code to suppress multiple warnings ? */
507 if (debug_type
!= DEBUG_DWARF2
)
508 as_warn ("dwarf line number information for %s ignored",
509 segment_name (now_seg
));
513 e
= XNEW (struct line_entry
);
518 lss
= get_line_subseg (now_seg
, now_subseg
, true);
520 /* Subseg heads are chained to previous subsegs in
522 if (loc
->filenum
!= -1u && loc
->u
.view
&& lss
->head
)
523 set_or_check_view (e
, (struct line_entry
*) lss
->ptail
, lss
->head
);
526 lss
->ptail
= &e
->next
;
529 /* Record an entry for LOC occurring at OFS within the current fragment. */
532 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
536 /* Early out for as-yet incomplete location information. */
539 if (loc
->filenum
== 0)
543 if (DWARF2_LINE_VERSION
< 5)
547 /* Don't emit sequences of line symbols for the same line when the
548 symbols apply to assembler code. It is necessary to emit
549 duplicate line symbols when a compiler asks for them, because GDB
550 uses them to determine the end of the prologue. */
551 if (debug_type
== DEBUG_DWARF2
)
553 static unsigned int line
= -1;
554 static const char *filename
= NULL
;
556 if (line
== loc
->line
)
558 if (filename
== loc
->u
.filename
)
560 if (filename_cmp (filename
, loc
->u
.filename
) == 0)
562 filename
= loc
->u
.filename
;
568 filename
= loc
->u
.filename
;
573 static int label_num
= 0;
576 /* Use a non-fake name for the line number location,
577 so that it can be referred to by relocations. */
578 sprintf (name
, ".Loc.%u", label_num
);
580 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
583 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
584 dwarf2_gen_line_info_1 (sym
, loc
);
588 get_basename (const char * pathname
)
592 file
= lbasename (pathname
);
593 /* Don't make empty string from / or A: from A:/ . */
594 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
595 if (file
<= pathname
+ 3)
598 if (file
== pathname
+ 1)
605 get_directory_table_entry (const char *dirname
,
606 const char *file0_dirname
,
615 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
616 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
624 for (d
= 0; d
< dirs_in_use
; ++d
)
627 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
628 && dirs
[d
][dirlen
] == '\0')
634 if (dirs
== NULL
|| dirs
[0] == NULL
)
636 const char * pwd
= file0_dirname
? file0_dirname
: getpwd ();
638 if (dwarf_level
>= 5 && filename_cmp (dirname
, pwd
) != 0)
640 /* In DWARF-5 the 0 entry in the directory table is
641 expected to be the same as the DW_AT_comp_dir (which
642 is set to the current build directory). Since we are
643 about to create a directory entry that is not the
644 same, allocate the current directory first.
645 FIXME: Alternatively we could generate an error
647 (void) get_directory_table_entry (pwd
, NULL
, strlen (pwd
),
658 if (d
>= dirs_allocated
)
660 unsigned int old
= dirs_allocated
;
661 #define DIR_TABLE_INCREMENT 32
662 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
663 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
664 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
667 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
668 if (dirs_in_use
<= d
)
675 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
677 if (i
>= files_allocated
)
679 unsigned int old
= files_allocated
;
681 files_allocated
= i
+ 32;
682 /* Catch wraparound. */
683 if (files_allocated
<= old
)
685 as_bad (_("file number %lu is too big"), (unsigned long) i
);
689 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
690 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
693 files
[i
].filename
= file
;
695 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
697 if (files_in_use
< i
+ 1)
698 files_in_use
= i
+ 1;
703 /* Get a .debug_line file number for PATHNAME. If there is a
704 directory component to PATHNAME, then this will be stored
705 in the directory table, if it is not already present.
706 Returns the slot number allocated to that filename or -1
707 if there was a problem. */
710 allocate_filenum (const char * pathname
)
712 static signed int last_used
= -1, last_used_dir_len
= 0;
717 /* Short circuit the common case of adding the same pathname
721 const char * dirname
= NULL
;
724 dirname
= dirs
[files
[last_used
].dir
];
728 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
733 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
- 1) == 0
734 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
- 1])
735 && filename_cmp (pathname
+ last_used_dir_len
,
736 files
[last_used
].filename
) == 0)
741 file
= get_basename (pathname
);
742 dir_len
= file
- pathname
;
744 dir
= get_directory_table_entry (pathname
, NULL
, dir_len
, false);
746 /* Do not use slot-0. That is specifically reserved for use by
747 the '.file 0 "name"' directive. */
748 for (i
= 1; i
< files_in_use
; ++i
)
749 if (files
[i
].dir
== dir
751 && filename_cmp (file
, files
[i
].filename
) == 0)
754 last_used_dir_len
= dir_len
;
758 if (!assign_file_to_slot (i
, file
, dir
))
762 last_used_dir_len
= dir_len
;
767 /* Run through the list of line entries starting at E, allocating
768 file entries for gas generated debug. */
771 do_allocate_filenum (struct line_entry
*e
)
775 if (e
->loc
.filenum
== -1u)
777 e
->loc
.filenum
= allocate_filenum (e
->loc
.u
.filename
);
778 e
->loc
.u
.view
= NULL
;
785 /* Remove any generated line entries. These don't live comfortably
786 with compiler generated line info. */
789 purge_generated_debug (void)
793 for (s
= all_segs
; s
; s
= s
->next
)
795 struct line_subseg
*lss
;
797 for (lss
= s
->head
; lss
; lss
= lss
->next
)
799 struct line_entry
*e
, *next
;
801 for (e
= lss
->head
; e
; e
= next
)
803 know (e
->loc
.filenum
== -1u);
809 lss
->ptail
= &lss
->head
;
810 lss
->pmove_tail
= &lss
->head
;
815 /* Allocate slot NUM in the .debug_line file table to FILENAME.
816 If DIRNAME is not NULL or there is a directory component to FILENAME
817 then this will be stored in the directory table, if not already present.
818 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
819 Returns TRUE if allocation succeeded, FALSE otherwise. */
822 allocate_filename_to_slot (const char *dirname
,
823 const char *filename
,
830 const char *file0_dirname
= dirname
;
832 /* Short circuit the common case of adding the same pathname
834 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
836 const char * dir
= NULL
;
839 dir
= dirs
[files
[num
].dir
];
842 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
847 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
850 if (filename_cmp (filename
, files
[num
].filename
) != 0)
853 /* If the filenames match, but the directory table entry was
854 empty, then fill it with the provided directory name. */
859 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
860 dirs
= XCNEWVEC (char *, dirs_allocated
);
863 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
868 else if (dir
!= NULL
)
870 dirlen
= strlen (dir
);
871 if (filename_ncmp (filename
, dir
, dirlen
) == 0
872 && IS_DIR_SEPARATOR (filename
[dirlen
])
873 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
876 else /* dir == NULL */
878 file
= get_basename (filename
);
879 if (filename_cmp (file
, files
[num
].filename
) == 0)
881 /* The filenames match, but the directory table entry is empty.
882 Fill it with the provided directory name. */
887 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
888 dirs
= XCNEWVEC (char *, dirs_allocated
);
891 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
898 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
900 dir
== NULL
? "" : dir
,
901 dir
== NULL
? "" : "/",
903 dirname
== NULL
? "" : dirname
,
904 dirname
== NULL
? "" : "/",
912 file
= get_basename (filename
);
913 dirlen
= file
- filename
;
917 dirlen
= strlen (dirname
);
921 d
= get_directory_table_entry (dirname
, file0_dirname
, dirlen
,
925 if (! assign_file_to_slot (i
, file
, d
))
930 if (target_big_endian
)
932 /* md5's are stored in litte endian format. */
933 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
934 unsigned int byte
= NUM_MD5_BYTES
;
935 unsigned int bignum_index
= 0;
937 while (bits_remaining
)
939 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
940 valueT bignum_value
= generic_bignum
[bignum_index
];
943 while (bignum_bits_remaining
)
945 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
947 bignum_bits_remaining
-= 8;
954 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
955 unsigned int byte
= 0;
956 unsigned int bignum_index
= 0;
958 while (bits_remaining
)
960 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
961 valueT bignum_value
= generic_bignum
[bignum_index
];
965 while (bignum_bits_remaining
)
967 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
969 bignum_bits_remaining
-= 8;
976 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
981 /* Returns the current source information. If .file directives have
982 been encountered, the info for the corresponding source file is
983 returned. Otherwise, the info for the assembly source file is
987 dwarf2_where (struct dwarf2_line_info
*line
)
989 if (debug_type
== DEBUG_DWARF2
)
991 line
->u
.filename
= as_where (&line
->line
);
994 line
->flags
= DWARF2_FLAG_IS_STMT
;
995 line
->isa
= current
.isa
;
996 line
->discriminator
= current
.discriminator
;
1002 /* A hook to allow the target backend to inform the line number state
1003 machine of isa changes when assembler debug info is enabled. */
1006 dwarf2_set_isa (unsigned int isa
)
1011 /* Called for each machine instruction, or relatively atomic group of
1012 machine instructions (ie built-in macro). The instruction or group
1013 is SIZE bytes in length. If dwarf2 line number generation is called
1014 for, emit a line statement appropriately. */
1017 dwarf2_emit_insn (int size
)
1019 struct dwarf2_line_info loc
;
1021 if (debug_type
!= DEBUG_DWARF2
1022 ? !dwarf2_loc_directive_seen
1023 : !seen_at_least_1_file ())
1026 dwarf2_where (&loc
);
1028 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
1029 dwarf2_consume_line_info ();
1032 /* Move all previously-emitted line entries for the current position by
1033 DELTA bytes. This function cannot be used to move the same entries
1037 dwarf2_move_insn (int delta
)
1039 struct line_subseg
*lss
;
1040 struct line_entry
*e
;
1046 lss
= get_line_subseg (now_seg
, now_subseg
, false);
1050 now
= frag_now_fix ();
1051 while ((e
= *lss
->pmove_tail
))
1053 if (S_GET_VALUE (e
->label
) == now
)
1054 S_SET_VALUE (e
->label
, now
+ delta
);
1055 lss
->pmove_tail
= &e
->next
;
1059 /* Called after the current line information has been either used with
1060 dwarf2_gen_line_info or saved with a machine instruction for later use.
1061 This resets the state of the line number information to reflect that
1062 it has been used. */
1065 dwarf2_consume_line_info (void)
1067 /* Unless we generate DWARF2 debugging information for each
1068 assembler line, we only emit one line symbol for one LOC. */
1069 dwarf2_loc_directive_seen
= false;
1071 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1072 | DWARF2_FLAG_PROLOGUE_END
1073 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1074 current
.discriminator
= 0;
1075 current
.u
.view
= NULL
;
1078 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1079 is enabled, emit a basic block marker. */
1082 dwarf2_emit_label (symbolS
*label
)
1084 struct dwarf2_line_info loc
;
1086 if (!dwarf2_loc_mark_labels
)
1088 if (S_GET_SEGMENT (label
) != now_seg
)
1090 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1092 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1095 dwarf2_where (&loc
);
1097 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1099 dwarf2_gen_line_info_1 (label
, &loc
);
1100 dwarf2_consume_line_info ();
1103 /* Handle two forms of .file directive:
1104 - Pass .file "source.c" to s_app_file
1105 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1107 If an entry is added to the file table, return a pointer to the filename. */
1110 dwarf2_directive_filename (void)
1112 bool with_md5
= false;
1115 const char * dirname
= NULL
;
1118 /* Continue to accept a bare string and pass it off. */
1120 if (*input_line_pointer
== '"')
1126 num
= get_absolute_expression ();
1128 if ((offsetT
) num
< 1)
1130 if (num
== 0 && dwarf_level
< 5)
1132 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1134 as_bad (_("file number less than one"));
1135 ignore_rest_of_line ();
1140 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1141 "switch back to the already allocated file <N> as the current
1144 filename
= demand_copy_C_string (&filename_len
);
1145 if (filename
== NULL
)
1146 /* demand_copy_C_string will have already generated an error message. */
1149 /* For DWARF-5 support we also accept:
1150 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1151 if (DWARF2_LINE_VERSION
> 4)
1154 if (*input_line_pointer
== '"')
1157 filename
= demand_copy_C_string (&filename_len
);
1161 if (startswith (input_line_pointer
, "md5"))
1163 input_line_pointer
+= 3;
1167 expression_and_evaluate (& exp
);
1168 if (exp
.X_op
!= O_big
)
1169 as_bad (_("md5 value too small or not a constant"));
1175 demand_empty_rest_of_line ();
1177 /* A .file directive implies compiler generated debug information is
1178 being supplied. Turn off gas generated debug info. */
1179 if (debug_type
== DEBUG_DWARF2
)
1180 purge_generated_debug ();
1181 debug_type
= DEBUG_NONE
;
1183 if (num
!= (unsigned int) num
1184 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1186 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1190 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1197 /* Calls dwarf2_directive_filename, but discards its result.
1198 Used in pseudo-op tables where the function result is ignored. */
1201 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1203 (void) dwarf2_directive_filename ();
1207 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1209 offsetT filenum
, line
;
1211 /* If we see two .loc directives in a row, force the first one to be
1213 if (dwarf2_loc_directive_seen
)
1214 dwarf2_emit_insn (0);
1216 filenum
= get_absolute_expression ();
1218 line
= get_absolute_expression ();
1222 if (filenum
== 0 && dwarf_level
< 5)
1224 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1226 as_bad (_("file number less than one"));
1231 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1233 as_bad (_("unassigned file number %ld"), (long) filenum
);
1237 /* debug_type will be turned off by dwarf2_directive_filename, and
1238 if we don't have a dwarf style .file then files_in_use will be
1239 zero and the above error will trigger. */
1240 gas_assert (debug_type
== DEBUG_NONE
);
1242 current
.filenum
= filenum
;
1243 current
.line
= line
;
1244 current
.discriminator
= 0;
1249 if (files
[filenum
].dir
)
1251 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1252 size_t file_len
= strlen (files
[filenum
].filename
);
1253 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1255 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1256 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1257 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1258 cp
[dir_len
+ file_len
+ 1] = '\0';
1259 listing_source_file (cp
);
1263 listing_source_file (files
[filenum
].filename
);
1264 listing_source_line (line
);
1269 if (ISDIGIT (*input_line_pointer
))
1271 current
.column
= get_absolute_expression ();
1275 while (ISALPHA (*input_line_pointer
))
1280 c
= get_symbol_name (& p
);
1282 if (strcmp (p
, "basic_block") == 0)
1284 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1285 *input_line_pointer
= c
;
1287 else if (strcmp (p
, "prologue_end") == 0)
1289 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1290 *input_line_pointer
= c
;
1292 else if (strcmp (p
, "epilogue_begin") == 0)
1294 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1295 *input_line_pointer
= c
;
1297 else if (strcmp (p
, "is_stmt") == 0)
1299 (void) restore_line_pointer (c
);
1300 value
= get_absolute_expression ();
1302 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1303 else if (value
== 1)
1304 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1307 as_bad (_("is_stmt value not 0 or 1"));
1311 else if (strcmp (p
, "isa") == 0)
1313 (void) restore_line_pointer (c
);
1314 value
= get_absolute_expression ();
1316 current
.isa
= value
;
1319 as_bad (_("isa number less than zero"));
1323 else if (strcmp (p
, "discriminator") == 0)
1325 (void) restore_line_pointer (c
);
1326 value
= get_absolute_expression ();
1328 current
.discriminator
= value
;
1331 as_bad (_("discriminator less than zero"));
1335 else if (strcmp (p
, "view") == 0)
1339 (void) restore_line_pointer (c
);
1342 if (ISDIGIT (*input_line_pointer
)
1343 || *input_line_pointer
== '-')
1345 bool force_reset
= *input_line_pointer
== '-';
1347 value
= get_absolute_expression ();
1350 as_bad (_("numeric view can only be asserted to zero"));
1353 if (force_reset
&& force_reset_view
)
1354 sym
= force_reset_view
;
1357 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1360 force_reset_view
= sym
;
1365 char *name
= read_symbol_name ();
1369 sym
= symbol_find_or_make (name
);
1370 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1372 if (S_IS_VOLATILE (sym
))
1373 sym
= symbol_clone (sym
, 1);
1374 else if (!S_CAN_BE_REDEFINED (sym
))
1376 as_bad (_("symbol `%s' is already defined"), name
);
1380 S_SET_SEGMENT (sym
, undefined_section
);
1381 S_SET_VALUE (sym
, 0);
1382 symbol_set_frag (sym
, &zero_address_frag
);
1384 current
.u
.view
= sym
;
1388 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1389 (void) restore_line_pointer (c
);
1393 SKIP_WHITESPACE_AFTER_NAME ();
1396 demand_empty_rest_of_line ();
1397 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1399 /* If we were given a view id, emit the row right away. */
1401 dwarf2_emit_insn (0);
1405 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1407 offsetT value
= get_absolute_expression ();
1409 if (value
!= 0 && value
!= 1)
1411 as_bad (_("expected 0 or 1"));
1412 ignore_rest_of_line ();
1416 dwarf2_loc_mark_labels
= value
!= 0;
1417 demand_empty_rest_of_line ();
1421 static struct frag
*
1422 first_frag_for_seg (segT seg
)
1424 return seg_info (seg
)->frchainP
->frch_root
;
1427 static struct frag
*
1428 last_frag_for_seg (segT seg
)
1430 frchainS
*f
= seg_info (seg
)->frchainP
;
1432 while (f
->frch_next
!= NULL
)
1435 return f
->frch_last
;
1438 /* Emit a single byte into the current segment. */
1443 FRAG_APPEND_1_CHAR (byte
);
1446 /* Emit a statement program opcode into the current segment. */
1449 out_opcode (int opc
)
1454 /* Emit a two-byte word into the current segment. */
1459 md_number_to_chars (frag_more (2), data
, 2);
1462 /* Emit a four byte word into the current segment. */
1467 md_number_to_chars (frag_more (4), data
, 4);
1470 /* Emit an unsigned "little-endian base 128" number. */
1473 out_uleb128 (addressT value
)
1475 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1478 /* Emit a signed "little-endian base 128" number. */
1481 out_leb128 (addressT value
)
1483 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1486 /* Emit a tuple for .debug_abbrev. */
1489 out_abbrev (int name
, int form
)
1495 /* Get the size of a fragment. */
1498 get_frag_fix (fragS
*frag
, segT seg
)
1503 return frag
->fr_fix
;
1505 /* If a fragment is the last in the chain, special measures must be
1506 taken to find its size before relaxation, since it may be pending
1507 on some subsegment chain. */
1508 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1509 if (fr
->frch_last
== frag
)
1510 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1515 /* Set an absolute address (may result in a relocation entry). */
1518 out_set_addr (symbolS
*sym
)
1522 memset (&exp
, 0, sizeof exp
);
1523 out_opcode (DW_LNS_extended_op
);
1524 out_uleb128 (sizeof_address
+ 1);
1526 out_opcode (DW_LNE_set_address
);
1527 exp
.X_op
= O_symbol
;
1528 exp
.X_add_symbol
= sym
;
1529 exp
.X_add_number
= 0;
1530 emit_expr (&exp
, sizeof_address
);
1533 static void scale_addr_delta (addressT
*);
1536 scale_addr_delta (addressT
*addr_delta
)
1538 static int printed_this
= 0;
1539 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1541 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1543 as_bad("unaligned opcodes detected in executable segment");
1546 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1550 /* Encode a pair of line and address skips as efficiently as possible.
1551 Note that the line skip is signed, whereas the address skip is unsigned.
1553 The following two routines *must* be kept in sync. This is
1554 enforced by making emit_inc_line_addr abort if we do not emit
1555 exactly the expected number of bytes. */
1558 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1560 unsigned int tmp
, opcode
;
1563 /* Scale the address delta by the minimum instruction length. */
1564 scale_addr_delta (&addr_delta
);
1566 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1567 We cannot use special opcodes here, since we want the end_sequence
1568 to emit the matrix entry. */
1569 if (line_delta
== INT_MAX
)
1571 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1573 else if (addr_delta
)
1574 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1578 /* Bias the line delta by the base. */
1579 tmp
= line_delta
- DWARF2_LINE_BASE
;
1581 /* If the line increment is out of range of a special opcode, we
1582 must encode it with DW_LNS_advance_line. */
1583 if (tmp
>= DWARF2_LINE_RANGE
)
1585 len
= 1 + sizeof_leb128 (line_delta
, 1);
1587 tmp
= 0 - DWARF2_LINE_BASE
;
1590 /* Bias the opcode by the special opcode base. */
1591 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1593 /* Avoid overflow when addr_delta is large. */
1594 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1596 /* Try using a special opcode. */
1597 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1601 /* Try using DW_LNS_const_add_pc followed by special op. */
1602 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1607 /* Otherwise use DW_LNS_advance_pc. */
1608 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1610 /* DW_LNS_copy or special opcode. */
1617 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1619 unsigned int tmp
, opcode
;
1621 char *end
= p
+ len
;
1623 /* Line number sequences cannot go backward in addresses. This means
1624 we've incorrectly ordered the statements in the sequence. */
1625 gas_assert ((offsetT
) addr_delta
>= 0);
1627 /* Scale the address delta by the minimum instruction length. */
1628 scale_addr_delta (&addr_delta
);
1630 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1631 We cannot use special opcodes here, since we want the end_sequence
1632 to emit the matrix entry. */
1633 if (line_delta
== INT_MAX
)
1635 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1636 *p
++ = DW_LNS_const_add_pc
;
1637 else if (addr_delta
)
1639 *p
++ = DW_LNS_advance_pc
;
1640 p
+= output_leb128 (p
, addr_delta
, 0);
1643 *p
++ = DW_LNS_extended_op
;
1645 *p
++ = DW_LNE_end_sequence
;
1649 /* Bias the line delta by the base. */
1650 tmp
= line_delta
- DWARF2_LINE_BASE
;
1652 /* If the line increment is out of range of a special opcode, we
1653 must encode it with DW_LNS_advance_line. */
1654 if (tmp
>= DWARF2_LINE_RANGE
)
1656 *p
++ = DW_LNS_advance_line
;
1657 p
+= output_leb128 (p
, line_delta
, 1);
1660 tmp
= 0 - DWARF2_LINE_BASE
;
1664 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1666 if (line_delta
== 0 && addr_delta
== 0)
1672 /* Bias the opcode by the special opcode base. */
1673 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1675 /* Avoid overflow when addr_delta is large. */
1676 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1678 /* Try using a special opcode. */
1679 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1686 /* Try using DW_LNS_const_add_pc followed by special op. */
1687 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1690 *p
++ = DW_LNS_const_add_pc
;
1696 /* Otherwise use DW_LNS_advance_pc. */
1697 *p
++ = DW_LNS_advance_pc
;
1698 p
+= output_leb128 (p
, addr_delta
, 0);
1706 gas_assert (p
== end
);
1709 /* Handy routine to combine calls to the above two routines. */
1712 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1714 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1715 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1718 /* Write out an alternative form of line and address skips using
1719 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1720 line and address information, but it is required if linker relaxation
1721 could change the code offsets. The following two routines *must* be
1723 #define ADDR_DELTA_LIMIT 50000
1726 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1730 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1731 if (line_delta
!= INT_MAX
)
1732 len
= 1 + sizeof_leb128 (line_delta
, 1);
1734 if (addr_delta
> ADDR_DELTA_LIMIT
)
1736 /* DW_LNS_extended_op */
1737 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1738 /* DW_LNE_set_address */
1739 len
+= 1 + sizeof_address
;
1742 /* DW_LNS_fixed_advance_pc */
1745 if (line_delta
== INT_MAX
)
1746 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1756 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1760 char *end
= p
+ len
;
1762 /* Line number sequences cannot go backward in addresses. This means
1763 we've incorrectly ordered the statements in the sequence. */
1764 gas_assert ((offsetT
) addr_delta
>= 0);
1766 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1767 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1769 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1770 if (line_delta
!= INT_MAX
)
1772 *p
++ = DW_LNS_advance_line
;
1773 p
+= output_leb128 (p
, line_delta
, 1);
1776 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1778 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1779 advance the address by at most 64K. Linker relaxation (without
1780 which this function would not be used) could change the operand by
1781 an unknown amount. If the address increment is getting close to
1782 the limit, just reset the address. */
1783 if (addr_delta
> ADDR_DELTA_LIMIT
)
1788 memset (&exp
, 0, sizeof exp
);
1789 gas_assert (pexp
->X_op
== O_subtract
);
1790 to_sym
= pexp
->X_add_symbol
;
1792 *p
++ = DW_LNS_extended_op
;
1793 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1794 *p
++ = DW_LNE_set_address
;
1795 exp
.X_op
= O_symbol
;
1796 exp
.X_add_symbol
= to_sym
;
1797 exp
.X_add_number
= 0;
1798 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1799 p
+= sizeof_address
;
1803 *p
++ = DW_LNS_fixed_advance_pc
;
1804 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1808 if (line_delta
== INT_MAX
)
1810 *p
++ = DW_LNS_extended_op
;
1812 *p
++ = DW_LNE_end_sequence
;
1817 gas_assert (p
== end
);
1820 /* Generate a variant frag that we can use to relax address/line
1821 increments between fragments of the target segment. */
1824 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1829 memset (&exp
, 0, sizeof exp
);
1830 exp
.X_op
= O_subtract
;
1831 exp
.X_add_symbol
= to_sym
;
1832 exp
.X_op_symbol
= from_sym
;
1833 exp
.X_add_number
= 0;
1835 /* The maximum size of the frag is the line delta with a maximum
1836 sized address delta. */
1837 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1838 max_chars
= size_fixed_inc_line_addr (line_delta
,
1839 -DWARF2_LINE_MIN_INSN_LENGTH
);
1841 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1843 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1844 make_expr_symbol (&exp
), line_delta
, NULL
);
1847 /* The function estimates the size of a rs_dwarf2dbg variant frag
1848 based on the current values of the symbols. It is called before
1849 the relaxation loop. We set fr_subtype to the expected length. */
1852 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1857 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1858 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1859 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1861 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1863 frag
->fr_subtype
= size
;
1868 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1869 current values of the symbols. fr_subtype is the current length
1870 of the frag. This returns the change in frag length. */
1873 dwarf2dbg_relax_frag (fragS
*frag
)
1875 int old_size
, new_size
;
1877 old_size
= frag
->fr_subtype
;
1878 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1880 return new_size
- old_size
;
1883 /* This function converts a rs_dwarf2dbg variant frag into a normal
1884 fill frag. This is called after all relaxation has been done.
1885 fr_subtype will be the desired length of the frag. */
1888 dwarf2dbg_convert_frag (fragS
*frag
)
1892 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1894 /* If linker relaxation is enabled then the distance between the two
1895 symbols in the frag->fr_symbol expression might change. Hence we
1896 cannot rely upon the value computed by resolve_symbol_value.
1897 Instead we leave the expression unfinalized and allow
1898 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1899 relocation) that will allow the linker to correctly compute the
1900 actual address difference. We have to use a fixed line advance for
1901 this as we cannot (easily) relocate leb128 encoded values. */
1902 int saved_finalize_syms
= finalize_syms
;
1905 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1906 finalize_syms
= saved_finalize_syms
;
1909 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1911 /* fr_var carries the max_chars that we created the fragment with.
1912 fr_subtype carries the current expected length. We must, of
1913 course, have allocated enough memory earlier. */
1914 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1916 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1917 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1918 frag
->fr_literal
+ frag
->fr_fix
,
1921 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1922 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1924 frag
->fr_fix
+= frag
->fr_subtype
;
1925 frag
->fr_type
= rs_fill
;
1927 frag
->fr_offset
= 0;
1930 /* Generate .debug_line content for the chain of line number entries
1931 beginning at E, for segment SEG. */
1934 process_entries (segT seg
, struct line_entry
*e
)
1936 unsigned filenum
= 1;
1938 unsigned column
= 0;
1940 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1941 fragS
*last_frag
= NULL
, *frag
;
1942 addressT last_frag_ofs
= 0, frag_ofs
;
1943 symbolS
*last_lab
= NULL
, *lab
;
1944 struct line_entry
*next
;
1946 if (flag_dwarf_sections
)
1949 const char * sec_name
;
1951 /* Switch to the relevant sub-section before we start to emit
1952 the line number table.
1954 FIXME: These sub-sections do not have a normal Line Number
1955 Program Header, thus strictly speaking they are not valid
1956 DWARF sections. Unfortunately the DWARF standard assumes
1957 a one-to-one relationship between compilation units and
1958 line number tables. Thus we have to have a .debug_line
1959 section, as well as our sub-sections, and we have to ensure
1960 that all of the sub-sections are merged into a proper
1961 .debug_line section before a debugger sees them. */
1963 sec_name
= bfd_section_name (seg
);
1964 if (strcmp (sec_name
, ".text") != 0)
1966 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1967 subseg_set (subseg_get (name
, false), 0);
1970 /* Don't create a .debug_line.text section -
1971 that is redundant. Instead just switch back to the
1972 normal .debug_line section. */
1973 subseg_set (subseg_get (".debug_line", false), 0);
1980 if (filenum
!= e
->loc
.filenum
)
1982 filenum
= e
->loc
.filenum
;
1983 out_opcode (DW_LNS_set_file
);
1984 out_uleb128 (filenum
);
1987 if (column
!= e
->loc
.column
)
1989 column
= e
->loc
.column
;
1990 out_opcode (DW_LNS_set_column
);
1991 out_uleb128 (column
);
1994 if (e
->loc
.discriminator
!= 0)
1996 out_opcode (DW_LNS_extended_op
);
1997 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1998 out_opcode (DW_LNE_set_discriminator
);
1999 out_uleb128 (e
->loc
.discriminator
);
2002 if (isa
!= e
->loc
.isa
)
2005 out_opcode (DW_LNS_set_isa
);
2009 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
2011 flags
= e
->loc
.flags
;
2012 out_opcode (DW_LNS_negate_stmt
);
2015 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
2016 out_opcode (DW_LNS_set_basic_block
);
2018 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
2019 out_opcode (DW_LNS_set_prologue_end
);
2021 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
2022 out_opcode (DW_LNS_set_epilogue_begin
);
2024 /* Don't try to optimize away redundant entries; gdb wants two
2025 entries for a function where the code starts on the same line as
2026 the {, and there's no way to identify that case here. Trust gcc
2027 to optimize appropriately. */
2028 line_delta
= e
->loc
.line
- line
;
2030 frag
= symbol_get_frag (lab
);
2031 frag_ofs
= S_GET_VALUE (lab
);
2033 if (last_frag
== NULL
2034 || (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
2035 /* If we're going to reset the view, but we know we're
2036 advancing the PC, we don't have to force with
2037 set_address. We know we do when we're at the same
2038 address of the same frag, and we know we might when
2039 we're in the beginning of a frag, and we were at the
2040 end of the previous frag. */
2041 && (frag
== last_frag
2042 ? (last_frag_ofs
== frag_ofs
)
2044 && ((offsetT
)last_frag_ofs
2045 >= get_frag_fix (last_frag
, seg
))))))
2048 out_inc_line_addr (line_delta
, 0);
2050 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2051 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2053 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2058 last_frag_ofs
= frag_ofs
;
2066 /* Emit a DW_LNE_end_sequence for the end of the section. */
2067 frag
= last_frag_for_seg (seg
);
2068 frag_ofs
= get_frag_fix (frag
, seg
);
2069 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2070 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2073 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2074 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2078 /* Switch to LINE_STR_SEG and output the given STR. Return the
2079 symbol pointing to the new string in the section. */
2082 add_line_strp (segT line_str_seg
, const char *str
)
2088 subseg_set (line_str_seg
, 0);
2090 sym
= symbol_temp_new_now_octets ();
2092 size
= strlen (str
) + 1;
2093 cp
= frag_more (size
);
2094 memcpy (cp
, str
, size
);
2100 /* Emit the directory and file tables for .debug_line. */
2103 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2109 bool emit_md5
= false;
2110 bool emit_timestamps
= true;
2111 bool emit_filesize
= true;
2112 segT line_str_seg
= NULL
;
2115 /* Output the Directory Table. */
2116 if (DWARF2_LINE_VERSION
>= 5)
2118 /* We only have one column in the directory table. */
2121 /* Describe the purpose and format of the column. */
2122 out_uleb128 (DW_LNCT_path
);
2123 /* Store these strings in the .debug_line_str section so they
2125 out_uleb128 (DW_FORM_line_strp
);
2127 /* Now state how many rows there are in the table. We need at
2128 least 1 if there is one or more file names to store the
2129 "working directory". */
2130 if (dirs_in_use
== 0 && files_in_use
> 0)
2133 out_uleb128 (dirs_in_use
);
2136 /* Emit directory list. */
2137 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2139 line_str_seg
= subseg_new (".debug_line_str", 0);
2140 bfd_set_section_flags (line_str_seg
,
2141 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2142 | SEC_MERGE
| SEC_STRINGS
);
2143 line_str_seg
->entsize
= 1;
2145 /* DWARF5 uses slot zero, but that is only set explicitly
2146 using a .file 0 directive. If that isn't used, but dir
2147 one is used, then use that as main file directory.
2148 Otherwise use pwd as main file directory. */
2149 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2150 dir
= remap_debug_filename (dirs
[0]);
2151 else if (dirs_in_use
> 1
2154 /* DWARF-5 directory tables expect dir[0] to be the same as
2155 DW_AT_comp_dir, which is the same as pwd. */
2157 dir
= remap_debug_filename (dirs
[1]);
2159 dir
= remap_debug_filename (getpwd ());
2161 line_strp
= add_line_strp (line_str_seg
, dir
);
2162 subseg_set (line_seg
, 0);
2163 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2165 for (i
= 1; i
< dirs_in_use
; ++i
)
2167 dir
= remap_debug_filename (dirs
[i
]);
2168 if (DWARF2_LINE_VERSION
< 5)
2170 size
= strlen (dir
) + 1;
2171 cp
= frag_more (size
);
2172 memcpy (cp
, dir
, size
);
2176 line_strp
= add_line_strp (line_str_seg
, dir
);
2177 subseg_set (line_seg
, 0);
2178 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2182 if (DWARF2_LINE_VERSION
< 5)
2186 /* Output the File Name Table. */
2187 if (DWARF2_LINE_VERSION
>= 5)
2189 unsigned int columns
= 4;
2191 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2193 emit_timestamps
= false;
2197 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2199 emit_filesize
= false;
2203 for (i
= 0; i
< files_in_use
; ++i
)
2204 if (files
[i
].md5
[0] != 0)
2206 if (i
< files_in_use
)
2212 /* The number of format entries to follow. */
2214 /* The format of the file name. */
2215 out_uleb128 (DW_LNCT_path
);
2216 /* Store these strings in the .debug_line_str section so they
2218 out_uleb128 (DW_FORM_line_strp
);
2220 /* The format of the directory index. */
2221 out_uleb128 (DW_LNCT_directory_index
);
2222 out_uleb128 (DW_FORM_udata
);
2224 if (emit_timestamps
)
2226 /* The format of the timestamp. */
2227 out_uleb128 (DW_LNCT_timestamp
);
2228 out_uleb128 (DW_FORM_udata
);
2233 /* The format of the file size. */
2234 out_uleb128 (DW_LNCT_size
);
2235 out_uleb128 (DW_FORM_udata
);
2240 /* The format of the MD5 sum. */
2241 out_uleb128 (DW_LNCT_MD5
);
2242 out_uleb128 (DW_FORM_data16
);
2245 /* The number of entries in the table. */
2246 out_uleb128 (files_in_use
);
2249 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2251 const char *fullfilename
;
2253 if (files
[i
].filename
== NULL
)
2255 /* Prevent a crash later, particularly for file 1. DWARF5
2256 uses slot zero, but that is only set explicitly using a
2257 .file 0 directive. If that isn't used, but file 1 is,
2258 then use that as main file name. */
2259 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1 && files
[0].filename
== NULL
)
2260 files
[0].filename
= files
[1].filename
;
2262 files
[i
].filename
= "";
2263 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2265 as_bad (_("unassigned file number %ld"), (long) i
);
2270 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2271 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2272 if (DWARF2_LINE_VERSION
< 5)
2274 size
= strlen (fullfilename
) + 1;
2275 cp
= frag_more (size
);
2276 memcpy (cp
, fullfilename
, size
);
2280 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2281 subseg_set (line_seg
, 0);
2282 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2285 /* Directory number. */
2286 out_uleb128 (files
[i
].dir
);
2288 /* Output the last modification timestamp. */
2289 if (emit_timestamps
)
2293 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2294 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2295 if (timestamp
== -1)
2297 out_uleb128 (timestamp
);
2300 /* Output the filesize. */
2304 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2305 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2308 out_uleb128 (filesize
);
2311 /* Output the md5 sum. */
2316 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2317 out_byte (files
[i
].md5
[b
]);
2321 if (DWARF2_LINE_VERSION
< 5)
2322 /* Terminate filename list. */
2326 /* Switch to SEC and output a header length field. Return the size of
2327 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2328 to the end of the section. EXPR->X_add_number will be set to the
2329 negative size of the header. */
2332 out_header (asection
*sec
, expressionS
*exp
)
2337 subseg_set (sec
, 0);
2339 if (flag_dwarf_sections
)
2341 /* If we are going to put the start and end symbols in different
2342 sections, then we need real symbols, not just fake, local ones. */
2344 start_sym
= symbol_make (".Ldebug_line_start");
2345 end_sym
= symbol_make (".Ldebug_line_end");
2346 symbol_set_value_now (start_sym
);
2350 start_sym
= symbol_temp_new_now_octets ();
2351 end_sym
= symbol_temp_make ();
2354 /* Total length of the information. */
2355 exp
->X_op
= O_subtract
;
2356 exp
->X_add_symbol
= end_sym
;
2357 exp
->X_op_symbol
= start_sym
;
2359 switch (DWARF2_FORMAT (sec
))
2361 case dwarf2_format_32bit
:
2362 exp
->X_add_number
= -4;
2366 case dwarf2_format_64bit
:
2367 exp
->X_add_number
= -12;
2372 case dwarf2_format_64bit_irix
:
2373 exp
->X_add_number
= -8;
2378 as_fatal (_("internal error: unknown dwarf2 format"));
2382 /* Emit the collected .debug_line data. */
2385 out_debug_line (segT line_seg
)
2388 symbolS
*prologue_start
, *prologue_end
;
2393 memset (&exp
, 0, sizeof exp
);
2394 sizeof_offset
= out_header (line_seg
, &exp
);
2395 line_end
= exp
.X_add_symbol
;
2398 out_two (DWARF2_LINE_VERSION
);
2400 if (DWARF2_LINE_VERSION
>= 5)
2402 out_byte (sizeof_address
);
2403 out_byte (0); /* Segment Selector size. */
2405 /* Length of the prologue following this length. */
2406 prologue_start
= symbol_temp_make ();
2407 prologue_end
= symbol_temp_make ();
2408 exp
.X_op
= O_subtract
;
2409 exp
.X_add_symbol
= prologue_end
;
2410 exp
.X_op_symbol
= prologue_start
;
2411 exp
.X_add_number
= 0;
2412 emit_expr (&exp
, sizeof_offset
);
2413 symbol_set_value_now (prologue_start
);
2415 /* Parameters of the state machine. */
2416 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2417 if (DWARF2_LINE_VERSION
>= 4)
2418 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2419 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2420 out_byte (DWARF2_LINE_BASE
);
2421 out_byte (DWARF2_LINE_RANGE
);
2422 out_byte (DWARF2_LINE_OPCODE_BASE
);
2424 /* Standard opcode lengths. */
2425 out_byte (0); /* DW_LNS_copy */
2426 out_byte (1); /* DW_LNS_advance_pc */
2427 out_byte (1); /* DW_LNS_advance_line */
2428 out_byte (1); /* DW_LNS_set_file */
2429 out_byte (1); /* DW_LNS_set_column */
2430 out_byte (0); /* DW_LNS_negate_stmt */
2431 out_byte (0); /* DW_LNS_set_basic_block */
2432 out_byte (0); /* DW_LNS_const_add_pc */
2433 out_byte (1); /* DW_LNS_fixed_advance_pc */
2434 out_byte (0); /* DW_LNS_set_prologue_end */
2435 out_byte (0); /* DW_LNS_set_epilogue_begin */
2436 out_byte (1); /* DW_LNS_set_isa */
2437 /* We have emitted 12 opcode lengths, so make that this
2438 matches up to the opcode base value we have been using. */
2439 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2441 out_dir_and_file_list (line_seg
, sizeof_offset
);
2443 symbol_set_value_now (prologue_end
);
2445 /* For each section, emit a statement program. */
2446 for (s
= all_segs
; s
; s
= s
->next
)
2447 /* Paranoia - this check should have already have
2448 been handled in dwarf2_gen_line_info_1(). */
2449 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2450 process_entries (s
->seg
, s
->head
->head
);
2452 if (flag_dwarf_sections
)
2453 /* We have to switch to the special .debug_line_end section
2454 before emitting the end-of-debug_line symbol. The linker
2455 script arranges for this section to be placed after all the
2456 (potentially garbage collected) .debug_line.<foo> sections.
2457 This section contains the line_end symbol which is used to
2458 compute the size of the linked .debug_line section, as seen
2459 in the DWARF Line Number header. */
2460 subseg_set (subseg_get (".debug_line_end", false), 0);
2462 symbol_set_value_now (line_end
);
2466 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2468 unsigned int addr_size
= sizeof_address
;
2473 memset (&exp
, 0, sizeof exp
);
2474 subseg_set (ranges_seg
, 0);
2476 /* For DW_AT_ranges to point at (there is no header, so really start
2477 of section, but see out_debug_rnglists). */
2478 *ranges_sym
= symbol_temp_new_now_octets ();
2480 /* Base Address Entry. */
2481 for (i
= 0; i
< addr_size
; i
++)
2483 for (i
= 0; i
< addr_size
; i
++)
2486 /* Range List Entry. */
2487 for (s
= all_segs
; s
; s
= s
->next
)
2492 frag
= first_frag_for_seg (s
->seg
);
2493 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2494 s
->text_start
= beg
;
2496 frag
= last_frag_for_seg (s
->seg
);
2497 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2500 exp
.X_op
= O_symbol
;
2501 exp
.X_add_symbol
= beg
;
2502 exp
.X_add_number
= 0;
2503 emit_expr (&exp
, addr_size
);
2505 exp
.X_op
= O_symbol
;
2506 exp
.X_add_symbol
= end
;
2507 exp
.X_add_number
= 0;
2508 emit_expr (&exp
, addr_size
);
2511 /* End of Range Entry. */
2512 for (i
= 0; i
< addr_size
; i
++)
2514 for (i
= 0; i
< addr_size
; i
++)
2519 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2522 symbolS
*ranges_end
;
2526 memset (&exp
, 0, sizeof exp
);
2527 out_header (ranges_seg
, &exp
);
2528 ranges_end
= exp
.X_add_symbol
;
2530 out_two (DWARF2_RNGLISTS_VERSION
);
2531 out_byte (sizeof_address
);
2532 out_byte (0); /* Segment Selector size. */
2533 out_four (0); /* Offset entry count. */
2535 /* For DW_AT_ranges to point at (must be after the header). */
2536 *ranges_sym
= symbol_temp_new_now_octets ();
2538 for (s
= all_segs
; s
; s
= s
->next
)
2543 out_byte (DW_RLE_start_length
);
2545 frag
= first_frag_for_seg (s
->seg
);
2546 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2547 s
->text_start
= beg
;
2549 frag
= last_frag_for_seg (s
->seg
);
2550 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2553 exp
.X_op
= O_symbol
;
2554 exp
.X_add_symbol
= beg
;
2555 exp
.X_add_number
= 0;
2556 emit_expr (&exp
, sizeof_address
);
2558 exp
.X_op
= O_symbol
;
2559 exp
.X_add_symbol
= end
;
2560 exp
.X_add_number
= 0;
2561 emit_leb128_expr (&exp
, 0);
2564 out_byte (DW_RLE_end_of_list
);
2566 symbol_set_value_now (ranges_end
);
2569 /* Emit data for .debug_aranges. */
2572 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2574 unsigned int addr_size
= sizeof_address
;
2578 symbolS
*aranges_end
;
2582 memset (&exp
, 0, sizeof exp
);
2583 sizeof_offset
= out_header (aranges_seg
, &exp
);
2584 aranges_end
= exp
.X_add_symbol
;
2585 size
= -exp
.X_add_number
;
2588 out_two (DWARF2_ARANGES_VERSION
);
2591 /* Offset to .debug_info. */
2592 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2593 size
+= sizeof_offset
;
2595 /* Size of an address (offset portion). */
2596 out_byte (addr_size
);
2599 /* Size of a segment descriptor. */
2603 /* Align the header. */
2604 while ((size
++ % (2 * addr_size
)) > 0)
2607 for (s
= all_segs
; s
; s
= s
->next
)
2612 frag
= first_frag_for_seg (s
->seg
);
2613 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2614 s
->text_start
= beg
;
2616 frag
= last_frag_for_seg (s
->seg
);
2617 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2620 exp
.X_op
= O_symbol
;
2621 exp
.X_add_symbol
= beg
;
2622 exp
.X_add_number
= 0;
2623 emit_expr (&exp
, addr_size
);
2625 exp
.X_op
= O_subtract
;
2626 exp
.X_add_symbol
= end
;
2627 exp
.X_op_symbol
= beg
;
2628 exp
.X_add_number
= 0;
2629 emit_expr (&exp
, addr_size
);
2632 p
= frag_more (2 * addr_size
);
2633 md_number_to_chars (p
, 0, addr_size
);
2634 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2636 symbol_set_value_now (aranges_end
);
2639 /* Emit data for .debug_abbrev. Note that this must be kept in
2640 sync with out_debug_info below. */
2643 out_debug_abbrev (segT abbrev_seg
,
2644 segT info_seg ATTRIBUTE_UNUSED
,
2645 segT line_seg ATTRIBUTE_UNUSED
)
2648 subseg_set (abbrev_seg
, 0);
2651 out_uleb128 (DW_TAG_compile_unit
);
2652 out_byte (DW_CHILDREN_no
);
2653 if (DWARF2_VERSION
< 4)
2655 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2656 secoff_form
= DW_FORM_data4
;
2658 secoff_form
= DW_FORM_data8
;
2661 secoff_form
= DW_FORM_sec_offset
;
2662 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2663 if (all_segs
->next
== NULL
)
2665 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2666 if (DWARF2_VERSION
< 4)
2667 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2669 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2672 out_abbrev (DW_AT_ranges
, secoff_form
);
2673 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2674 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2675 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2676 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2679 /* Terminate the abbreviations for this compilation unit. */
2683 /* Emit a description of this compilation unit for .debug_info. */
2686 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2687 symbolS
*ranges_sym
, symbolS
*name_sym
,
2688 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2694 memset (&exp
, 0, sizeof exp
);
2695 sizeof_offset
= out_header (info_seg
, &exp
);
2696 info_end
= exp
.X_add_symbol
;
2698 /* DWARF version. */
2699 out_two (DWARF2_VERSION
);
2701 if (DWARF2_VERSION
< 5)
2703 /* .debug_abbrev offset */
2704 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2708 /* unit (header) type */
2709 out_byte (DW_UT_compile
);
2712 /* Target address size. */
2713 out_byte (sizeof_address
);
2715 if (DWARF2_VERSION
>= 5)
2717 /* .debug_abbrev offset */
2718 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2721 /* DW_TAG_compile_unit DIE abbrev */
2724 /* DW_AT_stmt_list */
2725 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2726 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2729 /* These two attributes are emitted if all of the code is contiguous. */
2730 if (all_segs
->next
== NULL
)
2733 exp
.X_op
= O_symbol
;
2734 exp
.X_add_symbol
= all_segs
->text_start
;
2735 exp
.X_add_number
= 0;
2736 emit_expr (&exp
, sizeof_address
);
2739 if (DWARF2_VERSION
< 4)
2740 exp
.X_op
= O_symbol
;
2743 exp
.X_op
= O_subtract
;
2744 exp
.X_op_symbol
= all_segs
->text_start
;
2746 exp
.X_add_symbol
= all_segs
->text_end
;
2747 exp
.X_add_number
= 0;
2748 if (DWARF2_VERSION
< 4)
2749 emit_expr (&exp
, sizeof_address
);
2751 emit_leb128_expr (&exp
, 0);
2755 /* This attribute is emitted if the code is disjoint. */
2757 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2760 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2761 setup in out_debug_str below. */
2762 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2763 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2764 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2766 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2767 dwarf2 draft has no standard code for assembler. */
2768 out_two (DW_LANG_Mips_Assembler
);
2770 symbol_set_value_now (info_end
);
2773 /* Emit the three debug strings needed in .debug_str and setup symbols
2774 to them for use in out_debug_info. */
2776 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2777 symbolS
**producer_sym
)
2780 const char *comp_dir
;
2781 const char *dirname
;
2784 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2786 subseg_set (str_seg
, 0);
2788 /* DW_AT_name. We don't have the actual file name that was present
2789 on the command line, so assume files[first_file] is the main input file.
2790 We're not supposed to get called unless at least one line number
2791 entry was emitted, so this should always be defined. */
2792 *name_sym
= symbol_temp_new_now_octets ();
2793 if (files_in_use
== 0)
2795 if (files
[first_file
].dir
)
2797 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2798 len
= strlen (dirname
);
2800 /* Already has trailing slash. */
2801 p
= frag_more (len
);
2802 memcpy (p
, dirname
, len
);
2804 p
= frag_more (len
+ 1);
2805 memcpy (p
, dirname
, len
);
2806 INSERT_DIR_SEPARATOR (p
, len
);
2809 len
= strlen (files
[first_file
].filename
) + 1;
2810 p
= frag_more (len
);
2811 memcpy (p
, files
[first_file
].filename
, len
);
2813 /* DW_AT_comp_dir */
2814 *comp_dir_sym
= symbol_temp_new_now_octets ();
2815 comp_dir
= remap_debug_filename (getpwd ());
2816 len
= strlen (comp_dir
) + 1;
2817 p
= frag_more (len
);
2818 memcpy (p
, comp_dir
, len
);
2820 /* DW_AT_producer */
2821 *producer_sym
= symbol_temp_new_now_octets ();
2822 sprintf (producer
, "GNU AS %s", VERSION
);
2823 len
= strlen (producer
) + 1;
2824 p
= frag_more (len
);
2825 memcpy (p
, producer
, len
);
2831 last_seg_ptr
= &all_segs
;
2833 /* Select the default CIE version to produce here. The global
2834 starts with a value of -1 and will be modified to a valid value
2835 either by the user providing a command line option, or some
2836 targets will select their own default in md_after_parse_args. If
2837 we get here and the global still contains -1 then it is up to us
2838 to pick a sane default. The default we choose is 1, this is the
2839 CIE version gas has produced for a long time, and there seems no
2840 reason to change it yet. */
2841 if (flag_dwarf_cie_version
== -1)
2842 flag_dwarf_cie_version
= 1;
2845 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2846 were any .file/.loc directives, or --gdwarf2 was given, and if the
2847 file has a non-empty .debug_info section and an empty .debug_line
2848 section. If we emit .debug_line, and the .debug_info section is
2849 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2850 ALL_SEGS will be non-null if there were any .file/.loc directives,
2851 or --gdwarf2 was given and there were any located instructions
2855 dwarf2_finish (void)
2860 int emit_other_sections
= 0;
2861 int empty_debug_line
= 0;
2863 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2864 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2866 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2867 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2869 /* We can't construct a new debug_line section if we already have one.
2870 Give an error if we have seen any .loc, otherwise trust the user
2871 knows what they are doing and want to generate the .debug_line
2872 (and all other debug sections) themselves. */
2873 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2874 as_fatal ("duplicate .debug_line sections");
2876 if ((!all_segs
&& emit_other_sections
)
2877 || (!emit_other_sections
&& !empty_debug_line
))
2878 /* If there is no line information and no non-empty .debug_info
2879 section, or if there is both a non-empty .debug_info and a non-empty
2880 .debug_line, then we do nothing. */
2883 /* Calculate the size of an address for the target machine. */
2884 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2886 /* Create and switch to the line number section. */
2887 if (empty_debug_line
)
2889 line_seg
= subseg_new (".debug_line", 0);
2890 bfd_set_section_flags (line_seg
,
2891 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2894 for (s
= all_segs
; s
; s
= s
->next
)
2896 struct line_subseg
*lss
;
2898 for (lss
= s
->head
; lss
; lss
= lss
->next
)
2900 do_allocate_filenum (lss
->head
);
2903 /* For each subsection, chain the debug entries together. */
2904 for (s
= all_segs
; s
; s
= s
->next
)
2906 struct line_subseg
*lss
= s
->head
;
2907 struct line_entry
**ptail
= lss
->ptail
;
2909 /* Reset the initial view of the first subsection of the
2911 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2912 set_or_check_view (lss
->head
, NULL
, NULL
);
2914 while ((lss
= lss
->next
) != NULL
)
2916 /* Link the first view of subsequent subsections to the
2918 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2919 set_or_check_view (lss
->head
,
2920 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2921 s
->head
? s
->head
->head
: NULL
);
2927 if (empty_debug_line
)
2928 out_debug_line (line_seg
);
2930 /* If this is assembler generated line info, and there is no
2931 debug_info already, we need .debug_info, .debug_abbrev and
2932 .debug_str sections as well. */
2933 if (emit_other_sections
)
2938 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2940 gas_assert (all_segs
);
2942 info_seg
= subseg_new (".debug_info", 0);
2943 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2944 aranges_seg
= subseg_new (".debug_aranges", 0);
2945 str_seg
= subseg_new (".debug_str", 0);
2947 bfd_set_section_flags (info_seg
,
2948 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2949 bfd_set_section_flags (abbrev_seg
,
2950 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2951 bfd_set_section_flags (aranges_seg
,
2952 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2953 bfd_set_section_flags (str_seg
,
2954 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2955 | SEC_MERGE
| SEC_STRINGS
);
2956 str_seg
->entsize
= 1;
2958 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2960 if (all_segs
->next
== NULL
)
2964 if (DWARF2_VERSION
< 5)
2966 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2967 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2970 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2971 out_debug_ranges (ranges_seg
, &ranges_sym
);
2975 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2976 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2979 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2983 out_debug_aranges (aranges_seg
, info_seg
);
2984 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2985 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2986 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2987 name_sym
, comp_dir_sym
, producer_sym
);
2991 /* Perform any deferred checks pertaining to debug information. */
2994 dwarf2dbg_final_check (void)
2996 /* Perform reset-view checks. Don't evaluate view_assert_failed
2997 recursively: it could be very deep. It's a chain of adds, with
2998 each chain element pointing to the next in X_add_symbol, and
2999 holding the check value in X_op_symbol. */
3000 while (view_assert_failed
)
3006 gas_assert (!symbol_resolved_p (view_assert_failed
));
3008 exp
= symbol_get_value_expression (view_assert_failed
);
3009 sym
= view_assert_failed
;
3011 /* If view_assert_failed looks like a compound check in the
3012 chain, break it up. */
3013 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3015 view_assert_failed
= exp
->X_add_symbol
;
3016 sym
= exp
->X_op_symbol
;
3019 view_assert_failed
= NULL
;
3021 failed
= resolve_symbol_value (sym
);
3022 if (!symbol_resolved_p (sym
) || failed
)
3024 as_bad (_("view number mismatch"));