1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2022 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. */
213 static unsigned int dirs_in_use
;
214 static unsigned int dirs_allocated
;
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
;
233 /* This symbol is used to recognize view number forced resets in loc
235 static symbolS
*force_reset_view
;
237 /* This symbol evaluates to an expression that, if nonzero, indicates
238 some view assert check failed. */
239 static symbolS
*view_assert_failed
;
241 /* The size of an address on the target. */
242 static unsigned int sizeof_address
;
244 #ifndef TC_DWARF2_EMIT_OFFSET
245 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
247 /* Create an offset to .dwarf2_*. */
250 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
254 memset (&exp
, 0, sizeof exp
);
256 exp
.X_add_symbol
= symbol
;
257 exp
.X_add_number
= 0;
258 emit_expr (&exp
, size
);
262 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
264 static struct line_subseg
*
265 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
267 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
268 struct line_subseg
**pss
, *lss
;
275 s
= XNEW (struct line_seg
);
280 last_seg_ptr
= &s
->next
;
281 seg_info (seg
)->dwarf2_line_seg
= s
;
284 gas_assert (seg
== s
->seg
);
286 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
288 if (lss
->subseg
== subseg
)
290 if (lss
->subseg
> subseg
)
294 lss
= XNEW (struct line_subseg
);
296 lss
->subseg
= subseg
;
298 lss
->ptail
= &lss
->head
;
299 lss
->pmove_tail
= &lss
->head
;
306 /* (Un)reverse the line_entry list starting from H. */
308 static struct line_entry
*
309 reverse_line_entry_list (struct line_entry
*h
)
311 struct line_entry
*p
= NULL
, *e
, *n
;
313 for (e
= h
; e
; e
= n
)
322 /* Compute the view for E based on the previous entry P. If we
323 introduce an (undefined) view symbol for P, and H is given (P must
324 be the tail in this case), introduce view symbols for earlier list
325 entries as well, until one of them is constant. */
328 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
329 struct line_entry
*h
)
333 memset (&viewx
, 0, sizeof (viewx
));
334 viewx
.X_unsigned
= 1;
336 /* First, compute !(E->label > P->label), to tell whether or not
337 we're to reset the view number. If we can't resolve it to a
338 constant, keep it symbolic. */
339 if (!p
|| (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
))
341 viewx
.X_op
= O_constant
;
342 viewx
.X_add_number
= 0;
343 viewx
.X_add_symbol
= NULL
;
344 viewx
.X_op_symbol
= NULL
;
349 viewx
.X_add_number
= 0;
350 viewx
.X_add_symbol
= e
->label
;
351 viewx
.X_op_symbol
= p
->label
;
352 resolve_expression (&viewx
);
353 if (viewx
.X_op
== O_constant
)
354 viewx
.X_add_number
= !viewx
.X_add_number
;
357 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
358 viewx
.X_add_number
= 0;
359 viewx
.X_op_symbol
= NULL
;
360 viewx
.X_op
= O_logical_not
;
364 if (S_IS_DEFINED (e
->loc
.u
.view
) && symbol_constant_p (e
->loc
.u
.view
))
366 expressionS
*value
= symbol_get_value_expression (e
->loc
.u
.view
);
367 /* We can't compare the view numbers at this point, because in
368 VIEWX we've only determined whether we're to reset it so
370 if (viewx
.X_op
== O_constant
)
372 if (!value
->X_add_number
!= !viewx
.X_add_number
)
373 as_bad (_("view number mismatch"));
375 /* Record the expression to check it later. It is the result of
376 a logical not, thus 0 or 1. We just add up all such deferred
377 expressions, and resolve it at the end. */
378 else if (!value
->X_add_number
)
380 symbolS
*deferred
= make_expr_symbol (&viewx
);
381 if (view_assert_failed
)
385 memset (&chk
, 0, sizeof (chk
));
388 chk
.X_add_number
= 0;
389 chk
.X_add_symbol
= view_assert_failed
;
390 chk
.X_op_symbol
= deferred
;
391 deferred
= make_expr_symbol (&chk
);
393 view_assert_failed
= deferred
;
397 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
403 p
->loc
.u
.view
= symbol_temp_make ();
405 memset (&incv
, 0, sizeof (incv
));
407 incv
.X_op
= O_symbol
;
408 incv
.X_add_symbol
= p
->loc
.u
.view
;
409 incv
.X_add_number
= 1;
410 p_view
= symbol_get_value_expression (p
->loc
.u
.view
);
411 if (p_view
->X_op
== O_constant
|| p_view
->X_op
== O_symbol
)
413 /* If we can, constant fold increments so that a chain of
414 expressions v + 1 + 1 ... + 1 is not created.
415 resolve_expression isn't ideal for this purpose. The
416 base v might not be resolvable until later. */
417 incv
.X_op
= p_view
->X_op
;
418 incv
.X_add_symbol
= p_view
->X_add_symbol
;
419 incv
.X_add_number
= p_view
->X_add_number
+ 1;
422 if (viewx
.X_op
== O_constant
)
424 gas_assert (viewx
.X_add_number
== 1);
429 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
430 viewx
.X_add_number
= 0;
431 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
432 viewx
.X_op
= O_multiply
;
436 if (!S_IS_DEFINED (e
->loc
.u
.view
))
438 symbol_set_value_expression (e
->loc
.u
.view
, &viewx
);
439 S_SET_SEGMENT (e
->loc
.u
.view
, expr_section
);
440 symbol_set_frag (e
->loc
.u
.view
, &zero_address_frag
);
443 /* Define and attempt to simplify any earlier views needed to
445 if (h
&& p
&& p
->loc
.u
.view
&& !S_IS_DEFINED (p
->loc
.u
.view
))
447 struct line_entry
*h2
;
448 /* Reverse the list to avoid quadratic behavior going backwards
449 in a single-linked list. */
450 struct line_entry
*r
= reverse_line_entry_list (h
);
453 /* Set or check views until we find a defined or absent view. */
456 /* Do not define the head of a (sub?)segment view while
457 handling others. It would be defined too early, without
458 regard to the last view of other subsegments.
459 set_or_check_view will be called for every head segment
463 set_or_check_view (r
, r
->next
, NULL
);
466 && r
->next
->loc
.u
.view
467 && !S_IS_DEFINED (r
->next
->loc
.u
.view
)
470 /* Unreverse the list, so that we can go forward again. */
471 h2
= reverse_line_entry_list (p
);
472 gas_assert (h2
== h
);
474 /* Starting from the last view we just defined, attempt to
475 simplify the view expressions, until we do so to P. */
478 /* The head view of a subsegment may remain undefined while
479 handling other elements, before it is linked to the last
480 view of the previous subsegment. */
483 gas_assert (S_IS_DEFINED (r
->loc
.u
.view
));
484 resolve_expression (symbol_get_value_expression (r
->loc
.u
.view
));
486 while (r
!= p
&& (r
= r
->next
));
488 /* Now that we've defined and computed all earlier views that might
489 be needed to compute E's, attempt to simplify it. */
490 resolve_expression (symbol_get_value_expression (e
->loc
.u
.view
));
494 /* Record an entry for LOC occurring at LABEL. */
497 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
499 struct line_subseg
*lss
;
500 struct line_entry
*e
;
501 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
503 /* PR 26850: Do not record LOCs in non-executable or non-loaded
504 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
505 obj_coff_section is careless in setting SEC_ALLOC. */
507 need_flags
|= SEC_ALLOC
;
508 if ((now_seg
->flags
& need_flags
) != need_flags
)
510 /* FIXME: Add code to suppress multiple warnings ? */
511 if (debug_type
!= DEBUG_DWARF2
)
512 as_warn ("dwarf line number information for %s ignored",
513 segment_name (now_seg
));
517 e
= XNEW (struct line_entry
);
522 lss
= get_line_subseg (now_seg
, now_subseg
, true);
524 /* Subseg heads are chained to previous subsegs in
526 if (loc
->filenum
!= -1u && loc
->u
.view
&& lss
->head
)
527 set_or_check_view (e
, (struct line_entry
*) lss
->ptail
, lss
->head
);
530 lss
->ptail
= &e
->next
;
533 /* Record an entry for LOC occurring at OFS within the current fragment. */
536 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
540 /* Early out for as-yet incomplete location information. */
543 if (loc
->filenum
== 0)
547 if (DWARF2_LINE_VERSION
< 5)
551 /* Don't emit sequences of line symbols for the same line when the
552 symbols apply to assembler code. It is necessary to emit
553 duplicate line symbols when a compiler asks for them, because GDB
554 uses them to determine the end of the prologue. */
555 if (debug_type
== DEBUG_DWARF2
)
557 static unsigned int line
= -1;
558 static const char *filename
= NULL
;
560 if (line
== loc
->line
)
562 if (filename
== loc
->u
.filename
)
564 if (filename_cmp (filename
, loc
->u
.filename
) == 0)
566 filename
= loc
->u
.filename
;
572 filename
= loc
->u
.filename
;
577 static int label_num
= 0;
580 /* Use a non-fake name for the line number location,
581 so that it can be referred to by relocations. */
582 sprintf (name
, ".Loc.%u", label_num
);
584 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
587 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
588 dwarf2_gen_line_info_1 (sym
, loc
);
592 get_basename (const char * pathname
)
596 file
= lbasename (pathname
);
597 /* Don't make empty string from / or A: from A:/ . */
598 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
599 if (file
<= pathname
+ 3)
602 if (file
== pathname
+ 1)
609 get_directory_table_entry (const char *dirname
,
610 const char *file0_dirname
,
619 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
620 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
628 for (d
= 0; d
< dirs_in_use
; ++d
)
631 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
632 && dirs
[d
][dirlen
] == '\0')
638 if (dirs
== NULL
|| dirs
[0] == NULL
)
640 const char * pwd
= file0_dirname
? file0_dirname
: getpwd ();
642 if (dwarf_level
>= 5 && filename_cmp (dirname
, pwd
) != 0)
644 /* In DWARF-5 the 0 entry in the directory table is
645 expected to be the same as the DW_AT_comp_dir (which
646 is set to the current build directory). Since we are
647 about to create a directory entry that is not the
648 same, allocate the current directory first. */
649 (void) get_directory_table_entry (pwd
, file0_dirname
,
660 if (d
>= dirs_allocated
)
662 unsigned int old
= dirs_allocated
;
663 #define DIR_TABLE_INCREMENT 32
664 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
665 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
666 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
669 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
670 if (dirs_in_use
<= d
)
677 assign_file_to_slot (unsigned int i
, const char *file
, unsigned int dir
)
679 if (i
>= files_allocated
)
681 unsigned int want
= i
+ 32;
683 /* Catch wraparound. */
684 if (want
< files_allocated
686 || want
> UINT_MAX
/ sizeof (struct file_entry
))
688 as_bad (_("file number %u is too big"), i
);
692 files
= XRESIZEVEC (struct file_entry
, files
, want
);
693 memset (files
+ files_allocated
, 0,
694 (want
- files_allocated
) * sizeof (struct file_entry
));
695 files_allocated
= want
;
698 files
[i
].filename
= file
;
700 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
702 if (files_in_use
< i
+ 1)
703 files_in_use
= i
+ 1;
708 /* Get a .debug_line file number for PATHNAME. If there is a
709 directory component to PATHNAME, then this will be stored
710 in the directory table, if it is not already present.
711 Returns the slot number allocated to that filename or -1
712 if there was a problem. */
715 allocate_filenum (const char * pathname
)
717 static signed int last_used
= -1, last_used_dir_len
= 0;
722 /* Short circuit the common case of adding the same pathname
726 const char * dirname
= NULL
;
729 dirname
= dirs
[files
[last_used
].dir
];
733 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
738 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
- 1) == 0
739 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
- 1])
740 && filename_cmp (pathname
+ last_used_dir_len
,
741 files
[last_used
].filename
) == 0)
746 file
= get_basename (pathname
);
747 dir_len
= file
- pathname
;
749 dir
= get_directory_table_entry (pathname
, NULL
, dir_len
, false);
751 /* Do not use slot-0. That is specifically reserved for use by
752 the '.file 0 "name"' directive. */
753 for (i
= 1; i
< files_in_use
; ++i
)
754 if (files
[i
].dir
== dir
756 && filename_cmp (file
, files
[i
].filename
) == 0)
759 last_used_dir_len
= dir_len
;
763 if (!assign_file_to_slot (i
, file
, dir
))
767 last_used_dir_len
= dir_len
;
772 /* Run through the list of line entries starting at E, allocating
773 file entries for gas generated debug. */
776 do_allocate_filenum (struct line_entry
*e
)
780 if (e
->loc
.filenum
== -1u)
782 e
->loc
.filenum
= allocate_filenum (e
->loc
.u
.filename
);
783 e
->loc
.u
.view
= NULL
;
790 /* Remove any generated line entries. These don't live comfortably
791 with compiler generated line info. If THELOT then remove
792 everything, freeing all list entries we have created. */
795 purge_generated_debug (bool thelot
)
797 struct line_seg
*s
, *nexts
;
799 for (s
= all_segs
; s
; s
= nexts
)
801 struct line_subseg
*lss
, *nextlss
;
803 for (lss
= s
->head
; lss
; lss
= nextlss
)
805 struct line_entry
*e
, *next
;
807 for (e
= lss
->head
; e
; e
= next
)
810 know (e
->loc
.filenum
== -1u);
816 lss
->ptail
= &lss
->head
;
817 lss
->pmove_tail
= &lss
->head
;
825 seg_info (s
->seg
)->dwarf2_line_seg
= NULL
;
831 /* Allocate slot NUM in the .debug_line file table to FILENAME.
832 If DIRNAME is not NULL or there is a directory component to FILENAME
833 then this will be stored in the directory table, if not already present.
834 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
835 Returns TRUE if allocation succeeded, FALSE otherwise. */
838 allocate_filename_to_slot (const char *dirname
,
839 const char *filename
,
846 const char *file0_dirname
;
848 /* Short circuit the common case of adding the same pathname
850 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
852 const char * dir
= NULL
;
855 dir
= dirs
[files
[num
].dir
];
858 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
863 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
866 if (filename_cmp (filename
, files
[num
].filename
) != 0)
869 /* If the filenames match, but the directory table entry was
870 empty, then fill it with the provided directory name. */
875 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
876 dirs
= XCNEWVEC (char *, dirs_allocated
);
879 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
884 else if (dir
!= NULL
)
886 dirlen
= strlen (dir
);
887 if (filename_ncmp (filename
, dir
, dirlen
) == 0
888 && IS_DIR_SEPARATOR (filename
[dirlen
])
889 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
892 else /* dir == NULL */
894 file
= get_basename (filename
);
895 if (filename_cmp (file
, files
[num
].filename
) == 0)
897 /* The filenames match, but the directory table entry is empty.
898 Fill it with the provided directory name. */
903 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
904 dirs
= XCNEWVEC (char *, dirs_allocated
);
907 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
914 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
916 dir
== NULL
? "" : dir
,
917 dir
== NULL
? "" : "/",
919 dirname
== NULL
? "" : dirname
,
920 dirname
== NULL
? "" : "/",
925 /* For file .0, the directory name is the current directory and the file
926 may be in another directory contained in the file name. */
929 file0_dirname
= dirname
;
931 file
= get_basename (filename
);
933 if (dirname
&& file
== filename
)
934 dirlen
= strlen (dirname
);
938 dirlen
= file
- filename
;
943 file0_dirname
= NULL
;
948 file
= get_basename (filename
);
949 dirlen
= file
- filename
;
953 dirlen
= strlen (dirname
);
958 d
= get_directory_table_entry (dirname
, file0_dirname
, dirlen
, num
== 0);
961 if (! assign_file_to_slot (i
, file
, d
))
966 if (target_big_endian
)
968 /* md5's are stored in litte endian format. */
969 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
970 unsigned int byte
= NUM_MD5_BYTES
;
971 unsigned int bignum_index
= 0;
973 while (bits_remaining
)
975 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
976 valueT bignum_value
= generic_bignum
[bignum_index
];
979 while (bignum_bits_remaining
)
981 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
983 bignum_bits_remaining
-= 8;
990 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
991 unsigned int byte
= 0;
992 unsigned int bignum_index
= 0;
994 while (bits_remaining
)
996 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
997 valueT bignum_value
= generic_bignum
[bignum_index
];
1001 while (bignum_bits_remaining
)
1003 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
1005 bignum_bits_remaining
-= 8;
1006 bits_remaining
-= 8;
1012 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
1017 /* Returns the current source information. If .file directives have
1018 been encountered, the info for the corresponding source file is
1019 returned. Otherwise, the info for the assembly source file is
1023 dwarf2_where (struct dwarf2_line_info
*line
)
1025 if (debug_type
== DEBUG_DWARF2
)
1027 line
->u
.filename
= as_where (&line
->line
);
1028 line
->filenum
= -1u;
1030 line
->flags
= DWARF2_FLAG_IS_STMT
;
1031 line
->isa
= current
.isa
;
1032 line
->discriminator
= current
.discriminator
;
1038 /* A hook to allow the target backend to inform the line number state
1039 machine of isa changes when assembler debug info is enabled. */
1042 dwarf2_set_isa (unsigned int isa
)
1047 /* Called for each machine instruction, or relatively atomic group of
1048 machine instructions (ie built-in macro). The instruction or group
1049 is SIZE bytes in length. If dwarf2 line number generation is called
1050 for, emit a line statement appropriately. */
1053 dwarf2_emit_insn (int size
)
1055 struct dwarf2_line_info loc
;
1057 if (debug_type
!= DEBUG_DWARF2
1058 ? !dwarf2_loc_directive_seen
1059 : !seen_at_least_1_file ())
1062 dwarf2_where (&loc
);
1064 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
1065 dwarf2_consume_line_info ();
1068 /* Move all previously-emitted line entries for the current position by
1069 DELTA bytes. This function cannot be used to move the same entries
1073 dwarf2_move_insn (int delta
)
1075 struct line_subseg
*lss
;
1076 struct line_entry
*e
;
1082 lss
= get_line_subseg (now_seg
, now_subseg
, false);
1086 now
= frag_now_fix ();
1087 while ((e
= *lss
->pmove_tail
))
1089 if (S_GET_VALUE (e
->label
) == now
)
1090 S_SET_VALUE (e
->label
, now
+ delta
);
1091 lss
->pmove_tail
= &e
->next
;
1095 /* Called after the current line information has been either used with
1096 dwarf2_gen_line_info or saved with a machine instruction for later use.
1097 This resets the state of the line number information to reflect that
1098 it has been used. */
1101 dwarf2_consume_line_info (void)
1103 /* Unless we generate DWARF2 debugging information for each
1104 assembler line, we only emit one line symbol for one LOC. */
1105 dwarf2_loc_directive_seen
= false;
1107 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1108 | DWARF2_FLAG_PROLOGUE_END
1109 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1110 current
.discriminator
= 0;
1111 current
.u
.view
= NULL
;
1114 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1115 is enabled, emit a basic block marker. */
1118 dwarf2_emit_label (symbolS
*label
)
1120 struct dwarf2_line_info loc
;
1122 if (!dwarf2_loc_mark_labels
)
1124 if (S_GET_SEGMENT (label
) != now_seg
)
1126 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1128 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1131 dwarf2_where (&loc
);
1133 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1135 dwarf2_gen_line_info_1 (label
, &loc
);
1136 dwarf2_consume_line_info ();
1139 /* Handle two forms of .file directive:
1140 - Pass .file "source.c" to s_file
1141 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1143 If an entry is added to the file table, return a pointer to the filename. */
1146 dwarf2_directive_filename (void)
1148 bool with_md5
= false;
1151 const char * dirname
= NULL
;
1154 /* Continue to accept a bare string and pass it off. */
1156 if (*input_line_pointer
== '"')
1162 num
= get_absolute_expression ();
1164 if ((offsetT
) num
< 1)
1166 if (num
== 0 && dwarf_level
< 5)
1168 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1170 as_bad (_("file number less than one"));
1171 ignore_rest_of_line ();
1176 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1177 "switch back to the already allocated file <N> as the current
1180 filename
= demand_copy_C_string (&filename_len
);
1181 if (filename
== NULL
)
1182 /* demand_copy_C_string will have already generated an error message. */
1185 /* For DWARF-5 support we also accept:
1186 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1187 if (DWARF2_LINE_VERSION
> 4)
1190 if (*input_line_pointer
== '"')
1193 filename
= demand_copy_C_string (&filename_len
);
1197 if (startswith (input_line_pointer
, "md5"))
1199 input_line_pointer
+= 3;
1203 expression_and_evaluate (& exp
);
1204 if (exp
.X_op
!= O_big
)
1205 as_bad (_("md5 value too small or not a constant"));
1211 demand_empty_rest_of_line ();
1213 /* A .file directive implies compiler generated debug information is
1214 being supplied. Turn off gas generated debug info. */
1215 if (debug_type
== DEBUG_DWARF2
)
1216 purge_generated_debug (false);
1217 debug_type
= DEBUG_NONE
;
1219 if (num
!= (unsigned int) num
1220 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1222 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1226 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1233 /* Calls dwarf2_directive_filename, but discards its result.
1234 Used in pseudo-op tables where the function result is ignored. */
1237 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1239 (void) dwarf2_directive_filename ();
1243 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1245 offsetT filenum
, line
;
1247 /* If we see two .loc directives in a row, force the first one to be
1249 if (dwarf2_loc_directive_seen
)
1250 dwarf2_emit_insn (0);
1252 filenum
= get_absolute_expression ();
1254 line
= get_absolute_expression ();
1258 if (filenum
== 0 && dwarf_level
< 5)
1260 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1262 as_bad (_("file number less than one"));
1267 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1269 as_bad (_("unassigned file number %ld"), (long) filenum
);
1273 /* debug_type will be turned off by dwarf2_directive_filename, and
1274 if we don't have a dwarf style .file then files_in_use will be
1275 zero and the above error will trigger. */
1276 gas_assert (debug_type
== DEBUG_NONE
);
1278 current
.filenum
= filenum
;
1279 current
.line
= line
;
1280 current
.discriminator
= 0;
1285 if (files
[filenum
].dir
)
1287 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1288 size_t file_len
= strlen (files
[filenum
].filename
);
1289 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1291 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1292 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1293 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1294 cp
[dir_len
+ file_len
+ 1] = '\0';
1295 listing_source_file (cp
);
1299 listing_source_file (files
[filenum
].filename
);
1300 listing_source_line (line
);
1305 if (ISDIGIT (*input_line_pointer
))
1307 current
.column
= get_absolute_expression ();
1311 while (ISALPHA (*input_line_pointer
))
1316 c
= get_symbol_name (& p
);
1318 if (strcmp (p
, "basic_block") == 0)
1320 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1321 *input_line_pointer
= c
;
1323 else if (strcmp (p
, "prologue_end") == 0)
1325 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1326 *input_line_pointer
= c
;
1328 else if (strcmp (p
, "epilogue_begin") == 0)
1330 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1331 *input_line_pointer
= c
;
1333 else if (strcmp (p
, "is_stmt") == 0)
1335 (void) restore_line_pointer (c
);
1336 value
= get_absolute_expression ();
1338 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1339 else if (value
== 1)
1340 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1343 as_bad (_("is_stmt value not 0 or 1"));
1347 else if (strcmp (p
, "isa") == 0)
1349 (void) restore_line_pointer (c
);
1350 value
= get_absolute_expression ();
1352 current
.isa
= value
;
1355 as_bad (_("isa number less than zero"));
1359 else if (strcmp (p
, "discriminator") == 0)
1361 (void) restore_line_pointer (c
);
1362 value
= get_absolute_expression ();
1364 current
.discriminator
= value
;
1367 as_bad (_("discriminator less than zero"));
1371 else if (strcmp (p
, "view") == 0)
1375 (void) restore_line_pointer (c
);
1378 if (ISDIGIT (*input_line_pointer
)
1379 || *input_line_pointer
== '-')
1381 bool force_reset
= *input_line_pointer
== '-';
1383 value
= get_absolute_expression ();
1386 as_bad (_("numeric view can only be asserted to zero"));
1389 if (force_reset
&& force_reset_view
)
1390 sym
= force_reset_view
;
1393 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1396 force_reset_view
= sym
;
1401 char *name
= read_symbol_name ();
1405 sym
= symbol_find_or_make (name
);
1407 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1409 if (S_IS_VOLATILE (sym
))
1410 sym
= symbol_clone (sym
, 1);
1411 else if (!S_CAN_BE_REDEFINED (sym
))
1413 as_bad (_("symbol `%s' is already defined"),
1418 S_SET_SEGMENT (sym
, undefined_section
);
1419 S_SET_VALUE (sym
, 0);
1420 symbol_set_frag (sym
, &zero_address_frag
);
1422 current
.u
.view
= sym
;
1426 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1427 (void) restore_line_pointer (c
);
1431 SKIP_WHITESPACE_AFTER_NAME ();
1434 demand_empty_rest_of_line ();
1435 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1437 /* If we were given a view id, emit the row right away. */
1439 dwarf2_emit_insn (0);
1443 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1445 offsetT value
= get_absolute_expression ();
1447 if (value
!= 0 && value
!= 1)
1449 as_bad (_("expected 0 or 1"));
1450 ignore_rest_of_line ();
1454 dwarf2_loc_mark_labels
= value
!= 0;
1455 demand_empty_rest_of_line ();
1459 static struct frag
*
1460 first_frag_for_seg (segT seg
)
1462 return seg_info (seg
)->frchainP
->frch_root
;
1465 static struct frag
*
1466 last_frag_for_seg (segT seg
)
1468 frchainS
*f
= seg_info (seg
)->frchainP
;
1470 while (f
->frch_next
!= NULL
)
1473 return f
->frch_last
;
1476 /* Emit a single byte into the current segment. */
1481 FRAG_APPEND_1_CHAR (byte
);
1484 /* Emit a statement program opcode into the current segment. */
1487 out_opcode (int opc
)
1492 /* Emit a two-byte word into the current segment. */
1497 md_number_to_chars (frag_more (2), data
, 2);
1500 /* Emit a four byte word into the current segment. */
1505 md_number_to_chars (frag_more (4), data
, 4);
1508 /* Emit an unsigned "little-endian base 128" number. */
1511 out_uleb128 (addressT value
)
1513 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1516 /* Emit a signed "little-endian base 128" number. */
1519 out_leb128 (addressT value
)
1521 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1524 /* Emit a tuple for .debug_abbrev. */
1527 out_abbrev (int name
, int form
)
1533 /* Get the size of a fragment. */
1536 get_frag_fix (fragS
*frag
, segT seg
)
1541 return frag
->fr_fix
;
1543 /* If a fragment is the last in the chain, special measures must be
1544 taken to find its size before relaxation, since it may be pending
1545 on some subsegment chain. */
1546 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1547 if (fr
->frch_last
== frag
)
1548 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1553 /* Set an absolute address (may result in a relocation entry). */
1556 out_set_addr (symbolS
*sym
)
1560 memset (&exp
, 0, sizeof exp
);
1561 out_opcode (DW_LNS_extended_op
);
1562 out_uleb128 (sizeof_address
+ 1);
1564 out_opcode (DW_LNE_set_address
);
1565 exp
.X_op
= O_symbol
;
1566 exp
.X_add_symbol
= sym
;
1567 exp
.X_add_number
= 0;
1568 emit_expr (&exp
, sizeof_address
);
1571 static void scale_addr_delta (addressT
*);
1574 scale_addr_delta (addressT
*addr_delta
)
1576 static int printed_this
= 0;
1577 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1579 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1581 as_bad("unaligned opcodes detected in executable segment");
1584 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1588 /* Encode a pair of line and address skips as efficiently as possible.
1589 Note that the line skip is signed, whereas the address skip is unsigned.
1591 The following two routines *must* be kept in sync. This is
1592 enforced by making emit_inc_line_addr abort if we do not emit
1593 exactly the expected number of bytes. */
1596 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1598 unsigned int tmp
, opcode
;
1601 /* Scale the address delta by the minimum instruction length. */
1602 scale_addr_delta (&addr_delta
);
1604 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1605 We cannot use special opcodes here, since we want the end_sequence
1606 to emit the matrix entry. */
1607 if (line_delta
== INT_MAX
)
1609 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1611 else if (addr_delta
)
1612 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1616 /* Bias the line delta by the base. */
1617 tmp
= line_delta
- DWARF2_LINE_BASE
;
1619 /* If the line increment is out of range of a special opcode, we
1620 must encode it with DW_LNS_advance_line. */
1621 if (tmp
>= DWARF2_LINE_RANGE
)
1623 len
= 1 + sizeof_leb128 (line_delta
, 1);
1625 tmp
= 0 - DWARF2_LINE_BASE
;
1628 /* Bias the opcode by the special opcode base. */
1629 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1631 /* Avoid overflow when addr_delta is large. */
1632 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1634 /* Try using a special opcode. */
1635 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1639 /* Try using DW_LNS_const_add_pc followed by special op. */
1640 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1645 /* Otherwise use DW_LNS_advance_pc. */
1646 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1648 /* DW_LNS_copy or special opcode. */
1655 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1657 unsigned int tmp
, opcode
;
1659 char *end
= p
+ len
;
1661 /* Line number sequences cannot go backward in addresses. This means
1662 we've incorrectly ordered the statements in the sequence. */
1663 gas_assert ((offsetT
) addr_delta
>= 0);
1665 /* Scale the address delta by the minimum instruction length. */
1666 scale_addr_delta (&addr_delta
);
1668 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1669 We cannot use special opcodes here, since we want the end_sequence
1670 to emit the matrix entry. */
1671 if (line_delta
== INT_MAX
)
1673 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1674 *p
++ = DW_LNS_const_add_pc
;
1675 else if (addr_delta
)
1677 *p
++ = DW_LNS_advance_pc
;
1678 p
+= output_leb128 (p
, addr_delta
, 0);
1681 *p
++ = DW_LNS_extended_op
;
1683 *p
++ = DW_LNE_end_sequence
;
1687 /* Bias the line delta by the base. */
1688 tmp
= line_delta
- DWARF2_LINE_BASE
;
1690 /* If the line increment is out of range of a special opcode, we
1691 must encode it with DW_LNS_advance_line. */
1692 if (tmp
>= DWARF2_LINE_RANGE
)
1694 *p
++ = DW_LNS_advance_line
;
1695 p
+= output_leb128 (p
, line_delta
, 1);
1698 tmp
= 0 - DWARF2_LINE_BASE
;
1702 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1704 if (line_delta
== 0 && addr_delta
== 0)
1710 /* Bias the opcode by the special opcode base. */
1711 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1713 /* Avoid overflow when addr_delta is large. */
1714 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1716 /* Try using a special opcode. */
1717 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1724 /* Try using DW_LNS_const_add_pc followed by special op. */
1725 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1728 *p
++ = DW_LNS_const_add_pc
;
1734 /* Otherwise use DW_LNS_advance_pc. */
1735 *p
++ = DW_LNS_advance_pc
;
1736 p
+= output_leb128 (p
, addr_delta
, 0);
1744 gas_assert (p
== end
);
1747 /* Handy routine to combine calls to the above two routines. */
1750 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1752 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1753 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1756 /* Write out an alternative form of line and address skips using
1757 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1758 line and address information, but it is required if linker relaxation
1759 could change the code offsets. The following two routines *must* be
1761 #define ADDR_DELTA_LIMIT 50000
1764 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1768 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1769 if (line_delta
!= INT_MAX
)
1770 len
= 1 + sizeof_leb128 (line_delta
, 1);
1772 if (addr_delta
> ADDR_DELTA_LIMIT
)
1774 /* DW_LNS_extended_op */
1775 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1776 /* DW_LNE_set_address */
1777 len
+= 1 + sizeof_address
;
1780 /* DW_LNS_fixed_advance_pc */
1783 if (line_delta
== INT_MAX
)
1784 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1794 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1798 char *end
= p
+ len
;
1800 /* Line number sequences cannot go backward in addresses. This means
1801 we've incorrectly ordered the statements in the sequence. */
1802 gas_assert ((offsetT
) addr_delta
>= 0);
1804 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1805 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1807 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1808 if (line_delta
!= INT_MAX
)
1810 *p
++ = DW_LNS_advance_line
;
1811 p
+= output_leb128 (p
, line_delta
, 1);
1814 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1816 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1817 advance the address by at most 64K. Linker relaxation (without
1818 which this function would not be used) could change the operand by
1819 an unknown amount. If the address increment is getting close to
1820 the limit, just reset the address. */
1821 if (addr_delta
> ADDR_DELTA_LIMIT
)
1826 memset (&exp
, 0, sizeof exp
);
1827 gas_assert (pexp
->X_op
== O_subtract
);
1828 to_sym
= pexp
->X_add_symbol
;
1830 *p
++ = DW_LNS_extended_op
;
1831 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1832 *p
++ = DW_LNE_set_address
;
1833 exp
.X_op
= O_symbol
;
1834 exp
.X_add_symbol
= to_sym
;
1835 exp
.X_add_number
= 0;
1836 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1837 p
+= sizeof_address
;
1841 *p
++ = DW_LNS_fixed_advance_pc
;
1842 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1846 if (line_delta
== INT_MAX
)
1848 *p
++ = DW_LNS_extended_op
;
1850 *p
++ = DW_LNE_end_sequence
;
1855 gas_assert (p
== end
);
1858 /* Generate a variant frag that we can use to relax address/line
1859 increments between fragments of the target segment. */
1862 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1867 memset (&exp
, 0, sizeof exp
);
1868 exp
.X_op
= O_subtract
;
1869 exp
.X_add_symbol
= to_sym
;
1870 exp
.X_op_symbol
= from_sym
;
1871 exp
.X_add_number
= 0;
1873 /* The maximum size of the frag is the line delta with a maximum
1874 sized address delta. */
1875 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1876 max_chars
= size_fixed_inc_line_addr (line_delta
,
1877 -DWARF2_LINE_MIN_INSN_LENGTH
);
1879 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1881 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1882 make_expr_symbol (&exp
), line_delta
, NULL
);
1885 /* The function estimates the size of a rs_dwarf2dbg variant frag
1886 based on the current values of the symbols. It is called before
1887 the relaxation loop. We set fr_subtype to the expected length. */
1890 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1895 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1896 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1897 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1899 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1901 frag
->fr_subtype
= size
;
1906 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1907 current values of the symbols. fr_subtype is the current length
1908 of the frag. This returns the change in frag length. */
1911 dwarf2dbg_relax_frag (fragS
*frag
)
1913 int old_size
, new_size
;
1915 old_size
= frag
->fr_subtype
;
1916 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1918 return new_size
- old_size
;
1921 /* This function converts a rs_dwarf2dbg variant frag into a normal
1922 fill frag. This is called after all relaxation has been done.
1923 fr_subtype will be the desired length of the frag. */
1926 dwarf2dbg_convert_frag (fragS
*frag
)
1930 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1932 /* If linker relaxation is enabled then the distance between the two
1933 symbols in the frag->fr_symbol expression might change. Hence we
1934 cannot rely upon the value computed by resolve_symbol_value.
1935 Instead we leave the expression unfinalized and allow
1936 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1937 relocation) that will allow the linker to correctly compute the
1938 actual address difference. We have to use a fixed line advance for
1939 this as we cannot (easily) relocate leb128 encoded values. */
1940 int saved_finalize_syms
= finalize_syms
;
1943 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1944 finalize_syms
= saved_finalize_syms
;
1947 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1949 /* fr_var carries the max_chars that we created the fragment with.
1950 fr_subtype carries the current expected length. We must, of
1951 course, have allocated enough memory earlier. */
1952 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1954 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1955 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1956 frag
->fr_literal
+ frag
->fr_fix
,
1959 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1960 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1962 frag
->fr_fix
+= frag
->fr_subtype
;
1963 frag
->fr_type
= rs_fill
;
1965 frag
->fr_offset
= 0;
1968 /* Generate .debug_line content for the chain of line number entries
1969 beginning at E, for segment SEG. */
1972 process_entries (segT seg
, struct line_entry
*e
)
1974 unsigned filenum
= 1;
1976 unsigned column
= 0;
1978 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1979 fragS
*last_frag
= NULL
, *frag
;
1980 addressT last_frag_ofs
= 0, frag_ofs
;
1981 symbolS
*last_lab
= NULL
, *lab
;
1983 if (flag_dwarf_sections
)
1986 const char * sec_name
;
1988 /* Switch to the relevant sub-section before we start to emit
1989 the line number table.
1991 FIXME: These sub-sections do not have a normal Line Number
1992 Program Header, thus strictly speaking they are not valid
1993 DWARF sections. Unfortunately the DWARF standard assumes
1994 a one-to-one relationship between compilation units and
1995 line number tables. Thus we have to have a .debug_line
1996 section, as well as our sub-sections, and we have to ensure
1997 that all of the sub-sections are merged into a proper
1998 .debug_line section before a debugger sees them. */
2000 sec_name
= bfd_section_name (seg
);
2001 if (strcmp (sec_name
, ".text") != 0)
2003 name
= concat (".debug_line", sec_name
, (char *) NULL
);
2004 subseg_set (subseg_get (name
, false), 0);
2007 /* Don't create a .debug_line.text section -
2008 that is redundant. Instead just switch back to the
2009 normal .debug_line section. */
2010 subseg_set (subseg_get (".debug_line", false), 0);
2017 if (filenum
!= e
->loc
.filenum
)
2019 filenum
= e
->loc
.filenum
;
2020 out_opcode (DW_LNS_set_file
);
2021 out_uleb128 (filenum
);
2024 if (column
!= e
->loc
.column
)
2026 column
= e
->loc
.column
;
2027 out_opcode (DW_LNS_set_column
);
2028 out_uleb128 (column
);
2031 if (e
->loc
.discriminator
!= 0)
2033 out_opcode (DW_LNS_extended_op
);
2034 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
2035 out_opcode (DW_LNE_set_discriminator
);
2036 out_uleb128 (e
->loc
.discriminator
);
2039 if (isa
!= e
->loc
.isa
)
2042 out_opcode (DW_LNS_set_isa
);
2046 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
2048 flags
= e
->loc
.flags
;
2049 out_opcode (DW_LNS_negate_stmt
);
2052 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
2053 out_opcode (DW_LNS_set_basic_block
);
2055 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
2056 out_opcode (DW_LNS_set_prologue_end
);
2058 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
2059 out_opcode (DW_LNS_set_epilogue_begin
);
2061 /* Don't try to optimize away redundant entries; gdb wants two
2062 entries for a function where the code starts on the same line as
2063 the {, and there's no way to identify that case here. Trust gcc
2064 to optimize appropriately. */
2065 line_delta
= e
->loc
.line
- line
;
2067 frag
= symbol_get_frag (lab
);
2068 frag_ofs
= S_GET_VALUE (lab
);
2070 if (last_frag
== NULL
2071 || (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
2072 /* If we're going to reset the view, but we know we're
2073 advancing the PC, we don't have to force with
2074 set_address. We know we do when we're at the same
2075 address of the same frag, and we know we might when
2076 we're in the beginning of a frag, and we were at the
2077 end of the previous frag. */
2078 && (frag
== last_frag
2079 ? (last_frag_ofs
== frag_ofs
)
2081 && ((offsetT
)last_frag_ofs
2082 >= get_frag_fix (last_frag
, seg
))))))
2085 out_inc_line_addr (line_delta
, 0);
2087 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2088 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2090 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2095 last_frag_ofs
= frag_ofs
;
2101 /* Emit a DW_LNE_end_sequence for the end of the section. */
2102 frag
= last_frag_for_seg (seg
);
2103 frag_ofs
= get_frag_fix (frag
, seg
);
2104 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2105 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2108 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2109 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2113 /* Switch to LINE_STR_SEG and output the given STR. Return the
2114 symbol pointing to the new string in the section. */
2117 add_line_strp (segT line_str_seg
, const char *str
)
2123 subseg_set (line_str_seg
, 0);
2125 sym
= symbol_temp_new_now_octets ();
2127 size
= strlen (str
) + 1;
2128 cp
= frag_more (size
);
2129 memcpy (cp
, str
, size
);
2135 /* Emit the directory and file tables for .debug_line. */
2138 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2144 bool emit_md5
= false;
2145 bool emit_timestamps
= true;
2146 bool emit_filesize
= true;
2147 segT line_str_seg
= NULL
;
2148 symbolS
*line_strp
, *file0_strp
= NULL
;
2150 /* Output the Directory Table. */
2151 if (DWARF2_LINE_VERSION
>= 5)
2153 /* We only have one column in the directory table. */
2156 /* Describe the purpose and format of the column. */
2157 out_uleb128 (DW_LNCT_path
);
2158 /* Store these strings in the .debug_line_str section so they
2160 out_uleb128 (DW_FORM_line_strp
);
2162 /* Now state how many rows there are in the table. We need at
2163 least 1 if there is one or more file names to store the
2164 "working directory". */
2165 if (dirs_in_use
== 0 && files_in_use
> 0)
2168 out_uleb128 (dirs_in_use
);
2171 /* Emit directory list. */
2172 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2174 line_str_seg
= subseg_new (".debug_line_str", 0);
2175 bfd_set_section_flags (line_str_seg
,
2176 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2177 | SEC_MERGE
| SEC_STRINGS
);
2178 line_str_seg
->entsize
= 1;
2180 /* DWARF5 uses slot zero, but that is only set explicitly
2181 using a .file 0 directive. Otherwise use pwd as main file
2183 if (dirs_in_use
> 0 && dirs
[0] != NULL
)
2184 dir
= remap_debug_filename (dirs
[0]);
2186 dir
= remap_debug_filename (getpwd ());
2188 line_strp
= add_line_strp (line_str_seg
, dir
);
2190 subseg_set (line_seg
, 0);
2191 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2193 for (i
= 1; i
< dirs_in_use
; ++i
)
2195 dir
= remap_debug_filename (dirs
[i
]);
2196 if (DWARF2_LINE_VERSION
< 5)
2198 size
= strlen (dir
) + 1;
2199 cp
= frag_more (size
);
2200 memcpy (cp
, dir
, size
);
2204 line_strp
= add_line_strp (line_str_seg
, dir
);
2205 subseg_set (line_seg
, 0);
2206 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2211 if (DWARF2_LINE_VERSION
< 5)
2215 /* Output the File Name Table. */
2216 if (DWARF2_LINE_VERSION
>= 5)
2218 unsigned int columns
= 4;
2220 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2222 emit_timestamps
= false;
2226 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2228 emit_filesize
= false;
2232 for (i
= 0; i
< files_in_use
; ++i
)
2233 if (files
[i
].md5
[0] != 0)
2235 if (i
< files_in_use
)
2241 /* The number of format entries to follow. */
2243 /* The format of the file name. */
2244 out_uleb128 (DW_LNCT_path
);
2245 /* Store these strings in the .debug_line_str section so they
2247 out_uleb128 (DW_FORM_line_strp
);
2249 /* The format of the directory index. */
2250 out_uleb128 (DW_LNCT_directory_index
);
2251 out_uleb128 (DW_FORM_udata
);
2253 if (emit_timestamps
)
2255 /* The format of the timestamp. */
2256 out_uleb128 (DW_LNCT_timestamp
);
2257 out_uleb128 (DW_FORM_udata
);
2262 /* The format of the file size. */
2263 out_uleb128 (DW_LNCT_size
);
2264 out_uleb128 (DW_FORM_udata
);
2269 /* The format of the MD5 sum. */
2270 out_uleb128 (DW_LNCT_MD5
);
2271 out_uleb128 (DW_FORM_data16
);
2274 /* The number of entries in the table. */
2275 out_uleb128 (files_in_use
);
2278 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2280 const char *fullfilename
;
2282 if (files
[i
].filename
== NULL
)
2284 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2286 as_bad (_("unassigned file number %ld"), (long) i
);
2289 /* DWARF5 uses slot zero, but that is only set explicitly using
2290 a .file 0 directive. If that isn't used, but file 1 is, then
2291 use that as main file name. */
2292 if (files_in_use
> 1 && files
[1].filename
!= NULL
)
2294 files
[0].filename
= files
[1].filename
;
2295 files
[0].dir
= files
[1].dir
;
2297 for (j
= 0; j
< NUM_MD5_BYTES
; ++j
)
2298 files
[0].md5
[j
] = files
[1].md5
[j
];
2301 files
[0].filename
= "";
2304 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2305 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2306 if (DWARF2_LINE_VERSION
< 5)
2308 size
= strlen (fullfilename
) + 1;
2309 cp
= frag_more (size
);
2310 memcpy (cp
, fullfilename
, size
);
2315 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2317 line_strp
= file0_strp
;
2318 subseg_set (line_seg
, 0);
2319 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2320 if (i
== 0 && files_in_use
> 1
2321 && files
[0].filename
== files
[1].filename
)
2322 file0_strp
= line_strp
;
2327 /* Directory number. */
2328 out_uleb128 (files
[i
].dir
);
2330 /* Output the last modification timestamp. */
2331 if (emit_timestamps
)
2335 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2336 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2337 if (timestamp
== -1)
2339 out_uleb128 (timestamp
);
2342 /* Output the filesize. */
2346 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2347 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2350 out_uleb128 (filesize
);
2353 /* Output the md5 sum. */
2358 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2359 out_byte (files
[i
].md5
[b
]);
2363 if (DWARF2_LINE_VERSION
< 5)
2364 /* Terminate filename list. */
2368 /* Switch to SEC and output a header length field. Return the size of
2369 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2370 to the end of the section. EXPR->X_add_number will be set to the
2371 negative size of the header. */
2374 out_header (asection
*sec
, expressionS
*exp
)
2379 subseg_set (sec
, 0);
2381 if (flag_dwarf_sections
)
2383 /* If we are going to put the start and end symbols in different
2384 sections, then we need real symbols, not just fake, local ones. */
2386 start_sym
= symbol_make (".Ldebug_line_start");
2387 end_sym
= symbol_make (".Ldebug_line_end");
2388 symbol_set_value_now (start_sym
);
2392 start_sym
= symbol_temp_new_now_octets ();
2393 end_sym
= symbol_temp_make ();
2396 /* Total length of the information. */
2397 exp
->X_op
= O_subtract
;
2398 exp
->X_add_symbol
= end_sym
;
2399 exp
->X_op_symbol
= start_sym
;
2401 switch (DWARF2_FORMAT (sec
))
2403 case dwarf2_format_32bit
:
2404 exp
->X_add_number
= -4;
2408 case dwarf2_format_64bit
:
2409 exp
->X_add_number
= -12;
2414 case dwarf2_format_64bit_irix
:
2415 exp
->X_add_number
= -8;
2420 as_fatal (_("internal error: unknown dwarf2 format"));
2424 /* Emit the collected .debug_line data. */
2427 out_debug_line (segT line_seg
)
2430 symbolS
*prologue_start
, *prologue_end
;
2435 memset (&exp
, 0, sizeof exp
);
2436 sizeof_offset
= out_header (line_seg
, &exp
);
2437 line_end
= exp
.X_add_symbol
;
2440 out_two (DWARF2_LINE_VERSION
);
2442 if (DWARF2_LINE_VERSION
>= 5)
2444 out_byte (sizeof_address
);
2445 out_byte (0); /* Segment Selector size. */
2447 /* Length of the prologue following this length. */
2448 prologue_start
= symbol_temp_make ();
2449 prologue_end
= symbol_temp_make ();
2450 exp
.X_op
= O_subtract
;
2451 exp
.X_add_symbol
= prologue_end
;
2452 exp
.X_op_symbol
= prologue_start
;
2453 exp
.X_add_number
= 0;
2454 emit_expr (&exp
, sizeof_offset
);
2455 symbol_set_value_now (prologue_start
);
2457 /* Parameters of the state machine. */
2458 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2459 if (DWARF2_LINE_VERSION
>= 4)
2460 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2461 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2462 out_byte (DWARF2_LINE_BASE
);
2463 out_byte (DWARF2_LINE_RANGE
);
2464 out_byte (DWARF2_LINE_OPCODE_BASE
);
2466 /* Standard opcode lengths. */
2467 out_byte (0); /* DW_LNS_copy */
2468 out_byte (1); /* DW_LNS_advance_pc */
2469 out_byte (1); /* DW_LNS_advance_line */
2470 out_byte (1); /* DW_LNS_set_file */
2471 out_byte (1); /* DW_LNS_set_column */
2472 out_byte (0); /* DW_LNS_negate_stmt */
2473 out_byte (0); /* DW_LNS_set_basic_block */
2474 out_byte (0); /* DW_LNS_const_add_pc */
2475 out_byte (1); /* DW_LNS_fixed_advance_pc */
2476 out_byte (0); /* DW_LNS_set_prologue_end */
2477 out_byte (0); /* DW_LNS_set_epilogue_begin */
2478 out_byte (1); /* DW_LNS_set_isa */
2479 /* We have emitted 12 opcode lengths, so make that this
2480 matches up to the opcode base value we have been using. */
2481 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2483 out_dir_and_file_list (line_seg
, sizeof_offset
);
2485 symbol_set_value_now (prologue_end
);
2487 /* For each section, emit a statement program. */
2488 for (s
= all_segs
; s
; s
= s
->next
)
2489 /* Paranoia - this check should have already have
2490 been handled in dwarf2_gen_line_info_1(). */
2491 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2492 process_entries (s
->seg
, s
->head
->head
);
2494 if (flag_dwarf_sections
)
2495 /* We have to switch to the special .debug_line_end section
2496 before emitting the end-of-debug_line symbol. The linker
2497 script arranges for this section to be placed after all the
2498 (potentially garbage collected) .debug_line.<foo> sections.
2499 This section contains the line_end symbol which is used to
2500 compute the size of the linked .debug_line section, as seen
2501 in the DWARF Line Number header. */
2502 subseg_set (subseg_get (".debug_line_end", false), 0);
2504 symbol_set_value_now (line_end
);
2508 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2510 unsigned int addr_size
= sizeof_address
;
2515 memset (&exp
, 0, sizeof exp
);
2516 subseg_set (ranges_seg
, 0);
2518 /* For DW_AT_ranges to point at (there is no header, so really start
2519 of section, but see out_debug_rnglists). */
2520 *ranges_sym
= symbol_temp_new_now_octets ();
2522 /* Base Address Entry. */
2523 for (i
= 0; i
< addr_size
; i
++)
2525 for (i
= 0; i
< addr_size
; i
++)
2528 /* Range List Entry. */
2529 for (s
= all_segs
; s
; s
= s
->next
)
2534 frag
= first_frag_for_seg (s
->seg
);
2535 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2536 s
->text_start
= beg
;
2538 frag
= last_frag_for_seg (s
->seg
);
2539 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2542 exp
.X_op
= O_symbol
;
2543 exp
.X_add_symbol
= beg
;
2544 exp
.X_add_number
= 0;
2545 emit_expr (&exp
, addr_size
);
2547 exp
.X_op
= O_symbol
;
2548 exp
.X_add_symbol
= end
;
2549 exp
.X_add_number
= 0;
2550 emit_expr (&exp
, addr_size
);
2553 /* End of Range Entry. */
2554 for (i
= 0; i
< addr_size
; i
++)
2556 for (i
= 0; i
< addr_size
; i
++)
2561 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2564 symbolS
*ranges_end
;
2568 memset (&exp
, 0, sizeof exp
);
2569 out_header (ranges_seg
, &exp
);
2570 ranges_end
= exp
.X_add_symbol
;
2572 out_two (DWARF2_RNGLISTS_VERSION
);
2573 out_byte (sizeof_address
);
2574 out_byte (0); /* Segment Selector size. */
2575 out_four (0); /* Offset entry count. */
2577 /* For DW_AT_ranges to point at (must be after the header). */
2578 *ranges_sym
= symbol_temp_new_now_octets ();
2580 for (s
= all_segs
; s
; s
= s
->next
)
2585 out_byte (DW_RLE_start_length
);
2587 frag
= first_frag_for_seg (s
->seg
);
2588 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2589 s
->text_start
= beg
;
2591 frag
= last_frag_for_seg (s
->seg
);
2592 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2595 exp
.X_op
= O_symbol
;
2596 exp
.X_add_symbol
= beg
;
2597 exp
.X_add_number
= 0;
2598 emit_expr (&exp
, sizeof_address
);
2600 exp
.X_op
= O_symbol
;
2601 exp
.X_add_symbol
= end
;
2602 exp
.X_add_number
= 0;
2603 emit_leb128_expr (&exp
, 0);
2606 out_byte (DW_RLE_end_of_list
);
2608 symbol_set_value_now (ranges_end
);
2611 /* Emit data for .debug_aranges. */
2614 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2616 unsigned int addr_size
= sizeof_address
;
2620 symbolS
*aranges_end
;
2624 memset (&exp
, 0, sizeof exp
);
2625 sizeof_offset
= out_header (aranges_seg
, &exp
);
2626 aranges_end
= exp
.X_add_symbol
;
2627 size
= -exp
.X_add_number
;
2630 out_two (DWARF2_ARANGES_VERSION
);
2633 /* Offset to .debug_info. */
2634 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2635 size
+= sizeof_offset
;
2637 /* Size of an address (offset portion). */
2638 out_byte (addr_size
);
2641 /* Size of a segment descriptor. */
2645 /* Align the header. */
2646 while ((size
++ % (2 * addr_size
)) > 0)
2649 for (s
= all_segs
; s
; s
= s
->next
)
2654 frag
= first_frag_for_seg (s
->seg
);
2655 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2656 s
->text_start
= beg
;
2658 frag
= last_frag_for_seg (s
->seg
);
2659 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2662 exp
.X_op
= O_symbol
;
2663 exp
.X_add_symbol
= beg
;
2664 exp
.X_add_number
= 0;
2665 emit_expr (&exp
, addr_size
);
2667 exp
.X_op
= O_subtract
;
2668 exp
.X_add_symbol
= end
;
2669 exp
.X_op_symbol
= beg
;
2670 exp
.X_add_number
= 0;
2671 emit_expr (&exp
, addr_size
);
2674 p
= frag_more (2 * addr_size
);
2675 md_number_to_chars (p
, 0, addr_size
);
2676 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2678 symbol_set_value_now (aranges_end
);
2681 /* Emit data for .debug_abbrev. Note that this must be kept in
2682 sync with out_debug_info below. */
2685 out_debug_abbrev (segT abbrev_seg
,
2686 segT info_seg ATTRIBUTE_UNUSED
,
2687 segT line_seg ATTRIBUTE_UNUSED
,
2688 unsigned char *func_formP
)
2691 bool have_efunc
= false, have_lfunc
= false;
2693 /* Check the symbol table for function symbols which also have their size
2699 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2701 /* A warning construct is a warning symbol followed by the
2702 symbol warned about. Skip this and the following symbol. */
2703 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2705 symp
= symbol_next (symp
);
2711 if (!S_IS_DEFINED (symp
) || !S_IS_FUNCTION (symp
))
2714 #if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
2715 if (S_GET_SIZE (symp
) == 0)
2717 if (!IS_ELF
|| symbol_get_obj (symp
)->size
== NULL
)
2724 if (S_IS_EXTERNAL (symp
))
2731 subseg_set (abbrev_seg
, 0);
2734 out_uleb128 (DW_TAG_compile_unit
);
2735 out_byte (have_efunc
|| have_lfunc
? DW_CHILDREN_yes
: DW_CHILDREN_no
);
2736 if (DWARF2_VERSION
< 4)
2738 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2739 secoff_form
= DW_FORM_data4
;
2741 secoff_form
= DW_FORM_data8
;
2744 secoff_form
= DW_FORM_sec_offset
;
2745 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2746 if (all_segs
->next
== NULL
)
2748 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2749 if (DWARF2_VERSION
< 4)
2750 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2752 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2755 out_abbrev (DW_AT_ranges
, secoff_form
);
2756 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2757 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2758 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2759 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2762 if (have_efunc
|| have_lfunc
)
2765 out_uleb128 (DW_TAG_subprogram
);
2766 out_byte (DW_CHILDREN_no
);
2767 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2770 if (have_lfunc
|| DWARF2_VERSION
< 4)
2771 *func_formP
= DW_FORM_flag
;
2773 *func_formP
= DW_FORM_flag_present
;
2774 out_abbrev (DW_AT_external
, *func_formP
);
2777 /* Any non-zero value other than DW_FORM_flag will do. */
2778 *func_formP
= DW_FORM_block
;
2779 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2780 out_abbrev (DW_AT_high_pc
,
2781 DWARF2_VERSION
< 4 ? DW_FORM_addr
: DW_FORM_udata
);
2785 /* Terminate the abbreviations for this compilation unit. */
2789 /* Emit a description of this compilation unit for .debug_info. */
2792 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT str_seg
,
2793 symbolS
*ranges_sym
, symbolS
*name_sym
,
2794 symbolS
*comp_dir_sym
, symbolS
*producer_sym
,
2795 unsigned char func_form
)
2801 memset (&exp
, 0, sizeof exp
);
2802 sizeof_offset
= out_header (info_seg
, &exp
);
2803 info_end
= exp
.X_add_symbol
;
2805 /* DWARF version. */
2806 out_two (DWARF2_VERSION
);
2808 if (DWARF2_VERSION
< 5)
2810 /* .debug_abbrev offset */
2811 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2815 /* unit (header) type */
2816 out_byte (DW_UT_compile
);
2819 /* Target address size. */
2820 out_byte (sizeof_address
);
2822 if (DWARF2_VERSION
>= 5)
2824 /* .debug_abbrev offset */
2825 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2828 /* DW_TAG_compile_unit DIE abbrev */
2831 /* DW_AT_stmt_list */
2832 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2833 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2836 /* These two attributes are emitted if all of the code is contiguous. */
2837 if (all_segs
->next
== NULL
)
2840 exp
.X_op
= O_symbol
;
2841 exp
.X_add_symbol
= all_segs
->text_start
;
2842 exp
.X_add_number
= 0;
2843 emit_expr (&exp
, sizeof_address
);
2846 if (DWARF2_VERSION
< 4)
2847 exp
.X_op
= O_symbol
;
2850 exp
.X_op
= O_subtract
;
2851 exp
.X_op_symbol
= all_segs
->text_start
;
2853 exp
.X_add_symbol
= all_segs
->text_end
;
2854 exp
.X_add_number
= 0;
2855 if (DWARF2_VERSION
< 4)
2856 emit_expr (&exp
, sizeof_address
);
2858 emit_leb128_expr (&exp
, 0);
2862 /* This attribute is emitted if the code is disjoint. */
2864 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2867 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2868 setup in out_debug_str below. */
2869 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2870 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2871 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2873 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2874 dwarf2 draft has no standard code for assembler. */
2875 out_two (DW_LANG_Mips_Assembler
);
2881 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2886 /* Skip warning constructs (see above). */
2887 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2889 symp
= symbol_next (symp
);
2895 if (!S_IS_DEFINED (symp
) || !S_IS_FUNCTION (symp
))
2898 subseg_set (str_seg
, 0);
2899 name_sym
= symbol_temp_new_now_octets ();
2900 name
= S_GET_NAME (symp
);
2901 len
= strlen (name
) + 1;
2902 memcpy (frag_more (len
), name
, len
);
2904 subseg_set (info_seg
, 0);
2906 /* DW_TAG_subprogram DIE abbrev */
2910 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2912 /* DW_AT_external. */
2913 if (func_form
== DW_FORM_flag
)
2914 out_byte (S_IS_EXTERNAL (symp
));
2917 exp
.X_op
= O_symbol
;
2918 exp
.X_add_symbol
= symp
;
2919 exp
.X_add_number
= 0;
2920 emit_expr (&exp
, sizeof_address
);
2923 exp
.X_op
= O_constant
;
2924 #if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
2925 exp
.X_add_number
= S_GET_SIZE (symp
);
2926 if (exp
.X_add_number
== 0 && IS_ELF
2927 && symbol_get_obj (symp
)->size
!= NULL
)
2930 exp
.X_op_symbol
= make_expr_symbol (symbol_get_obj (symp
)->size
);
2933 exp
.X_add_number
= 0;
2935 if (DWARF2_VERSION
< 4)
2937 if (exp
.X_op
== O_constant
)
2938 exp
.X_op
= O_symbol
;
2939 exp
.X_add_symbol
= symp
;
2940 emit_expr (&exp
, sizeof_address
);
2942 else if (exp
.X_op
== O_constant
)
2943 out_uleb128 (exp
.X_add_number
);
2945 emit_leb128_expr (symbol_get_value_expression (exp
.X_op_symbol
), 0);
2948 /* End of children. */
2952 symbol_set_value_now (info_end
);
2955 /* Emit the three debug strings needed in .debug_str and setup symbols
2956 to them for use in out_debug_info. */
2958 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2959 symbolS
**producer_sym
)
2964 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2966 subseg_set (str_seg
, 0);
2968 /* DW_AT_name. We don't have the actual file name that was present
2969 on the command line, so assume files[first_file] is the main input file.
2970 We're not supposed to get called unless at least one line number
2971 entry was emitted, so this should always be defined. */
2972 *name_sym
= symbol_temp_new_now_octets ();
2973 if (files_in_use
== 0)
2975 if (files
[first_file
].dir
)
2977 char *dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2978 len
= strlen (dirname
);
2980 /* Already has trailing slash. */
2981 p
= frag_more (len
);
2982 memcpy (p
, dirname
, len
);
2984 p
= frag_more (len
+ 1);
2985 memcpy (p
, dirname
, len
);
2986 INSERT_DIR_SEPARATOR (p
, len
);
2990 len
= strlen (files
[first_file
].filename
) + 1;
2991 p
= frag_more (len
);
2992 memcpy (p
, files
[first_file
].filename
, len
);
2994 /* DW_AT_comp_dir */
2995 *comp_dir_sym
= symbol_temp_new_now_octets ();
2996 char *comp_dir
= remap_debug_filename (getpwd ());
2997 len
= strlen (comp_dir
) + 1;
2998 p
= frag_more (len
);
2999 memcpy (p
, comp_dir
, len
);
3002 /* DW_AT_producer */
3003 *producer_sym
= symbol_temp_new_now_octets ();
3004 sprintf (producer
, "GNU AS %s", VERSION
);
3005 len
= strlen (producer
) + 1;
3006 p
= frag_more (len
);
3007 memcpy (p
, producer
, len
);
3014 last_seg_ptr
= &all_segs
;
3017 files_allocated
= 0;
3021 dwarf2_loc_directive_seen
= false;
3022 dwarf2_any_loc_directive_seen
= false;
3023 dwarf2_loc_mark_labels
= false;
3024 current
.filenum
= 1;
3028 current
.flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
3029 current
.discriminator
= 0;
3030 current
.u
.view
= NULL
;
3031 force_reset_view
= NULL
;
3032 view_assert_failed
= NULL
;
3034 /* Select the default CIE version to produce here. The global
3035 starts with a value of -1 and will be modified to a valid value
3036 either by the user providing a command line option, or some
3037 targets will select their own default in md_after_parse_args. If
3038 we get here and the global still contains -1 then it is up to us
3039 to pick a sane default. The default we choose is 1, this is the
3040 CIE version gas has produced for a long time, and there seems no
3041 reason to change it yet. */
3042 if (flag_dwarf_cie_version
== -1)
3043 flag_dwarf_cie_version
= 1;
3047 dwarf2_cleanup (void)
3049 purge_generated_debug (true);
3054 /* Finish the dwarf2 debug sections. We emit .debug.line if there
3055 were any .file/.loc directives, or --gdwarf2 was given, and if the
3056 file has a non-empty .debug_info section and an empty .debug_line
3057 section. If we emit .debug_line, and the .debug_info section is
3058 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
3059 ALL_SEGS will be non-null if there were any .file/.loc directives,
3060 or --gdwarf2 was given and there were any located instructions
3064 dwarf2_finish (void)
3069 int emit_other_sections
= 0;
3070 int empty_debug_line
= 0;
3072 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
3073 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
3075 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
3076 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
3078 /* We can't construct a new debug_line section if we already have one.
3079 Give an error if we have seen any .loc, otherwise trust the user
3080 knows what they are doing and want to generate the .debug_line
3081 (and all other debug sections) themselves. */
3082 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
3083 as_fatal ("duplicate .debug_line sections");
3085 if ((!all_segs
&& emit_other_sections
)
3086 || (!emit_other_sections
&& !empty_debug_line
))
3087 /* If there is no line information and no non-empty .debug_info
3088 section, or if there is both a non-empty .debug_info and a non-empty
3089 .debug_line, then we do nothing. */
3095 /* Calculate the size of an address for the target machine. */
3096 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
3098 /* Create and switch to the line number section. */
3099 if (empty_debug_line
)
3101 line_seg
= subseg_new (".debug_line", 0);
3102 bfd_set_section_flags (line_seg
,
3103 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3106 for (s
= all_segs
; s
; s
= s
->next
)
3108 struct line_subseg
*lss
;
3110 for (lss
= s
->head
; lss
; lss
= lss
->next
)
3112 do_allocate_filenum (lss
->head
);
3115 /* For each subsection, chain the debug entries together. */
3116 for (s
= all_segs
; s
; s
= s
->next
)
3118 struct line_subseg
*lss
= s
->head
;
3119 struct line_entry
**ptail
= lss
->ptail
;
3121 /* Reset the initial view of the first subsection of the
3123 if (lss
->head
&& lss
->head
->loc
.u
.view
)
3124 set_or_check_view (lss
->head
, NULL
, NULL
);
3126 while ((lss
= lss
->next
) != NULL
)
3128 /* Link the first view of subsequent subsections to the
3130 if (lss
->head
&& lss
->head
->loc
.u
.view
)
3131 set_or_check_view (lss
->head
,
3132 !s
->head
? NULL
: (struct line_entry
*)ptail
,
3133 s
->head
? s
->head
->head
: NULL
);
3140 if (empty_debug_line
)
3141 out_debug_line (line_seg
);
3143 /* If this is assembler generated line info, and there is no
3144 debug_info already, we need .debug_info, .debug_abbrev and
3145 .debug_str sections as well. */
3146 if (emit_other_sections
)
3151 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
3152 unsigned char func_form
= 0;
3154 gas_assert (all_segs
);
3156 info_seg
= subseg_new (".debug_info", 0);
3157 abbrev_seg
= subseg_new (".debug_abbrev", 0);
3158 aranges_seg
= subseg_new (".debug_aranges", 0);
3159 str_seg
= subseg_new (".debug_str", 0);
3161 bfd_set_section_flags (info_seg
,
3162 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3163 bfd_set_section_flags (abbrev_seg
,
3164 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3165 bfd_set_section_flags (aranges_seg
,
3166 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
3167 bfd_set_section_flags (str_seg
,
3168 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
3169 | SEC_MERGE
| SEC_STRINGS
);
3170 str_seg
->entsize
= 1;
3172 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
3174 if (all_segs
->next
== NULL
)
3178 if (DWARF2_VERSION
< 5)
3180 segT ranges_seg
= subseg_new (".debug_ranges", 0);
3181 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
3184 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
3185 out_debug_ranges (ranges_seg
, &ranges_sym
);
3189 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
3190 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
3193 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
3197 out_debug_aranges (aranges_seg
, info_seg
);
3198 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
, &func_form
);
3199 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
3200 out_debug_info (info_seg
, abbrev_seg
, line_seg
, str_seg
,
3201 ranges_sym
, name_sym
, comp_dir_sym
, producer_sym
,
3207 /* Perform any deferred checks pertaining to debug information. */
3210 dwarf2dbg_final_check (void)
3212 /* Perform reset-view checks. Don't evaluate view_assert_failed
3213 recursively: it could be very deep. It's a chain of adds, with
3214 each chain element pointing to the next in X_add_symbol, and
3215 holding the check value in X_op_symbol. */
3216 while (view_assert_failed
)
3222 gas_assert (!symbol_resolved_p (view_assert_failed
));
3224 exp
= symbol_get_value_expression (view_assert_failed
);
3225 sym
= view_assert_failed
;
3227 /* If view_assert_failed looks like a compound check in the
3228 chain, break it up. */
3229 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3231 view_assert_failed
= exp
->X_add_symbol
;
3232 sym
= exp
->X_op_symbol
;
3235 view_assert_failed
= NULL
;
3237 failed
= resolve_symbol_value (sym
);
3238 if (!symbol_resolved_p (sym
) || failed
)
3240 as_bad (_("view number mismatch"));