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. */
212 static char ** dirs
= NULL
;
213 static unsigned int dirs_in_use
= 0;
214 static unsigned int dirs_allocated
= 0;
216 /* TRUE when we've seen a .loc directive recently. Used to avoid
217 doing work when there's nothing to do. Will be reset by
218 dwarf2_consume_line_info. */
219 bool dwarf2_loc_directive_seen
;
221 /* TRUE when we've seen any .loc directive at any time during parsing.
222 Indicates the user wants us to generate a .debug_line section.
223 Used in dwarf2_finish as sanity check. */
224 static bool dwarf2_any_loc_directive_seen
;
226 /* TRUE when we're supposed to set the basic block mark whenever a
228 bool dwarf2_loc_mark_labels
;
230 /* Current location as indicated by the most recent .loc directive. */
231 static struct dwarf2_line_info current
=
234 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
238 /* This symbol is used to recognize view number forced resets in loc
240 static symbolS
*force_reset_view
;
242 /* This symbol evaluates to an expression that, if nonzero, indicates
243 some view assert check failed. */
244 static symbolS
*view_assert_failed
;
246 /* The size of an address on the target. */
247 static unsigned int sizeof_address
;
249 #ifndef TC_DWARF2_EMIT_OFFSET
250 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
252 /* Create an offset to .dwarf2_*. */
255 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
259 memset (&exp
, 0, sizeof exp
);
261 exp
.X_add_symbol
= symbol
;
262 exp
.X_add_number
= 0;
263 emit_expr (&exp
, size
);
267 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
269 static struct line_subseg
*
270 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
272 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
273 struct line_subseg
**pss
, *lss
;
280 s
= XNEW (struct line_seg
);
285 last_seg_ptr
= &s
->next
;
286 seg_info (seg
)->dwarf2_line_seg
= s
;
289 gas_assert (seg
== s
->seg
);
291 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
293 if (lss
->subseg
== subseg
)
295 if (lss
->subseg
> subseg
)
299 lss
= XNEW (struct line_subseg
);
301 lss
->subseg
= subseg
;
303 lss
->ptail
= &lss
->head
;
304 lss
->pmove_tail
= &lss
->head
;
311 /* (Un)reverse the line_entry list starting from H. */
313 static struct line_entry
*
314 reverse_line_entry_list (struct line_entry
*h
)
316 struct line_entry
*p
= NULL
, *e
, *n
;
318 for (e
= h
; e
; e
= n
)
327 /* Compute the view for E based on the previous entry P. If we
328 introduce an (undefined) view symbol for P, and H is given (P must
329 be the tail in this case), introduce view symbols for earlier list
330 entries as well, until one of them is constant. */
333 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
334 struct line_entry
*h
)
338 memset (&viewx
, 0, sizeof (viewx
));
339 viewx
.X_unsigned
= 1;
341 /* First, compute !(E->label > P->label), to tell whether or not
342 we're to reset the view number. If we can't resolve it to a
343 constant, keep it symbolic. */
344 if (!p
|| (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
))
346 viewx
.X_op
= O_constant
;
347 viewx
.X_add_number
= 0;
348 viewx
.X_add_symbol
= NULL
;
349 viewx
.X_op_symbol
= NULL
;
354 viewx
.X_add_number
= 0;
355 viewx
.X_add_symbol
= e
->label
;
356 viewx
.X_op_symbol
= p
->label
;
357 resolve_expression (&viewx
);
358 if (viewx
.X_op
== O_constant
)
359 viewx
.X_add_number
= !viewx
.X_add_number
;
362 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
363 viewx
.X_add_number
= 0;
364 viewx
.X_op_symbol
= NULL
;
365 viewx
.X_op
= O_logical_not
;
369 if (S_IS_DEFINED (e
->loc
.u
.view
) && symbol_constant_p (e
->loc
.u
.view
))
371 expressionS
*value
= symbol_get_value_expression (e
->loc
.u
.view
);
372 /* We can't compare the view numbers at this point, because in
373 VIEWX we've only determined whether we're to reset it so
375 if (viewx
.X_op
== O_constant
)
377 if (!value
->X_add_number
!= !viewx
.X_add_number
)
378 as_bad (_("view number mismatch"));
380 /* Record the expression to check it later. It is the result of
381 a logical not, thus 0 or 1. We just add up all such deferred
382 expressions, and resolve it at the end. */
383 else if (!value
->X_add_number
)
385 symbolS
*deferred
= make_expr_symbol (&viewx
);
386 if (view_assert_failed
)
390 memset (&chk
, 0, sizeof (chk
));
393 chk
.X_add_number
= 0;
394 chk
.X_add_symbol
= view_assert_failed
;
395 chk
.X_op_symbol
= deferred
;
396 deferred
= make_expr_symbol (&chk
);
398 view_assert_failed
= deferred
;
402 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
408 p
->loc
.u
.view
= symbol_temp_make ();
410 memset (&incv
, 0, sizeof (incv
));
412 incv
.X_op
= O_symbol
;
413 incv
.X_add_symbol
= p
->loc
.u
.view
;
414 incv
.X_add_number
= 1;
415 p_view
= symbol_get_value_expression (p
->loc
.u
.view
);
416 if (p_view
->X_op
== O_constant
|| p_view
->X_op
== O_symbol
)
418 /* If we can, constant fold increments so that a chain of
419 expressions v + 1 + 1 ... + 1 is not created.
420 resolve_expression isn't ideal for this purpose. The
421 base v might not be resolvable until later. */
422 incv
.X_op
= p_view
->X_op
;
423 incv
.X_add_symbol
= p_view
->X_add_symbol
;
424 incv
.X_add_number
= p_view
->X_add_number
+ 1;
427 if (viewx
.X_op
== O_constant
)
429 gas_assert (viewx
.X_add_number
== 1);
434 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
435 viewx
.X_add_number
= 0;
436 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
437 viewx
.X_op
= O_multiply
;
441 if (!S_IS_DEFINED (e
->loc
.u
.view
))
443 symbol_set_value_expression (e
->loc
.u
.view
, &viewx
);
444 S_SET_SEGMENT (e
->loc
.u
.view
, expr_section
);
445 symbol_set_frag (e
->loc
.u
.view
, &zero_address_frag
);
448 /* Define and attempt to simplify any earlier views needed to
450 if (h
&& p
&& p
->loc
.u
.view
&& !S_IS_DEFINED (p
->loc
.u
.view
))
452 struct line_entry
*h2
;
453 /* Reverse the list to avoid quadratic behavior going backwards
454 in a single-linked list. */
455 struct line_entry
*r
= reverse_line_entry_list (h
);
458 /* Set or check views until we find a defined or absent view. */
461 /* Do not define the head of a (sub?)segment view while
462 handling others. It would be defined too early, without
463 regard to the last view of other subsegments.
464 set_or_check_view will be called for every head segment
468 set_or_check_view (r
, r
->next
, NULL
);
471 && r
->next
->loc
.u
.view
472 && !S_IS_DEFINED (r
->next
->loc
.u
.view
)
475 /* Unreverse the list, so that we can go forward again. */
476 h2
= reverse_line_entry_list (p
);
477 gas_assert (h2
== h
);
479 /* Starting from the last view we just defined, attempt to
480 simplify the view expressions, until we do so to P. */
483 /* The head view of a subsegment may remain undefined while
484 handling other elements, before it is linked to the last
485 view of the previous subsegment. */
488 gas_assert (S_IS_DEFINED (r
->loc
.u
.view
));
489 resolve_expression (symbol_get_value_expression (r
->loc
.u
.view
));
491 while (r
!= p
&& (r
= r
->next
));
493 /* Now that we've defined and computed all earlier views that might
494 be needed to compute E's, attempt to simplify it. */
495 resolve_expression (symbol_get_value_expression (e
->loc
.u
.view
));
499 /* Record an entry for LOC occurring at LABEL. */
502 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
504 struct line_subseg
*lss
;
505 struct line_entry
*e
;
506 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
508 /* PR 26850: Do not record LOCs in non-executable or non-loaded
509 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
510 obj_coff_section is careless in setting SEC_ALLOC. */
512 need_flags
|= SEC_ALLOC
;
513 if ((now_seg
->flags
& need_flags
) != need_flags
)
515 /* FIXME: Add code to suppress multiple warnings ? */
516 if (debug_type
!= DEBUG_DWARF2
)
517 as_warn ("dwarf line number information for %s ignored",
518 segment_name (now_seg
));
522 e
= XNEW (struct line_entry
);
527 lss
= get_line_subseg (now_seg
, now_subseg
, true);
529 /* Subseg heads are chained to previous subsegs in
531 if (loc
->filenum
!= -1u && loc
->u
.view
&& lss
->head
)
532 set_or_check_view (e
, (struct line_entry
*) lss
->ptail
, lss
->head
);
535 lss
->ptail
= &e
->next
;
538 /* Record an entry for LOC occurring at OFS within the current fragment. */
541 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
545 /* Early out for as-yet incomplete location information. */
548 if (loc
->filenum
== 0)
552 if (DWARF2_LINE_VERSION
< 5)
556 /* Don't emit sequences of line symbols for the same line when the
557 symbols apply to assembler code. It is necessary to emit
558 duplicate line symbols when a compiler asks for them, because GDB
559 uses them to determine the end of the prologue. */
560 if (debug_type
== DEBUG_DWARF2
)
562 static unsigned int line
= -1;
563 static const char *filename
= NULL
;
565 if (line
== loc
->line
)
567 if (filename
== loc
->u
.filename
)
569 if (filename_cmp (filename
, loc
->u
.filename
) == 0)
571 filename
= loc
->u
.filename
;
577 filename
= loc
->u
.filename
;
582 static int label_num
= 0;
585 /* Use a non-fake name for the line number location,
586 so that it can be referred to by relocations. */
587 sprintf (name
, ".Loc.%u", label_num
);
589 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
592 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
593 dwarf2_gen_line_info_1 (sym
, loc
);
597 get_basename (const char * pathname
)
601 file
= lbasename (pathname
);
602 /* Don't make empty string from / or A: from A:/ . */
603 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
604 if (file
<= pathname
+ 3)
607 if (file
== pathname
+ 1)
614 get_directory_table_entry (const char *dirname
,
615 const char *file0_dirname
,
624 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
625 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
633 for (d
= 0; d
< dirs_in_use
; ++d
)
636 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
637 && dirs
[d
][dirlen
] == '\0')
643 if (dirs
== NULL
|| dirs
[0] == NULL
)
645 const char * pwd
= file0_dirname
? file0_dirname
: getpwd ();
647 if (dwarf_level
>= 5 && filename_cmp (dirname
, pwd
) != 0)
649 /* In DWARF-5 the 0 entry in the directory table is
650 expected to be the same as the DW_AT_comp_dir (which
651 is set to the current build directory). Since we are
652 about to create a directory entry that is not the
653 same, allocate the current directory first. */
654 (void) get_directory_table_entry (pwd
, file0_dirname
,
665 if (d
>= dirs_allocated
)
667 unsigned int old
= dirs_allocated
;
668 #define DIR_TABLE_INCREMENT 32
669 dirs_allocated
= d
+ DIR_TABLE_INCREMENT
;
670 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
671 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
674 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
675 if (dirs_in_use
<= d
)
682 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
684 if (i
>= files_allocated
)
686 unsigned int old
= files_allocated
;
688 files_allocated
= i
+ 32;
689 /* Catch wraparound. */
690 if (files_allocated
<= old
)
692 as_bad (_("file number %lu is too big"), (unsigned long) i
);
696 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
697 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
700 files
[i
].filename
= file
;
702 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
704 if (files_in_use
< i
+ 1)
705 files_in_use
= i
+ 1;
710 /* Get a .debug_line file number for PATHNAME. If there is a
711 directory component to PATHNAME, then this will be stored
712 in the directory table, if it is not already present.
713 Returns the slot number allocated to that filename or -1
714 if there was a problem. */
717 allocate_filenum (const char * pathname
)
719 static signed int last_used
= -1, last_used_dir_len
= 0;
724 /* Short circuit the common case of adding the same pathname
728 const char * dirname
= NULL
;
731 dirname
= dirs
[files
[last_used
].dir
];
735 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
740 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
- 1) == 0
741 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
- 1])
742 && filename_cmp (pathname
+ last_used_dir_len
,
743 files
[last_used
].filename
) == 0)
748 file
= get_basename (pathname
);
749 dir_len
= file
- pathname
;
751 dir
= get_directory_table_entry (pathname
, NULL
, dir_len
, false);
753 /* Do not use slot-0. That is specifically reserved for use by
754 the '.file 0 "name"' directive. */
755 for (i
= 1; i
< files_in_use
; ++i
)
756 if (files
[i
].dir
== dir
758 && filename_cmp (file
, files
[i
].filename
) == 0)
761 last_used_dir_len
= dir_len
;
765 if (!assign_file_to_slot (i
, file
, dir
))
769 last_used_dir_len
= dir_len
;
774 /* Run through the list of line entries starting at E, allocating
775 file entries for gas generated debug. */
778 do_allocate_filenum (struct line_entry
*e
)
782 if (e
->loc
.filenum
== -1u)
784 e
->loc
.filenum
= allocate_filenum (e
->loc
.u
.filename
);
785 e
->loc
.u
.view
= NULL
;
792 /* Remove any generated line entries. These don't live comfortably
793 with compiler generated line info. */
796 purge_generated_debug (void)
800 for (s
= all_segs
; s
; s
= s
->next
)
802 struct line_subseg
*lss
;
804 for (lss
= s
->head
; lss
; lss
= lss
->next
)
806 struct line_entry
*e
, *next
;
808 for (e
= lss
->head
; e
; e
= next
)
810 know (e
->loc
.filenum
== -1u);
816 lss
->ptail
= &lss
->head
;
817 lss
->pmove_tail
= &lss
->head
;
822 /* Allocate slot NUM in the .debug_line file table to FILENAME.
823 If DIRNAME is not NULL or there is a directory component to FILENAME
824 then this will be stored in the directory table, if not already present.
825 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
826 Returns TRUE if allocation succeeded, FALSE otherwise. */
829 allocate_filename_to_slot (const char *dirname
,
830 const char *filename
,
837 const char *file0_dirname
;
839 /* Short circuit the common case of adding the same pathname
841 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
843 const char * dir
= NULL
;
846 dir
= dirs
[files
[num
].dir
];
849 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
854 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
857 if (filename_cmp (filename
, files
[num
].filename
) != 0)
860 /* If the filenames match, but the directory table entry was
861 empty, then fill it with the provided directory name. */
866 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
867 dirs
= XCNEWVEC (char *, dirs_allocated
);
870 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
875 else if (dir
!= NULL
)
877 dirlen
= strlen (dir
);
878 if (filename_ncmp (filename
, dir
, dirlen
) == 0
879 && IS_DIR_SEPARATOR (filename
[dirlen
])
880 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
883 else /* dir == NULL */
885 file
= get_basename (filename
);
886 if (filename_cmp (file
, files
[num
].filename
) == 0)
888 /* The filenames match, but the directory table entry is empty.
889 Fill it with the provided directory name. */
894 dirs_allocated
= files
[num
].dir
+ DIR_TABLE_INCREMENT
;
895 dirs
= XCNEWVEC (char *, dirs_allocated
);
898 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
905 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
907 dir
== NULL
? "" : dir
,
908 dir
== NULL
? "" : "/",
910 dirname
== NULL
? "" : dirname
,
911 dirname
== NULL
? "" : "/",
916 /* For file .0, the directory name is the current directory and the file
917 may be in another directory contained in the file name. */
920 file0_dirname
= dirname
;
922 file
= get_basename (filename
);
924 if (dirname
&& file
== filename
)
925 dirlen
= strlen (dirname
);
929 dirlen
= file
- filename
;
934 file0_dirname
= NULL
;
939 file
= get_basename (filename
);
940 dirlen
= file
- filename
;
944 dirlen
= strlen (dirname
);
949 d
= get_directory_table_entry (dirname
, file0_dirname
, dirlen
, num
== 0);
952 if (! assign_file_to_slot (i
, file
, d
))
957 if (target_big_endian
)
959 /* md5's are stored in litte endian format. */
960 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
961 unsigned int byte
= NUM_MD5_BYTES
;
962 unsigned int bignum_index
= 0;
964 while (bits_remaining
)
966 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
967 valueT bignum_value
= generic_bignum
[bignum_index
];
970 while (bignum_bits_remaining
)
972 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
974 bignum_bits_remaining
-= 8;
981 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
982 unsigned int byte
= 0;
983 unsigned int bignum_index
= 0;
985 while (bits_remaining
)
987 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
988 valueT bignum_value
= generic_bignum
[bignum_index
];
992 while (bignum_bits_remaining
)
994 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
996 bignum_bits_remaining
-= 8;
1003 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
1008 /* Returns the current source information. If .file directives have
1009 been encountered, the info for the corresponding source file is
1010 returned. Otherwise, the info for the assembly source file is
1014 dwarf2_where (struct dwarf2_line_info
*line
)
1016 if (debug_type
== DEBUG_DWARF2
)
1018 line
->u
.filename
= as_where (&line
->line
);
1019 line
->filenum
= -1u;
1021 line
->flags
= DWARF2_FLAG_IS_STMT
;
1022 line
->isa
= current
.isa
;
1023 line
->discriminator
= current
.discriminator
;
1029 /* A hook to allow the target backend to inform the line number state
1030 machine of isa changes when assembler debug info is enabled. */
1033 dwarf2_set_isa (unsigned int isa
)
1038 /* Called for each machine instruction, or relatively atomic group of
1039 machine instructions (ie built-in macro). The instruction or group
1040 is SIZE bytes in length. If dwarf2 line number generation is called
1041 for, emit a line statement appropriately. */
1044 dwarf2_emit_insn (int size
)
1046 struct dwarf2_line_info loc
;
1048 if (debug_type
!= DEBUG_DWARF2
1049 ? !dwarf2_loc_directive_seen
1050 : !seen_at_least_1_file ())
1053 dwarf2_where (&loc
);
1055 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
1056 dwarf2_consume_line_info ();
1059 /* Move all previously-emitted line entries for the current position by
1060 DELTA bytes. This function cannot be used to move the same entries
1064 dwarf2_move_insn (int delta
)
1066 struct line_subseg
*lss
;
1067 struct line_entry
*e
;
1073 lss
= get_line_subseg (now_seg
, now_subseg
, false);
1077 now
= frag_now_fix ();
1078 while ((e
= *lss
->pmove_tail
))
1080 if (S_GET_VALUE (e
->label
) == now
)
1081 S_SET_VALUE (e
->label
, now
+ delta
);
1082 lss
->pmove_tail
= &e
->next
;
1086 /* Called after the current line information has been either used with
1087 dwarf2_gen_line_info or saved with a machine instruction for later use.
1088 This resets the state of the line number information to reflect that
1089 it has been used. */
1092 dwarf2_consume_line_info (void)
1094 /* Unless we generate DWARF2 debugging information for each
1095 assembler line, we only emit one line symbol for one LOC. */
1096 dwarf2_loc_directive_seen
= false;
1098 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1099 | DWARF2_FLAG_PROLOGUE_END
1100 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1101 current
.discriminator
= 0;
1102 current
.u
.view
= NULL
;
1105 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1106 is enabled, emit a basic block marker. */
1109 dwarf2_emit_label (symbolS
*label
)
1111 struct dwarf2_line_info loc
;
1113 if (!dwarf2_loc_mark_labels
)
1115 if (S_GET_SEGMENT (label
) != now_seg
)
1117 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1119 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1122 dwarf2_where (&loc
);
1124 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1126 dwarf2_gen_line_info_1 (label
, &loc
);
1127 dwarf2_consume_line_info ();
1130 /* Handle two forms of .file directive:
1131 - Pass .file "source.c" to s_app_file
1132 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1134 If an entry is added to the file table, return a pointer to the filename. */
1137 dwarf2_directive_filename (void)
1139 bool with_md5
= false;
1142 const char * dirname
= NULL
;
1145 /* Continue to accept a bare string and pass it off. */
1147 if (*input_line_pointer
== '"')
1153 num
= get_absolute_expression ();
1155 if ((offsetT
) num
< 1)
1157 if (num
== 0 && dwarf_level
< 5)
1159 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1161 as_bad (_("file number less than one"));
1162 ignore_rest_of_line ();
1167 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1168 "switch back to the already allocated file <N> as the current
1171 filename
= demand_copy_C_string (&filename_len
);
1172 if (filename
== NULL
)
1173 /* demand_copy_C_string will have already generated an error message. */
1176 /* For DWARF-5 support we also accept:
1177 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1178 if (DWARF2_LINE_VERSION
> 4)
1181 if (*input_line_pointer
== '"')
1184 filename
= demand_copy_C_string (&filename_len
);
1188 if (startswith (input_line_pointer
, "md5"))
1190 input_line_pointer
+= 3;
1194 expression_and_evaluate (& exp
);
1195 if (exp
.X_op
!= O_big
)
1196 as_bad (_("md5 value too small or not a constant"));
1202 demand_empty_rest_of_line ();
1204 /* A .file directive implies compiler generated debug information is
1205 being supplied. Turn off gas generated debug info. */
1206 if (debug_type
== DEBUG_DWARF2
)
1207 purge_generated_debug ();
1208 debug_type
= DEBUG_NONE
;
1210 if (num
!= (unsigned int) num
1211 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1213 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1217 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1224 /* Calls dwarf2_directive_filename, but discards its result.
1225 Used in pseudo-op tables where the function result is ignored. */
1228 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1230 (void) dwarf2_directive_filename ();
1234 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1236 offsetT filenum
, line
;
1238 /* If we see two .loc directives in a row, force the first one to be
1240 if (dwarf2_loc_directive_seen
)
1241 dwarf2_emit_insn (0);
1243 filenum
= get_absolute_expression ();
1245 line
= get_absolute_expression ();
1249 if (filenum
== 0 && dwarf_level
< 5)
1251 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1253 as_bad (_("file number less than one"));
1258 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1260 as_bad (_("unassigned file number %ld"), (long) filenum
);
1264 /* debug_type will be turned off by dwarf2_directive_filename, and
1265 if we don't have a dwarf style .file then files_in_use will be
1266 zero and the above error will trigger. */
1267 gas_assert (debug_type
== DEBUG_NONE
);
1269 current
.filenum
= filenum
;
1270 current
.line
= line
;
1271 current
.discriminator
= 0;
1276 if (files
[filenum
].dir
)
1278 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1279 size_t file_len
= strlen (files
[filenum
].filename
);
1280 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1282 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1283 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1284 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1285 cp
[dir_len
+ file_len
+ 1] = '\0';
1286 listing_source_file (cp
);
1290 listing_source_file (files
[filenum
].filename
);
1291 listing_source_line (line
);
1296 if (ISDIGIT (*input_line_pointer
))
1298 current
.column
= get_absolute_expression ();
1302 while (ISALPHA (*input_line_pointer
))
1307 c
= get_symbol_name (& p
);
1309 if (strcmp (p
, "basic_block") == 0)
1311 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1312 *input_line_pointer
= c
;
1314 else if (strcmp (p
, "prologue_end") == 0)
1316 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1317 *input_line_pointer
= c
;
1319 else if (strcmp (p
, "epilogue_begin") == 0)
1321 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1322 *input_line_pointer
= c
;
1324 else if (strcmp (p
, "is_stmt") == 0)
1326 (void) restore_line_pointer (c
);
1327 value
= get_absolute_expression ();
1329 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1330 else if (value
== 1)
1331 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1334 as_bad (_("is_stmt value not 0 or 1"));
1338 else if (strcmp (p
, "isa") == 0)
1340 (void) restore_line_pointer (c
);
1341 value
= get_absolute_expression ();
1343 current
.isa
= value
;
1346 as_bad (_("isa number less than zero"));
1350 else if (strcmp (p
, "discriminator") == 0)
1352 (void) restore_line_pointer (c
);
1353 value
= get_absolute_expression ();
1355 current
.discriminator
= value
;
1358 as_bad (_("discriminator less than zero"));
1362 else if (strcmp (p
, "view") == 0)
1366 (void) restore_line_pointer (c
);
1369 if (ISDIGIT (*input_line_pointer
)
1370 || *input_line_pointer
== '-')
1372 bool force_reset
= *input_line_pointer
== '-';
1374 value
= get_absolute_expression ();
1377 as_bad (_("numeric view can only be asserted to zero"));
1380 if (force_reset
&& force_reset_view
)
1381 sym
= force_reset_view
;
1384 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1387 force_reset_view
= sym
;
1392 char *name
= read_symbol_name ();
1396 sym
= symbol_find_or_make (name
);
1397 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1399 if (S_IS_VOLATILE (sym
))
1400 sym
= symbol_clone (sym
, 1);
1401 else if (!S_CAN_BE_REDEFINED (sym
))
1403 as_bad (_("symbol `%s' is already defined"), name
);
1407 S_SET_SEGMENT (sym
, undefined_section
);
1408 S_SET_VALUE (sym
, 0);
1409 symbol_set_frag (sym
, &zero_address_frag
);
1411 current
.u
.view
= sym
;
1415 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1416 (void) restore_line_pointer (c
);
1420 SKIP_WHITESPACE_AFTER_NAME ();
1423 demand_empty_rest_of_line ();
1424 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1426 /* If we were given a view id, emit the row right away. */
1428 dwarf2_emit_insn (0);
1432 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1434 offsetT value
= get_absolute_expression ();
1436 if (value
!= 0 && value
!= 1)
1438 as_bad (_("expected 0 or 1"));
1439 ignore_rest_of_line ();
1443 dwarf2_loc_mark_labels
= value
!= 0;
1444 demand_empty_rest_of_line ();
1448 static struct frag
*
1449 first_frag_for_seg (segT seg
)
1451 return seg_info (seg
)->frchainP
->frch_root
;
1454 static struct frag
*
1455 last_frag_for_seg (segT seg
)
1457 frchainS
*f
= seg_info (seg
)->frchainP
;
1459 while (f
->frch_next
!= NULL
)
1462 return f
->frch_last
;
1465 /* Emit a single byte into the current segment. */
1470 FRAG_APPEND_1_CHAR (byte
);
1473 /* Emit a statement program opcode into the current segment. */
1476 out_opcode (int opc
)
1481 /* Emit a two-byte word into the current segment. */
1486 md_number_to_chars (frag_more (2), data
, 2);
1489 /* Emit a four byte word into the current segment. */
1494 md_number_to_chars (frag_more (4), data
, 4);
1497 /* Emit an unsigned "little-endian base 128" number. */
1500 out_uleb128 (addressT value
)
1502 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1505 /* Emit a signed "little-endian base 128" number. */
1508 out_leb128 (addressT value
)
1510 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1513 /* Emit a tuple for .debug_abbrev. */
1516 out_abbrev (int name
, int form
)
1522 /* Get the size of a fragment. */
1525 get_frag_fix (fragS
*frag
, segT seg
)
1530 return frag
->fr_fix
;
1532 /* If a fragment is the last in the chain, special measures must be
1533 taken to find its size before relaxation, since it may be pending
1534 on some subsegment chain. */
1535 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1536 if (fr
->frch_last
== frag
)
1537 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1542 /* Set an absolute address (may result in a relocation entry). */
1545 out_set_addr (symbolS
*sym
)
1549 memset (&exp
, 0, sizeof exp
);
1550 out_opcode (DW_LNS_extended_op
);
1551 out_uleb128 (sizeof_address
+ 1);
1553 out_opcode (DW_LNE_set_address
);
1554 exp
.X_op
= O_symbol
;
1555 exp
.X_add_symbol
= sym
;
1556 exp
.X_add_number
= 0;
1557 emit_expr (&exp
, sizeof_address
);
1560 static void scale_addr_delta (addressT
*);
1563 scale_addr_delta (addressT
*addr_delta
)
1565 static int printed_this
= 0;
1566 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1568 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1570 as_bad("unaligned opcodes detected in executable segment");
1573 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1577 /* Encode a pair of line and address skips as efficiently as possible.
1578 Note that the line skip is signed, whereas the address skip is unsigned.
1580 The following two routines *must* be kept in sync. This is
1581 enforced by making emit_inc_line_addr abort if we do not emit
1582 exactly the expected number of bytes. */
1585 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1587 unsigned int tmp
, opcode
;
1590 /* Scale the address delta by the minimum instruction length. */
1591 scale_addr_delta (&addr_delta
);
1593 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1594 We cannot use special opcodes here, since we want the end_sequence
1595 to emit the matrix entry. */
1596 if (line_delta
== INT_MAX
)
1598 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1600 else if (addr_delta
)
1601 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1605 /* Bias the line delta by the base. */
1606 tmp
= line_delta
- DWARF2_LINE_BASE
;
1608 /* If the line increment is out of range of a special opcode, we
1609 must encode it with DW_LNS_advance_line. */
1610 if (tmp
>= DWARF2_LINE_RANGE
)
1612 len
= 1 + sizeof_leb128 (line_delta
, 1);
1614 tmp
= 0 - DWARF2_LINE_BASE
;
1617 /* Bias the opcode by the special opcode base. */
1618 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1620 /* Avoid overflow when addr_delta is large. */
1621 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1623 /* Try using a special opcode. */
1624 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1628 /* Try using DW_LNS_const_add_pc followed by special op. */
1629 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1634 /* Otherwise use DW_LNS_advance_pc. */
1635 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1637 /* DW_LNS_copy or special opcode. */
1644 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1646 unsigned int tmp
, opcode
;
1648 char *end
= p
+ len
;
1650 /* Line number sequences cannot go backward in addresses. This means
1651 we've incorrectly ordered the statements in the sequence. */
1652 gas_assert ((offsetT
) addr_delta
>= 0);
1654 /* Scale the address delta by the minimum instruction length. */
1655 scale_addr_delta (&addr_delta
);
1657 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1658 We cannot use special opcodes here, since we want the end_sequence
1659 to emit the matrix entry. */
1660 if (line_delta
== INT_MAX
)
1662 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1663 *p
++ = DW_LNS_const_add_pc
;
1664 else if (addr_delta
)
1666 *p
++ = DW_LNS_advance_pc
;
1667 p
+= output_leb128 (p
, addr_delta
, 0);
1670 *p
++ = DW_LNS_extended_op
;
1672 *p
++ = DW_LNE_end_sequence
;
1676 /* Bias the line delta by the base. */
1677 tmp
= line_delta
- DWARF2_LINE_BASE
;
1679 /* If the line increment is out of range of a special opcode, we
1680 must encode it with DW_LNS_advance_line. */
1681 if (tmp
>= DWARF2_LINE_RANGE
)
1683 *p
++ = DW_LNS_advance_line
;
1684 p
+= output_leb128 (p
, line_delta
, 1);
1687 tmp
= 0 - DWARF2_LINE_BASE
;
1691 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1693 if (line_delta
== 0 && addr_delta
== 0)
1699 /* Bias the opcode by the special opcode base. */
1700 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1702 /* Avoid overflow when addr_delta is large. */
1703 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1705 /* Try using a special opcode. */
1706 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1713 /* Try using DW_LNS_const_add_pc followed by special op. */
1714 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1717 *p
++ = DW_LNS_const_add_pc
;
1723 /* Otherwise use DW_LNS_advance_pc. */
1724 *p
++ = DW_LNS_advance_pc
;
1725 p
+= output_leb128 (p
, addr_delta
, 0);
1733 gas_assert (p
== end
);
1736 /* Handy routine to combine calls to the above two routines. */
1739 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1741 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1742 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1745 /* Write out an alternative form of line and address skips using
1746 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1747 line and address information, but it is required if linker relaxation
1748 could change the code offsets. The following two routines *must* be
1750 #define ADDR_DELTA_LIMIT 50000
1753 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1757 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1758 if (line_delta
!= INT_MAX
)
1759 len
= 1 + sizeof_leb128 (line_delta
, 1);
1761 if (addr_delta
> ADDR_DELTA_LIMIT
)
1763 /* DW_LNS_extended_op */
1764 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1765 /* DW_LNE_set_address */
1766 len
+= 1 + sizeof_address
;
1769 /* DW_LNS_fixed_advance_pc */
1772 if (line_delta
== INT_MAX
)
1773 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1783 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1787 char *end
= p
+ len
;
1789 /* Line number sequences cannot go backward in addresses. This means
1790 we've incorrectly ordered the statements in the sequence. */
1791 gas_assert ((offsetT
) addr_delta
>= 0);
1793 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1794 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1796 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1797 if (line_delta
!= INT_MAX
)
1799 *p
++ = DW_LNS_advance_line
;
1800 p
+= output_leb128 (p
, line_delta
, 1);
1803 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1805 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1806 advance the address by at most 64K. Linker relaxation (without
1807 which this function would not be used) could change the operand by
1808 an unknown amount. If the address increment is getting close to
1809 the limit, just reset the address. */
1810 if (addr_delta
> ADDR_DELTA_LIMIT
)
1815 memset (&exp
, 0, sizeof exp
);
1816 gas_assert (pexp
->X_op
== O_subtract
);
1817 to_sym
= pexp
->X_add_symbol
;
1819 *p
++ = DW_LNS_extended_op
;
1820 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1821 *p
++ = DW_LNE_set_address
;
1822 exp
.X_op
= O_symbol
;
1823 exp
.X_add_symbol
= to_sym
;
1824 exp
.X_add_number
= 0;
1825 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1826 p
+= sizeof_address
;
1830 *p
++ = DW_LNS_fixed_advance_pc
;
1831 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1835 if (line_delta
== INT_MAX
)
1837 *p
++ = DW_LNS_extended_op
;
1839 *p
++ = DW_LNE_end_sequence
;
1844 gas_assert (p
== end
);
1847 /* Generate a variant frag that we can use to relax address/line
1848 increments between fragments of the target segment. */
1851 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1856 memset (&exp
, 0, sizeof exp
);
1857 exp
.X_op
= O_subtract
;
1858 exp
.X_add_symbol
= to_sym
;
1859 exp
.X_op_symbol
= from_sym
;
1860 exp
.X_add_number
= 0;
1862 /* The maximum size of the frag is the line delta with a maximum
1863 sized address delta. */
1864 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1865 max_chars
= size_fixed_inc_line_addr (line_delta
,
1866 -DWARF2_LINE_MIN_INSN_LENGTH
);
1868 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1870 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1871 make_expr_symbol (&exp
), line_delta
, NULL
);
1874 /* The function estimates the size of a rs_dwarf2dbg variant frag
1875 based on the current values of the symbols. It is called before
1876 the relaxation loop. We set fr_subtype to the expected length. */
1879 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1884 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1885 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1886 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1888 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1890 frag
->fr_subtype
= size
;
1895 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1896 current values of the symbols. fr_subtype is the current length
1897 of the frag. This returns the change in frag length. */
1900 dwarf2dbg_relax_frag (fragS
*frag
)
1902 int old_size
, new_size
;
1904 old_size
= frag
->fr_subtype
;
1905 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1907 return new_size
- old_size
;
1910 /* This function converts a rs_dwarf2dbg variant frag into a normal
1911 fill frag. This is called after all relaxation has been done.
1912 fr_subtype will be the desired length of the frag. */
1915 dwarf2dbg_convert_frag (fragS
*frag
)
1919 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1921 /* If linker relaxation is enabled then the distance between the two
1922 symbols in the frag->fr_symbol expression might change. Hence we
1923 cannot rely upon the value computed by resolve_symbol_value.
1924 Instead we leave the expression unfinalized and allow
1925 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1926 relocation) that will allow the linker to correctly compute the
1927 actual address difference. We have to use a fixed line advance for
1928 this as we cannot (easily) relocate leb128 encoded values. */
1929 int saved_finalize_syms
= finalize_syms
;
1932 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1933 finalize_syms
= saved_finalize_syms
;
1936 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1938 /* fr_var carries the max_chars that we created the fragment with.
1939 fr_subtype carries the current expected length. We must, of
1940 course, have allocated enough memory earlier. */
1941 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1943 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1944 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1945 frag
->fr_literal
+ frag
->fr_fix
,
1948 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1949 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1951 frag
->fr_fix
+= frag
->fr_subtype
;
1952 frag
->fr_type
= rs_fill
;
1954 frag
->fr_offset
= 0;
1957 /* Generate .debug_line content for the chain of line number entries
1958 beginning at E, for segment SEG. */
1961 process_entries (segT seg
, struct line_entry
*e
)
1963 unsigned filenum
= 1;
1965 unsigned column
= 0;
1967 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1968 fragS
*last_frag
= NULL
, *frag
;
1969 addressT last_frag_ofs
= 0, frag_ofs
;
1970 symbolS
*last_lab
= NULL
, *lab
;
1971 struct line_entry
*next
;
1973 if (flag_dwarf_sections
)
1976 const char * sec_name
;
1978 /* Switch to the relevant sub-section before we start to emit
1979 the line number table.
1981 FIXME: These sub-sections do not have a normal Line Number
1982 Program Header, thus strictly speaking they are not valid
1983 DWARF sections. Unfortunately the DWARF standard assumes
1984 a one-to-one relationship between compilation units and
1985 line number tables. Thus we have to have a .debug_line
1986 section, as well as our sub-sections, and we have to ensure
1987 that all of the sub-sections are merged into a proper
1988 .debug_line section before a debugger sees them. */
1990 sec_name
= bfd_section_name (seg
);
1991 if (strcmp (sec_name
, ".text") != 0)
1993 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1994 subseg_set (subseg_get (name
, false), 0);
1997 /* Don't create a .debug_line.text section -
1998 that is redundant. Instead just switch back to the
1999 normal .debug_line section. */
2000 subseg_set (subseg_get (".debug_line", false), 0);
2007 if (filenum
!= e
->loc
.filenum
)
2009 filenum
= e
->loc
.filenum
;
2010 out_opcode (DW_LNS_set_file
);
2011 out_uleb128 (filenum
);
2014 if (column
!= e
->loc
.column
)
2016 column
= e
->loc
.column
;
2017 out_opcode (DW_LNS_set_column
);
2018 out_uleb128 (column
);
2021 if (e
->loc
.discriminator
!= 0)
2023 out_opcode (DW_LNS_extended_op
);
2024 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
2025 out_opcode (DW_LNE_set_discriminator
);
2026 out_uleb128 (e
->loc
.discriminator
);
2029 if (isa
!= e
->loc
.isa
)
2032 out_opcode (DW_LNS_set_isa
);
2036 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
2038 flags
= e
->loc
.flags
;
2039 out_opcode (DW_LNS_negate_stmt
);
2042 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
2043 out_opcode (DW_LNS_set_basic_block
);
2045 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
2046 out_opcode (DW_LNS_set_prologue_end
);
2048 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
2049 out_opcode (DW_LNS_set_epilogue_begin
);
2051 /* Don't try to optimize away redundant entries; gdb wants two
2052 entries for a function where the code starts on the same line as
2053 the {, and there's no way to identify that case here. Trust gcc
2054 to optimize appropriately. */
2055 line_delta
= e
->loc
.line
- line
;
2057 frag
= symbol_get_frag (lab
);
2058 frag_ofs
= S_GET_VALUE (lab
);
2060 if (last_frag
== NULL
2061 || (e
->loc
.u
.view
== force_reset_view
&& force_reset_view
2062 /* If we're going to reset the view, but we know we're
2063 advancing the PC, we don't have to force with
2064 set_address. We know we do when we're at the same
2065 address of the same frag, and we know we might when
2066 we're in the beginning of a frag, and we were at the
2067 end of the previous frag. */
2068 && (frag
== last_frag
2069 ? (last_frag_ofs
== frag_ofs
)
2071 && ((offsetT
)last_frag_ofs
2072 >= get_frag_fix (last_frag
, seg
))))))
2075 out_inc_line_addr (line_delta
, 0);
2077 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2078 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
2080 relax_inc_line_addr (line_delta
, lab
, last_lab
);
2085 last_frag_ofs
= frag_ofs
;
2093 /* Emit a DW_LNE_end_sequence for the end of the section. */
2094 frag
= last_frag_for_seg (seg
);
2095 frag_ofs
= get_frag_fix (frag
, seg
);
2096 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2097 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2100 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2101 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2105 /* Switch to LINE_STR_SEG and output the given STR. Return the
2106 symbol pointing to the new string in the section. */
2109 add_line_strp (segT line_str_seg
, const char *str
)
2115 subseg_set (line_str_seg
, 0);
2117 sym
= symbol_temp_new_now_octets ();
2119 size
= strlen (str
) + 1;
2120 cp
= frag_more (size
);
2121 memcpy (cp
, str
, size
);
2127 /* Emit the directory and file tables for .debug_line. */
2130 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2136 bool emit_md5
= false;
2137 bool emit_timestamps
= true;
2138 bool emit_filesize
= true;
2139 segT line_str_seg
= NULL
;
2140 symbolS
*line_strp
, *file0_strp
= NULL
;
2142 /* Output the Directory Table. */
2143 if (DWARF2_LINE_VERSION
>= 5)
2145 /* We only have one column in the directory table. */
2148 /* Describe the purpose and format of the column. */
2149 out_uleb128 (DW_LNCT_path
);
2150 /* Store these strings in the .debug_line_str section so they
2152 out_uleb128 (DW_FORM_line_strp
);
2154 /* Now state how many rows there are in the table. We need at
2155 least 1 if there is one or more file names to store the
2156 "working directory". */
2157 if (dirs_in_use
== 0 && files_in_use
> 0)
2160 out_uleb128 (dirs_in_use
);
2163 /* Emit directory list. */
2164 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2166 line_str_seg
= subseg_new (".debug_line_str", 0);
2167 bfd_set_section_flags (line_str_seg
,
2168 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2169 | SEC_MERGE
| SEC_STRINGS
);
2170 line_str_seg
->entsize
= 1;
2172 /* DWARF5 uses slot zero, but that is only set explicitly
2173 using a .file 0 directive. Otherwise use pwd as main file
2175 if (dirs_in_use
> 0 && dirs
[0] != NULL
)
2176 dir
= remap_debug_filename (dirs
[0]);
2178 dir
= remap_debug_filename (getpwd ());
2180 line_strp
= add_line_strp (line_str_seg
, dir
);
2181 subseg_set (line_seg
, 0);
2182 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2184 for (i
= 1; i
< dirs_in_use
; ++i
)
2186 dir
= remap_debug_filename (dirs
[i
]);
2187 if (DWARF2_LINE_VERSION
< 5)
2189 size
= strlen (dir
) + 1;
2190 cp
= frag_more (size
);
2191 memcpy (cp
, dir
, size
);
2195 line_strp
= add_line_strp (line_str_seg
, dir
);
2196 subseg_set (line_seg
, 0);
2197 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2201 if (DWARF2_LINE_VERSION
< 5)
2205 /* Output the File Name Table. */
2206 if (DWARF2_LINE_VERSION
>= 5)
2208 unsigned int columns
= 4;
2210 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2212 emit_timestamps
= false;
2216 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2218 emit_filesize
= false;
2222 for (i
= 0; i
< files_in_use
; ++i
)
2223 if (files
[i
].md5
[0] != 0)
2225 if (i
< files_in_use
)
2231 /* The number of format entries to follow. */
2233 /* The format of the file name. */
2234 out_uleb128 (DW_LNCT_path
);
2235 /* Store these strings in the .debug_line_str section so they
2237 out_uleb128 (DW_FORM_line_strp
);
2239 /* The format of the directory index. */
2240 out_uleb128 (DW_LNCT_directory_index
);
2241 out_uleb128 (DW_FORM_udata
);
2243 if (emit_timestamps
)
2245 /* The format of the timestamp. */
2246 out_uleb128 (DW_LNCT_timestamp
);
2247 out_uleb128 (DW_FORM_udata
);
2252 /* The format of the file size. */
2253 out_uleb128 (DW_LNCT_size
);
2254 out_uleb128 (DW_FORM_udata
);
2259 /* The format of the MD5 sum. */
2260 out_uleb128 (DW_LNCT_MD5
);
2261 out_uleb128 (DW_FORM_data16
);
2264 /* The number of entries in the table. */
2265 out_uleb128 (files_in_use
);
2268 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2270 const char *fullfilename
;
2272 if (files
[i
].filename
== NULL
)
2274 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2276 as_bad (_("unassigned file number %ld"), (long) i
);
2279 /* DWARF5 uses slot zero, but that is only set explicitly using
2280 a .file 0 directive. If that isn't used, but file 1 is, then
2281 use that as main file name. */
2282 if (files_in_use
> 1 && files
[1].filename
!= NULL
)
2284 files
[0].filename
= files
[1].filename
;
2285 files
[0].dir
= files
[1].dir
;
2287 for (j
= 0; j
< NUM_MD5_BYTES
; ++j
)
2288 files
[0].md5
[j
] = files
[1].md5
[j
];
2291 files
[0].filename
= "";
2294 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2295 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2296 if (DWARF2_LINE_VERSION
< 5)
2298 size
= strlen (fullfilename
) + 1;
2299 cp
= frag_more (size
);
2300 memcpy (cp
, fullfilename
, size
);
2305 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2307 line_strp
= file0_strp
;
2308 subseg_set (line_seg
, 0);
2309 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2310 if (i
== 0 && files_in_use
> 1
2311 && files
[0].filename
== files
[1].filename
)
2312 file0_strp
= line_strp
;
2317 /* Directory number. */
2318 out_uleb128 (files
[i
].dir
);
2320 /* Output the last modification timestamp. */
2321 if (emit_timestamps
)
2325 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2326 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2327 if (timestamp
== -1)
2329 out_uleb128 (timestamp
);
2332 /* Output the filesize. */
2336 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2337 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2340 out_uleb128 (filesize
);
2343 /* Output the md5 sum. */
2348 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2349 out_byte (files
[i
].md5
[b
]);
2353 if (DWARF2_LINE_VERSION
< 5)
2354 /* Terminate filename list. */
2358 /* Switch to SEC and output a header length field. Return the size of
2359 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2360 to the end of the section. EXPR->X_add_number will be set to the
2361 negative size of the header. */
2364 out_header (asection
*sec
, expressionS
*exp
)
2369 subseg_set (sec
, 0);
2371 if (flag_dwarf_sections
)
2373 /* If we are going to put the start and end symbols in different
2374 sections, then we need real symbols, not just fake, local ones. */
2376 start_sym
= symbol_make (".Ldebug_line_start");
2377 end_sym
= symbol_make (".Ldebug_line_end");
2378 symbol_set_value_now (start_sym
);
2382 start_sym
= symbol_temp_new_now_octets ();
2383 end_sym
= symbol_temp_make ();
2386 /* Total length of the information. */
2387 exp
->X_op
= O_subtract
;
2388 exp
->X_add_symbol
= end_sym
;
2389 exp
->X_op_symbol
= start_sym
;
2391 switch (DWARF2_FORMAT (sec
))
2393 case dwarf2_format_32bit
:
2394 exp
->X_add_number
= -4;
2398 case dwarf2_format_64bit
:
2399 exp
->X_add_number
= -12;
2404 case dwarf2_format_64bit_irix
:
2405 exp
->X_add_number
= -8;
2410 as_fatal (_("internal error: unknown dwarf2 format"));
2414 /* Emit the collected .debug_line data. */
2417 out_debug_line (segT line_seg
)
2420 symbolS
*prologue_start
, *prologue_end
;
2425 memset (&exp
, 0, sizeof exp
);
2426 sizeof_offset
= out_header (line_seg
, &exp
);
2427 line_end
= exp
.X_add_symbol
;
2430 out_two (DWARF2_LINE_VERSION
);
2432 if (DWARF2_LINE_VERSION
>= 5)
2434 out_byte (sizeof_address
);
2435 out_byte (0); /* Segment Selector size. */
2437 /* Length of the prologue following this length. */
2438 prologue_start
= symbol_temp_make ();
2439 prologue_end
= symbol_temp_make ();
2440 exp
.X_op
= O_subtract
;
2441 exp
.X_add_symbol
= prologue_end
;
2442 exp
.X_op_symbol
= prologue_start
;
2443 exp
.X_add_number
= 0;
2444 emit_expr (&exp
, sizeof_offset
);
2445 symbol_set_value_now (prologue_start
);
2447 /* Parameters of the state machine. */
2448 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2449 if (DWARF2_LINE_VERSION
>= 4)
2450 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2451 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2452 out_byte (DWARF2_LINE_BASE
);
2453 out_byte (DWARF2_LINE_RANGE
);
2454 out_byte (DWARF2_LINE_OPCODE_BASE
);
2456 /* Standard opcode lengths. */
2457 out_byte (0); /* DW_LNS_copy */
2458 out_byte (1); /* DW_LNS_advance_pc */
2459 out_byte (1); /* DW_LNS_advance_line */
2460 out_byte (1); /* DW_LNS_set_file */
2461 out_byte (1); /* DW_LNS_set_column */
2462 out_byte (0); /* DW_LNS_negate_stmt */
2463 out_byte (0); /* DW_LNS_set_basic_block */
2464 out_byte (0); /* DW_LNS_const_add_pc */
2465 out_byte (1); /* DW_LNS_fixed_advance_pc */
2466 out_byte (0); /* DW_LNS_set_prologue_end */
2467 out_byte (0); /* DW_LNS_set_epilogue_begin */
2468 out_byte (1); /* DW_LNS_set_isa */
2469 /* We have emitted 12 opcode lengths, so make that this
2470 matches up to the opcode base value we have been using. */
2471 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2473 out_dir_and_file_list (line_seg
, sizeof_offset
);
2475 symbol_set_value_now (prologue_end
);
2477 /* For each section, emit a statement program. */
2478 for (s
= all_segs
; s
; s
= s
->next
)
2479 /* Paranoia - this check should have already have
2480 been handled in dwarf2_gen_line_info_1(). */
2481 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2482 process_entries (s
->seg
, s
->head
->head
);
2484 if (flag_dwarf_sections
)
2485 /* We have to switch to the special .debug_line_end section
2486 before emitting the end-of-debug_line symbol. The linker
2487 script arranges for this section to be placed after all the
2488 (potentially garbage collected) .debug_line.<foo> sections.
2489 This section contains the line_end symbol which is used to
2490 compute the size of the linked .debug_line section, as seen
2491 in the DWARF Line Number header. */
2492 subseg_set (subseg_get (".debug_line_end", false), 0);
2494 symbol_set_value_now (line_end
);
2498 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2500 unsigned int addr_size
= sizeof_address
;
2505 memset (&exp
, 0, sizeof exp
);
2506 subseg_set (ranges_seg
, 0);
2508 /* For DW_AT_ranges to point at (there is no header, so really start
2509 of section, but see out_debug_rnglists). */
2510 *ranges_sym
= symbol_temp_new_now_octets ();
2512 /* Base Address Entry. */
2513 for (i
= 0; i
< addr_size
; i
++)
2515 for (i
= 0; i
< addr_size
; i
++)
2518 /* Range List Entry. */
2519 for (s
= all_segs
; s
; s
= s
->next
)
2524 frag
= first_frag_for_seg (s
->seg
);
2525 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2526 s
->text_start
= beg
;
2528 frag
= last_frag_for_seg (s
->seg
);
2529 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2532 exp
.X_op
= O_symbol
;
2533 exp
.X_add_symbol
= beg
;
2534 exp
.X_add_number
= 0;
2535 emit_expr (&exp
, addr_size
);
2537 exp
.X_op
= O_symbol
;
2538 exp
.X_add_symbol
= end
;
2539 exp
.X_add_number
= 0;
2540 emit_expr (&exp
, addr_size
);
2543 /* End of Range Entry. */
2544 for (i
= 0; i
< addr_size
; i
++)
2546 for (i
= 0; i
< addr_size
; i
++)
2551 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2554 symbolS
*ranges_end
;
2558 memset (&exp
, 0, sizeof exp
);
2559 out_header (ranges_seg
, &exp
);
2560 ranges_end
= exp
.X_add_symbol
;
2562 out_two (DWARF2_RNGLISTS_VERSION
);
2563 out_byte (sizeof_address
);
2564 out_byte (0); /* Segment Selector size. */
2565 out_four (0); /* Offset entry count. */
2567 /* For DW_AT_ranges to point at (must be after the header). */
2568 *ranges_sym
= symbol_temp_new_now_octets ();
2570 for (s
= all_segs
; s
; s
= s
->next
)
2575 out_byte (DW_RLE_start_length
);
2577 frag
= first_frag_for_seg (s
->seg
);
2578 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2579 s
->text_start
= beg
;
2581 frag
= last_frag_for_seg (s
->seg
);
2582 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2585 exp
.X_op
= O_symbol
;
2586 exp
.X_add_symbol
= beg
;
2587 exp
.X_add_number
= 0;
2588 emit_expr (&exp
, sizeof_address
);
2590 exp
.X_op
= O_symbol
;
2591 exp
.X_add_symbol
= end
;
2592 exp
.X_add_number
= 0;
2593 emit_leb128_expr (&exp
, 0);
2596 out_byte (DW_RLE_end_of_list
);
2598 symbol_set_value_now (ranges_end
);
2601 /* Emit data for .debug_aranges. */
2604 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2606 unsigned int addr_size
= sizeof_address
;
2610 symbolS
*aranges_end
;
2614 memset (&exp
, 0, sizeof exp
);
2615 sizeof_offset
= out_header (aranges_seg
, &exp
);
2616 aranges_end
= exp
.X_add_symbol
;
2617 size
= -exp
.X_add_number
;
2620 out_two (DWARF2_ARANGES_VERSION
);
2623 /* Offset to .debug_info. */
2624 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2625 size
+= sizeof_offset
;
2627 /* Size of an address (offset portion). */
2628 out_byte (addr_size
);
2631 /* Size of a segment descriptor. */
2635 /* Align the header. */
2636 while ((size
++ % (2 * addr_size
)) > 0)
2639 for (s
= all_segs
; s
; s
= s
->next
)
2644 frag
= first_frag_for_seg (s
->seg
);
2645 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2646 s
->text_start
= beg
;
2648 frag
= last_frag_for_seg (s
->seg
);
2649 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2652 exp
.X_op
= O_symbol
;
2653 exp
.X_add_symbol
= beg
;
2654 exp
.X_add_number
= 0;
2655 emit_expr (&exp
, addr_size
);
2657 exp
.X_op
= O_subtract
;
2658 exp
.X_add_symbol
= end
;
2659 exp
.X_op_symbol
= beg
;
2660 exp
.X_add_number
= 0;
2661 emit_expr (&exp
, addr_size
);
2664 p
= frag_more (2 * addr_size
);
2665 md_number_to_chars (p
, 0, addr_size
);
2666 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2668 symbol_set_value_now (aranges_end
);
2671 /* Emit data for .debug_abbrev. Note that this must be kept in
2672 sync with out_debug_info below. */
2675 out_debug_abbrev (segT abbrev_seg
,
2676 segT info_seg ATTRIBUTE_UNUSED
,
2677 segT line_seg ATTRIBUTE_UNUSED
)
2680 subseg_set (abbrev_seg
, 0);
2683 out_uleb128 (DW_TAG_compile_unit
);
2684 out_byte (DW_CHILDREN_no
);
2685 if (DWARF2_VERSION
< 4)
2687 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2688 secoff_form
= DW_FORM_data4
;
2690 secoff_form
= DW_FORM_data8
;
2693 secoff_form
= DW_FORM_sec_offset
;
2694 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2695 if (all_segs
->next
== NULL
)
2697 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2698 if (DWARF2_VERSION
< 4)
2699 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2701 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2704 out_abbrev (DW_AT_ranges
, secoff_form
);
2705 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2706 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2707 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2708 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2711 /* Terminate the abbreviations for this compilation unit. */
2715 /* Emit a description of this compilation unit for .debug_info. */
2718 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2719 symbolS
*ranges_sym
, symbolS
*name_sym
,
2720 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2726 memset (&exp
, 0, sizeof exp
);
2727 sizeof_offset
= out_header (info_seg
, &exp
);
2728 info_end
= exp
.X_add_symbol
;
2730 /* DWARF version. */
2731 out_two (DWARF2_VERSION
);
2733 if (DWARF2_VERSION
< 5)
2735 /* .debug_abbrev offset */
2736 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2740 /* unit (header) type */
2741 out_byte (DW_UT_compile
);
2744 /* Target address size. */
2745 out_byte (sizeof_address
);
2747 if (DWARF2_VERSION
>= 5)
2749 /* .debug_abbrev offset */
2750 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2753 /* DW_TAG_compile_unit DIE abbrev */
2756 /* DW_AT_stmt_list */
2757 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2758 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2761 /* These two attributes are emitted if all of the code is contiguous. */
2762 if (all_segs
->next
== NULL
)
2765 exp
.X_op
= O_symbol
;
2766 exp
.X_add_symbol
= all_segs
->text_start
;
2767 exp
.X_add_number
= 0;
2768 emit_expr (&exp
, sizeof_address
);
2771 if (DWARF2_VERSION
< 4)
2772 exp
.X_op
= O_symbol
;
2775 exp
.X_op
= O_subtract
;
2776 exp
.X_op_symbol
= all_segs
->text_start
;
2778 exp
.X_add_symbol
= all_segs
->text_end
;
2779 exp
.X_add_number
= 0;
2780 if (DWARF2_VERSION
< 4)
2781 emit_expr (&exp
, sizeof_address
);
2783 emit_leb128_expr (&exp
, 0);
2787 /* This attribute is emitted if the code is disjoint. */
2789 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2792 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2793 setup in out_debug_str below. */
2794 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2795 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2796 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2798 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2799 dwarf2 draft has no standard code for assembler. */
2800 out_two (DW_LANG_Mips_Assembler
);
2802 symbol_set_value_now (info_end
);
2805 /* Emit the three debug strings needed in .debug_str and setup symbols
2806 to them for use in out_debug_info. */
2808 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2809 symbolS
**producer_sym
)
2812 const char *comp_dir
;
2813 const char *dirname
;
2816 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2818 subseg_set (str_seg
, 0);
2820 /* DW_AT_name. We don't have the actual file name that was present
2821 on the command line, so assume files[first_file] is the main input file.
2822 We're not supposed to get called unless at least one line number
2823 entry was emitted, so this should always be defined. */
2824 *name_sym
= symbol_temp_new_now_octets ();
2825 if (files_in_use
== 0)
2827 if (files
[first_file
].dir
)
2829 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2830 len
= strlen (dirname
);
2832 /* Already has trailing slash. */
2833 p
= frag_more (len
);
2834 memcpy (p
, dirname
, len
);
2836 p
= frag_more (len
+ 1);
2837 memcpy (p
, dirname
, len
);
2838 INSERT_DIR_SEPARATOR (p
, len
);
2841 len
= strlen (files
[first_file
].filename
) + 1;
2842 p
= frag_more (len
);
2843 memcpy (p
, files
[first_file
].filename
, len
);
2845 /* DW_AT_comp_dir */
2846 *comp_dir_sym
= symbol_temp_new_now_octets ();
2847 comp_dir
= remap_debug_filename (getpwd ());
2848 len
= strlen (comp_dir
) + 1;
2849 p
= frag_more (len
);
2850 memcpy (p
, comp_dir
, len
);
2852 /* DW_AT_producer */
2853 *producer_sym
= symbol_temp_new_now_octets ();
2854 sprintf (producer
, "GNU AS %s", VERSION
);
2855 len
= strlen (producer
) + 1;
2856 p
= frag_more (len
);
2857 memcpy (p
, producer
, len
);
2863 last_seg_ptr
= &all_segs
;
2865 /* Select the default CIE version to produce here. The global
2866 starts with a value of -1 and will be modified to a valid value
2867 either by the user providing a command line option, or some
2868 targets will select their own default in md_after_parse_args. If
2869 we get here and the global still contains -1 then it is up to us
2870 to pick a sane default. The default we choose is 1, this is the
2871 CIE version gas has produced for a long time, and there seems no
2872 reason to change it yet. */
2873 if (flag_dwarf_cie_version
== -1)
2874 flag_dwarf_cie_version
= 1;
2877 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2878 were any .file/.loc directives, or --gdwarf2 was given, and if the
2879 file has a non-empty .debug_info section and an empty .debug_line
2880 section. If we emit .debug_line, and the .debug_info section is
2881 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2882 ALL_SEGS will be non-null if there were any .file/.loc directives,
2883 or --gdwarf2 was given and there were any located instructions
2887 dwarf2_finish (void)
2892 int emit_other_sections
= 0;
2893 int empty_debug_line
= 0;
2895 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2896 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2898 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2899 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2901 /* We can't construct a new debug_line section if we already have one.
2902 Give an error if we have seen any .loc, otherwise trust the user
2903 knows what they are doing and want to generate the .debug_line
2904 (and all other debug sections) themselves. */
2905 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2906 as_fatal ("duplicate .debug_line sections");
2908 if ((!all_segs
&& emit_other_sections
)
2909 || (!emit_other_sections
&& !empty_debug_line
))
2910 /* If there is no line information and no non-empty .debug_info
2911 section, or if there is both a non-empty .debug_info and a non-empty
2912 .debug_line, then we do nothing. */
2915 /* Calculate the size of an address for the target machine. */
2916 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2918 /* Create and switch to the line number section. */
2919 if (empty_debug_line
)
2921 line_seg
= subseg_new (".debug_line", 0);
2922 bfd_set_section_flags (line_seg
,
2923 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2926 for (s
= all_segs
; s
; s
= s
->next
)
2928 struct line_subseg
*lss
;
2930 for (lss
= s
->head
; lss
; lss
= lss
->next
)
2932 do_allocate_filenum (lss
->head
);
2935 /* For each subsection, chain the debug entries together. */
2936 for (s
= all_segs
; s
; s
= s
->next
)
2938 struct line_subseg
*lss
= s
->head
;
2939 struct line_entry
**ptail
= lss
->ptail
;
2941 /* Reset the initial view of the first subsection of the
2943 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2944 set_or_check_view (lss
->head
, NULL
, NULL
);
2946 while ((lss
= lss
->next
) != NULL
)
2948 /* Link the first view of subsequent subsections to the
2950 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2951 set_or_check_view (lss
->head
,
2952 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2953 s
->head
? s
->head
->head
: NULL
);
2959 if (empty_debug_line
)
2960 out_debug_line (line_seg
);
2962 /* If this is assembler generated line info, and there is no
2963 debug_info already, we need .debug_info, .debug_abbrev and
2964 .debug_str sections as well. */
2965 if (emit_other_sections
)
2970 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2972 gas_assert (all_segs
);
2974 info_seg
= subseg_new (".debug_info", 0);
2975 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2976 aranges_seg
= subseg_new (".debug_aranges", 0);
2977 str_seg
= subseg_new (".debug_str", 0);
2979 bfd_set_section_flags (info_seg
,
2980 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2981 bfd_set_section_flags (abbrev_seg
,
2982 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2983 bfd_set_section_flags (aranges_seg
,
2984 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2985 bfd_set_section_flags (str_seg
,
2986 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2987 | SEC_MERGE
| SEC_STRINGS
);
2988 str_seg
->entsize
= 1;
2990 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2992 if (all_segs
->next
== NULL
)
2996 if (DWARF2_VERSION
< 5)
2998 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2999 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
3002 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
3003 out_debug_ranges (ranges_seg
, &ranges_sym
);
3007 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
3008 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
3011 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
3015 out_debug_aranges (aranges_seg
, info_seg
);
3016 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
3017 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
3018 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
3019 name_sym
, comp_dir_sym
, producer_sym
);
3023 /* Perform any deferred checks pertaining to debug information. */
3026 dwarf2dbg_final_check (void)
3028 /* Perform reset-view checks. Don't evaluate view_assert_failed
3029 recursively: it could be very deep. It's a chain of adds, with
3030 each chain element pointing to the next in X_add_symbol, and
3031 holding the check value in X_op_symbol. */
3032 while (view_assert_failed
)
3038 gas_assert (!symbol_resolved_p (view_assert_failed
));
3040 exp
= symbol_get_value_expression (view_assert_failed
);
3041 sym
= view_assert_failed
;
3043 /* If view_assert_failed looks like a compound check in the
3044 chain, break it up. */
3045 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3047 view_assert_failed
= exp
->X_add_symbol
;
3048 sym
= exp
->X_op_symbol
;
3051 view_assert_failed
= NULL
;
3053 failed
= resolve_symbol_value (sym
);
3054 if (!symbol_resolved_p (sym
) || failed
)
3056 as_bad (_("view number mismatch"));