1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2021 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
34 #include "dwarf2dbg.h"
35 #include <filenames.h>
37 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
38 /* We need to decide which character to use as a directory separator.
39 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
40 necessarily mean that the backslash character is the one to use.
41 Some environments, eg Cygwin, can support both naming conventions.
42 So we use the heuristic that we only need to use the backslash if
43 the path is an absolute path starting with a DOS style drive
44 selector. eg C: or D: */
45 # define INSERT_DIR_SEPARATOR(string, offset) \
50 && string[1] == ':') \
51 string [offset] = '\\'; \
53 string [offset] = '/'; \
57 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
61 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
64 #ifndef DWARF2_ADDR_SIZE
65 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
68 #ifndef DWARF2_FILE_NAME
69 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
72 #ifndef DWARF2_FILE_TIME_NAME
73 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
76 #ifndef DWARF2_FILE_SIZE_NAME
77 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
80 #ifndef DWARF2_VERSION
81 #define DWARF2_VERSION dwarf_level
84 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
85 #ifndef DWARF2_ARANGES_VERSION
86 #define DWARF2_ARANGES_VERSION 2
89 /* This implementation outputs version 3 .debug_line information. */
90 #ifndef DWARF2_LINE_VERSION
91 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
94 /* The .debug_rnglists has only been in DWARF version 5. */
95 #ifndef DWARF2_RNGLISTS_VERSION
96 #define DWARF2_RNGLISTS_VERSION 5
103 /* Since we can't generate the prolog until the body is complete, we
104 use three different subsegments for .debug_line: one holding the
105 prolog, one for the directory and filename info, and one for the
106 body ("statement program"). */
111 /* If linker relaxation might change offsets in the code, the DWARF special
112 opcodes and variable-length operands cannot be used. If this macro is
113 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
114 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
115 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
118 /* First special line opcode - leave room for the standard opcodes.
119 Note: If you want to change this, you'll have to update the
120 "standard_opcode_lengths" table that is emitted below in
122 #define DWARF2_LINE_OPCODE_BASE 13
124 #ifndef DWARF2_LINE_BASE
125 /* Minimum line offset in a special line info. opcode. This value
126 was chosen to give a reasonable range of values. */
127 # define DWARF2_LINE_BASE -5
130 /* Range of line offsets in a special line info. opcode. */
131 #ifndef DWARF2_LINE_RANGE
132 # define DWARF2_LINE_RANGE 14
135 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
136 /* Define the architecture-dependent minimum instruction length (in
137 bytes). This value should be rather too small than too big. */
138 # define DWARF2_LINE_MIN_INSN_LENGTH 1
141 /* Flag that indicates the initial value of the is_stmt_start flag. */
142 #define DWARF2_LINE_DEFAULT_IS_STMT 1
144 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
145 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
148 /* Given a special op, return the line skip amount. */
149 #define SPECIAL_LINE(op) \
150 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
152 /* Given a special op, return the address skip amount (in units of
153 DWARF2_LINE_MIN_INSN_LENGTH. */
154 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
156 /* The maximum address skip amount that can be encoded with a special op. */
157 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
159 #ifndef TC_PARSE_CONS_RETURN_NONE
160 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
165 struct line_entry
*next
;
167 struct dwarf2_line_info loc
;
170 /* Don't change the offset of next in line_entry. set_or_check_view
171 calls in dwarf2_gen_line_info_1 depend on it. */
172 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
177 struct line_subseg
*next
;
179 struct line_entry
*head
;
180 struct line_entry
**ptail
;
181 struct line_entry
**pmove_tail
;
186 struct line_seg
*next
;
188 struct line_subseg
*head
;
193 /* Collects data for all line table entries during assembly. */
194 static struct line_seg
*all_segs
;
195 static struct line_seg
**last_seg_ptr
;
197 #define NUM_MD5_BYTES 16
201 const char * filename
;
203 unsigned char md5
[NUM_MD5_BYTES
];
206 /* Table of files used by .debug_line. */
207 static struct file_entry
*files
;
208 static unsigned int files_in_use
;
209 static unsigned int files_allocated
;
210 static unsigned int num_of_auto_assigned
;
212 /* Table of directories used by .debug_line. */
213 static char ** dirs
= NULL
;
214 static unsigned int dirs_in_use
= 0;
215 static unsigned int dirs_allocated
= 0;
217 /* TRUE when we've seen a .loc directive recently. Used to avoid
218 doing work when there's nothing to do. Will be reset by
219 dwarf2_consume_line_info. */
220 bool dwarf2_loc_directive_seen
;
222 /* TRUE when we've seen any .loc directive at any time during parsing.
223 Indicates the user wants us to generate a .debug_line section.
224 Used in dwarf2_finish as sanity check. */
225 static bool dwarf2_any_loc_directive_seen
;
227 /* TRUE when we're supposed to set the basic block mark whenever a
229 bool dwarf2_loc_mark_labels
;
231 /* Current location as indicated by the most recent .loc directive. */
232 static struct dwarf2_line_info current
=
235 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
239 /* This symbol is used to recognize view number forced resets in loc
241 static symbolS
*force_reset_view
;
243 /* This symbol evaluates to an expression that, if nonzero, indicates
244 some view assert check failed. */
245 static symbolS
*view_assert_failed
;
247 /* The size of an address on the target. */
248 static unsigned int sizeof_address
;
250 #ifndef TC_DWARF2_EMIT_OFFSET
251 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
253 /* Create an offset to .dwarf2_*. */
256 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
260 memset (&exp
, 0, sizeof exp
);
262 exp
.X_add_symbol
= symbol
;
263 exp
.X_add_number
= 0;
264 emit_expr (&exp
, size
);
268 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
270 static struct line_subseg
*
271 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
273 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
274 struct line_subseg
**pss
, *lss
;
281 s
= XNEW (struct line_seg
);
286 last_seg_ptr
= &s
->next
;
287 seg_info (seg
)->dwarf2_line_seg
= s
;
290 gas_assert (seg
== s
->seg
);
292 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
294 if (lss
->subseg
== subseg
)
296 if (lss
->subseg
> subseg
)
300 lss
= XNEW (struct line_subseg
);
302 lss
->subseg
= subseg
;
304 lss
->ptail
= &lss
->head
;
305 lss
->pmove_tail
= &lss
->head
;
312 /* (Un)reverse the line_entry list starting from H. */
314 static struct line_entry
*
315 reverse_line_entry_list (struct line_entry
*h
)
317 struct line_entry
*p
= NULL
, *e
, *n
;
319 for (e
= h
; e
; e
= n
)
328 /* Compute the view for E based on the previous entry P. If we
329 introduce an (undefined) view symbol for P, and H is given (P must
330 be the tail in this case), introduce view symbols for earlier list
331 entries as well, until one of them is constant. */
334 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
335 struct line_entry
*h
)
339 memset (&viewx
, 0, sizeof (viewx
));
340 viewx
.X_unsigned
= 1;
342 /* First, compute !(E->label > P->label), to tell whether or not
343 we're to reset the view number. If we can't resolve it to a
344 constant, keep it symbolic. */
345 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
347 viewx
.X_op
= O_constant
;
348 viewx
.X_add_number
= 0;
349 viewx
.X_add_symbol
= NULL
;
350 viewx
.X_op_symbol
= NULL
;
355 viewx
.X_add_number
= 0;
356 viewx
.X_add_symbol
= e
->label
;
357 viewx
.X_op_symbol
= p
->label
;
358 resolve_expression (&viewx
);
359 if (viewx
.X_op
== O_constant
)
360 viewx
.X_add_number
= !viewx
.X_add_number
;
363 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
364 viewx
.X_add_number
= 0;
365 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_op
= O_logical_not
;
370 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
372 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
373 /* We can't compare the view numbers at this point, because in
374 VIEWX we've only determined whether we're to reset it so
376 if (viewx
.X_op
== O_constant
)
378 if (!value
->X_add_number
!= !viewx
.X_add_number
)
379 as_bad (_("view number mismatch"));
381 /* Record the expression to check it later. It is the result of
382 a logical not, thus 0 or 1. We just add up all such deferred
383 expressions, and resolve it at the end. */
384 else if (!value
->X_add_number
)
386 symbolS
*deferred
= make_expr_symbol (&viewx
);
387 if (view_assert_failed
)
391 memset (&chk
, 0, sizeof (chk
));
394 chk
.X_add_number
= 0;
395 chk
.X_add_symbol
= view_assert_failed
;
396 chk
.X_op_symbol
= deferred
;
397 deferred
= make_expr_symbol (&chk
);
399 view_assert_failed
= deferred
;
403 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
409 p
->loc
.view
= symbol_temp_make ();
410 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
413 memset (&incv
, 0, sizeof (incv
));
415 incv
.X_op
= O_symbol
;
416 incv
.X_add_symbol
= p
->loc
.view
;
417 incv
.X_add_number
= 1;
419 if (viewx
.X_op
== O_constant
)
421 gas_assert (viewx
.X_add_number
== 1);
426 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
427 viewx
.X_add_number
= 0;
428 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
429 viewx
.X_op
= O_multiply
;
433 if (!S_IS_DEFINED (e
->loc
.view
))
435 symbol_set_value_expression (e
->loc
.view
, &viewx
);
436 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
437 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
440 /* Define and attempt to simplify any earlier views needed to
442 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
444 struct line_entry
*h2
;
445 /* Reverse the list to avoid quadratic behavior going backwards
446 in a single-linked list. */
447 struct line_entry
*r
= reverse_line_entry_list (h
);
450 /* Set or check views until we find a defined or absent view. */
453 /* Do not define the head of a (sub?)segment view while
454 handling others. It would be defined too early, without
455 regard to the last view of other subsegments.
456 set_or_check_view will be called for every head segment
460 set_or_check_view (r
, r
->next
, NULL
);
462 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
465 /* Unreverse the list, so that we can go forward again. */
466 h2
= reverse_line_entry_list (p
);
467 gas_assert (h2
== h
);
469 /* Starting from the last view we just defined, attempt to
470 simplify the view expressions, until we do so to P. */
473 /* The head view of a subsegment may remain undefined while
474 handling other elements, before it is linked to the last
475 view of the previous subsegment. */
478 gas_assert (S_IS_DEFINED (r
->loc
.view
));
479 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
481 while (r
!= p
&& (r
= r
->next
));
483 /* Now that we've defined and computed all earlier views that might
484 be needed to compute E's, attempt to simplify it. */
485 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
489 /* Record an entry for LOC occurring at LABEL. */
492 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
494 struct line_subseg
*lss
;
495 struct line_entry
*e
;
496 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
498 /* PR 26850: Do not record LOCs in non-executable or non-loaded
499 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
500 obj_coff_section is careless in setting SEC_ALLOC. */
502 need_flags
|= SEC_ALLOC
;
503 if ((now_seg
->flags
& need_flags
) != need_flags
)
505 /* FIXME: Add code to suppress multiple warnings ? */
506 if (debug_type
!= DEBUG_DWARF2
)
507 as_warn ("dwarf line number information for %s ignored",
508 segment_name (now_seg
));
512 e
= XNEW (struct line_entry
);
517 lss
= get_line_subseg (now_seg
, now_subseg
, true);
519 /* Subseg heads are chained to previous subsegs in
521 if (loc
->view
&& lss
->head
)
522 set_or_check_view (e
,
523 (struct line_entry
*)lss
->ptail
,
527 lss
->ptail
= &e
->next
;
530 /* Record an entry for LOC occurring at OFS within the current fragment. */
533 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
535 static unsigned int line
= -1;
536 static unsigned int filenum
= -1;
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
556 && line
== loc
->line
&& filenum
== loc
->filenum
)
560 filenum
= loc
->filenum
;
566 /* Use a non-fake name for the line number location,
567 so that it can be referred to by relocations. */
568 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
569 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
572 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
573 dwarf2_gen_line_info_1 (sym
, loc
);
577 get_basename (const char * pathname
)
581 file
= lbasename (pathname
);
582 /* Don't make empty string from / or A: from A:/ . */
583 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
584 if (file
<= pathname
+ 3)
587 if (file
== pathname
+ 1)
594 get_directory_table_entry (const char *dirname
,
603 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
604 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
612 for (d
= 0; d
< dirs_in_use
; ++d
)
615 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
616 && dirs
[d
][dirlen
] == '\0')
622 if (dirs
== NULL
|| dirs
[0] == NULL
)
624 const char * pwd
= getpwd ();
626 if (dwarf_level
>= 5 && strcmp (dirname
, pwd
) != 0)
628 /* In DWARF-5 the 0 entry in the directory table is expected to be
629 the same as the DW_AT_comp_dir (which is set to the current build
630 directory). Since we are about to create a directory entry that
631 is not the same, allocate the current directory first.
632 FIXME: Alternatively we could generate an error message here. */
633 (void) get_directory_table_entry (pwd
, strlen (pwd
), true);
643 if (d
>= dirs_allocated
)
645 unsigned int old
= dirs_allocated
;
646 #define DIR_TABLE_INCREMENT 32
647 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
648 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
649 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
652 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
653 if (dirs_in_use
<= d
)
660 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
662 if (i
>= files_allocated
)
664 unsigned int old
= files_allocated
;
666 files_allocated
= i
+ 32;
667 /* Catch wraparound. */
668 if (files_allocated
<= old
)
670 as_bad (_("file number %lu is too big"), (unsigned long) i
);
674 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
675 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
678 files
[i
].filename
= file
;
680 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
682 if (files_in_use
< i
+ 1)
683 files_in_use
= i
+ 1;
688 /* Get a .debug_line file number for PATHNAME. If there is a
689 directory component to PATHNAME, then this will be stored
690 in the directory table, if it is not already present.
691 Returns the slot number allocated to that filename or -1
692 if there was a problem. */
695 allocate_filenum (const char * pathname
)
697 static signed int last_used
= -1, last_used_dir_len
= 0;
702 /* Short circuit the common case of adding the same pathname
706 const char * dirname
= NULL
;
709 dirname
= dirs
[files
[last_used
].dir
];
713 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
718 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
719 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
720 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
721 files
[last_used
].filename
) == 0)
726 file
= get_basename (pathname
);
727 dir_len
= file
- pathname
;
729 dir
= get_directory_table_entry (pathname
, dir_len
, false);
731 /* Do not use slot-0. That is specifically reserved for use by
732 the '.file 0 "name"' directive. */
733 for (i
= 1; i
< files_in_use
; ++i
)
734 if (files
[i
].dir
== dir
736 && filename_cmp (file
, files
[i
].filename
) == 0)
739 last_used_dir_len
= dir_len
;
743 if (!assign_file_to_slot (i
, file
, dir
))
746 num_of_auto_assigned
++;
749 last_used_dir_len
= dir_len
;
754 /* Allocate slot NUM in the .debug_line file table to FILENAME.
755 If DIRNAME is not NULL or there is a directory component to FILENAME
756 then this will be stored in the directory table, if not already present.
757 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
758 Returns TRUE if allocation succeeded, FALSE otherwise. */
761 allocate_filename_to_slot (const char *dirname
,
762 const char *filename
,
770 /* Short circuit the common case of adding the same pathname
772 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
774 const char * dir
= NULL
;
777 dir
= dirs
[files
[num
].dir
];
780 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
785 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
788 if (filename_cmp (filename
, files
[num
].filename
) != 0)
791 /* If the filenames match, but the directory table entry was
792 empty, then fill it with the provided directory name. */
797 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
798 dirs
= XCNEWVEC (char *, dirs_allocated
);
801 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
806 else if (dir
!= NULL
)
808 dirlen
= strlen (dir
);
809 if (filename_ncmp (filename
, dir
, dirlen
) == 0
810 && IS_DIR_SEPARATOR (filename
[dirlen
])
811 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
814 else /* dir == NULL */
816 file
= get_basename (filename
);
817 if (filename_cmp (file
, files
[num
].filename
) == 0)
819 /* The filenames match, but the directory table entry is empty.
820 Fill it with the provided directory name. */
825 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
826 dirs
= XCNEWVEC (char *, dirs_allocated
);
829 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
836 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
838 dir
== NULL
? "" : dir
,
839 dir
== NULL
? "" : "/",
841 dirname
== NULL
? "" : dirname
,
842 dirname
== NULL
? "" : "/",
850 file
= get_basename (filename
);
851 dirlen
= file
- filename
;
855 dirlen
= strlen (dirname
);
859 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
862 if (! assign_file_to_slot (i
, file
, d
))
867 if (target_big_endian
)
869 /* md5's are stored in litte endian format. */
870 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
871 unsigned int byte
= NUM_MD5_BYTES
;
872 unsigned int bignum_index
= 0;
874 while (bits_remaining
)
876 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
877 valueT bignum_value
= generic_bignum
[bignum_index
];
880 while (bignum_bits_remaining
)
882 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
884 bignum_bits_remaining
-= 8;
891 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
892 unsigned int byte
= 0;
893 unsigned int bignum_index
= 0;
895 while (bits_remaining
)
897 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
898 valueT bignum_value
= generic_bignum
[bignum_index
];
902 while (bignum_bits_remaining
)
904 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
906 bignum_bits_remaining
-= 8;
913 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
918 /* Returns the current source information. If .file directives have
919 been encountered, the info for the corresponding source file is
920 returned. Otherwise, the info for the assembly source file is
924 dwarf2_where (struct dwarf2_line_info
*line
)
926 if (debug_type
== DEBUG_DWARF2
)
928 const char *filename
;
930 memset (line
, 0, sizeof (*line
));
931 filename
= as_where (&line
->line
);
932 line
->filenum
= allocate_filenum (filename
);
933 /* FIXME: We should check the return value from allocate_filenum. */
935 line
->flags
= DWARF2_FLAG_IS_STMT
;
936 line
->isa
= current
.isa
;
937 line
->discriminator
= current
.discriminator
;
944 /* A hook to allow the target backend to inform the line number state
945 machine of isa changes when assembler debug info is enabled. */
948 dwarf2_set_isa (unsigned int isa
)
953 /* Called for each machine instruction, or relatively atomic group of
954 machine instructions (ie built-in macro). The instruction or group
955 is SIZE bytes in length. If dwarf2 line number generation is called
956 for, emit a line statement appropriately. */
959 dwarf2_emit_insn (int size
)
961 struct dwarf2_line_info loc
;
963 if (debug_type
!= DEBUG_DWARF2
964 ? !dwarf2_loc_directive_seen
965 : !seen_at_least_1_file ())
970 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
971 dwarf2_consume_line_info ();
974 /* Move all previously-emitted line entries for the current position by
975 DELTA bytes. This function cannot be used to move the same entries
979 dwarf2_move_insn (int delta
)
981 struct line_subseg
*lss
;
982 struct line_entry
*e
;
988 lss
= get_line_subseg (now_seg
, now_subseg
, false);
992 now
= frag_now_fix ();
993 while ((e
= *lss
->pmove_tail
))
995 if (S_GET_VALUE (e
->label
) == now
)
996 S_SET_VALUE (e
->label
, now
+ delta
);
997 lss
->pmove_tail
= &e
->next
;
1001 /* Called after the current line information has been either used with
1002 dwarf2_gen_line_info or saved with a machine instruction for later use.
1003 This resets the state of the line number information to reflect that
1004 it has been used. */
1007 dwarf2_consume_line_info (void)
1009 /* Unless we generate DWARF2 debugging information for each
1010 assembler line, we only emit one line symbol for one LOC. */
1011 dwarf2_loc_directive_seen
= false;
1013 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1014 | DWARF2_FLAG_PROLOGUE_END
1015 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1016 current
.discriminator
= 0;
1017 current
.view
= NULL
;
1020 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1021 is enabled, emit a basic block marker. */
1024 dwarf2_emit_label (symbolS
*label
)
1026 struct dwarf2_line_info loc
;
1028 if (!dwarf2_loc_mark_labels
)
1030 if (S_GET_SEGMENT (label
) != now_seg
)
1032 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1034 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1037 dwarf2_where (&loc
);
1039 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1041 dwarf2_gen_line_info_1 (label
, &loc
);
1042 dwarf2_consume_line_info ();
1045 /* Handle two forms of .file directive:
1046 - Pass .file "source.c" to s_app_file
1047 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1049 If an entry is added to the file table, return a pointer to the filename. */
1052 dwarf2_directive_filename (void)
1054 bool with_md5
= false;
1057 const char * dirname
= NULL
;
1061 /* Continue to accept a bare string and pass it off. */
1063 if (*input_line_pointer
== '"')
1069 num
= get_absolute_expression ();
1071 if ((offsetT
) num
< 1)
1073 if (num
== 0 && dwarf_level
< 5)
1075 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1077 as_bad (_("file number less than one"));
1078 ignore_rest_of_line ();
1083 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1084 "switch back to the already allocated file <N> as the current
1087 filename
= demand_copy_C_string (&filename_len
);
1088 if (filename
== NULL
)
1089 /* demand_copy_C_string will have already generated an error message. */
1092 /* For DWARF-5 support we also accept:
1093 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1094 if (DWARF2_LINE_VERSION
> 4)
1097 if (*input_line_pointer
== '"')
1100 filename
= demand_copy_C_string (&filename_len
);
1104 if (startswith (input_line_pointer
, "md5"))
1106 input_line_pointer
+= 3;
1110 expression_and_evaluate (& exp
);
1111 if (exp
.X_op
!= O_big
)
1112 as_bad (_("md5 value too small or not a constant"));
1118 demand_empty_rest_of_line ();
1120 /* A .file directive implies compiler generated debug information is
1121 being supplied. Turn off gas generated debug info. */
1122 debug_type
= DEBUG_NONE
;
1124 if (num
!= (unsigned int) num
1125 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1127 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1131 if (num_of_auto_assigned
)
1133 /* Clear slots auto-assigned before the first .file <NUMBER>
1134 directive was seen. */
1135 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1137 for (i
= 1; i
< files_in_use
; i
++)
1138 files
[i
].filename
= NULL
;
1140 num_of_auto_assigned
= 0;
1143 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1150 /* Calls dwarf2_directive_filename, but discards its result.
1151 Used in pseudo-op tables where the function result is ignored. */
1154 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1156 (void) dwarf2_directive_filename ();
1160 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1162 offsetT filenum
, line
;
1164 /* If we see two .loc directives in a row, force the first one to be
1166 if (dwarf2_loc_directive_seen
)
1167 dwarf2_emit_insn (0);
1169 filenum
= get_absolute_expression ();
1171 line
= get_absolute_expression ();
1175 if (filenum
== 0 && dwarf_level
< 5)
1177 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1179 as_bad (_("file number less than one"));
1184 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1186 as_bad (_("unassigned file number %ld"), (long) filenum
);
1190 current
.filenum
= filenum
;
1191 current
.line
= line
;
1192 current
.discriminator
= 0;
1197 if (files
[filenum
].dir
)
1199 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1200 size_t file_len
= strlen (files
[filenum
].filename
);
1201 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1203 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1204 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1205 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1206 cp
[dir_len
+ file_len
+ 1] = '\0';
1207 listing_source_file (cp
);
1211 listing_source_file (files
[filenum
].filename
);
1212 listing_source_line (line
);
1217 if (ISDIGIT (*input_line_pointer
))
1219 current
.column
= get_absolute_expression ();
1223 while (ISALPHA (*input_line_pointer
))
1228 c
= get_symbol_name (& p
);
1230 if (strcmp (p
, "basic_block") == 0)
1232 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1233 *input_line_pointer
= c
;
1235 else if (strcmp (p
, "prologue_end") == 0)
1237 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1238 *input_line_pointer
= c
;
1240 else if (strcmp (p
, "epilogue_begin") == 0)
1242 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1243 *input_line_pointer
= c
;
1245 else if (strcmp (p
, "is_stmt") == 0)
1247 (void) restore_line_pointer (c
);
1248 value
= get_absolute_expression ();
1250 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1251 else if (value
== 1)
1252 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1255 as_bad (_("is_stmt value not 0 or 1"));
1259 else if (strcmp (p
, "isa") == 0)
1261 (void) restore_line_pointer (c
);
1262 value
= get_absolute_expression ();
1264 current
.isa
= value
;
1267 as_bad (_("isa number less than zero"));
1271 else if (strcmp (p
, "discriminator") == 0)
1273 (void) restore_line_pointer (c
);
1274 value
= get_absolute_expression ();
1276 current
.discriminator
= value
;
1279 as_bad (_("discriminator less than zero"));
1283 else if (strcmp (p
, "view") == 0)
1287 (void) restore_line_pointer (c
);
1290 if (ISDIGIT (*input_line_pointer
)
1291 || *input_line_pointer
== '-')
1293 bool force_reset
= *input_line_pointer
== '-';
1295 value
= get_absolute_expression ();
1298 as_bad (_("numeric view can only be asserted to zero"));
1301 if (force_reset
&& force_reset_view
)
1302 sym
= force_reset_view
;
1305 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1308 force_reset_view
= sym
;
1313 char *name
= read_symbol_name ();
1317 sym
= symbol_find_or_make (name
);
1318 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1320 if (S_IS_VOLATILE (sym
))
1321 sym
= symbol_clone (sym
, 1);
1322 else if (!S_CAN_BE_REDEFINED (sym
))
1324 as_bad (_("symbol `%s' is already defined"), name
);
1328 S_SET_SEGMENT (sym
, undefined_section
);
1329 S_SET_VALUE (sym
, 0);
1330 symbol_set_frag (sym
, &zero_address_frag
);
1336 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1337 (void) restore_line_pointer (c
);
1341 SKIP_WHITESPACE_AFTER_NAME ();
1344 demand_empty_rest_of_line ();
1345 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1346 debug_type
= DEBUG_NONE
;
1348 /* If we were given a view id, emit the row right away. */
1350 dwarf2_emit_insn (0);
1354 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1356 offsetT value
= get_absolute_expression ();
1358 if (value
!= 0 && value
!= 1)
1360 as_bad (_("expected 0 or 1"));
1361 ignore_rest_of_line ();
1365 dwarf2_loc_mark_labels
= value
!= 0;
1366 demand_empty_rest_of_line ();
1370 static struct frag
*
1371 first_frag_for_seg (segT seg
)
1373 return seg_info (seg
)->frchainP
->frch_root
;
1376 static struct frag
*
1377 last_frag_for_seg (segT seg
)
1379 frchainS
*f
= seg_info (seg
)->frchainP
;
1381 while (f
->frch_next
!= NULL
)
1384 return f
->frch_last
;
1387 /* Emit a single byte into the current segment. */
1392 FRAG_APPEND_1_CHAR (byte
);
1395 /* Emit a statement program opcode into the current segment. */
1398 out_opcode (int opc
)
1403 /* Emit a two-byte word into the current segment. */
1408 md_number_to_chars (frag_more (2), data
, 2);
1411 /* Emit a four byte word into the current segment. */
1416 md_number_to_chars (frag_more (4), data
, 4);
1419 /* Emit an unsigned "little-endian base 128" number. */
1422 out_uleb128 (addressT value
)
1424 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1427 /* Emit a signed "little-endian base 128" number. */
1430 out_leb128 (addressT value
)
1432 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1435 /* Emit a tuple for .debug_abbrev. */
1438 out_abbrev (int name
, int form
)
1444 /* Get the size of a fragment. */
1447 get_frag_fix (fragS
*frag
, segT seg
)
1452 return frag
->fr_fix
;
1454 /* If a fragment is the last in the chain, special measures must be
1455 taken to find its size before relaxation, since it may be pending
1456 on some subsegment chain. */
1457 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1458 if (fr
->frch_last
== frag
)
1459 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1464 /* Set an absolute address (may result in a relocation entry). */
1467 out_set_addr (symbolS
*sym
)
1471 memset (&exp
, 0, sizeof exp
);
1472 out_opcode (DW_LNS_extended_op
);
1473 out_uleb128 (sizeof_address
+ 1);
1475 out_opcode (DW_LNE_set_address
);
1476 exp
.X_op
= O_symbol
;
1477 exp
.X_add_symbol
= sym
;
1478 exp
.X_add_number
= 0;
1479 emit_expr (&exp
, sizeof_address
);
1482 static void scale_addr_delta (addressT
*);
1485 scale_addr_delta (addressT
*addr_delta
)
1487 static int printed_this
= 0;
1488 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1490 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1492 as_bad("unaligned opcodes detected in executable segment");
1495 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1499 /* Encode a pair of line and address skips as efficiently as possible.
1500 Note that the line skip is signed, whereas the address skip is unsigned.
1502 The following two routines *must* be kept in sync. This is
1503 enforced by making emit_inc_line_addr abort if we do not emit
1504 exactly the expected number of bytes. */
1507 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1509 unsigned int tmp
, opcode
;
1512 /* Scale the address delta by the minimum instruction length. */
1513 scale_addr_delta (&addr_delta
);
1515 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1516 We cannot use special opcodes here, since we want the end_sequence
1517 to emit the matrix entry. */
1518 if (line_delta
== INT_MAX
)
1520 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1522 else if (addr_delta
)
1523 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1527 /* Bias the line delta by the base. */
1528 tmp
= line_delta
- DWARF2_LINE_BASE
;
1530 /* If the line increment is out of range of a special opcode, we
1531 must encode it with DW_LNS_advance_line. */
1532 if (tmp
>= DWARF2_LINE_RANGE
)
1534 len
= 1 + sizeof_leb128 (line_delta
, 1);
1536 tmp
= 0 - DWARF2_LINE_BASE
;
1539 /* Bias the opcode by the special opcode base. */
1540 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1542 /* Avoid overflow when addr_delta is large. */
1543 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1545 /* Try using a special opcode. */
1546 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1550 /* Try using DW_LNS_const_add_pc followed by special op. */
1551 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1556 /* Otherwise use DW_LNS_advance_pc. */
1557 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1559 /* DW_LNS_copy or special opcode. */
1566 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1568 unsigned int tmp
, opcode
;
1570 char *end
= p
+ len
;
1572 /* Line number sequences cannot go backward in addresses. This means
1573 we've incorrectly ordered the statements in the sequence. */
1574 gas_assert ((offsetT
) addr_delta
>= 0);
1576 /* Scale the address delta by the minimum instruction length. */
1577 scale_addr_delta (&addr_delta
);
1579 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1580 We cannot use special opcodes here, since we want the end_sequence
1581 to emit the matrix entry. */
1582 if (line_delta
== INT_MAX
)
1584 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1585 *p
++ = DW_LNS_const_add_pc
;
1586 else if (addr_delta
)
1588 *p
++ = DW_LNS_advance_pc
;
1589 p
+= output_leb128 (p
, addr_delta
, 0);
1592 *p
++ = DW_LNS_extended_op
;
1594 *p
++ = DW_LNE_end_sequence
;
1598 /* Bias the line delta by the base. */
1599 tmp
= line_delta
- DWARF2_LINE_BASE
;
1601 /* If the line increment is out of range of a special opcode, we
1602 must encode it with DW_LNS_advance_line. */
1603 if (tmp
>= DWARF2_LINE_RANGE
)
1605 *p
++ = DW_LNS_advance_line
;
1606 p
+= output_leb128 (p
, line_delta
, 1);
1609 tmp
= 0 - DWARF2_LINE_BASE
;
1613 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1615 if (line_delta
== 0 && addr_delta
== 0)
1621 /* Bias the opcode by the special opcode base. */
1622 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1624 /* Avoid overflow when addr_delta is large. */
1625 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1627 /* Try using a special opcode. */
1628 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1635 /* Try using DW_LNS_const_add_pc followed by special op. */
1636 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1639 *p
++ = DW_LNS_const_add_pc
;
1645 /* Otherwise use DW_LNS_advance_pc. */
1646 *p
++ = DW_LNS_advance_pc
;
1647 p
+= output_leb128 (p
, addr_delta
, 0);
1655 gas_assert (p
== end
);
1658 /* Handy routine to combine calls to the above two routines. */
1661 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1663 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1664 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1667 /* Write out an alternative form of line and address skips using
1668 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1669 line and address information, but it is required if linker relaxation
1670 could change the code offsets. The following two routines *must* be
1672 #define ADDR_DELTA_LIMIT 50000
1675 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1679 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1680 if (line_delta
!= INT_MAX
)
1681 len
= 1 + sizeof_leb128 (line_delta
, 1);
1683 if (addr_delta
> ADDR_DELTA_LIMIT
)
1685 /* DW_LNS_extended_op */
1686 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1687 /* DW_LNE_set_address */
1688 len
+= 1 + sizeof_address
;
1691 /* DW_LNS_fixed_advance_pc */
1694 if (line_delta
== INT_MAX
)
1695 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1705 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1709 char *end
= p
+ len
;
1711 /* Line number sequences cannot go backward in addresses. This means
1712 we've incorrectly ordered the statements in the sequence. */
1713 gas_assert ((offsetT
) addr_delta
>= 0);
1715 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1716 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1718 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1719 if (line_delta
!= INT_MAX
)
1721 *p
++ = DW_LNS_advance_line
;
1722 p
+= output_leb128 (p
, line_delta
, 1);
1725 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1727 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1728 advance the address by at most 64K. Linker relaxation (without
1729 which this function would not be used) could change the operand by
1730 an unknown amount. If the address increment is getting close to
1731 the limit, just reset the address. */
1732 if (addr_delta
> ADDR_DELTA_LIMIT
)
1737 memset (&exp
, 0, sizeof exp
);
1738 gas_assert (pexp
->X_op
== O_subtract
);
1739 to_sym
= pexp
->X_add_symbol
;
1741 *p
++ = DW_LNS_extended_op
;
1742 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1743 *p
++ = DW_LNE_set_address
;
1744 exp
.X_op
= O_symbol
;
1745 exp
.X_add_symbol
= to_sym
;
1746 exp
.X_add_number
= 0;
1747 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1748 p
+= sizeof_address
;
1752 *p
++ = DW_LNS_fixed_advance_pc
;
1753 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1757 if (line_delta
== INT_MAX
)
1759 *p
++ = DW_LNS_extended_op
;
1761 *p
++ = DW_LNE_end_sequence
;
1766 gas_assert (p
== end
);
1769 /* Generate a variant frag that we can use to relax address/line
1770 increments between fragments of the target segment. */
1773 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1778 memset (&exp
, 0, sizeof exp
);
1779 exp
.X_op
= O_subtract
;
1780 exp
.X_add_symbol
= to_sym
;
1781 exp
.X_op_symbol
= from_sym
;
1782 exp
.X_add_number
= 0;
1784 /* The maximum size of the frag is the line delta with a maximum
1785 sized address delta. */
1786 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1787 max_chars
= size_fixed_inc_line_addr (line_delta
,
1788 -DWARF2_LINE_MIN_INSN_LENGTH
);
1790 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1792 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1793 make_expr_symbol (&exp
), line_delta
, NULL
);
1796 /* The function estimates the size of a rs_dwarf2dbg variant frag
1797 based on the current values of the symbols. It is called before
1798 the relaxation loop. We set fr_subtype to the expected length. */
1801 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1806 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1807 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1808 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1810 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1812 frag
->fr_subtype
= size
;
1817 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1818 current values of the symbols. fr_subtype is the current length
1819 of the frag. This returns the change in frag length. */
1822 dwarf2dbg_relax_frag (fragS
*frag
)
1824 int old_size
, new_size
;
1826 old_size
= frag
->fr_subtype
;
1827 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1829 return new_size
- old_size
;
1832 /* This function converts a rs_dwarf2dbg variant frag into a normal
1833 fill frag. This is called after all relaxation has been done.
1834 fr_subtype will be the desired length of the frag. */
1837 dwarf2dbg_convert_frag (fragS
*frag
)
1841 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1843 /* If linker relaxation is enabled then the distance between the two
1844 symbols in the frag->fr_symbol expression might change. Hence we
1845 cannot rely upon the value computed by resolve_symbol_value.
1846 Instead we leave the expression unfinalized and allow
1847 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1848 relocation) that will allow the linker to correctly compute the
1849 actual address difference. We have to use a fixed line advance for
1850 this as we cannot (easily) relocate leb128 encoded values. */
1851 int saved_finalize_syms
= finalize_syms
;
1854 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1855 finalize_syms
= saved_finalize_syms
;
1858 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1860 /* fr_var carries the max_chars that we created the fragment with.
1861 fr_subtype carries the current expected length. We must, of
1862 course, have allocated enough memory earlier. */
1863 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1865 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1866 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1867 frag
->fr_literal
+ frag
->fr_fix
,
1870 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1871 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1873 frag
->fr_fix
+= frag
->fr_subtype
;
1874 frag
->fr_type
= rs_fill
;
1876 frag
->fr_offset
= 0;
1879 /* Generate .debug_line content for the chain of line number entries
1880 beginning at E, for segment SEG. */
1883 process_entries (segT seg
, struct line_entry
*e
)
1885 unsigned filenum
= 1;
1887 unsigned column
= 0;
1889 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1890 fragS
*last_frag
= NULL
, *frag
;
1891 addressT last_frag_ofs
= 0, frag_ofs
;
1892 symbolS
*last_lab
= NULL
, *lab
;
1893 struct line_entry
*next
;
1895 if (flag_dwarf_sections
)
1898 const char * sec_name
;
1900 /* Switch to the relevant sub-section before we start to emit
1901 the line number table.
1903 FIXME: These sub-sections do not have a normal Line Number
1904 Program Header, thus strictly speaking they are not valid
1905 DWARF sections. Unfortunately the DWARF standard assumes
1906 a one-to-one relationship between compilation units and
1907 line number tables. Thus we have to have a .debug_line
1908 section, as well as our sub-sections, and we have to ensure
1909 that all of the sub-sections are merged into a proper
1910 .debug_line section before a debugger sees them. */
1912 sec_name
= bfd_section_name (seg
);
1913 if (strcmp (sec_name
, ".text") != 0)
1915 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1916 subseg_set (subseg_get (name
, false), 0);
1919 /* Don't create a .debug_line.text section -
1920 that is redundant. Instead just switch back to the
1921 normal .debug_line section. */
1922 subseg_set (subseg_get (".debug_line", false), 0);
1929 if (filenum
!= e
->loc
.filenum
)
1931 filenum
= e
->loc
.filenum
;
1932 out_opcode (DW_LNS_set_file
);
1933 out_uleb128 (filenum
);
1936 if (column
!= e
->loc
.column
)
1938 column
= e
->loc
.column
;
1939 out_opcode (DW_LNS_set_column
);
1940 out_uleb128 (column
);
1943 if (e
->loc
.discriminator
!= 0)
1945 out_opcode (DW_LNS_extended_op
);
1946 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1947 out_opcode (DW_LNE_set_discriminator
);
1948 out_uleb128 (e
->loc
.discriminator
);
1951 if (isa
!= e
->loc
.isa
)
1954 out_opcode (DW_LNS_set_isa
);
1958 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1960 flags
= e
->loc
.flags
;
1961 out_opcode (DW_LNS_negate_stmt
);
1964 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1965 out_opcode (DW_LNS_set_basic_block
);
1967 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1968 out_opcode (DW_LNS_set_prologue_end
);
1970 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1971 out_opcode (DW_LNS_set_epilogue_begin
);
1973 /* Don't try to optimize away redundant entries; gdb wants two
1974 entries for a function where the code starts on the same line as
1975 the {, and there's no way to identify that case here. Trust gcc
1976 to optimize appropriately. */
1977 line_delta
= e
->loc
.line
- line
;
1979 frag
= symbol_get_frag (lab
);
1980 frag_ofs
= S_GET_VALUE (lab
);
1982 if (last_frag
== NULL
1983 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1984 /* If we're going to reset the view, but we know we're
1985 advancing the PC, we don't have to force with
1986 set_address. We know we do when we're at the same
1987 address of the same frag, and we know we might when
1988 we're in the beginning of a frag, and we were at the
1989 end of the previous frag. */
1990 && (frag
== last_frag
1991 ? (last_frag_ofs
== frag_ofs
)
1993 && ((offsetT
)last_frag_ofs
1994 >= get_frag_fix (last_frag
, seg
))))))
1997 out_inc_line_addr (line_delta
, 0);
1999 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2000 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2002 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2007 last_frag_ofs
= frag_ofs
;
2015 /* Emit a DW_LNE_end_sequence for the end of the section. */
2016 frag
= last_frag_for_seg (seg
);
2017 frag_ofs
= get_frag_fix (frag
, seg
);
2018 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2019 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2022 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2023 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2027 /* Switch to LINE_STR_SEG and output the given STR. Return the
2028 symbol pointing to the new string in the section. */
2031 add_line_strp (segT line_str_seg
, const char *str
)
2037 subseg_set (line_str_seg
, 0);
2039 sym
= symbol_temp_new_now_octets ();
2041 size
= strlen (str
) + 1;
2042 cp
= frag_more (size
);
2043 memcpy (cp
, str
, size
);
2049 /* Emit the directory and file tables for .debug_line. */
2052 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2058 bool emit_md5
= false;
2059 bool emit_timestamps
= true;
2060 bool emit_filesize
= true;
2061 segT line_str_seg
= NULL
;
2064 /* Output the Directory Table. */
2065 if (DWARF2_LINE_VERSION
>= 5)
2067 /* We only have one column in the directory table. */
2070 /* Describe the purpose and format of the column. */
2071 out_uleb128 (DW_LNCT_path
);
2072 /* Store these strings in the .debug_line_str section so they
2074 out_uleb128 (DW_FORM_line_strp
);
2076 /* Now state how many rows there are in the table. We need at
2077 least 1 if there is one or more file names to store the
2078 "working directory". */
2079 if (dirs_in_use
== 0 && files_in_use
> 0)
2082 out_uleb128 (dirs_in_use
);
2085 /* Emit directory list. */
2086 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2088 line_str_seg
= subseg_new (".debug_line_str", 0);
2089 bfd_set_section_flags (line_str_seg
,
2090 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2091 | SEC_MERGE
| SEC_STRINGS
);
2092 line_str_seg
->entsize
= 1;
2094 /* DWARF5 uses slot zero, but that is only set explicitly
2095 using a .file 0 directive. If that isn't used, but dir
2096 one is used, then use that as main file directory.
2097 Otherwise use pwd as main file directory. */
2098 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2099 dir
= remap_debug_filename (dirs
[0]);
2100 else if (dirs_in_use
> 1
2103 /* DWARF-5 directory tables expect dir[0] to be the same as
2104 DW_AT_comp_dir, which is the same as pwd. */
2106 dir
= remap_debug_filename (dirs
[1]);
2108 dir
= remap_debug_filename (getpwd ());
2110 line_strp
= add_line_strp (line_str_seg
, dir
);
2111 subseg_set (line_seg
, 0);
2112 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2114 for (i
= 1; i
< dirs_in_use
; ++i
)
2116 dir
= remap_debug_filename (dirs
[i
]);
2117 if (DWARF2_LINE_VERSION
< 5)
2119 size
= strlen (dir
) + 1;
2120 cp
= frag_more (size
);
2121 memcpy (cp
, dir
, size
);
2125 line_strp
= add_line_strp (line_str_seg
, dir
);
2126 subseg_set (line_seg
, 0);
2127 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2131 if (DWARF2_LINE_VERSION
< 5)
2135 /* Output the File Name Table. */
2136 if (DWARF2_LINE_VERSION
>= 5)
2138 unsigned int columns
= 4;
2140 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2142 emit_timestamps
= false;
2146 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2148 emit_filesize
= false;
2152 for (i
= 0; i
< files_in_use
; ++i
)
2153 if (files
[i
].md5
[0] != 0)
2155 if (i
< files_in_use
)
2161 /* The number of format entries to follow. */
2163 /* The format of the file name. */
2164 out_uleb128 (DW_LNCT_path
);
2165 /* Store these strings in the .debug_line_str section so they
2167 out_uleb128 (DW_FORM_line_strp
);
2169 /* The format of the directory index. */
2170 out_uleb128 (DW_LNCT_directory_index
);
2171 out_uleb128 (DW_FORM_udata
);
2173 if (emit_timestamps
)
2175 /* The format of the timestamp. */
2176 out_uleb128 (DW_LNCT_timestamp
);
2177 out_uleb128 (DW_FORM_udata
);
2182 /* The format of the file size. */
2183 out_uleb128 (DW_LNCT_size
);
2184 out_uleb128 (DW_FORM_udata
);
2189 /* The format of the MD5 sum. */
2190 out_uleb128 (DW_LNCT_MD5
);
2191 out_uleb128 (DW_FORM_data16
);
2194 /* The number of entries in the table. */
2195 out_uleb128 (files_in_use
);
2198 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2200 const char *fullfilename
;
2202 if (files
[i
].filename
== NULL
)
2204 /* Prevent a crash later, particularly for file 1. DWARF5
2205 uses slot zero, but that is only set explicitly using a
2206 .file 0 directive. If that isn't used, but file 1 is,
2207 then use that as main file name. */
2208 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1 && files
[0].filename
== NULL
)
2209 files
[0].filename
= files
[1].filename
;
2211 files
[i
].filename
= "";
2212 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2214 as_bad (_("unassigned file number %ld"), (long) i
);
2219 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2220 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2221 if (DWARF2_LINE_VERSION
< 5)
2223 size
= strlen (fullfilename
) + 1;
2224 cp
= frag_more (size
);
2225 memcpy (cp
, fullfilename
, size
);
2229 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2230 subseg_set (line_seg
, 0);
2231 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2234 /* Directory number. */
2235 out_uleb128 (files
[i
].dir
);
2237 /* Output the last modification timestamp. */
2238 if (emit_timestamps
)
2242 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2243 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2244 if (timestamp
== -1)
2246 out_uleb128 (timestamp
);
2249 /* Output the filesize. */
2253 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2254 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2257 out_uleb128 (filesize
);
2260 /* Output the md5 sum. */
2265 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2266 out_byte (files
[i
].md5
[b
]);
2270 if (DWARF2_LINE_VERSION
< 5)
2271 /* Terminate filename list. */
2275 /* Switch to SEC and output a header length field. Return the size of
2276 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2277 to the end of the section. EXPR->X_add_number will be set to the
2278 negative size of the header. */
2281 out_header (asection
*sec
, expressionS
*exp
)
2286 subseg_set (sec
, 0);
2288 if (flag_dwarf_sections
)
2290 /* If we are going to put the start and end symbols in different
2291 sections, then we need real symbols, not just fake, local ones. */
2293 start_sym
= symbol_make (".Ldebug_line_start");
2294 end_sym
= symbol_make (".Ldebug_line_end");
2295 symbol_set_value_now (start_sym
);
2299 start_sym
= symbol_temp_new_now_octets ();
2300 end_sym
= symbol_temp_make ();
2303 /* Total length of the information. */
2304 exp
->X_op
= O_subtract
;
2305 exp
->X_add_symbol
= end_sym
;
2306 exp
->X_op_symbol
= start_sym
;
2308 switch (DWARF2_FORMAT (sec
))
2310 case dwarf2_format_32bit
:
2311 exp
->X_add_number
= -4;
2315 case dwarf2_format_64bit
:
2316 exp
->X_add_number
= -12;
2321 case dwarf2_format_64bit_irix
:
2322 exp
->X_add_number
= -8;
2327 as_fatal (_("internal error: unknown dwarf2 format"));
2331 /* Emit the collected .debug_line data. */
2334 out_debug_line (segT line_seg
)
2337 symbolS
*prologue_start
, *prologue_end
;
2342 memset (&exp
, 0, sizeof exp
);
2343 sizeof_offset
= out_header (line_seg
, &exp
);
2344 line_end
= exp
.X_add_symbol
;
2347 out_two (DWARF2_LINE_VERSION
);
2349 if (DWARF2_LINE_VERSION
>= 5)
2351 out_byte (sizeof_address
);
2352 out_byte (0); /* Segment Selector size. */
2354 /* Length of the prologue following this length. */
2355 prologue_start
= symbol_temp_make ();
2356 prologue_end
= symbol_temp_make ();
2357 exp
.X_op
= O_subtract
;
2358 exp
.X_add_symbol
= prologue_end
;
2359 exp
.X_op_symbol
= prologue_start
;
2360 exp
.X_add_number
= 0;
2361 emit_expr (&exp
, sizeof_offset
);
2362 symbol_set_value_now (prologue_start
);
2364 /* Parameters of the state machine. */
2365 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2366 if (DWARF2_LINE_VERSION
>= 4)
2367 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2368 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2369 out_byte (DWARF2_LINE_BASE
);
2370 out_byte (DWARF2_LINE_RANGE
);
2371 out_byte (DWARF2_LINE_OPCODE_BASE
);
2373 /* Standard opcode lengths. */
2374 out_byte (0); /* DW_LNS_copy */
2375 out_byte (1); /* DW_LNS_advance_pc */
2376 out_byte (1); /* DW_LNS_advance_line */
2377 out_byte (1); /* DW_LNS_set_file */
2378 out_byte (1); /* DW_LNS_set_column */
2379 out_byte (0); /* DW_LNS_negate_stmt */
2380 out_byte (0); /* DW_LNS_set_basic_block */
2381 out_byte (0); /* DW_LNS_const_add_pc */
2382 out_byte (1); /* DW_LNS_fixed_advance_pc */
2383 out_byte (0); /* DW_LNS_set_prologue_end */
2384 out_byte (0); /* DW_LNS_set_epilogue_begin */
2385 out_byte (1); /* DW_LNS_set_isa */
2386 /* We have emitted 12 opcode lengths, so make that this
2387 matches up to the opcode base value we have been using. */
2388 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2390 out_dir_and_file_list (line_seg
, sizeof_offset
);
2392 symbol_set_value_now (prologue_end
);
2394 /* For each section, emit a statement program. */
2395 for (s
= all_segs
; s
; s
= s
->next
)
2396 /* Paranoia - this check should have already have
2397 been handled in dwarf2_gen_line_info_1(). */
2398 if (SEG_NORMAL (s
->seg
))
2399 process_entries (s
->seg
, s
->head
->head
);
2401 if (flag_dwarf_sections
)
2402 /* We have to switch to the special .debug_line_end section
2403 before emitting the end-of-debug_line symbol. The linker
2404 script arranges for this section to be placed after all the
2405 (potentially garbage collected) .debug_line.<foo> sections.
2406 This section contains the line_end symbol which is used to
2407 compute the size of the linked .debug_line section, as seen
2408 in the DWARF Line Number header. */
2409 subseg_set (subseg_get (".debug_line_end", false), 0);
2411 symbol_set_value_now (line_end
);
2415 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2417 unsigned int addr_size
= sizeof_address
;
2422 memset (&exp
, 0, sizeof exp
);
2423 subseg_set (ranges_seg
, 0);
2425 /* For DW_AT_ranges to point at (there is no header, so really start
2426 of section, but see out_debug_rnglists). */
2427 *ranges_sym
= symbol_temp_new_now_octets ();
2429 /* Base Address Entry. */
2430 for (i
= 0; i
< addr_size
; i
++)
2432 for (i
= 0; i
< addr_size
; i
++)
2435 /* Range List Entry. */
2436 for (s
= all_segs
; s
; s
= s
->next
)
2441 frag
= first_frag_for_seg (s
->seg
);
2442 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2443 s
->text_start
= beg
;
2445 frag
= last_frag_for_seg (s
->seg
);
2446 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2449 exp
.X_op
= O_symbol
;
2450 exp
.X_add_symbol
= beg
;
2451 exp
.X_add_number
= 0;
2452 emit_expr (&exp
, addr_size
);
2454 exp
.X_op
= O_symbol
;
2455 exp
.X_add_symbol
= end
;
2456 exp
.X_add_number
= 0;
2457 emit_expr (&exp
, addr_size
);
2460 /* End of Range Entry. */
2461 for (i
= 0; i
< addr_size
; i
++)
2463 for (i
= 0; i
< addr_size
; i
++)
2468 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2471 symbolS
*ranges_end
;
2475 memset (&exp
, 0, sizeof exp
);
2476 out_header (ranges_seg
, &exp
);
2477 ranges_end
= exp
.X_add_symbol
;
2479 out_two (DWARF2_RNGLISTS_VERSION
);
2480 out_byte (sizeof_address
);
2481 out_byte (0); /* Segment Selector size. */
2482 out_four (0); /* Offset entry count. */
2484 /* For DW_AT_ranges to point at (must be after the header). */
2485 *ranges_sym
= symbol_temp_new_now_octets ();
2487 for (s
= all_segs
; s
; s
= s
->next
)
2492 out_byte (DW_RLE_start_length
);
2494 frag
= first_frag_for_seg (s
->seg
);
2495 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2496 s
->text_start
= beg
;
2498 frag
= last_frag_for_seg (s
->seg
);
2499 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2502 exp
.X_op
= O_symbol
;
2503 exp
.X_add_symbol
= beg
;
2504 exp
.X_add_number
= 0;
2505 emit_expr (&exp
, sizeof_address
);
2507 exp
.X_op
= O_symbol
;
2508 exp
.X_add_symbol
= end
;
2509 exp
.X_add_number
= 0;
2510 emit_leb128_expr (&exp
, 0);
2513 out_byte (DW_RLE_end_of_list
);
2515 symbol_set_value_now (ranges_end
);
2518 /* Emit data for .debug_aranges. */
2521 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2523 unsigned int addr_size
= sizeof_address
;
2527 symbolS
*aranges_end
;
2531 memset (&exp
, 0, sizeof exp
);
2532 sizeof_offset
= out_header (aranges_seg
, &exp
);
2533 aranges_end
= exp
.X_add_symbol
;
2534 size
= -exp
.X_add_number
;
2537 out_two (DWARF2_ARANGES_VERSION
);
2540 /* Offset to .debug_info. */
2541 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2542 size
+= sizeof_offset
;
2544 /* Size of an address (offset portion). */
2545 out_byte (addr_size
);
2548 /* Size of a segment descriptor. */
2552 /* Align the header. */
2553 while ((size
++ % (2 * addr_size
)) > 0)
2556 for (s
= all_segs
; s
; s
= s
->next
)
2561 frag
= first_frag_for_seg (s
->seg
);
2562 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2563 s
->text_start
= beg
;
2565 frag
= last_frag_for_seg (s
->seg
);
2566 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2569 exp
.X_op
= O_symbol
;
2570 exp
.X_add_symbol
= beg
;
2571 exp
.X_add_number
= 0;
2572 emit_expr (&exp
, addr_size
);
2574 exp
.X_op
= O_subtract
;
2575 exp
.X_add_symbol
= end
;
2576 exp
.X_op_symbol
= beg
;
2577 exp
.X_add_number
= 0;
2578 emit_expr (&exp
, addr_size
);
2581 p
= frag_more (2 * addr_size
);
2582 md_number_to_chars (p
, 0, addr_size
);
2583 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2585 symbol_set_value_now (aranges_end
);
2588 /* Emit data for .debug_abbrev. Note that this must be kept in
2589 sync with out_debug_info below. */
2592 out_debug_abbrev (segT abbrev_seg
,
2593 segT info_seg ATTRIBUTE_UNUSED
,
2594 segT line_seg ATTRIBUTE_UNUSED
)
2597 subseg_set (abbrev_seg
, 0);
2600 out_uleb128 (DW_TAG_compile_unit
);
2601 out_byte (DW_CHILDREN_no
);
2602 if (DWARF2_VERSION
< 4)
2604 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2605 secoff_form
= DW_FORM_data4
;
2607 secoff_form
= DW_FORM_data8
;
2610 secoff_form
= DW_FORM_sec_offset
;
2611 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2612 if (all_segs
->next
== NULL
)
2614 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2615 if (DWARF2_VERSION
< 4)
2616 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2618 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2621 out_abbrev (DW_AT_ranges
, secoff_form
);
2622 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2623 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2624 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2625 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2628 /* Terminate the abbreviations for this compilation unit. */
2632 /* Emit a description of this compilation unit for .debug_info. */
2635 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2636 symbolS
*ranges_sym
, symbolS
*name_sym
,
2637 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2643 memset (&exp
, 0, sizeof exp
);
2644 sizeof_offset
= out_header (info_seg
, &exp
);
2645 info_end
= exp
.X_add_symbol
;
2647 /* DWARF version. */
2648 out_two (DWARF2_VERSION
);
2650 if (DWARF2_VERSION
< 5)
2652 /* .debug_abbrev offset */
2653 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2657 /* unit (header) type */
2658 out_byte (DW_UT_compile
);
2661 /* Target address size. */
2662 out_byte (sizeof_address
);
2664 if (DWARF2_VERSION
>= 5)
2666 /* .debug_abbrev offset */
2667 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2670 /* DW_TAG_compile_unit DIE abbrev */
2673 /* DW_AT_stmt_list */
2674 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2675 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2678 /* These two attributes are emitted if all of the code is contiguous. */
2679 if (all_segs
->next
== NULL
)
2682 exp
.X_op
= O_symbol
;
2683 exp
.X_add_symbol
= all_segs
->text_start
;
2684 exp
.X_add_number
= 0;
2685 emit_expr (&exp
, sizeof_address
);
2688 if (DWARF2_VERSION
< 4)
2689 exp
.X_op
= O_symbol
;
2692 exp
.X_op
= O_subtract
;
2693 exp
.X_op_symbol
= all_segs
->text_start
;
2695 exp
.X_add_symbol
= all_segs
->text_end
;
2696 exp
.X_add_number
= 0;
2697 if (DWARF2_VERSION
< 4)
2698 emit_expr (&exp
, sizeof_address
);
2700 emit_leb128_expr (&exp
, 0);
2704 /* This attribute is emitted if the code is disjoint. */
2706 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2709 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2710 setup in out_debug_str below. */
2711 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2712 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2713 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2715 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2716 dwarf2 draft has no standard code for assembler. */
2717 out_two (DW_LANG_Mips_Assembler
);
2719 symbol_set_value_now (info_end
);
2722 /* Emit the three debug strings needed in .debug_str and setup symbols
2723 to them for use in out_debug_info. */
2725 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2726 symbolS
**producer_sym
)
2729 const char *comp_dir
;
2730 const char *dirname
;
2733 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2735 subseg_set (str_seg
, 0);
2737 /* DW_AT_name. We don't have the actual file name that was present
2738 on the command line, so assume files[first_file] is the main input file.
2739 We're not supposed to get called unless at least one line number
2740 entry was emitted, so this should always be defined. */
2741 *name_sym
= symbol_temp_new_now_octets ();
2742 if (files_in_use
== 0)
2744 if (files
[first_file
].dir
)
2746 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2747 len
= strlen (dirname
);
2749 /* Already has trailing slash. */
2750 p
= frag_more (len
);
2751 memcpy (p
, dirname
, len
);
2753 p
= frag_more (len
+ 1);
2754 memcpy (p
, dirname
, len
);
2755 INSERT_DIR_SEPARATOR (p
, len
);
2758 len
= strlen (files
[first_file
].filename
) + 1;
2759 p
= frag_more (len
);
2760 memcpy (p
, files
[first_file
].filename
, len
);
2762 /* DW_AT_comp_dir */
2763 *comp_dir_sym
= symbol_temp_new_now_octets ();
2764 comp_dir
= remap_debug_filename (getpwd ());
2765 len
= strlen (comp_dir
) + 1;
2766 p
= frag_more (len
);
2767 memcpy (p
, comp_dir
, len
);
2769 /* DW_AT_producer */
2770 *producer_sym
= symbol_temp_new_now_octets ();
2771 sprintf (producer
, "GNU AS %s", VERSION
);
2772 len
= strlen (producer
) + 1;
2773 p
= frag_more (len
);
2774 memcpy (p
, producer
, len
);
2780 last_seg_ptr
= &all_segs
;
2782 /* Select the default CIE version to produce here. The global
2783 starts with a value of -1 and will be modified to a valid value
2784 either by the user providing a command line option, or some
2785 targets will select their own default in md_after_parse_args. If
2786 we get here and the global still contains -1 then it is up to us
2787 to pick a sane default. The default we choose is 1, this is the
2788 CIE version gas has produced for a long time, and there seems no
2789 reason to change it yet. */
2790 if (flag_dwarf_cie_version
== -1)
2791 flag_dwarf_cie_version
= 1;
2794 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2795 were any .file/.loc directives, or --gdwarf2 was given, and if the
2796 file has a non-empty .debug_info section and an empty .debug_line
2797 section. If we emit .debug_line, and the .debug_info section is
2798 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2799 ALL_SEGS will be non-null if there were any .file/.loc directives,
2800 or --gdwarf2 was given and there were any located instructions
2804 dwarf2_finish (void)
2809 int emit_other_sections
= 0;
2810 int empty_debug_line
= 0;
2812 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2813 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2815 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2816 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2818 /* We can't construct a new debug_line section if we already have one.
2819 Give an error if we have seen any .loc, otherwise trust the user
2820 knows what they are doing and want to generate the .debug_line
2821 (and all other debug sections) themselves. */
2822 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2823 as_fatal ("duplicate .debug_line sections");
2825 if ((!all_segs
&& emit_other_sections
)
2826 || (!emit_other_sections
&& !empty_debug_line
))
2827 /* If there is no line information and no non-empty .debug_info
2828 section, or if there is both a non-empty .debug_info and a non-empty
2829 .debug_line, then we do nothing. */
2832 /* Calculate the size of an address for the target machine. */
2833 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2835 /* Create and switch to the line number section. */
2836 if (empty_debug_line
)
2838 line_seg
= subseg_new (".debug_line", 0);
2839 bfd_set_section_flags (line_seg
,
2840 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2843 /* For each subsection, chain the debug entries together. */
2844 for (s
= all_segs
; s
; s
= s
->next
)
2846 struct line_subseg
*lss
= s
->head
;
2847 struct line_entry
**ptail
= lss
->ptail
;
2849 /* Reset the initial view of the first subsection of the
2851 if (lss
->head
&& lss
->head
->loc
.view
)
2852 set_or_check_view (lss
->head
, NULL
, NULL
);
2854 while ((lss
= lss
->next
) != NULL
)
2856 /* Link the first view of subsequent subsections to the
2858 if (lss
->head
&& lss
->head
->loc
.view
)
2859 set_or_check_view (lss
->head
,
2860 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2861 s
->head
? s
->head
->head
: NULL
);
2867 if (empty_debug_line
)
2868 out_debug_line (line_seg
);
2870 /* If this is assembler generated line info, and there is no
2871 debug_info already, we need .debug_info, .debug_abbrev and
2872 .debug_str sections as well. */
2873 if (emit_other_sections
)
2878 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2880 gas_assert (all_segs
);
2882 info_seg
= subseg_new (".debug_info", 0);
2883 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2884 aranges_seg
= subseg_new (".debug_aranges", 0);
2885 str_seg
= subseg_new (".debug_str", 0);
2887 bfd_set_section_flags (info_seg
,
2888 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2889 bfd_set_section_flags (abbrev_seg
,
2890 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2891 bfd_set_section_flags (aranges_seg
,
2892 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2893 bfd_set_section_flags (str_seg
,
2894 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2895 | SEC_MERGE
| SEC_STRINGS
);
2896 str_seg
->entsize
= 1;
2898 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2900 if (all_segs
->next
== NULL
)
2904 if (DWARF2_VERSION
< 5)
2906 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2907 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2910 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2911 out_debug_ranges (ranges_seg
, &ranges_sym
);
2915 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2916 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2919 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2923 out_debug_aranges (aranges_seg
, info_seg
);
2924 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2925 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2926 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2927 name_sym
, comp_dir_sym
, producer_sym
);
2931 /* Perform any deferred checks pertaining to debug information. */
2934 dwarf2dbg_final_check (void)
2936 /* Perform reset-view checks. Don't evaluate view_assert_failed
2937 recursively: it could be very deep. It's a chain of adds, with
2938 each chain element pointing to the next in X_add_symbol, and
2939 holding the check value in X_op_symbol. */
2940 while (view_assert_failed
)
2946 gas_assert (!symbol_resolved_p (view_assert_failed
));
2948 exp
= symbol_get_value_expression (view_assert_failed
);
2949 sym
= view_assert_failed
;
2951 /* If view_assert_failed looks like a compound check in the
2952 chain, break it up. */
2953 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2955 view_assert_failed
= exp
->X_add_symbol
;
2956 sym
= exp
->X_op_symbol
;
2959 view_assert_failed
= NULL
;
2961 failed
= resolve_symbol_value (sym
);
2962 if (!symbol_resolved_p (sym
) || failed
)
2964 as_bad (_("view number mismatch"));