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 (void) get_directory_table_entry (pwd
, file0_dirname
,
656 if (d
>= dirs_allocated
)
658 unsigned int old
= dirs_allocated
;
659 #define DIR_TABLE_INCREMENT 32
660 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
661 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
662 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
665 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
666 if (dirs_in_use
<= d
)
673 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
675 if (i
>= files_allocated
)
677 unsigned int old
= files_allocated
;
679 files_allocated
= i
+ 32;
680 /* Catch wraparound. */
681 if (files_allocated
<= old
)
683 as_bad (_("file number %lu is too big"), (unsigned long) i
);
687 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
688 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
691 files
[i
].filename
= file
;
693 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
695 if (files_in_use
< i
+ 1)
696 files_in_use
= i
+ 1;
701 /* Get a .debug_line file number for PATHNAME. If there is a
702 directory component to PATHNAME, then this will be stored
703 in the directory table, if it is not already present.
704 Returns the slot number allocated to that filename or -1
705 if there was a problem. */
708 allocate_filenum (const char * pathname
)
710 static signed int last_used
= -1, last_used_dir_len
= 0;
715 /* Short circuit the common case of adding the same pathname
719 const char * dirname
= NULL
;
722 dirname
= dirs
[files
[last_used
].dir
];
726 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
731 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
- 1) == 0
732 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
- 1])
733 && filename_cmp (pathname
+ last_used_dir_len
,
734 files
[last_used
].filename
) == 0)
739 file
= get_basename (pathname
);
740 dir_len
= file
- pathname
;
742 dir
= get_directory_table_entry (pathname
, NULL
, dir_len
, false);
744 /* Do not use slot-0. That is specifically reserved for use by
745 the '.file 0 "name"' directive. */
746 for (i
= 1; i
< files_in_use
; ++i
)
747 if (files
[i
].dir
== dir
749 && filename_cmp (file
, files
[i
].filename
) == 0)
752 last_used_dir_len
= dir_len
;
756 if (!assign_file_to_slot (i
, file
, dir
))
760 last_used_dir_len
= dir_len
;
765 /* Run through the list of line entries starting at E, allocating
766 file entries for gas generated debug. */
769 do_allocate_filenum (struct line_entry
*e
)
773 if (e
->loc
.filenum
== -1u)
775 e
->loc
.filenum
= allocate_filenum (e
->loc
.u
.filename
);
776 e
->loc
.u
.view
= NULL
;
783 /* Remove any generated line entries. These don't live comfortably
784 with compiler generated line info. */
787 purge_generated_debug (void)
791 for (s
= all_segs
; s
; s
= s
->next
)
793 struct line_subseg
*lss
;
795 for (lss
= s
->head
; lss
; lss
= lss
->next
)
797 struct line_entry
*e
, *next
;
799 for (e
= lss
->head
; e
; e
= next
)
801 know (e
->loc
.filenum
== -1u);
807 lss
->ptail
= &lss
->head
;
808 lss
->pmove_tail
= &lss
->head
;
813 /* Allocate slot NUM in the .debug_line file table to FILENAME.
814 If DIRNAME is not NULL or there is a directory component to FILENAME
815 then this will be stored in the directory table, if not already present.
816 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
817 Returns TRUE if allocation succeeded, FALSE otherwise. */
820 allocate_filename_to_slot (const char *dirname
,
821 const char *filename
,
828 const char *file0_dirname
;
830 /* Short circuit the common case of adding the same pathname
832 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
834 const char * dir
= NULL
;
837 dir
= dirs
[files
[num
].dir
];
840 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
845 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
848 if (filename_cmp (filename
, files
[num
].filename
) != 0)
851 /* If the filenames match, but the directory table entry was
852 empty, then fill it with the provided directory name. */
857 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
858 dirs
= XCNEWVEC (char *, dirs_allocated
);
861 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
866 else if (dir
!= NULL
)
868 dirlen
= strlen (dir
);
869 if (filename_ncmp (filename
, dir
, dirlen
) == 0
870 && IS_DIR_SEPARATOR (filename
[dirlen
])
871 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
874 else /* dir == NULL */
876 file
= get_basename (filename
);
877 if (filename_cmp (file
, files
[num
].filename
) == 0)
879 /* The filenames match, but the directory table entry is empty.
880 Fill it with the provided directory name. */
885 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
886 dirs
= XCNEWVEC (char *, dirs_allocated
);
889 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
896 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
898 dir
== NULL
? "" : dir
,
899 dir
== NULL
? "" : "/",
901 dirname
== NULL
? "" : dirname
,
902 dirname
== NULL
? "" : "/",
907 /* For file .0, the directory name is the current directory and the file
908 may be in another directory contained in the file name. */
911 file0_dirname
= dirname
;
913 file
= get_basename (filename
);
915 if (dirname
&& file
== filename
)
916 dirlen
= strlen (dirname
);
920 dirlen
= file
- filename
;
925 file0_dirname
= NULL
;
930 file
= get_basename (filename
);
931 dirlen
= file
- filename
;
935 dirlen
= strlen (dirname
);
940 d
= get_directory_table_entry (dirname
, file0_dirname
, dirlen
, num
== 0);
943 if (! assign_file_to_slot (i
, file
, d
))
948 if (target_big_endian
)
950 /* md5's are stored in litte endian format. */
951 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
952 unsigned int byte
= NUM_MD5_BYTES
;
953 unsigned int bignum_index
= 0;
955 while (bits_remaining
)
957 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
958 valueT bignum_value
= generic_bignum
[bignum_index
];
961 while (bignum_bits_remaining
)
963 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
965 bignum_bits_remaining
-= 8;
972 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
973 unsigned int byte
= 0;
974 unsigned int bignum_index
= 0;
976 while (bits_remaining
)
978 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
979 valueT bignum_value
= generic_bignum
[bignum_index
];
983 while (bignum_bits_remaining
)
985 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
987 bignum_bits_remaining
-= 8;
994 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
999 /* Returns the current source information. If .file directives have
1000 been encountered, the info for the corresponding source file is
1001 returned. Otherwise, the info for the assembly source file is
1005 dwarf2_where (struct dwarf2_line_info
*line
)
1007 if (debug_type
== DEBUG_DWARF2
)
1009 line
->u
.filename
= as_where (&line
->line
);
1010 line
->filenum
= -1u;
1012 line
->flags
= DWARF2_FLAG_IS_STMT
;
1013 line
->isa
= current
.isa
;
1014 line
->discriminator
= current
.discriminator
;
1020 /* A hook to allow the target backend to inform the line number state
1021 machine of isa changes when assembler debug info is enabled. */
1024 dwarf2_set_isa (unsigned int isa
)
1029 /* Called for each machine instruction, or relatively atomic group of
1030 machine instructions (ie built-in macro). The instruction or group
1031 is SIZE bytes in length. If dwarf2 line number generation is called
1032 for, emit a line statement appropriately. */
1035 dwarf2_emit_insn (int size
)
1037 struct dwarf2_line_info loc
;
1039 if (debug_type
!= DEBUG_DWARF2
1040 ? !dwarf2_loc_directive_seen
1041 : !seen_at_least_1_file ())
1044 dwarf2_where (&loc
);
1046 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
1047 dwarf2_consume_line_info ();
1050 /* Move all previously-emitted line entries for the current position by
1051 DELTA bytes. This function cannot be used to move the same entries
1055 dwarf2_move_insn (int delta
)
1057 struct line_subseg
*lss
;
1058 struct line_entry
*e
;
1064 lss
= get_line_subseg (now_seg
, now_subseg
, false);
1068 now
= frag_now_fix ();
1069 while ((e
= *lss
->pmove_tail
))
1071 if (S_GET_VALUE (e
->label
) == now
)
1072 S_SET_VALUE (e
->label
, now
+ delta
);
1073 lss
->pmove_tail
= &e
->next
;
1077 /* Called after the current line information has been either used with
1078 dwarf2_gen_line_info or saved with a machine instruction for later use.
1079 This resets the state of the line number information to reflect that
1080 it has been used. */
1083 dwarf2_consume_line_info (void)
1085 /* Unless we generate DWARF2 debugging information for each
1086 assembler line, we only emit one line symbol for one LOC. */
1087 dwarf2_loc_directive_seen
= false;
1089 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1090 | DWARF2_FLAG_PROLOGUE_END
1091 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1092 current
.discriminator
= 0;
1093 current
.u
.view
= NULL
;
1096 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1097 is enabled, emit a basic block marker. */
1100 dwarf2_emit_label (symbolS
*label
)
1102 struct dwarf2_line_info loc
;
1104 if (!dwarf2_loc_mark_labels
)
1106 if (S_GET_SEGMENT (label
) != now_seg
)
1108 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1110 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1113 dwarf2_where (&loc
);
1115 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1117 dwarf2_gen_line_info_1 (label
, &loc
);
1118 dwarf2_consume_line_info ();
1121 /* Handle two forms of .file directive:
1122 - Pass .file "source.c" to s_app_file
1123 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1125 If an entry is added to the file table, return a pointer to the filename. */
1128 dwarf2_directive_filename (void)
1130 bool with_md5
= false;
1133 const char * dirname
= NULL
;
1136 /* Continue to accept a bare string and pass it off. */
1138 if (*input_line_pointer
== '"')
1144 num
= get_absolute_expression ();
1146 if ((offsetT
) num
< 1)
1148 if (num
== 0 && dwarf_level
< 5)
1150 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1152 as_bad (_("file number less than one"));
1153 ignore_rest_of_line ();
1158 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1159 "switch back to the already allocated file <N> as the current
1162 filename
= demand_copy_C_string (&filename_len
);
1163 if (filename
== NULL
)
1164 /* demand_copy_C_string will have already generated an error message. */
1167 /* For DWARF-5 support we also accept:
1168 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1169 if (DWARF2_LINE_VERSION
> 4)
1172 if (*input_line_pointer
== '"')
1175 filename
= demand_copy_C_string (&filename_len
);
1179 if (startswith (input_line_pointer
, "md5"))
1181 input_line_pointer
+= 3;
1185 expression_and_evaluate (& exp
);
1186 if (exp
.X_op
!= O_big
)
1187 as_bad (_("md5 value too small or not a constant"));
1193 demand_empty_rest_of_line ();
1195 /* A .file directive implies compiler generated debug information is
1196 being supplied. Turn off gas generated debug info. */
1197 if (debug_type
== DEBUG_DWARF2
)
1198 purge_generated_debug ();
1199 debug_type
= DEBUG_NONE
;
1201 if (num
!= (unsigned int) num
1202 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1204 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1208 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1215 /* Calls dwarf2_directive_filename, but discards its result.
1216 Used in pseudo-op tables where the function result is ignored. */
1219 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1221 (void) dwarf2_directive_filename ();
1225 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1227 offsetT filenum
, line
;
1229 /* If we see two .loc directives in a row, force the first one to be
1231 if (dwarf2_loc_directive_seen
)
1232 dwarf2_emit_insn (0);
1234 filenum
= get_absolute_expression ();
1236 line
= get_absolute_expression ();
1240 if (filenum
== 0 && dwarf_level
< 5)
1242 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1244 as_bad (_("file number less than one"));
1249 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1251 as_bad (_("unassigned file number %ld"), (long) filenum
);
1255 /* debug_type will be turned off by dwarf2_directive_filename, and
1256 if we don't have a dwarf style .file then files_in_use will be
1257 zero and the above error will trigger. */
1258 gas_assert (debug_type
== DEBUG_NONE
);
1260 current
.filenum
= filenum
;
1261 current
.line
= line
;
1262 current
.discriminator
= 0;
1267 if (files
[filenum
].dir
)
1269 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1270 size_t file_len
= strlen (files
[filenum
].filename
);
1271 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1273 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1274 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1275 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1276 cp
[dir_len
+ file_len
+ 1] = '\0';
1277 listing_source_file (cp
);
1281 listing_source_file (files
[filenum
].filename
);
1282 listing_source_line (line
);
1287 if (ISDIGIT (*input_line_pointer
))
1289 current
.column
= get_absolute_expression ();
1293 while (ISALPHA (*input_line_pointer
))
1298 c
= get_symbol_name (& p
);
1300 if (strcmp (p
, "basic_block") == 0)
1302 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1303 *input_line_pointer
= c
;
1305 else if (strcmp (p
, "prologue_end") == 0)
1307 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1308 *input_line_pointer
= c
;
1310 else if (strcmp (p
, "epilogue_begin") == 0)
1312 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1313 *input_line_pointer
= c
;
1315 else if (strcmp (p
, "is_stmt") == 0)
1317 (void) restore_line_pointer (c
);
1318 value
= get_absolute_expression ();
1320 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1321 else if (value
== 1)
1322 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1325 as_bad (_("is_stmt value not 0 or 1"));
1329 else if (strcmp (p
, "isa") == 0)
1331 (void) restore_line_pointer (c
);
1332 value
= get_absolute_expression ();
1334 current
.isa
= value
;
1337 as_bad (_("isa number less than zero"));
1341 else if (strcmp (p
, "discriminator") == 0)
1343 (void) restore_line_pointer (c
);
1344 value
= get_absolute_expression ();
1346 current
.discriminator
= value
;
1349 as_bad (_("discriminator less than zero"));
1353 else if (strcmp (p
, "view") == 0)
1357 (void) restore_line_pointer (c
);
1360 if (ISDIGIT (*input_line_pointer
)
1361 || *input_line_pointer
== '-')
1363 bool force_reset
= *input_line_pointer
== '-';
1365 value
= get_absolute_expression ();
1368 as_bad (_("numeric view can only be asserted to zero"));
1371 if (force_reset
&& force_reset_view
)
1372 sym
= force_reset_view
;
1375 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1378 force_reset_view
= sym
;
1383 char *name
= read_symbol_name ();
1387 sym
= symbol_find_or_make (name
);
1388 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1390 if (S_IS_VOLATILE (sym
))
1391 sym
= symbol_clone (sym
, 1);
1392 else if (!S_CAN_BE_REDEFINED (sym
))
1394 as_bad (_("symbol `%s' is already defined"), name
);
1398 S_SET_SEGMENT (sym
, undefined_section
);
1399 S_SET_VALUE (sym
, 0);
1400 symbol_set_frag (sym
, &zero_address_frag
);
1402 current
.u
.view
= sym
;
1406 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1407 (void) restore_line_pointer (c
);
1411 SKIP_WHITESPACE_AFTER_NAME ();
1414 demand_empty_rest_of_line ();
1415 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1417 /* If we were given a view id, emit the row right away. */
1419 dwarf2_emit_insn (0);
1423 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1425 offsetT value
= get_absolute_expression ();
1427 if (value
!= 0 && value
!= 1)
1429 as_bad (_("expected 0 or 1"));
1430 ignore_rest_of_line ();
1434 dwarf2_loc_mark_labels
= value
!= 0;
1435 demand_empty_rest_of_line ();
1439 static struct frag
*
1440 first_frag_for_seg (segT seg
)
1442 return seg_info (seg
)->frchainP
->frch_root
;
1445 static struct frag
*
1446 last_frag_for_seg (segT seg
)
1448 frchainS
*f
= seg_info (seg
)->frchainP
;
1450 while (f
->frch_next
!= NULL
)
1453 return f
->frch_last
;
1456 /* Emit a single byte into the current segment. */
1461 FRAG_APPEND_1_CHAR (byte
);
1464 /* Emit a statement program opcode into the current segment. */
1467 out_opcode (int opc
)
1472 /* Emit a two-byte word into the current segment. */
1477 md_number_to_chars (frag_more (2), data
, 2);
1480 /* Emit a four byte word into the current segment. */
1485 md_number_to_chars (frag_more (4), data
, 4);
1488 /* Emit an unsigned "little-endian base 128" number. */
1491 out_uleb128 (addressT value
)
1493 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1496 /* Emit a signed "little-endian base 128" number. */
1499 out_leb128 (addressT value
)
1501 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1504 /* Emit a tuple for .debug_abbrev. */
1507 out_abbrev (int name
, int form
)
1513 /* Get the size of a fragment. */
1516 get_frag_fix (fragS
*frag
, segT seg
)
1521 return frag
->fr_fix
;
1523 /* If a fragment is the last in the chain, special measures must be
1524 taken to find its size before relaxation, since it may be pending
1525 on some subsegment chain. */
1526 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1527 if (fr
->frch_last
== frag
)
1528 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1533 /* Set an absolute address (may result in a relocation entry). */
1536 out_set_addr (symbolS
*sym
)
1540 memset (&exp
, 0, sizeof exp
);
1541 out_opcode (DW_LNS_extended_op
);
1542 out_uleb128 (sizeof_address
+ 1);
1544 out_opcode (DW_LNE_set_address
);
1545 exp
.X_op
= O_symbol
;
1546 exp
.X_add_symbol
= sym
;
1547 exp
.X_add_number
= 0;
1548 emit_expr (&exp
, sizeof_address
);
1551 static void scale_addr_delta (addressT
*);
1554 scale_addr_delta (addressT
*addr_delta
)
1556 static int printed_this
= 0;
1557 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1559 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1561 as_bad("unaligned opcodes detected in executable segment");
1564 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1568 /* Encode a pair of line and address skips as efficiently as possible.
1569 Note that the line skip is signed, whereas the address skip is unsigned.
1571 The following two routines *must* be kept in sync. This is
1572 enforced by making emit_inc_line_addr abort if we do not emit
1573 exactly the expected number of bytes. */
1576 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1578 unsigned int tmp
, opcode
;
1581 /* Scale the address delta by the minimum instruction length. */
1582 scale_addr_delta (&addr_delta
);
1584 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1585 We cannot use special opcodes here, since we want the end_sequence
1586 to emit the matrix entry. */
1587 if (line_delta
== INT_MAX
)
1589 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1591 else if (addr_delta
)
1592 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1596 /* Bias the line delta by the base. */
1597 tmp
= line_delta
- DWARF2_LINE_BASE
;
1599 /* If the line increment is out of range of a special opcode, we
1600 must encode it with DW_LNS_advance_line. */
1601 if (tmp
>= DWARF2_LINE_RANGE
)
1603 len
= 1 + sizeof_leb128 (line_delta
, 1);
1605 tmp
= 0 - DWARF2_LINE_BASE
;
1608 /* Bias the opcode by the special opcode base. */
1609 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1611 /* Avoid overflow when addr_delta is large. */
1612 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1614 /* Try using a special opcode. */
1615 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1619 /* Try using DW_LNS_const_add_pc followed by special op. */
1620 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1625 /* Otherwise use DW_LNS_advance_pc. */
1626 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1628 /* DW_LNS_copy or special opcode. */
1635 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1637 unsigned int tmp
, opcode
;
1639 char *end
= p
+ len
;
1641 /* Line number sequences cannot go backward in addresses. This means
1642 we've incorrectly ordered the statements in the sequence. */
1643 gas_assert ((offsetT
) addr_delta
>= 0);
1645 /* Scale the address delta by the minimum instruction length. */
1646 scale_addr_delta (&addr_delta
);
1648 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1649 We cannot use special opcodes here, since we want the end_sequence
1650 to emit the matrix entry. */
1651 if (line_delta
== INT_MAX
)
1653 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1654 *p
++ = DW_LNS_const_add_pc
;
1655 else if (addr_delta
)
1657 *p
++ = DW_LNS_advance_pc
;
1658 p
+= output_leb128 (p
, addr_delta
, 0);
1661 *p
++ = DW_LNS_extended_op
;
1663 *p
++ = DW_LNE_end_sequence
;
1667 /* Bias the line delta by the base. */
1668 tmp
= line_delta
- DWARF2_LINE_BASE
;
1670 /* If the line increment is out of range of a special opcode, we
1671 must encode it with DW_LNS_advance_line. */
1672 if (tmp
>= DWARF2_LINE_RANGE
)
1674 *p
++ = DW_LNS_advance_line
;
1675 p
+= output_leb128 (p
, line_delta
, 1);
1678 tmp
= 0 - DWARF2_LINE_BASE
;
1682 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1684 if (line_delta
== 0 && addr_delta
== 0)
1690 /* Bias the opcode by the special opcode base. */
1691 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1693 /* Avoid overflow when addr_delta is large. */
1694 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1696 /* Try using a special opcode. */
1697 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1704 /* Try using DW_LNS_const_add_pc followed by special op. */
1705 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1708 *p
++ = DW_LNS_const_add_pc
;
1714 /* Otherwise use DW_LNS_advance_pc. */
1715 *p
++ = DW_LNS_advance_pc
;
1716 p
+= output_leb128 (p
, addr_delta
, 0);
1724 gas_assert (p
== end
);
1727 /* Handy routine to combine calls to the above two routines. */
1730 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1732 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1733 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1736 /* Write out an alternative form of line and address skips using
1737 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1738 line and address information, but it is required if linker relaxation
1739 could change the code offsets. The following two routines *must* be
1741 #define ADDR_DELTA_LIMIT 50000
1744 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1748 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1749 if (line_delta
!= INT_MAX
)
1750 len
= 1 + sizeof_leb128 (line_delta
, 1);
1752 if (addr_delta
> ADDR_DELTA_LIMIT
)
1754 /* DW_LNS_extended_op */
1755 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1756 /* DW_LNE_set_address */
1757 len
+= 1 + sizeof_address
;
1760 /* DW_LNS_fixed_advance_pc */
1763 if (line_delta
== INT_MAX
)
1764 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1774 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1778 char *end
= p
+ len
;
1780 /* Line number sequences cannot go backward in addresses. This means
1781 we've incorrectly ordered the statements in the sequence. */
1782 gas_assert ((offsetT
) addr_delta
>= 0);
1784 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1785 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1787 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1788 if (line_delta
!= INT_MAX
)
1790 *p
++ = DW_LNS_advance_line
;
1791 p
+= output_leb128 (p
, line_delta
, 1);
1794 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1796 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1797 advance the address by at most 64K. Linker relaxation (without
1798 which this function would not be used) could change the operand by
1799 an unknown amount. If the address increment is getting close to
1800 the limit, just reset the address. */
1801 if (addr_delta
> ADDR_DELTA_LIMIT
)
1806 memset (&exp
, 0, sizeof exp
);
1807 gas_assert (pexp
->X_op
== O_subtract
);
1808 to_sym
= pexp
->X_add_symbol
;
1810 *p
++ = DW_LNS_extended_op
;
1811 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1812 *p
++ = DW_LNE_set_address
;
1813 exp
.X_op
= O_symbol
;
1814 exp
.X_add_symbol
= to_sym
;
1815 exp
.X_add_number
= 0;
1816 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1817 p
+= sizeof_address
;
1821 *p
++ = DW_LNS_fixed_advance_pc
;
1822 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1826 if (line_delta
== INT_MAX
)
1828 *p
++ = DW_LNS_extended_op
;
1830 *p
++ = DW_LNE_end_sequence
;
1835 gas_assert (p
== end
);
1838 /* Generate a variant frag that we can use to relax address/line
1839 increments between fragments of the target segment. */
1842 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1847 memset (&exp
, 0, sizeof exp
);
1848 exp
.X_op
= O_subtract
;
1849 exp
.X_add_symbol
= to_sym
;
1850 exp
.X_op_symbol
= from_sym
;
1851 exp
.X_add_number
= 0;
1853 /* The maximum size of the frag is the line delta with a maximum
1854 sized address delta. */
1855 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1856 max_chars
= size_fixed_inc_line_addr (line_delta
,
1857 -DWARF2_LINE_MIN_INSN_LENGTH
);
1859 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1861 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1862 make_expr_symbol (&exp
), line_delta
, NULL
);
1865 /* The function estimates the size of a rs_dwarf2dbg variant frag
1866 based on the current values of the symbols. It is called before
1867 the relaxation loop. We set fr_subtype to the expected length. */
1870 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1875 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1876 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1877 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1879 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1881 frag
->fr_subtype
= size
;
1886 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1887 current values of the symbols. fr_subtype is the current length
1888 of the frag. This returns the change in frag length. */
1891 dwarf2dbg_relax_frag (fragS
*frag
)
1893 int old_size
, new_size
;
1895 old_size
= frag
->fr_subtype
;
1896 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1898 return new_size
- old_size
;
1901 /* This function converts a rs_dwarf2dbg variant frag into a normal
1902 fill frag. This is called after all relaxation has been done.
1903 fr_subtype will be the desired length of the frag. */
1906 dwarf2dbg_convert_frag (fragS
*frag
)
1910 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1912 /* If linker relaxation is enabled then the distance between the two
1913 symbols in the frag->fr_symbol expression might change. Hence we
1914 cannot rely upon the value computed by resolve_symbol_value.
1915 Instead we leave the expression unfinalized and allow
1916 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1917 relocation) that will allow the linker to correctly compute the
1918 actual address difference. We have to use a fixed line advance for
1919 this as we cannot (easily) relocate leb128 encoded values. */
1920 int saved_finalize_syms
= finalize_syms
;
1923 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1924 finalize_syms
= saved_finalize_syms
;
1927 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1929 /* fr_var carries the max_chars that we created the fragment with.
1930 fr_subtype carries the current expected length. We must, of
1931 course, have allocated enough memory earlier. */
1932 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1934 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1935 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1936 frag
->fr_literal
+ frag
->fr_fix
,
1939 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1940 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1942 frag
->fr_fix
+= frag
->fr_subtype
;
1943 frag
->fr_type
= rs_fill
;
1945 frag
->fr_offset
= 0;
1948 /* Generate .debug_line content for the chain of line number entries
1949 beginning at E, for segment SEG. */
1952 process_entries (segT seg
, struct line_entry
*e
)
1954 unsigned filenum
= 1;
1956 unsigned column
= 0;
1958 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1959 fragS
*last_frag
= NULL
, *frag
;
1960 addressT last_frag_ofs
= 0, frag_ofs
;
1961 symbolS
*last_lab
= NULL
, *lab
;
1962 struct line_entry
*next
;
1964 if (flag_dwarf_sections
)
1967 const char * sec_name
;
1969 /* Switch to the relevant sub-section before we start to emit
1970 the line number table.
1972 FIXME: These sub-sections do not have a normal Line Number
1973 Program Header, thus strictly speaking they are not valid
1974 DWARF sections. Unfortunately the DWARF standard assumes
1975 a one-to-one relationship between compilation units and
1976 line number tables. Thus we have to have a .debug_line
1977 section, as well as our sub-sections, and we have to ensure
1978 that all of the sub-sections are merged into a proper
1979 .debug_line section before a debugger sees them. */
1981 sec_name
= bfd_section_name (seg
);
1982 if (strcmp (sec_name
, ".text") != 0)
1984 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1985 subseg_set (subseg_get (name
, false), 0);
1988 /* Don't create a .debug_line.text section -
1989 that is redundant. Instead just switch back to the
1990 normal .debug_line section. */
1991 subseg_set (subseg_get (".debug_line", false), 0);
1998 if (filenum
!= e
->loc
.filenum
)
2000 filenum
= e
->loc
.filenum
;
2001 out_opcode (DW_LNS_set_file
);
2002 out_uleb128 (filenum
);
2005 if (column
!= e
->loc
.column
)
2007 column
= e
->loc
.column
;
2008 out_opcode (DW_LNS_set_column
);
2009 out_uleb128 (column
);
2012 if (e
->loc
.discriminator
!= 0)
2014 out_opcode (DW_LNS_extended_op
);
2015 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
2016 out_opcode (DW_LNE_set_discriminator
);
2017 out_uleb128 (e
->loc
.discriminator
);
2020 if (isa
!= e
->loc
.isa
)
2023 out_opcode (DW_LNS_set_isa
);
2027 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
2029 flags
= e
->loc
.flags
;
2030 out_opcode (DW_LNS_negate_stmt
);
2033 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
2034 out_opcode (DW_LNS_set_basic_block
);
2036 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
2037 out_opcode (DW_LNS_set_prologue_end
);
2039 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
2040 out_opcode (DW_LNS_set_epilogue_begin
);
2042 /* Don't try to optimize away redundant entries; gdb wants two
2043 entries for a function where the code starts on the same line as
2044 the {, and there's no way to identify that case here. Trust gcc
2045 to optimize appropriately. */
2046 line_delta
= e
->loc
.line
- line
;
2048 frag
= symbol_get_frag (lab
);
2049 frag_ofs
= S_GET_VALUE (lab
);
2051 if (last_frag
== NULL
2052 || (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
2053 /* If we're going to reset the view, but we know we're
2054 advancing the PC, we don't have to force with
2055 set_address. We know we do when we're at the same
2056 address of the same frag, and we know we might when
2057 we're in the beginning of a frag, and we were at the
2058 end of the previous frag. */
2059 && (frag
== last_frag
2060 ? (last_frag_ofs
== frag_ofs
)
2062 && ((offsetT
)last_frag_ofs
2063 >= get_frag_fix (last_frag
, seg
))))))
2066 out_inc_line_addr (line_delta
, 0);
2068 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2069 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2071 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2076 last_frag_ofs
= frag_ofs
;
2084 /* Emit a DW_LNE_end_sequence for the end of the section. */
2085 frag
= last_frag_for_seg (seg
);
2086 frag_ofs
= get_frag_fix (frag
, seg
);
2087 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2088 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2091 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2092 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2096 /* Switch to LINE_STR_SEG and output the given STR. Return the
2097 symbol pointing to the new string in the section. */
2100 add_line_strp (segT line_str_seg
, const char *str
)
2106 subseg_set (line_str_seg
, 0);
2108 sym
= symbol_temp_new_now_octets ();
2110 size
= strlen (str
) + 1;
2111 cp
= frag_more (size
);
2112 memcpy (cp
, str
, size
);
2118 /* Emit the directory and file tables for .debug_line. */
2121 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2127 bool emit_md5
= false;
2128 bool emit_timestamps
= true;
2129 bool emit_filesize
= true;
2130 segT line_str_seg
= NULL
;
2133 /* Output the Directory Table. */
2134 if (DWARF2_LINE_VERSION
>= 5)
2136 /* We only have one column in the directory table. */
2139 /* Describe the purpose and format of the column. */
2140 out_uleb128 (DW_LNCT_path
);
2141 /* Store these strings in the .debug_line_str section so they
2143 out_uleb128 (DW_FORM_line_strp
);
2145 /* Now state how many rows there are in the table. We need at
2146 least 1 if there is one or more file names to store the
2147 "working directory". */
2148 if (dirs_in_use
== 0 && files_in_use
> 0)
2151 out_uleb128 (dirs_in_use
);
2154 /* Emit directory list. */
2155 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2157 line_str_seg
= subseg_new (".debug_line_str", 0);
2158 bfd_set_section_flags (line_str_seg
,
2159 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2160 | SEC_MERGE
| SEC_STRINGS
);
2161 line_str_seg
->entsize
= 1;
2163 /* DWARF5 uses slot zero, but that is only set explicitly
2164 using a .file 0 directive. If that isn't used, but dir
2165 one is used, then use that as main file directory.
2166 Otherwise use pwd as main file directory. */
2167 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2168 dir
= remap_debug_filename (dirs
[0]);
2169 else if (dirs_in_use
> 1
2172 /* DWARF-5 directory tables expect dir[0] to be the same as
2173 DW_AT_comp_dir, which is the same as pwd. */
2175 dir
= remap_debug_filename (dirs
[1]);
2177 dir
= remap_debug_filename (getpwd ());
2179 line_strp
= add_line_strp (line_str_seg
, dir
);
2180 subseg_set (line_seg
, 0);
2181 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2183 for (i
= 1; i
< dirs_in_use
; ++i
)
2185 dir
= remap_debug_filename (dirs
[i
]);
2186 if (DWARF2_LINE_VERSION
< 5)
2188 size
= strlen (dir
) + 1;
2189 cp
= frag_more (size
);
2190 memcpy (cp
, dir
, size
);
2194 line_strp
= add_line_strp (line_str_seg
, dir
);
2195 subseg_set (line_seg
, 0);
2196 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2200 if (DWARF2_LINE_VERSION
< 5)
2204 /* Output the File Name Table. */
2205 if (DWARF2_LINE_VERSION
>= 5)
2207 unsigned int columns
= 4;
2209 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2211 emit_timestamps
= false;
2215 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2217 emit_filesize
= false;
2221 for (i
= 0; i
< files_in_use
; ++i
)
2222 if (files
[i
].md5
[0] != 0)
2224 if (i
< files_in_use
)
2230 /* The number of format entries to follow. */
2232 /* The format of the file name. */
2233 out_uleb128 (DW_LNCT_path
);
2234 /* Store these strings in the .debug_line_str section so they
2236 out_uleb128 (DW_FORM_line_strp
);
2238 /* The format of the directory index. */
2239 out_uleb128 (DW_LNCT_directory_index
);
2240 out_uleb128 (DW_FORM_udata
);
2242 if (emit_timestamps
)
2244 /* The format of the timestamp. */
2245 out_uleb128 (DW_LNCT_timestamp
);
2246 out_uleb128 (DW_FORM_udata
);
2251 /* The format of the file size. */
2252 out_uleb128 (DW_LNCT_size
);
2253 out_uleb128 (DW_FORM_udata
);
2258 /* The format of the MD5 sum. */
2259 out_uleb128 (DW_LNCT_MD5
);
2260 out_uleb128 (DW_FORM_data16
);
2263 /* The number of entries in the table. */
2264 out_uleb128 (files_in_use
);
2267 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2269 const char *fullfilename
;
2271 if (files
[i
].filename
== NULL
)
2273 /* Prevent a crash later, particularly for file 1. DWARF5
2274 uses slot zero, but that is only set explicitly using a
2275 .file 0 directive. If that isn't used, but file 1 is,
2276 then use that as main file name. */
2277 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1 && files
[0].filename
== NULL
)
2278 files
[0].filename
= files
[1].filename
;
2280 files
[i
].filename
= "";
2281 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2283 as_bad (_("unassigned file number %ld"), (long) i
);
2288 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2289 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2290 if (DWARF2_LINE_VERSION
< 5)
2292 size
= strlen (fullfilename
) + 1;
2293 cp
= frag_more (size
);
2294 memcpy (cp
, fullfilename
, size
);
2298 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2299 subseg_set (line_seg
, 0);
2300 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2303 /* Directory number. */
2304 out_uleb128 (files
[i
].dir
);
2306 /* Output the last modification timestamp. */
2307 if (emit_timestamps
)
2311 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2312 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2313 if (timestamp
== -1)
2315 out_uleb128 (timestamp
);
2318 /* Output the filesize. */
2322 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2323 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2326 out_uleb128 (filesize
);
2329 /* Output the md5 sum. */
2334 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2335 out_byte (files
[i
].md5
[b
]);
2339 if (DWARF2_LINE_VERSION
< 5)
2340 /* Terminate filename list. */
2344 /* Switch to SEC and output a header length field. Return the size of
2345 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2346 to the end of the section. EXPR->X_add_number will be set to the
2347 negative size of the header. */
2350 out_header (asection
*sec
, expressionS
*exp
)
2355 subseg_set (sec
, 0);
2357 if (flag_dwarf_sections
)
2359 /* If we are going to put the start and end symbols in different
2360 sections, then we need real symbols, not just fake, local ones. */
2362 start_sym
= symbol_make (".Ldebug_line_start");
2363 end_sym
= symbol_make (".Ldebug_line_end");
2364 symbol_set_value_now (start_sym
);
2368 start_sym
= symbol_temp_new_now_octets ();
2369 end_sym
= symbol_temp_make ();
2372 /* Total length of the information. */
2373 exp
->X_op
= O_subtract
;
2374 exp
->X_add_symbol
= end_sym
;
2375 exp
->X_op_symbol
= start_sym
;
2377 switch (DWARF2_FORMAT (sec
))
2379 case dwarf2_format_32bit
:
2380 exp
->X_add_number
= -4;
2384 case dwarf2_format_64bit
:
2385 exp
->X_add_number
= -12;
2390 case dwarf2_format_64bit_irix
:
2391 exp
->X_add_number
= -8;
2396 as_fatal (_("internal error: unknown dwarf2 format"));
2400 /* Emit the collected .debug_line data. */
2403 out_debug_line (segT line_seg
)
2406 symbolS
*prologue_start
, *prologue_end
;
2411 memset (&exp
, 0, sizeof exp
);
2412 sizeof_offset
= out_header (line_seg
, &exp
);
2413 line_end
= exp
.X_add_symbol
;
2416 out_two (DWARF2_LINE_VERSION
);
2418 if (DWARF2_LINE_VERSION
>= 5)
2420 out_byte (sizeof_address
);
2421 out_byte (0); /* Segment Selector size. */
2423 /* Length of the prologue following this length. */
2424 prologue_start
= symbol_temp_make ();
2425 prologue_end
= symbol_temp_make ();
2426 exp
.X_op
= O_subtract
;
2427 exp
.X_add_symbol
= prologue_end
;
2428 exp
.X_op_symbol
= prologue_start
;
2429 exp
.X_add_number
= 0;
2430 emit_expr (&exp
, sizeof_offset
);
2431 symbol_set_value_now (prologue_start
);
2433 /* Parameters of the state machine. */
2434 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2435 if (DWARF2_LINE_VERSION
>= 4)
2436 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2437 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2438 out_byte (DWARF2_LINE_BASE
);
2439 out_byte (DWARF2_LINE_RANGE
);
2440 out_byte (DWARF2_LINE_OPCODE_BASE
);
2442 /* Standard opcode lengths. */
2443 out_byte (0); /* DW_LNS_copy */
2444 out_byte (1); /* DW_LNS_advance_pc */
2445 out_byte (1); /* DW_LNS_advance_line */
2446 out_byte (1); /* DW_LNS_set_file */
2447 out_byte (1); /* DW_LNS_set_column */
2448 out_byte (0); /* DW_LNS_negate_stmt */
2449 out_byte (0); /* DW_LNS_set_basic_block */
2450 out_byte (0); /* DW_LNS_const_add_pc */
2451 out_byte (1); /* DW_LNS_fixed_advance_pc */
2452 out_byte (0); /* DW_LNS_set_prologue_end */
2453 out_byte (0); /* DW_LNS_set_epilogue_begin */
2454 out_byte (1); /* DW_LNS_set_isa */
2455 /* We have emitted 12 opcode lengths, so make that this
2456 matches up to the opcode base value we have been using. */
2457 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2459 out_dir_and_file_list (line_seg
, sizeof_offset
);
2461 symbol_set_value_now (prologue_end
);
2463 /* For each section, emit a statement program. */
2464 for (s
= all_segs
; s
; s
= s
->next
)
2465 /* Paranoia - this check should have already have
2466 been handled in dwarf2_gen_line_info_1(). */
2467 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2468 process_entries (s
->seg
, s
->head
->head
);
2470 if (flag_dwarf_sections
)
2471 /* We have to switch to the special .debug_line_end section
2472 before emitting the end-of-debug_line symbol. The linker
2473 script arranges for this section to be placed after all the
2474 (potentially garbage collected) .debug_line.<foo> sections.
2475 This section contains the line_end symbol which is used to
2476 compute the size of the linked .debug_line section, as seen
2477 in the DWARF Line Number header. */
2478 subseg_set (subseg_get (".debug_line_end", false), 0);
2480 symbol_set_value_now (line_end
);
2484 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2486 unsigned int addr_size
= sizeof_address
;
2491 memset (&exp
, 0, sizeof exp
);
2492 subseg_set (ranges_seg
, 0);
2494 /* For DW_AT_ranges to point at (there is no header, so really start
2495 of section, but see out_debug_rnglists). */
2496 *ranges_sym
= symbol_temp_new_now_octets ();
2498 /* Base Address Entry. */
2499 for (i
= 0; i
< addr_size
; i
++)
2501 for (i
= 0; i
< addr_size
; i
++)
2504 /* Range List Entry. */
2505 for (s
= all_segs
; s
; s
= s
->next
)
2510 frag
= first_frag_for_seg (s
->seg
);
2511 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2512 s
->text_start
= beg
;
2514 frag
= last_frag_for_seg (s
->seg
);
2515 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2518 exp
.X_op
= O_symbol
;
2519 exp
.X_add_symbol
= beg
;
2520 exp
.X_add_number
= 0;
2521 emit_expr (&exp
, addr_size
);
2523 exp
.X_op
= O_symbol
;
2524 exp
.X_add_symbol
= end
;
2525 exp
.X_add_number
= 0;
2526 emit_expr (&exp
, addr_size
);
2529 /* End of Range Entry. */
2530 for (i
= 0; i
< addr_size
; i
++)
2532 for (i
= 0; i
< addr_size
; i
++)
2537 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2540 symbolS
*ranges_end
;
2544 memset (&exp
, 0, sizeof exp
);
2545 out_header (ranges_seg
, &exp
);
2546 ranges_end
= exp
.X_add_symbol
;
2548 out_two (DWARF2_RNGLISTS_VERSION
);
2549 out_byte (sizeof_address
);
2550 out_byte (0); /* Segment Selector size. */
2551 out_four (0); /* Offset entry count. */
2553 /* For DW_AT_ranges to point at (must be after the header). */
2554 *ranges_sym
= symbol_temp_new_now_octets ();
2556 for (s
= all_segs
; s
; s
= s
->next
)
2561 out_byte (DW_RLE_start_length
);
2563 frag
= first_frag_for_seg (s
->seg
);
2564 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2565 s
->text_start
= beg
;
2567 frag
= last_frag_for_seg (s
->seg
);
2568 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2571 exp
.X_op
= O_symbol
;
2572 exp
.X_add_symbol
= beg
;
2573 exp
.X_add_number
= 0;
2574 emit_expr (&exp
, sizeof_address
);
2576 exp
.X_op
= O_symbol
;
2577 exp
.X_add_symbol
= end
;
2578 exp
.X_add_number
= 0;
2579 emit_leb128_expr (&exp
, 0);
2582 out_byte (DW_RLE_end_of_list
);
2584 symbol_set_value_now (ranges_end
);
2587 /* Emit data for .debug_aranges. */
2590 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2592 unsigned int addr_size
= sizeof_address
;
2596 symbolS
*aranges_end
;
2600 memset (&exp
, 0, sizeof exp
);
2601 sizeof_offset
= out_header (aranges_seg
, &exp
);
2602 aranges_end
= exp
.X_add_symbol
;
2603 size
= -exp
.X_add_number
;
2606 out_two (DWARF2_ARANGES_VERSION
);
2609 /* Offset to .debug_info. */
2610 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2611 size
+= sizeof_offset
;
2613 /* Size of an address (offset portion). */
2614 out_byte (addr_size
);
2617 /* Size of a segment descriptor. */
2621 /* Align the header. */
2622 while ((size
++ % (2 * addr_size
)) > 0)
2625 for (s
= all_segs
; s
; s
= s
->next
)
2630 frag
= first_frag_for_seg (s
->seg
);
2631 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2632 s
->text_start
= beg
;
2634 frag
= last_frag_for_seg (s
->seg
);
2635 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2638 exp
.X_op
= O_symbol
;
2639 exp
.X_add_symbol
= beg
;
2640 exp
.X_add_number
= 0;
2641 emit_expr (&exp
, addr_size
);
2643 exp
.X_op
= O_subtract
;
2644 exp
.X_add_symbol
= end
;
2645 exp
.X_op_symbol
= beg
;
2646 exp
.X_add_number
= 0;
2647 emit_expr (&exp
, addr_size
);
2650 p
= frag_more (2 * addr_size
);
2651 md_number_to_chars (p
, 0, addr_size
);
2652 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2654 symbol_set_value_now (aranges_end
);
2657 /* Emit data for .debug_abbrev. Note that this must be kept in
2658 sync with out_debug_info below. */
2661 out_debug_abbrev (segT abbrev_seg
,
2662 segT info_seg ATTRIBUTE_UNUSED
,
2663 segT line_seg ATTRIBUTE_UNUSED
)
2666 subseg_set (abbrev_seg
, 0);
2669 out_uleb128 (DW_TAG_compile_unit
);
2670 out_byte (DW_CHILDREN_no
);
2671 if (DWARF2_VERSION
< 4)
2673 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2674 secoff_form
= DW_FORM_data4
;
2676 secoff_form
= DW_FORM_data8
;
2679 secoff_form
= DW_FORM_sec_offset
;
2680 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2681 if (all_segs
->next
== NULL
)
2683 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2684 if (DWARF2_VERSION
< 4)
2685 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2687 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2690 out_abbrev (DW_AT_ranges
, secoff_form
);
2691 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2692 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2693 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2694 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2697 /* Terminate the abbreviations for this compilation unit. */
2701 /* Emit a description of this compilation unit for .debug_info. */
2704 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2705 symbolS
*ranges_sym
, symbolS
*name_sym
,
2706 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2712 memset (&exp
, 0, sizeof exp
);
2713 sizeof_offset
= out_header (info_seg
, &exp
);
2714 info_end
= exp
.X_add_symbol
;
2716 /* DWARF version. */
2717 out_two (DWARF2_VERSION
);
2719 if (DWARF2_VERSION
< 5)
2721 /* .debug_abbrev offset */
2722 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2726 /* unit (header) type */
2727 out_byte (DW_UT_compile
);
2730 /* Target address size. */
2731 out_byte (sizeof_address
);
2733 if (DWARF2_VERSION
>= 5)
2735 /* .debug_abbrev offset */
2736 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2739 /* DW_TAG_compile_unit DIE abbrev */
2742 /* DW_AT_stmt_list */
2743 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2744 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2747 /* These two attributes are emitted if all of the code is contiguous. */
2748 if (all_segs
->next
== NULL
)
2751 exp
.X_op
= O_symbol
;
2752 exp
.X_add_symbol
= all_segs
->text_start
;
2753 exp
.X_add_number
= 0;
2754 emit_expr (&exp
, sizeof_address
);
2757 if (DWARF2_VERSION
< 4)
2758 exp
.X_op
= O_symbol
;
2761 exp
.X_op
= O_subtract
;
2762 exp
.X_op_symbol
= all_segs
->text_start
;
2764 exp
.X_add_symbol
= all_segs
->text_end
;
2765 exp
.X_add_number
= 0;
2766 if (DWARF2_VERSION
< 4)
2767 emit_expr (&exp
, sizeof_address
);
2769 emit_leb128_expr (&exp
, 0);
2773 /* This attribute is emitted if the code is disjoint. */
2775 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2778 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2779 setup in out_debug_str below. */
2780 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2781 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2782 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2784 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2785 dwarf2 draft has no standard code for assembler. */
2786 out_two (DW_LANG_Mips_Assembler
);
2788 symbol_set_value_now (info_end
);
2791 /* Emit the three debug strings needed in .debug_str and setup symbols
2792 to them for use in out_debug_info. */
2794 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2795 symbolS
**producer_sym
)
2798 const char *comp_dir
;
2799 const char *dirname
;
2802 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2804 subseg_set (str_seg
, 0);
2806 /* DW_AT_name. We don't have the actual file name that was present
2807 on the command line, so assume files[first_file] is the main input file.
2808 We're not supposed to get called unless at least one line number
2809 entry was emitted, so this should always be defined. */
2810 *name_sym
= symbol_temp_new_now_octets ();
2811 if (files_in_use
== 0)
2813 if (files
[first_file
].dir
)
2815 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2816 len
= strlen (dirname
);
2818 /* Already has trailing slash. */
2819 p
= frag_more (len
);
2820 memcpy (p
, dirname
, len
);
2822 p
= frag_more (len
+ 1);
2823 memcpy (p
, dirname
, len
);
2824 INSERT_DIR_SEPARATOR (p
, len
);
2827 len
= strlen (files
[first_file
].filename
) + 1;
2828 p
= frag_more (len
);
2829 memcpy (p
, files
[first_file
].filename
, len
);
2831 /* DW_AT_comp_dir */
2832 *comp_dir_sym
= symbol_temp_new_now_octets ();
2833 comp_dir
= remap_debug_filename (getpwd ());
2834 len
= strlen (comp_dir
) + 1;
2835 p
= frag_more (len
);
2836 memcpy (p
, comp_dir
, len
);
2838 /* DW_AT_producer */
2839 *producer_sym
= symbol_temp_new_now_octets ();
2840 sprintf (producer
, "GNU AS %s", VERSION
);
2841 len
= strlen (producer
) + 1;
2842 p
= frag_more (len
);
2843 memcpy (p
, producer
, len
);
2849 last_seg_ptr
= &all_segs
;
2851 /* Select the default CIE version to produce here. The global
2852 starts with a value of -1 and will be modified to a valid value
2853 either by the user providing a command line option, or some
2854 targets will select their own default in md_after_parse_args. If
2855 we get here and the global still contains -1 then it is up to us
2856 to pick a sane default. The default we choose is 1, this is the
2857 CIE version gas has produced for a long time, and there seems no
2858 reason to change it yet. */
2859 if (flag_dwarf_cie_version
== -1)
2860 flag_dwarf_cie_version
= 1;
2863 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2864 were any .file/.loc directives, or --gdwarf2 was given, and if the
2865 file has a non-empty .debug_info section and an empty .debug_line
2866 section. If we emit .debug_line, and the .debug_info section is
2867 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2868 ALL_SEGS will be non-null if there were any .file/.loc directives,
2869 or --gdwarf2 was given and there were any located instructions
2873 dwarf2_finish (void)
2878 int emit_other_sections
= 0;
2879 int empty_debug_line
= 0;
2881 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2882 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2884 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2885 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2887 /* We can't construct a new debug_line section if we already have one.
2888 Give an error if we have seen any .loc, otherwise trust the user
2889 knows what they are doing and want to generate the .debug_line
2890 (and all other debug sections) themselves. */
2891 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2892 as_fatal ("duplicate .debug_line sections");
2894 if ((!all_segs
&& emit_other_sections
)
2895 || (!emit_other_sections
&& !empty_debug_line
))
2896 /* If there is no line information and no non-empty .debug_info
2897 section, or if there is both a non-empty .debug_info and a non-empty
2898 .debug_line, then we do nothing. */
2901 /* Calculate the size of an address for the target machine. */
2902 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2904 /* Create and switch to the line number section. */
2905 if (empty_debug_line
)
2907 line_seg
= subseg_new (".debug_line", 0);
2908 bfd_set_section_flags (line_seg
,
2909 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2912 for (s
= all_segs
; s
; s
= s
->next
)
2914 struct line_subseg
*lss
;
2916 for (lss
= s
->head
; lss
; lss
= lss
->next
)
2918 do_allocate_filenum (lss
->head
);
2921 /* For each subsection, chain the debug entries together. */
2922 for (s
= all_segs
; s
; s
= s
->next
)
2924 struct line_subseg
*lss
= s
->head
;
2925 struct line_entry
**ptail
= lss
->ptail
;
2927 /* Reset the initial view of the first subsection of the
2929 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2930 set_or_check_view (lss
->head
, NULL
, NULL
);
2932 while ((lss
= lss
->next
) != NULL
)
2934 /* Link the first view of subsequent subsections to the
2936 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2937 set_or_check_view (lss
->head
,
2938 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2939 s
->head
? s
->head
->head
: NULL
);
2945 if (empty_debug_line
)
2946 out_debug_line (line_seg
);
2948 /* If this is assembler generated line info, and there is no
2949 debug_info already, we need .debug_info, .debug_abbrev and
2950 .debug_str sections as well. */
2951 if (emit_other_sections
)
2956 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2958 gas_assert (all_segs
);
2960 info_seg
= subseg_new (".debug_info", 0);
2961 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2962 aranges_seg
= subseg_new (".debug_aranges", 0);
2963 str_seg
= subseg_new (".debug_str", 0);
2965 bfd_set_section_flags (info_seg
,
2966 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2967 bfd_set_section_flags (abbrev_seg
,
2968 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2969 bfd_set_section_flags (aranges_seg
,
2970 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2971 bfd_set_section_flags (str_seg
,
2972 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2973 | SEC_MERGE
| SEC_STRINGS
);
2974 str_seg
->entsize
= 1;
2976 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2978 if (all_segs
->next
== NULL
)
2982 if (DWARF2_VERSION
< 5)
2984 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2985 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2988 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2989 out_debug_ranges (ranges_seg
, &ranges_sym
);
2993 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2994 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2997 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
3001 out_debug_aranges (aranges_seg
, info_seg
);
3002 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
3003 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
3004 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
3005 name_sym
, comp_dir_sym
, producer_sym
);
3009 /* Perform any deferred checks pertaining to debug information. */
3012 dwarf2dbg_final_check (void)
3014 /* Perform reset-view checks. Don't evaluate view_assert_failed
3015 recursively: it could be very deep. It's a chain of adds, with
3016 each chain element pointing to the next in X_add_symbol, and
3017 holding the check value in X_op_symbol. */
3018 while (view_assert_failed
)
3024 gas_assert (!symbol_resolved_p (view_assert_failed
));
3026 exp
= symbol_get_value_expression (view_assert_failed
);
3027 sym
= view_assert_failed
;
3029 /* If view_assert_failed looks like a compound check in the
3030 chain, break it up. */
3031 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3033 view_assert_failed
= exp
->X_add_symbol
;
3034 sym
= exp
->X_op_symbol
;
3037 view_assert_failed
= NULL
;
3039 failed
= resolve_symbol_value (sym
);
3040 if (!symbol_resolved_p (sym
) || failed
)
3042 as_bad (_("view number mismatch"));