1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2023 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
163 #define GAS_ABBREV_COMP_UNIT 1
164 #define GAS_ABBREV_SUBPROG 2
165 #define GAS_ABBREV_NO_TYPE 3
169 struct line_entry
*next
;
171 struct dwarf2_line_info loc
;
174 /* Don't change the offset of next in line_entry. set_or_check_view
175 calls in dwarf2_gen_line_info_1 depend on it. */
176 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
181 struct line_subseg
*next
;
183 struct line_entry
*head
;
184 struct line_entry
**ptail
;
185 struct line_entry
**pmove_tail
;
190 struct line_seg
*next
;
192 struct line_subseg
*head
;
197 /* Collects data for all line table entries during assembly. */
198 static struct line_seg
*all_segs
;
199 static struct line_seg
**last_seg_ptr
;
201 #define NUM_MD5_BYTES 16
205 const char * filename
;
207 unsigned char md5
[NUM_MD5_BYTES
];
210 /* Table of files used by .debug_line. */
211 static struct file_entry
*files
;
212 static unsigned int files_in_use
;
213 static unsigned int files_allocated
;
215 /* Table of directories used by .debug_line. */
217 static unsigned int dirs_in_use
;
218 static unsigned int dirs_allocated
;
220 /* TRUE when we've seen a .loc directive recently. Used to avoid
221 doing work when there's nothing to do. Will be reset by
222 dwarf2_consume_line_info. */
223 bool dwarf2_loc_directive_seen
;
225 /* TRUE when we've seen any .loc directive at any time during parsing.
226 Indicates the user wants us to generate a .debug_line section.
227 Used in dwarf2_finish as sanity check. */
228 static bool dwarf2_any_loc_directive_seen
;
230 /* TRUE when we're supposed to set the basic block mark whenever a
232 bool dwarf2_loc_mark_labels
;
234 /* Current location as indicated by the most recent .loc directive. */
235 static struct dwarf2_line_info current
;
237 /* This symbol is used to recognize view number forced resets in loc
239 static symbolS
*force_reset_view
;
241 /* This symbol evaluates to an expression that, if nonzero, indicates
242 some view assert check failed. */
243 static symbolS
*view_assert_failed
;
245 /* The size of an address on the target. */
246 static unsigned int sizeof_address
;
248 #ifndef TC_DWARF2_EMIT_OFFSET
249 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
251 /* Create an offset to .dwarf2_*. */
254 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
258 memset (&exp
, 0, sizeof exp
);
260 exp
.X_add_symbol
= symbol
;
261 exp
.X_add_number
= 0;
262 emit_expr (&exp
, size
);
266 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
268 static struct line_subseg
*
269 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
271 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
272 struct line_subseg
**pss
, *lss
;
279 s
= XNEW (struct line_seg
);
284 last_seg_ptr
= &s
->next
;
285 seg_info (seg
)->dwarf2_line_seg
= s
;
288 gas_assert (seg
== s
->seg
);
290 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
292 if (lss
->subseg
== subseg
)
294 if (lss
->subseg
> subseg
)
298 lss
= XNEW (struct line_subseg
);
300 lss
->subseg
= subseg
;
302 lss
->ptail
= &lss
->head
;
303 lss
->pmove_tail
= &lss
->head
;
310 /* (Un)reverse the line_entry list starting from H. */
312 static struct line_entry
*
313 reverse_line_entry_list (struct line_entry
*h
)
315 struct line_entry
*p
= NULL
, *e
, *n
;
317 for (e
= h
; e
; e
= n
)
326 /* Compute the view for E based on the previous entry P. If we
327 introduce an (undefined) view symbol for P, and H is given (P must
328 be the tail in this case), introduce view symbols for earlier list
329 entries as well, until one of them is constant. */
332 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
333 struct line_entry
*h
)
337 memset (&viewx
, 0, sizeof (viewx
));
338 viewx
.X_unsigned
= 1;
340 /* First, compute !(E->label > P->label), to tell whether or not
341 we're to reset the view number. If we can't resolve it to a
342 constant, keep it symbolic. */
343 if (!p
|| (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
))
345 viewx
.X_op
= O_constant
;
346 viewx
.X_add_number
= 0;
347 viewx
.X_add_symbol
= NULL
;
348 viewx
.X_op_symbol
= NULL
;
353 viewx
.X_add_number
= 0;
354 viewx
.X_add_symbol
= e
->label
;
355 viewx
.X_op_symbol
= p
->label
;
356 resolve_expression (&viewx
);
357 if (viewx
.X_op
== O_constant
)
358 viewx
.X_add_number
= !viewx
.X_add_number
;
361 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
362 viewx
.X_add_number
= 0;
363 viewx
.X_op_symbol
= NULL
;
364 viewx
.X_op
= O_logical_not
;
368 if (S_IS_DEFINED (e
->loc
.u
.view
) && symbol_constant_p (e
->loc
.u
.view
))
370 expressionS
*value
= symbol_get_value_expression (e
->loc
.u
.view
);
371 /* We can't compare the view numbers at this point, because in
372 VIEWX we've only determined whether we're to reset it so
374 if (viewx
.X_op
== O_constant
)
376 if (!value
->X_add_number
!= !viewx
.X_add_number
)
377 as_bad (_("view number mismatch"));
379 /* Record the expression to check it later. It is the result of
380 a logical not, thus 0 or 1. We just add up all such deferred
381 expressions, and resolve it at the end. */
382 else if (!value
->X_add_number
)
384 symbolS
*deferred
= make_expr_symbol (&viewx
);
385 if (view_assert_failed
)
389 memset (&chk
, 0, sizeof (chk
));
392 chk
.X_add_number
= 0;
393 chk
.X_add_symbol
= view_assert_failed
;
394 chk
.X_op_symbol
= deferred
;
395 deferred
= make_expr_symbol (&chk
);
397 view_assert_failed
= deferred
;
401 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
407 p
->loc
.u
.view
= symbol_temp_make ();
409 memset (&incv
, 0, sizeof (incv
));
411 incv
.X_op
= O_symbol
;
412 incv
.X_add_symbol
= p
->loc
.u
.view
;
413 incv
.X_add_number
= 1;
414 p_view
= symbol_get_value_expression (p
->loc
.u
.view
);
415 if (p_view
->X_op
== O_constant
|| p_view
->X_op
== O_symbol
)
417 /* If we can, constant fold increments so that a chain of
418 expressions v + 1 + 1 ... + 1 is not created.
419 resolve_expression isn't ideal for this purpose. The
420 base v might not be resolvable until later. */
421 incv
.X_op
= p_view
->X_op
;
422 incv
.X_add_symbol
= p_view
->X_add_symbol
;
423 incv
.X_add_number
= p_view
->X_add_number
+ 1;
426 if (viewx
.X_op
== O_constant
)
428 gas_assert (viewx
.X_add_number
== 1);
433 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
434 viewx
.X_add_number
= 0;
435 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
436 viewx
.X_op
= O_multiply
;
440 if (!S_IS_DEFINED (e
->loc
.u
.view
))
442 symbol_set_value_expression (e
->loc
.u
.view
, &viewx
);
443 S_SET_SEGMENT (e
->loc
.u
.view
, expr_section
);
444 symbol_set_frag (e
->loc
.u
.view
, &zero_address_frag
);
447 /* Define and attempt to simplify any earlier views needed to
449 if (h
&& p
&& p
->loc
.u
.view
&& !S_IS_DEFINED (p
->loc
.u
.view
))
451 struct line_entry
*h2
;
452 /* Reverse the list to avoid quadratic behavior going backwards
453 in a single-linked list. */
454 struct line_entry
*r
= reverse_line_entry_list (h
);
457 /* Set or check views until we find a defined or absent view. */
460 /* Do not define the head of a (sub?)segment view while
461 handling others. It would be defined too early, without
462 regard to the last view of other subsegments.
463 set_or_check_view will be called for every head segment
467 set_or_check_view (r
, r
->next
, NULL
);
470 && r
->next
->loc
.u
.view
471 && !S_IS_DEFINED (r
->next
->loc
.u
.view
)
474 /* Unreverse the list, so that we can go forward again. */
475 h2
= reverse_line_entry_list (p
);
476 gas_assert (h2
== h
);
478 /* Starting from the last view we just defined, attempt to
479 simplify the view expressions, until we do so to P. */
482 /* The head view of a subsegment may remain undefined while
483 handling other elements, before it is linked to the last
484 view of the previous subsegment. */
487 gas_assert (S_IS_DEFINED (r
->loc
.u
.view
));
488 resolve_expression (symbol_get_value_expression (r
->loc
.u
.view
));
490 while (r
!= p
&& (r
= r
->next
));
492 /* Now that we've defined and computed all earlier views that might
493 be needed to compute E's, attempt to simplify it. */
494 resolve_expression (symbol_get_value_expression (e
->loc
.u
.view
));
498 /* Record an entry for LOC occurring at LABEL. */
501 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
503 struct line_subseg
*lss
;
504 struct line_entry
*e
;
505 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
507 /* PR 26850: Do not record LOCs in non-executable or non-loaded
508 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
509 obj_coff_section is careless in setting SEC_ALLOC. */
511 need_flags
|= SEC_ALLOC
;
512 if ((now_seg
->flags
& need_flags
) != need_flags
)
514 /* FIXME: Add code to suppress multiple warnings ? */
515 if (debug_type
!= DEBUG_DWARF2
)
516 as_warn ("dwarf line number information for %s ignored",
517 segment_name (now_seg
));
521 e
= XNEW (struct line_entry
);
526 lss
= get_line_subseg (now_seg
, now_subseg
, true);
528 /* Subseg heads are chained to previous subsegs in
530 if (loc
->filenum
!= -1u && loc
->u
.view
&& lss
->head
)
531 set_or_check_view (e
, (struct line_entry
*) lss
->ptail
, lss
->head
);
534 lss
->ptail
= &e
->next
;
537 /* Record an entry for LOC occurring at OFS within the current fragment. */
540 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
544 /* Early out for as-yet incomplete location information. */
547 if (loc
->filenum
== 0)
551 if (DWARF2_LINE_VERSION
< 5)
555 /* Don't emit sequences of line symbols for the same line when the
556 symbols apply to assembler code. It is necessary to emit
557 duplicate line symbols when a compiler asks for them, because GDB
558 uses them to determine the end of the prologue. */
559 if (debug_type
== DEBUG_DWARF2
)
561 static unsigned int line
= -1;
562 static const char *filename
= NULL
;
564 if (line
== loc
->line
)
566 if (filename
== loc
->u
.filename
)
568 if (filename_cmp (filename
, loc
->u
.filename
) == 0)
570 filename
= loc
->u
.filename
;
576 filename
= loc
->u
.filename
;
581 static int label_num
= 0;
584 /* Use a non-fake name for the line number location,
585 so that it can be referred to by relocations. */
586 sprintf (name
, ".Loc.%u", label_num
);
588 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
591 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
592 dwarf2_gen_line_info_1 (sym
, loc
);
596 get_basename (const char * pathname
)
600 file
= lbasename (pathname
);
601 /* Don't make empty string from / or A: from A:/ . */
602 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
603 if (file
<= pathname
+ 3)
606 if (file
== pathname
+ 1)
613 get_directory_table_entry (const char *dirname
,
614 const char *file0_dirname
,
623 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
624 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
632 for (d
= 0; d
< dirs_in_use
; ++d
)
635 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
636 && dirs
[d
][dirlen
] == '\0')
642 if (dirs
== NULL
|| dirs
[0] == NULL
)
644 const char * pwd
= file0_dirname
? file0_dirname
: getpwd ();
646 if (dwarf_level
>= 5 && filename_cmp (dirname
, pwd
) != 0)
648 /* In DWARF-5 the 0 entry in the directory table is
649 expected to be the same as the DW_AT_comp_dir (which
650 is set to the current build directory). Since we are
651 about to create a directory entry that is not the
652 same, allocate the current directory first. */
653 (void) get_directory_table_entry (pwd
, file0_dirname
,
664 if (d
>= dirs_allocated
)
666 unsigned int old
= dirs_allocated
;
667 #define DIR_TABLE_INCREMENT 32
668 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
669 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
670 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
673 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
674 if (dirs_in_use
<= d
)
681 assign_file_to_slot (unsigned int i
, const char *file
, unsigned int dir
)
683 if (i
>= files_allocated
)
685 unsigned int want
= i
+ 32;
687 /* Catch wraparound. */
688 if (want
< files_allocated
690 || want
> UINT_MAX
/ sizeof (struct file_entry
))
692 as_bad (_("file number %u is too big"), i
);
696 files
= XRESIZEVEC (struct file_entry
, files
, want
);
697 memset (files
+ files_allocated
, 0,
698 (want
- files_allocated
) * sizeof (struct file_entry
));
699 files_allocated
= want
;
702 files
[i
].filename
= file
;
704 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
706 if (files_in_use
< i
+ 1)
707 files_in_use
= i
+ 1;
712 /* Get a .debug_line file number for PATHNAME. If there is a
713 directory component to PATHNAME, then this will be stored
714 in the directory table, if it is not already present.
715 Returns the slot number allocated to that filename or -1
716 if there was a problem. */
719 allocate_filenum (const char * pathname
)
721 static signed int last_used
= -1, last_used_dir_len
= 0;
726 /* Short circuit the common case of adding the same pathname
730 const char * dirname
= NULL
;
733 dirname
= dirs
[files
[last_used
].dir
];
737 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
742 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
- 1) == 0
743 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
- 1])
744 && filename_cmp (pathname
+ last_used_dir_len
,
745 files
[last_used
].filename
) == 0)
750 file
= get_basename (pathname
);
751 dir_len
= file
- pathname
;
753 dir
= get_directory_table_entry (pathname
, NULL
, dir_len
, false);
755 /* Do not use slot-0. That is specifically reserved for use by
756 the '.file 0 "name"' directive. */
757 for (i
= 1; i
< files_in_use
; ++i
)
758 if (files
[i
].dir
== dir
760 && filename_cmp (file
, files
[i
].filename
) == 0)
763 last_used_dir_len
= dir_len
;
767 if (!assign_file_to_slot (i
, file
, dir
))
771 last_used_dir_len
= dir_len
;
776 /* Run through the list of line entries starting at E, allocating
777 file entries for gas generated debug. */
780 do_allocate_filenum (struct line_entry
*e
)
784 if (e
->loc
.filenum
== -1u)
786 e
->loc
.filenum
= allocate_filenum (e
->loc
.u
.filename
);
787 e
->loc
.u
.view
= NULL
;
794 /* Remove any generated line entries. These don't live comfortably
795 with compiler generated line info. If THELOT then remove
796 everything, freeing all list entries we have created. */
799 purge_generated_debug (bool thelot
)
801 struct line_seg
*s
, *nexts
;
803 for (s
= all_segs
; s
; s
= nexts
)
805 struct line_subseg
*lss
, *nextlss
;
807 for (lss
= s
->head
; lss
; lss
= nextlss
)
809 struct line_entry
*e
, *next
;
811 for (e
= lss
->head
; e
; e
= next
)
814 know (e
->loc
.filenum
== -1u);
820 lss
->ptail
= &lss
->head
;
821 lss
->pmove_tail
= &lss
->head
;
829 seg_info (s
->seg
)->dwarf2_line_seg
= NULL
;
835 /* Allocate slot NUM in the .debug_line file table to FILENAME.
836 If DIRNAME is not NULL or there is a directory component to FILENAME
837 then this will be stored in the directory table, if not already present.
838 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
839 Returns TRUE if allocation succeeded, FALSE otherwise. */
842 allocate_filename_to_slot (const char *dirname
,
843 const char *filename
,
850 const char *file0_dirname
;
852 /* Short circuit the common case of adding the same pathname
854 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
856 const char * dir
= NULL
;
859 dir
= dirs
[files
[num
].dir
];
862 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
867 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
870 if (filename_cmp (filename
, files
[num
].filename
) != 0)
873 /* If the filenames match, but the directory table entry was
874 empty, then fill it with the provided directory name. */
879 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
880 dirs
= XCNEWVEC (char *, dirs_allocated
);
883 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
888 else if (dir
!= NULL
)
890 dirlen
= strlen (dir
);
891 if (filename_ncmp (filename
, dir
, dirlen
) == 0
892 && IS_DIR_SEPARATOR (filename
[dirlen
])
893 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
896 else /* dir == NULL */
898 file
= get_basename (filename
);
899 if (filename_cmp (file
, files
[num
].filename
) == 0)
901 /* The filenames match, but the directory table entry is empty.
902 Fill it with the provided directory name. */
907 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
908 dirs
= XCNEWVEC (char *, dirs_allocated
);
911 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
918 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
920 dir
== NULL
? "" : dir
,
921 dir
== NULL
? "" : "/",
923 dirname
== NULL
? "" : dirname
,
924 dirname
== NULL
? "" : "/",
929 /* For file .0, the directory name is the current directory and the file
930 may be in another directory contained in the file name. */
933 file0_dirname
= dirname
;
935 file
= get_basename (filename
);
937 if (dirname
&& file
== filename
)
938 dirlen
= strlen (dirname
);
942 dirlen
= file
- filename
;
947 file0_dirname
= NULL
;
952 file
= get_basename (filename
);
953 dirlen
= file
- filename
;
957 dirlen
= strlen (dirname
);
962 d
= get_directory_table_entry (dirname
, file0_dirname
, dirlen
, num
== 0);
965 if (! assign_file_to_slot (i
, file
, d
))
970 if (target_big_endian
)
972 /* md5's are stored in litte endian format. */
973 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
974 unsigned int byte
= NUM_MD5_BYTES
;
975 unsigned int bignum_index
= 0;
977 while (bits_remaining
)
979 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
980 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 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
995 unsigned int byte
= 0;
996 unsigned int bignum_index
= 0;
998 while (bits_remaining
)
1000 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
1001 valueT bignum_value
= generic_bignum
[bignum_index
];
1005 while (bignum_bits_remaining
)
1007 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
1009 bignum_bits_remaining
-= 8;
1010 bits_remaining
-= 8;
1016 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
1021 /* Returns the current source information. If .file directives have
1022 been encountered, the info for the corresponding source file is
1023 returned. Otherwise, the info for the assembly source file is
1027 dwarf2_where (struct dwarf2_line_info
*line
)
1029 if (debug_type
== DEBUG_DWARF2
)
1031 line
->u
.filename
= as_where (&line
->line
);
1032 line
->filenum
= -1u;
1034 line
->flags
= DWARF2_FLAG_IS_STMT
;
1035 line
->isa
= current
.isa
;
1036 line
->discriminator
= current
.discriminator
;
1042 /* A hook to allow the target backend to inform the line number state
1043 machine of isa changes when assembler debug info is enabled. */
1046 dwarf2_set_isa (unsigned int isa
)
1051 /* Called for each machine instruction, or relatively atomic group of
1052 machine instructions (ie built-in macro). The instruction or group
1053 is SIZE bytes in length. If dwarf2 line number generation is called
1054 for, emit a line statement appropriately. */
1057 dwarf2_emit_insn (int size
)
1059 struct dwarf2_line_info loc
;
1061 if (debug_type
!= DEBUG_DWARF2
1062 ? !dwarf2_loc_directive_seen
1063 : !seen_at_least_1_file ())
1066 dwarf2_where (&loc
);
1068 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
1069 dwarf2_consume_line_info ();
1072 /* Move all previously-emitted line entries for the current position by
1073 DELTA bytes. This function cannot be used to move the same entries
1077 dwarf2_move_insn (int delta
)
1079 struct line_subseg
*lss
;
1080 struct line_entry
*e
;
1086 lss
= get_line_subseg (now_seg
, now_subseg
, false);
1090 now
= frag_now_fix ();
1091 while ((e
= *lss
->pmove_tail
))
1093 if (S_GET_VALUE (e
->label
) == now
)
1094 S_SET_VALUE (e
->label
, now
+ delta
);
1095 lss
->pmove_tail
= &e
->next
;
1099 /* Called after the current line information has been either used with
1100 dwarf2_gen_line_info or saved with a machine instruction for later use.
1101 This resets the state of the line number information to reflect that
1102 it has been used. */
1105 dwarf2_consume_line_info (void)
1107 /* Unless we generate DWARF2 debugging information for each
1108 assembler line, we only emit one line symbol for one LOC. */
1109 dwarf2_loc_directive_seen
= false;
1111 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1112 | DWARF2_FLAG_PROLOGUE_END
1113 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1114 current
.discriminator
= 0;
1115 current
.u
.view
= NULL
;
1118 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1119 is enabled, emit a basic block marker. */
1122 dwarf2_emit_label (symbolS
*label
)
1124 struct dwarf2_line_info loc
;
1126 if (!dwarf2_loc_mark_labels
)
1128 if (S_GET_SEGMENT (label
) != now_seg
)
1130 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1132 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1135 dwarf2_where (&loc
);
1137 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1139 dwarf2_gen_line_info_1 (label
, &loc
);
1140 dwarf2_consume_line_info ();
1143 /* Handle two forms of .file directive:
1144 - Pass .file "source.c" to s_file
1145 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1147 If an entry is added to the file table, return a pointer to the filename. */
1150 dwarf2_directive_filename (void)
1152 bool with_md5
= false;
1155 const char * dirname
= NULL
;
1158 /* Continue to accept a bare string and pass it off. */
1160 if (*input_line_pointer
== '"')
1166 num
= get_absolute_expression ();
1168 if ((offsetT
) num
< 1)
1170 if (num
== 0 && dwarf_level
< 5)
1172 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1174 as_bad (_("file number less than one"));
1175 ignore_rest_of_line ();
1180 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1181 "switch back to the already allocated file <N> as the current
1184 filename
= demand_copy_C_string (&filename_len
);
1185 if (filename
== NULL
)
1186 /* demand_copy_C_string will have already generated an error message. */
1189 /* For DWARF-5 support we also accept:
1190 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1191 if (DWARF2_LINE_VERSION
> 4)
1194 if (*input_line_pointer
== '"')
1197 filename
= demand_copy_C_string (&filename_len
);
1198 if (filename
== NULL
)
1203 if (startswith (input_line_pointer
, "md5"))
1205 input_line_pointer
+= 3;
1209 expression_and_evaluate (& exp
);
1210 if (exp
.X_op
!= O_big
)
1211 as_bad (_("md5 value too small or not a constant"));
1217 demand_empty_rest_of_line ();
1219 /* A .file directive implies compiler generated debug information is
1220 being supplied. Turn off gas generated debug info. */
1221 if (debug_type
== DEBUG_DWARF2
)
1222 purge_generated_debug (false);
1223 debug_type
= DEBUG_NONE
;
1225 if (num
!= (unsigned int) num
1226 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1228 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1232 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1239 /* Calls dwarf2_directive_filename, but discards its result.
1240 Used in pseudo-op tables where the function result is ignored. */
1243 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1245 (void) dwarf2_directive_filename ();
1249 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1251 offsetT filenum
, line
;
1253 /* If we see two .loc directives in a row, force the first one to be
1255 if (dwarf2_loc_directive_seen
)
1256 dwarf2_emit_insn (0);
1258 filenum
= get_absolute_expression ();
1260 line
= get_absolute_expression ();
1264 if (filenum
== 0 && dwarf_level
< 5)
1266 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1268 as_bad (_("file number less than one"));
1273 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1275 as_bad (_("unassigned file number %ld"), (long) filenum
);
1279 /* debug_type will be turned off by dwarf2_directive_filename, and
1280 if we don't have a dwarf style .file then files_in_use will be
1281 zero and the above error will trigger. */
1282 gas_assert (debug_type
== DEBUG_NONE
);
1284 current
.filenum
= filenum
;
1285 current
.line
= line
;
1286 current
.discriminator
= 0;
1291 if (files
[filenum
].dir
)
1293 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1294 size_t file_len
= strlen (files
[filenum
].filename
);
1295 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1297 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1298 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1299 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1300 cp
[dir_len
+ file_len
+ 1] = '\0';
1301 listing_source_file (cp
);
1305 listing_source_file (files
[filenum
].filename
);
1306 listing_source_line (line
);
1311 if (ISDIGIT (*input_line_pointer
))
1313 current
.column
= get_absolute_expression ();
1317 while (ISALPHA (*input_line_pointer
))
1322 c
= get_symbol_name (& p
);
1324 if (strcmp (p
, "basic_block") == 0)
1326 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1327 *input_line_pointer
= c
;
1329 else if (strcmp (p
, "prologue_end") == 0)
1331 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1332 *input_line_pointer
= c
;
1334 else if (strcmp (p
, "epilogue_begin") == 0)
1336 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1337 *input_line_pointer
= c
;
1339 else if (strcmp (p
, "is_stmt") == 0)
1341 (void) restore_line_pointer (c
);
1342 value
= get_absolute_expression ();
1344 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1345 else if (value
== 1)
1346 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1349 as_bad (_("is_stmt value not 0 or 1"));
1353 else if (strcmp (p
, "isa") == 0)
1355 (void) restore_line_pointer (c
);
1356 value
= get_absolute_expression ();
1358 current
.isa
= value
;
1361 as_bad (_("isa number less than zero"));
1365 else if (strcmp (p
, "discriminator") == 0)
1367 (void) restore_line_pointer (c
);
1368 value
= get_absolute_expression ();
1370 current
.discriminator
= value
;
1373 as_bad (_("discriminator less than zero"));
1377 else if (strcmp (p
, "view") == 0)
1381 (void) restore_line_pointer (c
);
1384 if (ISDIGIT (*input_line_pointer
)
1385 || *input_line_pointer
== '-')
1387 bool force_reset
= *input_line_pointer
== '-';
1389 value
= get_absolute_expression ();
1392 as_bad (_("numeric view can only be asserted to zero"));
1395 if (force_reset
&& force_reset_view
)
1396 sym
= force_reset_view
;
1399 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1402 force_reset_view
= sym
;
1407 char *name
= read_symbol_name ();
1411 sym
= symbol_find_or_make (name
);
1413 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1415 if (S_IS_VOLATILE (sym
))
1416 sym
= symbol_clone (sym
, 1);
1417 else if (!S_CAN_BE_REDEFINED (sym
))
1419 as_bad (_("symbol `%s' is already defined"),
1424 S_SET_SEGMENT (sym
, undefined_section
);
1425 S_SET_VALUE (sym
, 0);
1426 symbol_set_frag (sym
, &zero_address_frag
);
1428 current
.u
.view
= sym
;
1432 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1433 (void) restore_line_pointer (c
);
1437 SKIP_WHITESPACE_AFTER_NAME ();
1440 demand_empty_rest_of_line ();
1441 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1443 /* If we were given a view id, emit the row right away. */
1445 dwarf2_emit_insn (0);
1449 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1451 offsetT value
= get_absolute_expression ();
1453 if (value
!= 0 && value
!= 1)
1455 as_bad (_("expected 0 or 1"));
1456 ignore_rest_of_line ();
1460 dwarf2_loc_mark_labels
= value
!= 0;
1461 demand_empty_rest_of_line ();
1465 static struct frag
*
1466 first_frag_for_seg (segT seg
)
1468 return seg_info (seg
)->frchainP
->frch_root
;
1471 static struct frag
*
1472 last_frag_for_seg (segT seg
)
1474 frchainS
*f
= seg_info (seg
)->frchainP
;
1476 while (f
->frch_next
!= NULL
)
1479 return f
->frch_last
;
1482 /* Emit a single byte into the current segment. */
1487 FRAG_APPEND_1_CHAR (byte
);
1490 /* Emit a statement program opcode into the current segment. */
1493 out_opcode (int opc
)
1498 /* Emit a two-byte word into the current segment. */
1503 md_number_to_chars (frag_more (2), data
, 2);
1506 /* Emit a four byte word into the current segment. */
1511 md_number_to_chars (frag_more (4), data
, 4);
1514 /* Emit an unsigned "little-endian base 128" number. */
1517 out_uleb128 (addressT value
)
1519 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1522 /* Emit a signed "little-endian base 128" number. */
1525 out_leb128 (addressT value
)
1527 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1530 /* Emit a tuple for .debug_abbrev. */
1533 out_abbrev (int name
, int form
)
1539 /* Get the size of a fragment. */
1542 get_frag_fix (fragS
*frag
, segT seg
)
1547 return frag
->fr_fix
;
1549 /* If a fragment is the last in the chain, special measures must be
1550 taken to find its size before relaxation, since it may be pending
1551 on some subsegment chain. */
1552 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1553 if (fr
->frch_last
== frag
)
1554 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1559 /* Set an absolute address (may result in a relocation entry). */
1562 out_set_addr (symbolS
*sym
)
1566 memset (&exp
, 0, sizeof exp
);
1567 out_opcode (DW_LNS_extended_op
);
1568 out_uleb128 (sizeof_address
+ 1);
1570 out_opcode (DW_LNE_set_address
);
1571 exp
.X_op
= O_symbol
;
1572 exp
.X_add_symbol
= sym
;
1573 exp
.X_add_number
= 0;
1574 emit_expr (&exp
, sizeof_address
);
1578 scale_addr_delta (int line_delta
, addressT
*addr_delta
)
1580 static int printed_this
= 0;
1581 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1583 /* Don't error on non-instruction bytes at end of section. */
1584 if (line_delta
!= INT_MAX
1585 && *addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1587 as_bad("unaligned opcodes detected in executable segment");
1590 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1594 /* Encode a pair of line and address skips as efficiently as possible.
1595 Note that the line skip is signed, whereas the address skip is unsigned.
1597 The following two routines *must* be kept in sync. This is
1598 enforced by making emit_inc_line_addr abort if we do not emit
1599 exactly the expected number of bytes. */
1602 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1604 unsigned int tmp
, opcode
;
1607 /* Scale the address delta by the minimum instruction length. */
1608 scale_addr_delta (line_delta
, &addr_delta
);
1610 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1611 We cannot use special opcodes here, since we want the end_sequence
1612 to emit the matrix entry. */
1613 if (line_delta
== INT_MAX
)
1615 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1617 else if (addr_delta
)
1618 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1622 /* Bias the line delta by the base. */
1623 tmp
= line_delta
- DWARF2_LINE_BASE
;
1625 /* If the line increment is out of range of a special opcode, we
1626 must encode it with DW_LNS_advance_line. */
1627 if (tmp
>= DWARF2_LINE_RANGE
)
1629 len
= 1 + sizeof_leb128 (line_delta
, 1);
1631 tmp
= 0 - DWARF2_LINE_BASE
;
1634 /* Bias the opcode by the special opcode base. */
1635 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1637 /* Avoid overflow when addr_delta is large. */
1638 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1640 /* Try using a special opcode. */
1641 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1645 /* Try using DW_LNS_const_add_pc followed by special op. */
1646 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1651 /* Otherwise use DW_LNS_advance_pc. */
1652 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1654 /* DW_LNS_copy or special opcode. */
1661 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1663 unsigned int tmp
, opcode
;
1665 char *end
= p
+ len
;
1667 /* Line number sequences cannot go backward in addresses. This means
1668 we've incorrectly ordered the statements in the sequence. */
1669 gas_assert ((offsetT
) addr_delta
>= 0);
1671 /* Scale the address delta by the minimum instruction length. */
1672 scale_addr_delta (line_delta
, &addr_delta
);
1674 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1675 We cannot use special opcodes here, since we want the end_sequence
1676 to emit the matrix entry. */
1677 if (line_delta
== INT_MAX
)
1679 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1680 *p
++ = DW_LNS_const_add_pc
;
1681 else if (addr_delta
)
1683 *p
++ = DW_LNS_advance_pc
;
1684 p
+= output_leb128 (p
, addr_delta
, 0);
1687 *p
++ = DW_LNS_extended_op
;
1689 *p
++ = DW_LNE_end_sequence
;
1693 /* Bias the line delta by the base. */
1694 tmp
= line_delta
- DWARF2_LINE_BASE
;
1696 /* If the line increment is out of range of a special opcode, we
1697 must encode it with DW_LNS_advance_line. */
1698 if (tmp
>= DWARF2_LINE_RANGE
)
1700 *p
++ = DW_LNS_advance_line
;
1701 p
+= output_leb128 (p
, line_delta
, 1);
1704 tmp
= 0 - DWARF2_LINE_BASE
;
1708 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1710 if (line_delta
== 0 && addr_delta
== 0)
1716 /* Bias the opcode by the special opcode base. */
1717 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1719 /* Avoid overflow when addr_delta is large. */
1720 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1722 /* Try using a special opcode. */
1723 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1730 /* Try using DW_LNS_const_add_pc followed by special op. */
1731 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1734 *p
++ = DW_LNS_const_add_pc
;
1740 /* Otherwise use DW_LNS_advance_pc. */
1741 *p
++ = DW_LNS_advance_pc
;
1742 p
+= output_leb128 (p
, addr_delta
, 0);
1750 gas_assert (p
== end
);
1753 /* Handy routine to combine calls to the above two routines. */
1756 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1758 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1759 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1762 /* Write out an alternative form of line and address skips using
1763 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1764 line and address information, but it is required if linker relaxation
1765 could change the code offsets. The following two routines *must* be
1767 #define ADDR_DELTA_LIMIT 50000
1770 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1774 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1775 if (line_delta
!= INT_MAX
)
1776 len
= 1 + sizeof_leb128 (line_delta
, 1);
1778 if (addr_delta
> ADDR_DELTA_LIMIT
)
1780 /* DW_LNS_extended_op */
1781 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1782 /* DW_LNE_set_address */
1783 len
+= 1 + sizeof_address
;
1786 /* DW_LNS_fixed_advance_pc */
1789 if (line_delta
== INT_MAX
)
1790 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1800 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1804 char *end
= p
+ len
;
1806 /* Line number sequences cannot go backward in addresses. This means
1807 we've incorrectly ordered the statements in the sequence. */
1808 gas_assert ((offsetT
) addr_delta
>= 0);
1810 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1811 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1813 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1814 if (line_delta
!= INT_MAX
)
1816 *p
++ = DW_LNS_advance_line
;
1817 p
+= output_leb128 (p
, line_delta
, 1);
1820 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1822 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1823 advance the address by at most 64K. Linker relaxation (without
1824 which this function would not be used) could change the operand by
1825 an unknown amount. If the address increment is getting close to
1826 the limit, just reset the address. */
1827 if (addr_delta
> ADDR_DELTA_LIMIT
)
1832 memset (&exp
, 0, sizeof exp
);
1833 gas_assert (pexp
->X_op
== O_subtract
);
1834 to_sym
= pexp
->X_add_symbol
;
1836 *p
++ = DW_LNS_extended_op
;
1837 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1838 *p
++ = DW_LNE_set_address
;
1839 exp
.X_op
= O_symbol
;
1840 exp
.X_add_symbol
= to_sym
;
1841 exp
.X_add_number
= 0;
1842 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1843 p
+= sizeof_address
;
1847 *p
++ = DW_LNS_fixed_advance_pc
;
1848 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1852 if (line_delta
== INT_MAX
)
1854 *p
++ = DW_LNS_extended_op
;
1856 *p
++ = DW_LNE_end_sequence
;
1861 gas_assert (p
== end
);
1864 /* Generate a variant frag that we can use to relax address/line
1865 increments between fragments of the target segment. */
1868 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1873 memset (&exp
, 0, sizeof exp
);
1874 exp
.X_op
= O_subtract
;
1875 exp
.X_add_symbol
= to_sym
;
1876 exp
.X_op_symbol
= from_sym
;
1877 exp
.X_add_number
= 0;
1879 /* The maximum size of the frag is the line delta with a maximum
1880 sized address delta. */
1881 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1882 max_chars
= size_fixed_inc_line_addr (line_delta
,
1883 -DWARF2_LINE_MIN_INSN_LENGTH
);
1885 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1887 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1888 make_expr_symbol (&exp
), line_delta
, NULL
);
1891 /* The function estimates the size of a rs_dwarf2dbg variant frag
1892 based on the current values of the symbols. It is called before
1893 the relaxation loop. We set fr_subtype to the expected length. */
1896 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1901 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1902 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1903 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1905 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1907 frag
->fr_subtype
= size
;
1912 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1913 current values of the symbols. fr_subtype is the current length
1914 of the frag. This returns the change in frag length. */
1917 dwarf2dbg_relax_frag (fragS
*frag
)
1919 int old_size
, new_size
;
1921 old_size
= frag
->fr_subtype
;
1922 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1924 return new_size
- old_size
;
1927 /* This function converts a rs_dwarf2dbg variant frag into a normal
1928 fill frag. This is called after all relaxation has been done.
1929 fr_subtype will be the desired length of the frag. */
1932 dwarf2dbg_convert_frag (fragS
*frag
)
1936 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1938 /* If linker relaxation is enabled then the distance between the two
1939 symbols in the frag->fr_symbol expression might change. Hence we
1940 cannot rely upon the value computed by resolve_symbol_value.
1941 Instead we leave the expression unfinalized and allow
1942 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1943 relocation) that will allow the linker to correctly compute the
1944 actual address difference. We have to use a fixed line advance for
1945 this as we cannot (easily) relocate leb128 encoded values. */
1946 int saved_finalize_syms
= finalize_syms
;
1949 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1950 finalize_syms
= saved_finalize_syms
;
1953 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1955 /* fr_var carries the max_chars that we created the fragment with.
1956 fr_subtype carries the current expected length. We must, of
1957 course, have allocated enough memory earlier. */
1958 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1960 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1961 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1962 frag
->fr_literal
+ frag
->fr_fix
,
1965 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1966 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1968 frag
->fr_fix
+= frag
->fr_subtype
;
1969 frag
->fr_type
= rs_fill
;
1971 frag
->fr_offset
= 0;
1974 /* Generate .debug_line content for the chain of line number entries
1975 beginning at E, for segment SEG. */
1978 process_entries (segT seg
, struct line_entry
*e
)
1980 unsigned filenum
= 1;
1982 unsigned column
= 0;
1984 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1985 fragS
*last_frag
= NULL
, *frag
;
1986 addressT last_frag_ofs
= 0, frag_ofs
;
1987 symbolS
*last_lab
= NULL
, *lab
;
1989 if (flag_dwarf_sections
)
1992 const char * sec_name
;
1994 /* Switch to the relevant sub-section before we start to emit
1995 the line number table.
1997 FIXME: These sub-sections do not have a normal Line Number
1998 Program Header, thus strictly speaking they are not valid
1999 DWARF sections. Unfortunately the DWARF standard assumes
2000 a one-to-one relationship between compilation units and
2001 line number tables. Thus we have to have a .debug_line
2002 section, as well as our sub-sections, and we have to ensure
2003 that all of the sub-sections are merged into a proper
2004 .debug_line section before a debugger sees them. */
2006 sec_name
= bfd_section_name (seg
);
2007 if (strcmp (sec_name
, ".text") != 0)
2009 name
= concat (".debug_line", sec_name
, (char *) NULL
);
2010 subseg_set (subseg_get (name
, false), 0);
2013 /* Don't create a .debug_line.text section -
2014 that is redundant. Instead just switch back to the
2015 normal .debug_line section. */
2016 subseg_set (subseg_get (".debug_line", false), 0);
2023 if (filenum
!= e
->loc
.filenum
)
2025 filenum
= e
->loc
.filenum
;
2026 out_opcode (DW_LNS_set_file
);
2027 out_uleb128 (filenum
);
2030 if (column
!= e
->loc
.column
)
2032 column
= e
->loc
.column
;
2033 out_opcode (DW_LNS_set_column
);
2034 out_uleb128 (column
);
2037 if (e
->loc
.discriminator
!= 0)
2039 out_opcode (DW_LNS_extended_op
);
2040 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
2041 out_opcode (DW_LNE_set_discriminator
);
2042 out_uleb128 (e
->loc
.discriminator
);
2045 if (isa
!= e
->loc
.isa
)
2048 out_opcode (DW_LNS_set_isa
);
2052 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
2054 flags
= e
->loc
.flags
;
2055 out_opcode (DW_LNS_negate_stmt
);
2058 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
2059 out_opcode (DW_LNS_set_basic_block
);
2061 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
2062 out_opcode (DW_LNS_set_prologue_end
);
2064 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
2065 out_opcode (DW_LNS_set_epilogue_begin
);
2067 /* Don't try to optimize away redundant entries; gdb wants two
2068 entries for a function where the code starts on the same line as
2069 the {, and there's no way to identify that case here. Trust gcc
2070 to optimize appropriately. */
2071 line_delta
= e
->loc
.line
- line
;
2073 frag
= symbol_get_frag (lab
);
2074 frag_ofs
= S_GET_VALUE (lab
);
2076 if (last_frag
== NULL
2077 || (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
2078 /* If we're going to reset the view, but we know we're
2079 advancing the PC, we don't have to force with
2080 set_address. We know we do when we're at the same
2081 address of the same frag, and we know we might when
2082 we're in the beginning of a frag, and we were at the
2083 end of the previous frag. */
2084 && (frag
== last_frag
2085 ? (last_frag_ofs
== frag_ofs
)
2087 && ((offsetT
)last_frag_ofs
2088 >= get_frag_fix (last_frag
, seg
))))))
2091 out_inc_line_addr (line_delta
, 0);
2093 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2094 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2096 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2101 last_frag_ofs
= frag_ofs
;
2107 /* Emit a DW_LNE_end_sequence for the end of the section. */
2108 frag
= last_frag_for_seg (seg
);
2109 frag_ofs
= get_frag_fix (frag
, seg
);
2110 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2111 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2114 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2115 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2119 /* Switch to LINE_STR_SEG and output the given STR. Return the
2120 symbol pointing to the new string in the section. */
2123 add_line_strp (segT line_str_seg
, const char *str
)
2129 subseg_set (line_str_seg
, 0);
2131 sym
= symbol_temp_new_now_octets ();
2133 size
= strlen (str
) + 1;
2134 cp
= frag_more (size
);
2135 memcpy (cp
, str
, size
);
2141 /* Emit the directory and file tables for .debug_line. */
2144 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2150 bool emit_md5
= false;
2151 bool emit_timestamps
= true;
2152 bool emit_filesize
= true;
2153 segT line_str_seg
= NULL
;
2154 symbolS
*line_strp
, *file0_strp
= NULL
;
2156 /* Output the Directory Table. */
2157 if (DWARF2_LINE_VERSION
>= 5)
2159 /* We only have one column in the directory table. */
2162 /* Describe the purpose and format of the column. */
2163 out_uleb128 (DW_LNCT_path
);
2164 /* Store these strings in the .debug_line_str section so they
2166 out_uleb128 (DW_FORM_line_strp
);
2168 /* Now state how many rows there are in the table. We need at
2169 least 1 if there is one or more file names to store the
2170 "working directory". */
2171 if (dirs_in_use
== 0 && files_in_use
> 0)
2174 out_uleb128 (dirs_in_use
);
2177 /* Emit directory list. */
2178 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2180 line_str_seg
= subseg_new (".debug_line_str", 0);
2181 bfd_set_section_flags (line_str_seg
,
2182 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2183 | SEC_MERGE
| SEC_STRINGS
);
2184 line_str_seg
->entsize
= 1;
2186 /* DWARF5 uses slot zero, but that is only set explicitly
2187 using a .file 0 directive. Otherwise use pwd as main file
2189 if (dirs_in_use
> 0 && dirs
[0] != NULL
)
2190 dir
= remap_debug_filename (dirs
[0]);
2192 dir
= remap_debug_filename (getpwd ());
2194 line_strp
= add_line_strp (line_str_seg
, dir
);
2196 subseg_set (line_seg
, 0);
2197 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2199 for (i
= 1; i
< dirs_in_use
; ++i
)
2201 dir
= remap_debug_filename (dirs
[i
]);
2202 if (DWARF2_LINE_VERSION
< 5)
2204 size
= strlen (dir
) + 1;
2205 cp
= frag_more (size
);
2206 memcpy (cp
, dir
, size
);
2210 line_strp
= add_line_strp (line_str_seg
, dir
);
2211 subseg_set (line_seg
, 0);
2212 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2217 if (DWARF2_LINE_VERSION
< 5)
2221 /* Output the File Name Table. */
2222 if (DWARF2_LINE_VERSION
>= 5)
2224 unsigned int columns
= 4;
2226 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2228 emit_timestamps
= false;
2232 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2234 emit_filesize
= false;
2238 for (i
= 0; i
< files_in_use
; ++i
)
2239 if (files
[i
].md5
[0] != 0)
2241 if (i
< files_in_use
)
2247 /* The number of format entries to follow. */
2249 /* The format of the file name. */
2250 out_uleb128 (DW_LNCT_path
);
2251 /* Store these strings in the .debug_line_str section so they
2253 out_uleb128 (DW_FORM_line_strp
);
2255 /* The format of the directory index. */
2256 out_uleb128 (DW_LNCT_directory_index
);
2257 out_uleb128 (DW_FORM_udata
);
2259 if (emit_timestamps
)
2261 /* The format of the timestamp. */
2262 out_uleb128 (DW_LNCT_timestamp
);
2263 out_uleb128 (DW_FORM_udata
);
2268 /* The format of the file size. */
2269 out_uleb128 (DW_LNCT_size
);
2270 out_uleb128 (DW_FORM_udata
);
2275 /* The format of the MD5 sum. */
2276 out_uleb128 (DW_LNCT_MD5
);
2277 out_uleb128 (DW_FORM_data16
);
2280 /* The number of entries in the table. */
2281 out_uleb128 (files_in_use
);
2284 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2286 const char *fullfilename
;
2288 if (files
[i
].filename
== NULL
)
2290 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2292 as_bad (_("unassigned file number %ld"), (long) i
);
2295 /* DWARF5 uses slot zero, but that is only set explicitly using
2296 a .file 0 directive. If that isn't used, but file 1 is, then
2297 use that as main file name. */
2298 if (files_in_use
> 1 && files
[1].filename
!= NULL
)
2300 files
[0].filename
= files
[1].filename
;
2301 files
[0].dir
= files
[1].dir
;
2303 for (j
= 0; j
< NUM_MD5_BYTES
; ++j
)
2304 files
[0].md5
[j
] = files
[1].md5
[j
];
2307 files
[0].filename
= "";
2310 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2311 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2312 if (DWARF2_LINE_VERSION
< 5)
2314 size
= strlen (fullfilename
) + 1;
2315 cp
= frag_more (size
);
2316 memcpy (cp
, fullfilename
, size
);
2321 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2323 line_strp
= file0_strp
;
2324 subseg_set (line_seg
, 0);
2325 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2326 if (i
== 0 && files_in_use
> 1
2327 && files
[0].filename
== files
[1].filename
)
2328 file0_strp
= line_strp
;
2333 /* Directory number. */
2334 out_uleb128 (files
[i
].dir
);
2336 /* Output the last modification timestamp. */
2337 if (emit_timestamps
)
2341 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2342 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2343 if (timestamp
== -1)
2345 out_uleb128 (timestamp
);
2348 /* Output the filesize. */
2352 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2353 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2356 out_uleb128 (filesize
);
2359 /* Output the md5 sum. */
2364 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2365 out_byte (files
[i
].md5
[b
]);
2369 if (DWARF2_LINE_VERSION
< 5)
2370 /* Terminate filename list. */
2374 /* Switch to SEC and output a header length field. Return the size of
2375 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2376 to the end of the section. EXPR->X_add_number will be set to the
2377 negative size of the header. */
2380 out_header (asection
*sec
, expressionS
*exp
)
2385 subseg_set (sec
, 0);
2387 if (flag_dwarf_sections
)
2389 /* If we are going to put the start and end symbols in different
2390 sections, then we need real symbols, not just fake, local ones. */
2392 start_sym
= symbol_make (".Ldebug_line_start");
2393 end_sym
= symbol_make (".Ldebug_line_end");
2394 symbol_set_value_now (start_sym
);
2398 start_sym
= symbol_temp_new_now_octets ();
2399 end_sym
= symbol_temp_make ();
2402 /* Total length of the information. */
2403 exp
->X_op
= O_subtract
;
2404 exp
->X_add_symbol
= end_sym
;
2405 exp
->X_op_symbol
= start_sym
;
2407 switch (DWARF2_FORMAT (sec
))
2409 case dwarf2_format_32bit
:
2410 exp
->X_add_number
= -4;
2414 case dwarf2_format_64bit
:
2415 exp
->X_add_number
= -12;
2420 case dwarf2_format_64bit_irix
:
2421 exp
->X_add_number
= -8;
2426 as_fatal (_("internal error: unknown dwarf2 format"));
2430 /* Emit the collected .debug_line data. */
2433 out_debug_line (segT line_seg
)
2436 symbolS
*prologue_start
, *prologue_end
;
2441 memset (&exp
, 0, sizeof exp
);
2442 sizeof_offset
= out_header (line_seg
, &exp
);
2443 line_end
= exp
.X_add_symbol
;
2446 out_two (DWARF2_LINE_VERSION
);
2448 if (DWARF2_LINE_VERSION
>= 5)
2450 out_byte (sizeof_address
);
2451 out_byte (0); /* Segment Selector size. */
2453 /* Length of the prologue following this length. */
2454 prologue_start
= symbol_temp_make ();
2455 prologue_end
= symbol_temp_make ();
2456 exp
.X_op
= O_subtract
;
2457 exp
.X_add_symbol
= prologue_end
;
2458 exp
.X_op_symbol
= prologue_start
;
2459 exp
.X_add_number
= 0;
2460 emit_expr (&exp
, sizeof_offset
);
2461 symbol_set_value_now (prologue_start
);
2463 /* Parameters of the state machine. */
2464 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2465 if (DWARF2_LINE_VERSION
>= 4)
2466 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2467 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2468 out_byte (DWARF2_LINE_BASE
);
2469 out_byte (DWARF2_LINE_RANGE
);
2470 out_byte (DWARF2_LINE_OPCODE_BASE
);
2472 /* Standard opcode lengths. */
2473 out_byte (0); /* DW_LNS_copy */
2474 out_byte (1); /* DW_LNS_advance_pc */
2475 out_byte (1); /* DW_LNS_advance_line */
2476 out_byte (1); /* DW_LNS_set_file */
2477 out_byte (1); /* DW_LNS_set_column */
2478 out_byte (0); /* DW_LNS_negate_stmt */
2479 out_byte (0); /* DW_LNS_set_basic_block */
2480 out_byte (0); /* DW_LNS_const_add_pc */
2481 out_byte (1); /* DW_LNS_fixed_advance_pc */
2482 out_byte (0); /* DW_LNS_set_prologue_end */
2483 out_byte (0); /* DW_LNS_set_epilogue_begin */
2484 out_byte (1); /* DW_LNS_set_isa */
2485 /* We have emitted 12 opcode lengths, so make that this
2486 matches up to the opcode base value we have been using. */
2487 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2489 out_dir_and_file_list (line_seg
, sizeof_offset
);
2491 symbol_set_value_now (prologue_end
);
2493 /* For each section, emit a statement program. */
2494 for (s
= all_segs
; s
; s
= s
->next
)
2495 /* Paranoia - this check should have already have
2496 been handled in dwarf2_gen_line_info_1(). */
2497 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2498 process_entries (s
->seg
, s
->head
->head
);
2500 if (flag_dwarf_sections
)
2501 /* We have to switch to the special .debug_line_end section
2502 before emitting the end-of-debug_line symbol. The linker
2503 script arranges for this section to be placed after all the
2504 (potentially garbage collected) .debug_line.<foo> sections.
2505 This section contains the line_end symbol which is used to
2506 compute the size of the linked .debug_line section, as seen
2507 in the DWARF Line Number header. */
2508 subseg_set (subseg_get (".debug_line_end", false), 0);
2510 symbol_set_value_now (line_end
);
2514 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2516 unsigned int addr_size
= sizeof_address
;
2521 memset (&exp
, 0, sizeof exp
);
2522 subseg_set (ranges_seg
, 0);
2524 /* For DW_AT_ranges to point at (there is no header, so really start
2525 of section, but see out_debug_rnglists). */
2526 *ranges_sym
= symbol_temp_new_now_octets ();
2528 /* Base Address Entry. */
2529 for (i
= 0; i
< addr_size
; i
++)
2531 for (i
= 0; i
< addr_size
; i
++)
2534 /* Range List Entry. */
2535 for (s
= all_segs
; s
; s
= s
->next
)
2540 frag
= first_frag_for_seg (s
->seg
);
2541 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2542 s
->text_start
= beg
;
2544 frag
= last_frag_for_seg (s
->seg
);
2545 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2548 exp
.X_op
= O_symbol
;
2549 exp
.X_add_symbol
= beg
;
2550 exp
.X_add_number
= 0;
2551 emit_expr (&exp
, addr_size
);
2553 exp
.X_op
= O_symbol
;
2554 exp
.X_add_symbol
= end
;
2555 exp
.X_add_number
= 0;
2556 emit_expr (&exp
, addr_size
);
2559 /* End of Range Entry. */
2560 for (i
= 0; i
< addr_size
; i
++)
2562 for (i
= 0; i
< addr_size
; i
++)
2567 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2570 symbolS
*ranges_end
;
2574 memset (&exp
, 0, sizeof exp
);
2575 out_header (ranges_seg
, &exp
);
2576 ranges_end
= exp
.X_add_symbol
;
2578 out_two (DWARF2_RNGLISTS_VERSION
);
2579 out_byte (sizeof_address
);
2580 out_byte (0); /* Segment Selector size. */
2581 out_four (0); /* Offset entry count. */
2583 /* For DW_AT_ranges to point at (must be after the header). */
2584 *ranges_sym
= symbol_temp_new_now_octets ();
2586 for (s
= all_segs
; s
; s
= s
->next
)
2591 out_byte (DW_RLE_start_length
);
2593 frag
= first_frag_for_seg (s
->seg
);
2594 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2595 s
->text_start
= beg
;
2597 frag
= last_frag_for_seg (s
->seg
);
2598 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2601 exp
.X_op
= O_symbol
;
2602 exp
.X_add_symbol
= beg
;
2603 exp
.X_add_number
= 0;
2604 emit_expr (&exp
, sizeof_address
);
2606 exp
.X_op
= O_symbol
;
2607 exp
.X_add_symbol
= end
;
2608 exp
.X_add_number
= 0;
2609 emit_leb128_expr (&exp
, 0);
2612 out_byte (DW_RLE_end_of_list
);
2614 symbol_set_value_now (ranges_end
);
2617 /* Emit data for .debug_aranges. */
2620 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2622 unsigned int addr_size
= sizeof_address
;
2626 symbolS
*aranges_end
;
2630 memset (&exp
, 0, sizeof exp
);
2631 sizeof_offset
= out_header (aranges_seg
, &exp
);
2632 aranges_end
= exp
.X_add_symbol
;
2633 size
= -exp
.X_add_number
;
2636 out_two (DWARF2_ARANGES_VERSION
);
2639 /* Offset to .debug_info. */
2640 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2641 size
+= sizeof_offset
;
2643 /* Size of an address (offset portion). */
2644 out_byte (addr_size
);
2647 /* Size of a segment descriptor. */
2651 /* Align the header. */
2652 while ((size
++ % (2 * addr_size
)) > 0)
2655 for (s
= all_segs
; s
; s
= s
->next
)
2660 frag
= first_frag_for_seg (s
->seg
);
2661 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2662 s
->text_start
= beg
;
2664 frag
= last_frag_for_seg (s
->seg
);
2665 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2668 exp
.X_op
= O_symbol
;
2669 exp
.X_add_symbol
= beg
;
2670 exp
.X_add_number
= 0;
2671 emit_expr (&exp
, addr_size
);
2673 exp
.X_op
= O_subtract
;
2674 exp
.X_add_symbol
= end
;
2675 exp
.X_op_symbol
= beg
;
2676 exp
.X_add_number
= 0;
2677 emit_expr (&exp
, addr_size
);
2680 p
= frag_more (2 * addr_size
);
2681 md_number_to_chars (p
, 0, addr_size
);
2682 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2684 symbol_set_value_now (aranges_end
);
2687 /* Emit data for .debug_abbrev. Note that this must be kept in
2688 sync with out_debug_info below. */
2691 out_debug_abbrev (segT abbrev_seg
,
2692 segT info_seg ATTRIBUTE_UNUSED
,
2693 segT line_seg ATTRIBUTE_UNUSED
,
2694 unsigned char *func_formP
)
2697 bool have_efunc
= false, have_lfunc
= false;
2699 /* Check the symbol table for function symbols which also have their size
2705 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2707 /* A warning construct is a warning symbol followed by the
2708 symbol warned about. Skip this and the following symbol. */
2709 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2711 symp
= symbol_next (symp
);
2717 if (!S_IS_DEFINED (symp
) || !S_IS_FUNCTION (symp
))
2720 #if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
2721 if (S_GET_SIZE (symp
) == 0)
2723 if (!IS_ELF
|| symbol_get_obj (symp
)->size
== NULL
)
2730 if (S_IS_EXTERNAL (symp
))
2737 subseg_set (abbrev_seg
, 0);
2739 out_uleb128 (GAS_ABBREV_COMP_UNIT
);
2740 out_uleb128 (DW_TAG_compile_unit
);
2741 out_byte (have_efunc
|| have_lfunc
? DW_CHILDREN_yes
: DW_CHILDREN_no
);
2742 if (DWARF2_VERSION
< 4)
2744 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2745 secoff_form
= DW_FORM_data4
;
2747 secoff_form
= DW_FORM_data8
;
2750 secoff_form
= DW_FORM_sec_offset
;
2751 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2752 if (all_segs
->next
== NULL
)
2754 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2755 if (DWARF2_VERSION
< 4)
2756 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2758 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2761 out_abbrev (DW_AT_ranges
, secoff_form
);
2762 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2763 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2764 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2765 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2768 if (have_efunc
|| have_lfunc
)
2770 out_uleb128 (GAS_ABBREV_SUBPROG
);
2771 out_uleb128 (DW_TAG_subprogram
);
2772 out_byte (DW_CHILDREN_no
);
2773 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2776 if (have_lfunc
|| DWARF2_VERSION
< 4)
2777 *func_formP
= DW_FORM_flag
;
2779 *func_formP
= DW_FORM_flag_present
;
2780 out_abbrev (DW_AT_external
, *func_formP
);
2783 /* Any non-zero value other than DW_FORM_flag will do. */
2784 *func_formP
= DW_FORM_block
;
2786 /* PR 29517: Provide a return type for the function. */
2787 if (DWARF2_VERSION
> 2)
2788 out_abbrev (DW_AT_type
, DW_FORM_ref_udata
);
2790 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2791 out_abbrev (DW_AT_high_pc
,
2792 DWARF2_VERSION
< 4 ? DW_FORM_addr
: DW_FORM_udata
);
2795 if (DWARF2_VERSION
> 2)
2797 /* PR 29517: We do not actually know the return type of these
2798 functions, so provide an abbrev that uses DWARF's unspecified
2800 out_uleb128 (GAS_ABBREV_NO_TYPE
);
2801 out_uleb128 (DW_TAG_unspecified_type
);
2802 out_byte (DW_CHILDREN_no
);
2807 /* Terminate the abbreviations for this compilation unit. */
2811 /* Emit a description of this compilation unit for .debug_info. */
2814 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT str_seg
,
2815 symbolS
*ranges_sym
, symbolS
*name_sym
,
2816 symbolS
*comp_dir_sym
, symbolS
*producer_sym
,
2817 unsigned char func_form
)
2823 memset (&exp
, 0, sizeof exp
);
2824 sizeof_offset
= out_header (info_seg
, &exp
);
2825 info_end
= exp
.X_add_symbol
;
2827 /* DWARF version. */
2828 out_two (DWARF2_VERSION
);
2830 if (DWARF2_VERSION
< 5)
2832 /* .debug_abbrev offset */
2833 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2837 /* unit (header) type */
2838 out_byte (DW_UT_compile
);
2841 /* Target address size. */
2842 out_byte (sizeof_address
);
2844 if (DWARF2_VERSION
>= 5)
2846 /* .debug_abbrev offset */
2847 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2850 /* DW_TAG_compile_unit DIE abbrev */
2851 out_uleb128 (GAS_ABBREV_COMP_UNIT
);
2853 /* DW_AT_stmt_list */
2854 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2855 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2858 /* These two attributes are emitted if all of the code is contiguous. */
2859 if (all_segs
->next
== NULL
)
2862 exp
.X_op
= O_symbol
;
2863 exp
.X_add_symbol
= all_segs
->text_start
;
2864 exp
.X_add_number
= 0;
2865 emit_expr (&exp
, sizeof_address
);
2868 if (DWARF2_VERSION
< 4)
2869 exp
.X_op
= O_symbol
;
2872 exp
.X_op
= O_subtract
;
2873 exp
.X_op_symbol
= all_segs
->text_start
;
2875 exp
.X_add_symbol
= all_segs
->text_end
;
2876 exp
.X_add_number
= 0;
2877 if (DWARF2_VERSION
< 4)
2878 emit_expr (&exp
, sizeof_address
);
2880 emit_leb128_expr (&exp
, 0);
2884 /* This attribute is emitted if the code is disjoint. */
2886 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2889 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2890 setup in out_debug_str below. */
2891 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2892 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2893 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2895 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2896 dwarf2 draft has no standard code for assembler. */
2897 out_two (DW_LANG_Mips_Assembler
);
2902 symbolS
*no_type_tag
;
2904 if (DWARF2_VERSION
> 2)
2905 no_type_tag
= symbol_make (".Ldebug_no_type_tag");
2909 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2913 expressionS size
= { .X_op
= O_constant
};
2915 /* Skip warning constructs (see above). */
2916 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2918 symp
= symbol_next (symp
);
2924 if (!S_IS_DEFINED (symp
) || !S_IS_FUNCTION (symp
))
2927 #if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
2928 size
.X_add_number
= S_GET_SIZE (symp
);
2929 if (size
.X_add_number
== 0 && IS_ELF
2930 && symbol_get_obj (symp
)->size
!= NULL
)
2933 size
.X_op_symbol
= make_expr_symbol (symbol_get_obj (symp
)->size
);
2936 if (size
.X_op
== O_constant
&& size
.X_add_number
== 0)
2939 subseg_set (str_seg
, 0);
2940 name_sym
= symbol_temp_new_now_octets ();
2941 name
= S_GET_NAME (symp
);
2942 len
= strlen (name
) + 1;
2943 memcpy (frag_more (len
), name
, len
);
2945 subseg_set (info_seg
, 0);
2947 /* DW_TAG_subprogram DIE abbrev */
2948 out_uleb128 (GAS_ABBREV_SUBPROG
);
2951 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2953 /* DW_AT_external. */
2954 if (func_form
== DW_FORM_flag
)
2955 out_byte (S_IS_EXTERNAL (symp
));
2957 /* PR 29517: Let consumers know that we do not have
2958 return type information for this function. */
2959 if (DWARF2_VERSION
> 2)
2961 exp
.X_op
= O_symbol
;
2962 exp
.X_add_symbol
= no_type_tag
;
2963 exp
.X_add_number
= 0;
2964 emit_leb128_expr (&exp
, 0);
2968 exp
.X_op
= O_symbol
;
2969 exp
.X_add_symbol
= symp
;
2970 exp
.X_add_number
= 0;
2971 emit_expr (&exp
, sizeof_address
);
2974 if (DWARF2_VERSION
< 4)
2976 if (size
.X_op
== O_constant
)
2977 size
.X_op
= O_symbol
;
2978 size
.X_add_symbol
= symp
;
2979 emit_expr (&size
, sizeof_address
);
2981 else if (size
.X_op
== O_constant
)
2982 out_uleb128 (size
.X_add_number
);
2984 emit_leb128_expr (symbol_get_value_expression (size
.X_op_symbol
), 0);
2987 if (DWARF2_VERSION
> 2)
2989 /* PR 29517: Generate a DIE for the unspecified type abbrev.
2990 We do it here because it cannot be part of the top level DIE. */
2991 subseg_set (info_seg
, 0);
2992 symbol_set_value_now (no_type_tag
);
2993 out_uleb128 (GAS_ABBREV_NO_TYPE
);
2996 /* End of children. */
3000 symbol_set_value_now (info_end
);
3003 /* Emit the three debug strings needed in .debug_str and setup symbols
3004 to them for use in out_debug_info. */
3006 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
3007 symbolS
**producer_sym
)
3012 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
3014 subseg_set (str_seg
, 0);
3016 /* DW_AT_name. We don't have the actual file name that was present
3017 on the command line, so assume files[first_file] is the main input file.
3018 We're not supposed to get called unless at least one line number
3019 entry was emitted, so this should always be defined. */
3020 *name_sym
= symbol_temp_new_now_octets ();
3021 if (files_in_use
== 0)
3023 if (files
[first_file
].dir
)
3025 char *dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
3026 len
= strlen (dirname
);
3028 /* Already has trailing slash. */
3029 p
= frag_more (len
);
3030 memcpy (p
, dirname
, len
);
3032 p
= frag_more (len
+ 1);
3033 memcpy (p
, dirname
, len
);
3034 INSERT_DIR_SEPARATOR (p
, len
);
3038 len
= strlen (files
[first_file
].filename
) + 1;
3039 p
= frag_more (len
);
3040 memcpy (p
, files
[first_file
].filename
, len
);
3042 /* DW_AT_comp_dir */
3043 *comp_dir_sym
= symbol_temp_new_now_octets ();
3044 char *comp_dir
= remap_debug_filename (getpwd ());
3045 len
= strlen (comp_dir
) + 1;
3046 p
= frag_more (len
);
3047 memcpy (p
, comp_dir
, len
);
3050 /* DW_AT_producer */
3051 *producer_sym
= symbol_temp_new_now_octets ();
3052 sprintf (producer
, "GNU AS %s", VERSION
);
3053 len
= strlen (producer
) + 1;
3054 p
= frag_more (len
);
3055 memcpy (p
, producer
, len
);
3062 last_seg_ptr
= &all_segs
;
3065 files_allocated
= 0;
3069 dwarf2_loc_directive_seen
= false;
3070 dwarf2_any_loc_directive_seen
= false;
3071 dwarf2_loc_mark_labels
= false;
3072 current
.filenum
= 1;
3076 current
.flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
3077 current
.discriminator
= 0;
3078 current
.u
.view
= NULL
;
3079 force_reset_view
= NULL
;
3080 view_assert_failed
= NULL
;
3082 /* Select the default CIE version to produce here. The global
3083 starts with a value of -1 and will be modified to a valid value
3084 either by the user providing a command line option, or some
3085 targets will select their own default in md_after_parse_args. If
3086 we get here and the global still contains -1 then it is up to us
3087 to pick a sane default. The default we choose is 1, this is the
3088 CIE version gas has produced for a long time, and there seems no
3089 reason to change it yet. */
3090 if (flag_dwarf_cie_version
== -1)
3091 flag_dwarf_cie_version
= 1;
3095 dwarf2_cleanup (void)
3097 purge_generated_debug (true);
3099 for (unsigned int i
= 0; i
< dirs_in_use
; i
++)
3104 /* Finish the dwarf2 debug sections. We emit .debug.line if there
3105 were any .file/.loc directives, or --gdwarf2 was given, and if the
3106 file has a non-empty .debug_info section and an empty .debug_line
3107 section. If we emit .debug_line, and the .debug_info section is
3108 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
3109 ALL_SEGS will be non-null if there were any .file/.loc directives,
3110 or --gdwarf2 was given and there were any located instructions
3114 dwarf2_finish (void)
3119 int emit_other_sections
= 0;
3120 int empty_debug_line
= 0;
3122 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
3123 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
3125 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
3126 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
3128 /* We can't construct a new debug_line section if we already have one.
3129 Give an error if we have seen any .loc, otherwise trust the user
3130 knows what they are doing and want to generate the .debug_line
3131 (and all other debug sections) themselves. */
3132 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
3133 as_fatal ("duplicate .debug_line sections");
3135 if ((!all_segs
&& emit_other_sections
)
3136 || (!emit_other_sections
&& !empty_debug_line
))
3137 /* If there is no line information and no non-empty .debug_info
3138 section, or if there is both a non-empty .debug_info and a non-empty
3139 .debug_line, then we do nothing. */
3145 /* Calculate the size of an address for the target machine. */
3146 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
3148 /* Create and switch to the line number section. */
3149 if (empty_debug_line
)
3151 line_seg
= subseg_new (".debug_line", 0);
3152 bfd_set_section_flags (line_seg
,
3153 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3156 for (s
= all_segs
; s
; s
= s
->next
)
3158 struct line_subseg
*lss
;
3160 for (lss
= s
->head
; lss
; lss
= lss
->next
)
3162 do_allocate_filenum (lss
->head
);
3165 /* For each subsection, chain the debug entries together. */
3166 for (s
= all_segs
; s
; s
= s
->next
)
3168 struct line_subseg
*lss
= s
->head
;
3169 struct line_entry
**ptail
= lss
->ptail
;
3171 /* Reset the initial view of the first subsection of the
3173 if (lss
->head
&& lss
->head
->loc
.u
.view
)
3174 set_or_check_view (lss
->head
, NULL
, NULL
);
3176 while ((lss
= lss
->next
) != NULL
)
3178 /* Link the first view of subsequent subsections to the
3180 if (lss
->head
&& lss
->head
->loc
.u
.view
)
3181 set_or_check_view (lss
->head
,
3182 !s
->head
? NULL
: (struct line_entry
*)ptail
,
3183 s
->head
? s
->head
->head
: NULL
);
3190 if (empty_debug_line
)
3191 out_debug_line (line_seg
);
3193 /* If this is assembler generated line info, and there is no
3194 debug_info already, we need .debug_info, .debug_abbrev and
3195 .debug_str sections as well. */
3196 if (emit_other_sections
)
3201 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
3202 unsigned char func_form
= 0;
3204 gas_assert (all_segs
);
3206 info_seg
= subseg_new (".debug_info", 0);
3207 abbrev_seg
= subseg_new (".debug_abbrev", 0);
3208 aranges_seg
= subseg_new (".debug_aranges", 0);
3209 str_seg
= subseg_new (".debug_str", 0);
3211 bfd_set_section_flags (info_seg
,
3212 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3213 bfd_set_section_flags (abbrev_seg
,
3214 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3215 bfd_set_section_flags (aranges_seg
,
3216 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3217 bfd_set_section_flags (str_seg
,
3218 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
3219 | SEC_MERGE
| SEC_STRINGS
);
3220 str_seg
->entsize
= 1;
3222 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
3224 if (all_segs
->next
== NULL
)
3228 if (DWARF2_VERSION
< 5)
3230 segT ranges_seg
= subseg_new (".debug_ranges", 0);
3231 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
3234 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
3235 out_debug_ranges (ranges_seg
, &ranges_sym
);
3239 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
3240 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
3243 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
3247 out_debug_aranges (aranges_seg
, info_seg
);
3248 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
, &func_form
);
3249 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
3250 out_debug_info (info_seg
, abbrev_seg
, line_seg
, str_seg
,
3251 ranges_sym
, name_sym
, comp_dir_sym
, producer_sym
,
3257 /* Perform any deferred checks pertaining to debug information. */
3260 dwarf2dbg_final_check (void)
3262 /* Perform reset-view checks. Don't evaluate view_assert_failed
3263 recursively: it could be very deep. It's a chain of adds, with
3264 each chain element pointing to the next in X_add_symbol, and
3265 holding the check value in X_op_symbol. */
3266 while (view_assert_failed
)
3272 gas_assert (!symbol_resolved_p (view_assert_failed
));
3274 exp
= symbol_get_value_expression (view_assert_failed
);
3275 sym
= view_assert_failed
;
3277 /* If view_assert_failed looks like a compound check in the
3278 chain, break it up. */
3279 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3281 view_assert_failed
= exp
->X_add_symbol
;
3282 sym
= exp
->X_op_symbol
;
3285 view_assert_failed
= NULL
;
3287 failed
= resolve_symbol_value (sym
);
3288 if (!symbol_resolved_p (sym
) || failed
)
3290 as_bad (_("view number mismatch"));