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
;
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. If that isn't used, but dir
2174 one is used, then use that as main file directory.
2175 Otherwise use pwd as main file directory. */
2176 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2177 dir
= remap_debug_filename (dirs
[0]);
2178 else if (dirs_in_use
> 1
2181 /* DWARF-5 directory tables expect dir[0] to be the same as
2182 DW_AT_comp_dir, which is the same as pwd. */
2184 dir
= remap_debug_filename (dirs
[1]);
2186 dir
= remap_debug_filename (getpwd ());
2188 line_strp
= add_line_strp (line_str_seg
, dir
);
2189 subseg_set (line_seg
, 0);
2190 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2192 for (i
= 1; i
< dirs_in_use
; ++i
)
2194 dir
= remap_debug_filename (dirs
[i
]);
2195 if (DWARF2_LINE_VERSION
< 5)
2197 size
= strlen (dir
) + 1;
2198 cp
= frag_more (size
);
2199 memcpy (cp
, dir
, size
);
2203 line_strp
= add_line_strp (line_str_seg
, dir
);
2204 subseg_set (line_seg
, 0);
2205 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2209 if (DWARF2_LINE_VERSION
< 5)
2213 /* Output the File Name Table. */
2214 if (DWARF2_LINE_VERSION
>= 5)
2216 unsigned int columns
= 4;
2218 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2220 emit_timestamps
= false;
2224 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2226 emit_filesize
= false;
2230 for (i
= 0; i
< files_in_use
; ++i
)
2231 if (files
[i
].md5
[0] != 0)
2233 if (i
< files_in_use
)
2239 /* The number of format entries to follow. */
2241 /* The format of the file name. */
2242 out_uleb128 (DW_LNCT_path
);
2243 /* Store these strings in the .debug_line_str section so they
2245 out_uleb128 (DW_FORM_line_strp
);
2247 /* The format of the directory index. */
2248 out_uleb128 (DW_LNCT_directory_index
);
2249 out_uleb128 (DW_FORM_udata
);
2251 if (emit_timestamps
)
2253 /* The format of the timestamp. */
2254 out_uleb128 (DW_LNCT_timestamp
);
2255 out_uleb128 (DW_FORM_udata
);
2260 /* The format of the file size. */
2261 out_uleb128 (DW_LNCT_size
);
2262 out_uleb128 (DW_FORM_udata
);
2267 /* The format of the MD5 sum. */
2268 out_uleb128 (DW_LNCT_MD5
);
2269 out_uleb128 (DW_FORM_data16
);
2272 /* The number of entries in the table. */
2273 out_uleb128 (files_in_use
);
2276 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2278 const char *fullfilename
;
2280 if (files
[i
].filename
== NULL
)
2282 /* Prevent a crash later, particularly for file 1. DWARF5
2283 uses slot zero, but that is only set explicitly using a
2284 .file 0 directive. If that isn't used, but file 1 is,
2285 then use that as main file name. */
2286 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1 && files
[0].filename
== NULL
)
2288 files
[0].filename
= files
[1].filename
;
2289 files
[0].dir
= files
[1].dir
;
2291 for (j
= 0; j
< NUM_MD5_BYTES
; ++j
)
2292 files
[0].md5
[j
] = files
[1].md5
[j
];
2295 files
[i
].filename
= "";
2296 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2298 as_bad (_("unassigned file number %ld"), (long) i
);
2303 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2304 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2305 if (DWARF2_LINE_VERSION
< 5)
2307 size
= strlen (fullfilename
) + 1;
2308 cp
= frag_more (size
);
2309 memcpy (cp
, fullfilename
, size
);
2313 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2314 subseg_set (line_seg
, 0);
2315 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2318 /* Directory number. */
2319 out_uleb128 (files
[i
].dir
);
2321 /* Output the last modification timestamp. */
2322 if (emit_timestamps
)
2326 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2327 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2328 if (timestamp
== -1)
2330 out_uleb128 (timestamp
);
2333 /* Output the filesize. */
2337 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2338 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2341 out_uleb128 (filesize
);
2344 /* Output the md5 sum. */
2349 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2350 out_byte (files
[i
].md5
[b
]);
2354 if (DWARF2_LINE_VERSION
< 5)
2355 /* Terminate filename list. */
2359 /* Switch to SEC and output a header length field. Return the size of
2360 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2361 to the end of the section. EXPR->X_add_number will be set to the
2362 negative size of the header. */
2365 out_header (asection
*sec
, expressionS
*exp
)
2370 subseg_set (sec
, 0);
2372 if (flag_dwarf_sections
)
2374 /* If we are going to put the start and end symbols in different
2375 sections, then we need real symbols, not just fake, local ones. */
2377 start_sym
= symbol_make (".Ldebug_line_start");
2378 end_sym
= symbol_make (".Ldebug_line_end");
2379 symbol_set_value_now (start_sym
);
2383 start_sym
= symbol_temp_new_now_octets ();
2384 end_sym
= symbol_temp_make ();
2387 /* Total length of the information. */
2388 exp
->X_op
= O_subtract
;
2389 exp
->X_add_symbol
= end_sym
;
2390 exp
->X_op_symbol
= start_sym
;
2392 switch (DWARF2_FORMAT (sec
))
2394 case dwarf2_format_32bit
:
2395 exp
->X_add_number
= -4;
2399 case dwarf2_format_64bit
:
2400 exp
->X_add_number
= -12;
2405 case dwarf2_format_64bit_irix
:
2406 exp
->X_add_number
= -8;
2411 as_fatal (_("internal error: unknown dwarf2 format"));
2415 /* Emit the collected .debug_line data. */
2418 out_debug_line (segT line_seg
)
2421 symbolS
*prologue_start
, *prologue_end
;
2426 memset (&exp
, 0, sizeof exp
);
2427 sizeof_offset
= out_header (line_seg
, &exp
);
2428 line_end
= exp
.X_add_symbol
;
2431 out_two (DWARF2_LINE_VERSION
);
2433 if (DWARF2_LINE_VERSION
>= 5)
2435 out_byte (sizeof_address
);
2436 out_byte (0); /* Segment Selector size. */
2438 /* Length of the prologue following this length. */
2439 prologue_start
= symbol_temp_make ();
2440 prologue_end
= symbol_temp_make ();
2441 exp
.X_op
= O_subtract
;
2442 exp
.X_add_symbol
= prologue_end
;
2443 exp
.X_op_symbol
= prologue_start
;
2444 exp
.X_add_number
= 0;
2445 emit_expr (&exp
, sizeof_offset
);
2446 symbol_set_value_now (prologue_start
);
2448 /* Parameters of the state machine. */
2449 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2450 if (DWARF2_LINE_VERSION
>= 4)
2451 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2452 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2453 out_byte (DWARF2_LINE_BASE
);
2454 out_byte (DWARF2_LINE_RANGE
);
2455 out_byte (DWARF2_LINE_OPCODE_BASE
);
2457 /* Standard opcode lengths. */
2458 out_byte (0); /* DW_LNS_copy */
2459 out_byte (1); /* DW_LNS_advance_pc */
2460 out_byte (1); /* DW_LNS_advance_line */
2461 out_byte (1); /* DW_LNS_set_file */
2462 out_byte (1); /* DW_LNS_set_column */
2463 out_byte (0); /* DW_LNS_negate_stmt */
2464 out_byte (0); /* DW_LNS_set_basic_block */
2465 out_byte (0); /* DW_LNS_const_add_pc */
2466 out_byte (1); /* DW_LNS_fixed_advance_pc */
2467 out_byte (0); /* DW_LNS_set_prologue_end */
2468 out_byte (0); /* DW_LNS_set_epilogue_begin */
2469 out_byte (1); /* DW_LNS_set_isa */
2470 /* We have emitted 12 opcode lengths, so make that this
2471 matches up to the opcode base value we have been using. */
2472 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2474 out_dir_and_file_list (line_seg
, sizeof_offset
);
2476 symbol_set_value_now (prologue_end
);
2478 /* For each section, emit a statement program. */
2479 for (s
= all_segs
; s
; s
= s
->next
)
2480 /* Paranoia - this check should have already have
2481 been handled in dwarf2_gen_line_info_1(). */
2482 if (s
->head
->head
&& SEG_NORMAL (s
->seg
))
2483 process_entries (s
->seg
, s
->head
->head
);
2485 if (flag_dwarf_sections
)
2486 /* We have to switch to the special .debug_line_end section
2487 before emitting the end-of-debug_line symbol. The linker
2488 script arranges for this section to be placed after all the
2489 (potentially garbage collected) .debug_line.<foo> sections.
2490 This section contains the line_end symbol which is used to
2491 compute the size of the linked .debug_line section, as seen
2492 in the DWARF Line Number header. */
2493 subseg_set (subseg_get (".debug_line_end", false), 0);
2495 symbol_set_value_now (line_end
);
2499 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2501 unsigned int addr_size
= sizeof_address
;
2506 memset (&exp
, 0, sizeof exp
);
2507 subseg_set (ranges_seg
, 0);
2509 /* For DW_AT_ranges to point at (there is no header, so really start
2510 of section, but see out_debug_rnglists). */
2511 *ranges_sym
= symbol_temp_new_now_octets ();
2513 /* Base Address Entry. */
2514 for (i
= 0; i
< addr_size
; i
++)
2516 for (i
= 0; i
< addr_size
; i
++)
2519 /* Range List Entry. */
2520 for (s
= all_segs
; s
; s
= s
->next
)
2525 frag
= first_frag_for_seg (s
->seg
);
2526 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2527 s
->text_start
= beg
;
2529 frag
= last_frag_for_seg (s
->seg
);
2530 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2533 exp
.X_op
= O_symbol
;
2534 exp
.X_add_symbol
= beg
;
2535 exp
.X_add_number
= 0;
2536 emit_expr (&exp
, addr_size
);
2538 exp
.X_op
= O_symbol
;
2539 exp
.X_add_symbol
= end
;
2540 exp
.X_add_number
= 0;
2541 emit_expr (&exp
, addr_size
);
2544 /* End of Range Entry. */
2545 for (i
= 0; i
< addr_size
; i
++)
2547 for (i
= 0; i
< addr_size
; i
++)
2552 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2555 symbolS
*ranges_end
;
2559 memset (&exp
, 0, sizeof exp
);
2560 out_header (ranges_seg
, &exp
);
2561 ranges_end
= exp
.X_add_symbol
;
2563 out_two (DWARF2_RNGLISTS_VERSION
);
2564 out_byte (sizeof_address
);
2565 out_byte (0); /* Segment Selector size. */
2566 out_four (0); /* Offset entry count. */
2568 /* For DW_AT_ranges to point at (must be after the header). */
2569 *ranges_sym
= symbol_temp_new_now_octets ();
2571 for (s
= all_segs
; s
; s
= s
->next
)
2576 out_byte (DW_RLE_start_length
);
2578 frag
= first_frag_for_seg (s
->seg
);
2579 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2580 s
->text_start
= beg
;
2582 frag
= last_frag_for_seg (s
->seg
);
2583 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2586 exp
.X_op
= O_symbol
;
2587 exp
.X_add_symbol
= beg
;
2588 exp
.X_add_number
= 0;
2589 emit_expr (&exp
, sizeof_address
);
2591 exp
.X_op
= O_symbol
;
2592 exp
.X_add_symbol
= end
;
2593 exp
.X_add_number
= 0;
2594 emit_leb128_expr (&exp
, 0);
2597 out_byte (DW_RLE_end_of_list
);
2599 symbol_set_value_now (ranges_end
);
2602 /* Emit data for .debug_aranges. */
2605 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2607 unsigned int addr_size
= sizeof_address
;
2611 symbolS
*aranges_end
;
2615 memset (&exp
, 0, sizeof exp
);
2616 sizeof_offset
= out_header (aranges_seg
, &exp
);
2617 aranges_end
= exp
.X_add_symbol
;
2618 size
= -exp
.X_add_number
;
2621 out_two (DWARF2_ARANGES_VERSION
);
2624 /* Offset to .debug_info. */
2625 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2626 size
+= sizeof_offset
;
2628 /* Size of an address (offset portion). */
2629 out_byte (addr_size
);
2632 /* Size of a segment descriptor. */
2636 /* Align the header. */
2637 while ((size
++ % (2 * addr_size
)) > 0)
2640 for (s
= all_segs
; s
; s
= s
->next
)
2645 frag
= first_frag_for_seg (s
->seg
);
2646 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2647 s
->text_start
= beg
;
2649 frag
= last_frag_for_seg (s
->seg
);
2650 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2653 exp
.X_op
= O_symbol
;
2654 exp
.X_add_symbol
= beg
;
2655 exp
.X_add_number
= 0;
2656 emit_expr (&exp
, addr_size
);
2658 exp
.X_op
= O_subtract
;
2659 exp
.X_add_symbol
= end
;
2660 exp
.X_op_symbol
= beg
;
2661 exp
.X_add_number
= 0;
2662 emit_expr (&exp
, addr_size
);
2665 p
= frag_more (2 * addr_size
);
2666 md_number_to_chars (p
, 0, addr_size
);
2667 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2669 symbol_set_value_now (aranges_end
);
2672 /* Emit data for .debug_abbrev. Note that this must be kept in
2673 sync with out_debug_info below. */
2676 out_debug_abbrev (segT abbrev_seg
,
2677 segT info_seg ATTRIBUTE_UNUSED
,
2678 segT line_seg ATTRIBUTE_UNUSED
)
2681 subseg_set (abbrev_seg
, 0);
2684 out_uleb128 (DW_TAG_compile_unit
);
2685 out_byte (DW_CHILDREN_no
);
2686 if (DWARF2_VERSION
< 4)
2688 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2689 secoff_form
= DW_FORM_data4
;
2691 secoff_form
= DW_FORM_data8
;
2694 secoff_form
= DW_FORM_sec_offset
;
2695 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2696 if (all_segs
->next
== NULL
)
2698 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2699 if (DWARF2_VERSION
< 4)
2700 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2702 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2705 out_abbrev (DW_AT_ranges
, secoff_form
);
2706 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2707 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2708 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2709 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2712 /* Terminate the abbreviations for this compilation unit. */
2716 /* Emit a description of this compilation unit for .debug_info. */
2719 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2720 symbolS
*ranges_sym
, symbolS
*name_sym
,
2721 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2727 memset (&exp
, 0, sizeof exp
);
2728 sizeof_offset
= out_header (info_seg
, &exp
);
2729 info_end
= exp
.X_add_symbol
;
2731 /* DWARF version. */
2732 out_two (DWARF2_VERSION
);
2734 if (DWARF2_VERSION
< 5)
2736 /* .debug_abbrev offset */
2737 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2741 /* unit (header) type */
2742 out_byte (DW_UT_compile
);
2745 /* Target address size. */
2746 out_byte (sizeof_address
);
2748 if (DWARF2_VERSION
>= 5)
2750 /* .debug_abbrev offset */
2751 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2754 /* DW_TAG_compile_unit DIE abbrev */
2757 /* DW_AT_stmt_list */
2758 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2759 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2762 /* These two attributes are emitted if all of the code is contiguous. */
2763 if (all_segs
->next
== NULL
)
2766 exp
.X_op
= O_symbol
;
2767 exp
.X_add_symbol
= all_segs
->text_start
;
2768 exp
.X_add_number
= 0;
2769 emit_expr (&exp
, sizeof_address
);
2772 if (DWARF2_VERSION
< 4)
2773 exp
.X_op
= O_symbol
;
2776 exp
.X_op
= O_subtract
;
2777 exp
.X_op_symbol
= all_segs
->text_start
;
2779 exp
.X_add_symbol
= all_segs
->text_end
;
2780 exp
.X_add_number
= 0;
2781 if (DWARF2_VERSION
< 4)
2782 emit_expr (&exp
, sizeof_address
);
2784 emit_leb128_expr (&exp
, 0);
2788 /* This attribute is emitted if the code is disjoint. */
2790 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2793 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2794 setup in out_debug_str below. */
2795 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2796 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2797 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2799 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2800 dwarf2 draft has no standard code for assembler. */
2801 out_two (DW_LANG_Mips_Assembler
);
2803 symbol_set_value_now (info_end
);
2806 /* Emit the three debug strings needed in .debug_str and setup symbols
2807 to them for use in out_debug_info. */
2809 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2810 symbolS
**producer_sym
)
2813 const char *comp_dir
;
2814 const char *dirname
;
2817 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2819 subseg_set (str_seg
, 0);
2821 /* DW_AT_name. We don't have the actual file name that was present
2822 on the command line, so assume files[first_file] is the main input file.
2823 We're not supposed to get called unless at least one line number
2824 entry was emitted, so this should always be defined. */
2825 *name_sym
= symbol_temp_new_now_octets ();
2826 if (files_in_use
== 0)
2828 if (files
[first_file
].dir
)
2830 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2831 len
= strlen (dirname
);
2833 /* Already has trailing slash. */
2834 p
= frag_more (len
);
2835 memcpy (p
, dirname
, len
);
2837 p
= frag_more (len
+ 1);
2838 memcpy (p
, dirname
, len
);
2839 INSERT_DIR_SEPARATOR (p
, len
);
2842 len
= strlen (files
[first_file
].filename
) + 1;
2843 p
= frag_more (len
);
2844 memcpy (p
, files
[first_file
].filename
, len
);
2846 /* DW_AT_comp_dir */
2847 *comp_dir_sym
= symbol_temp_new_now_octets ();
2848 comp_dir
= remap_debug_filename (getpwd ());
2849 len
= strlen (comp_dir
) + 1;
2850 p
= frag_more (len
);
2851 memcpy (p
, comp_dir
, len
);
2853 /* DW_AT_producer */
2854 *producer_sym
= symbol_temp_new_now_octets ();
2855 sprintf (producer
, "GNU AS %s", VERSION
);
2856 len
= strlen (producer
) + 1;
2857 p
= frag_more (len
);
2858 memcpy (p
, producer
, len
);
2864 last_seg_ptr
= &all_segs
;
2866 /* Select the default CIE version to produce here. The global
2867 starts with a value of -1 and will be modified to a valid value
2868 either by the user providing a command line option, or some
2869 targets will select their own default in md_after_parse_args. If
2870 we get here and the global still contains -1 then it is up to us
2871 to pick a sane default. The default we choose is 1, this is the
2872 CIE version gas has produced for a long time, and there seems no
2873 reason to change it yet. */
2874 if (flag_dwarf_cie_version
== -1)
2875 flag_dwarf_cie_version
= 1;
2878 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2879 were any .file/.loc directives, or --gdwarf2 was given, and if the
2880 file has a non-empty .debug_info section and an empty .debug_line
2881 section. If we emit .debug_line, and the .debug_info section is
2882 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2883 ALL_SEGS will be non-null if there were any .file/.loc directives,
2884 or --gdwarf2 was given and there were any located instructions
2888 dwarf2_finish (void)
2893 int emit_other_sections
= 0;
2894 int empty_debug_line
= 0;
2896 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2897 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2899 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2900 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2902 /* We can't construct a new debug_line section if we already have one.
2903 Give an error if we have seen any .loc, otherwise trust the user
2904 knows what they are doing and want to generate the .debug_line
2905 (and all other debug sections) themselves. */
2906 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2907 as_fatal ("duplicate .debug_line sections");
2909 if ((!all_segs
&& emit_other_sections
)
2910 || (!emit_other_sections
&& !empty_debug_line
))
2911 /* If there is no line information and no non-empty .debug_info
2912 section, or if there is both a non-empty .debug_info and a non-empty
2913 .debug_line, then we do nothing. */
2916 /* Calculate the size of an address for the target machine. */
2917 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2919 /* Create and switch to the line number section. */
2920 if (empty_debug_line
)
2922 line_seg
= subseg_new (".debug_line", 0);
2923 bfd_set_section_flags (line_seg
,
2924 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2927 for (s
= all_segs
; s
; s
= s
->next
)
2929 struct line_subseg
*lss
;
2931 for (lss
= s
->head
; lss
; lss
= lss
->next
)
2933 do_allocate_filenum (lss
->head
);
2936 /* For each subsection, chain the debug entries together. */
2937 for (s
= all_segs
; s
; s
= s
->next
)
2939 struct line_subseg
*lss
= s
->head
;
2940 struct line_entry
**ptail
= lss
->ptail
;
2942 /* Reset the initial view of the first subsection of the
2944 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2945 set_or_check_view (lss
->head
, NULL
, NULL
);
2947 while ((lss
= lss
->next
) != NULL
)
2949 /* Link the first view of subsequent subsections to the
2951 if (lss
->head
&& lss
->head
->loc
.u
.view
)
2952 set_or_check_view (lss
->head
,
2953 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2954 s
->head
? s
->head
->head
: NULL
);
2960 if (empty_debug_line
)
2961 out_debug_line (line_seg
);
2963 /* If this is assembler generated line info, and there is no
2964 debug_info already, we need .debug_info, .debug_abbrev and
2965 .debug_str sections as well. */
2966 if (emit_other_sections
)
2971 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2973 gas_assert (all_segs
);
2975 info_seg
= subseg_new (".debug_info", 0);
2976 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2977 aranges_seg
= subseg_new (".debug_aranges", 0);
2978 str_seg
= subseg_new (".debug_str", 0);
2980 bfd_set_section_flags (info_seg
,
2981 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2982 bfd_set_section_flags (abbrev_seg
,
2983 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2984 bfd_set_section_flags (aranges_seg
,
2985 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2986 bfd_set_section_flags (str_seg
,
2987 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2988 | SEC_MERGE
| SEC_STRINGS
);
2989 str_seg
->entsize
= 1;
2991 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2993 if (all_segs
->next
== NULL
)
2997 if (DWARF2_VERSION
< 5)
2999 segT ranges_seg
= subseg_new (".debug_ranges", 0);
3000 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
3003 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
3004 out_debug_ranges (ranges_seg
, &ranges_sym
);
3008 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
3009 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
3012 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
3016 out_debug_aranges (aranges_seg
, info_seg
);
3017 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
3018 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
3019 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
3020 name_sym
, comp_dir_sym
, producer_sym
);
3024 /* Perform any deferred checks pertaining to debug information. */
3027 dwarf2dbg_final_check (void)
3029 /* Perform reset-view checks. Don't evaluate view_assert_failed
3030 recursively: it could be very deep. It's a chain of adds, with
3031 each chain element pointing to the next in X_add_symbol, and
3032 holding the check value in X_op_symbol. */
3033 while (view_assert_failed
)
3039 gas_assert (!symbol_resolved_p (view_assert_failed
));
3041 exp
= symbol_get_value_expression (view_assert_failed
);
3042 sym
= view_assert_failed
;
3044 /* If view_assert_failed looks like a compound check in the
3045 chain, break it up. */
3046 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
3048 view_assert_failed
= exp
->X_add_symbol
;
3049 sym
= exp
->X_op_symbol
;
3052 view_assert_failed
= NULL
;
3054 failed
= resolve_symbol_value (sym
);
3055 if (!symbol_resolved_p (sym
) || failed
)
3057 as_bad (_("view number mismatch"));