1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2021 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
34 #include "dwarf2dbg.h"
35 #include <filenames.h>
37 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
38 /* We need to decide which character to use as a directory separator.
39 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
40 necessarily mean that the backslash character is the one to use.
41 Some environments, eg Cygwin, can support both naming conventions.
42 So we use the heuristic that we only need to use the backslash if
43 the path is an absolute path starting with a DOS style drive
44 selector. eg C: or D: */
45 # define INSERT_DIR_SEPARATOR(string, offset) \
50 && string[1] == ':') \
51 string [offset] = '\\'; \
53 string [offset] = '/'; \
57 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
61 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
64 #ifndef DWARF2_ADDR_SIZE
65 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
68 #ifndef DWARF2_FILE_NAME
69 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
72 #ifndef DWARF2_FILE_TIME_NAME
73 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
76 #ifndef DWARF2_FILE_SIZE_NAME
77 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
80 #ifndef DWARF2_VERSION
81 #define DWARF2_VERSION dwarf_level
84 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
85 #ifndef DWARF2_ARANGES_VERSION
86 #define DWARF2_ARANGES_VERSION 2
89 /* This implementation outputs version 3 .debug_line information. */
90 #ifndef DWARF2_LINE_VERSION
91 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
94 /* The .debug_rnglists has only been in DWARF version 5. */
95 #ifndef DWARF2_RNGLISTS_VERSION
96 #define DWARF2_RNGLISTS_VERSION 5
103 /* Since we can't generate the prolog until the body is complete, we
104 use three different subsegments for .debug_line: one holding the
105 prolog, one for the directory and filename info, and one for the
106 body ("statement program"). */
111 /* If linker relaxation might change offsets in the code, the DWARF special
112 opcodes and variable-length operands cannot be used. If this macro is
113 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
114 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
115 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
118 /* First special line opcode - leave room for the standard opcodes.
119 Note: If you want to change this, you'll have to update the
120 "standard_opcode_lengths" table that is emitted below in
122 #define DWARF2_LINE_OPCODE_BASE 13
124 #ifndef DWARF2_LINE_BASE
125 /* Minimum line offset in a special line info. opcode. This value
126 was chosen to give a reasonable range of values. */
127 # define DWARF2_LINE_BASE -5
130 /* Range of line offsets in a special line info. opcode. */
131 #ifndef DWARF2_LINE_RANGE
132 # define DWARF2_LINE_RANGE 14
135 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
136 /* Define the architecture-dependent minimum instruction length (in
137 bytes). This value should be rather too small than too big. */
138 # define DWARF2_LINE_MIN_INSN_LENGTH 1
141 /* Flag that indicates the initial value of the is_stmt_start flag. */
142 #define DWARF2_LINE_DEFAULT_IS_STMT 1
144 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
145 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
148 /* Given a special op, return the line skip amount. */
149 #define SPECIAL_LINE(op) \
150 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
152 /* Given a special op, return the address skip amount (in units of
153 DWARF2_LINE_MIN_INSN_LENGTH. */
154 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
156 /* The maximum address skip amount that can be encoded with a special op. */
157 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
159 #ifndef TC_PARSE_CONS_RETURN_NONE
160 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
165 struct line_entry
*next
;
167 struct dwarf2_line_info loc
;
170 /* Don't change the offset of next in line_entry. set_or_check_view
171 calls in dwarf2_gen_line_info_1 depend on it. */
172 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
177 struct line_subseg
*next
;
179 struct line_entry
*head
;
180 struct line_entry
**ptail
;
181 struct line_entry
**pmove_tail
;
186 struct line_seg
*next
;
188 struct line_subseg
*head
;
193 /* Collects data for all line table entries during assembly. */
194 static struct line_seg
*all_segs
;
195 static struct line_seg
**last_seg_ptr
;
197 #define NUM_MD5_BYTES 16
201 const char * filename
;
203 unsigned char md5
[NUM_MD5_BYTES
];
206 /* Table of files used by .debug_line. */
207 static struct file_entry
*files
;
208 static unsigned int files_in_use
;
209 static unsigned int files_allocated
;
210 static unsigned int num_of_auto_assigned
;
212 /* Table of directories used by .debug_line. */
213 static char ** dirs
= NULL
;
214 static unsigned int dirs_in_use
= 0;
215 static unsigned int dirs_allocated
= 0;
217 /* TRUE when we've seen a .loc directive recently. Used to avoid
218 doing work when there's nothing to do. Will be reset by
219 dwarf2_consume_line_info. */
220 bool dwarf2_loc_directive_seen
;
222 /* TRUE when we've seen any .loc directive at any time during parsing.
223 Indicates the user wants us to generate a .debug_line section.
224 Used in dwarf2_finish as sanity check. */
225 static bool dwarf2_any_loc_directive_seen
;
227 /* TRUE when we're supposed to set the basic block mark whenever a
229 bool dwarf2_loc_mark_labels
;
231 /* Current location as indicated by the most recent .loc directive. */
232 static struct dwarf2_line_info current
=
235 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
239 /* This symbol is used to recognize view number forced resets in loc
241 static symbolS
*force_reset_view
;
243 /* This symbol evaluates to an expression that, if nonzero, indicates
244 some view assert check failed. */
245 static symbolS
*view_assert_failed
;
247 /* The size of an address on the target. */
248 static unsigned int sizeof_address
;
250 #ifndef TC_DWARF2_EMIT_OFFSET
251 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
253 /* Create an offset to .dwarf2_*. */
256 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
260 memset (&exp
, 0, sizeof exp
);
262 exp
.X_add_symbol
= symbol
;
263 exp
.X_add_number
= 0;
264 emit_expr (&exp
, size
);
268 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
270 static struct line_subseg
*
271 get_line_subseg (segT seg
, subsegT subseg
, bool create_p
)
273 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
274 struct line_subseg
**pss
, *lss
;
281 s
= XNEW (struct line_seg
);
286 last_seg_ptr
= &s
->next
;
287 seg_info (seg
)->dwarf2_line_seg
= s
;
290 gas_assert (seg
== s
->seg
);
292 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
294 if (lss
->subseg
== subseg
)
296 if (lss
->subseg
> subseg
)
300 lss
= XNEW (struct line_subseg
);
302 lss
->subseg
= subseg
;
304 lss
->ptail
= &lss
->head
;
305 lss
->pmove_tail
= &lss
->head
;
312 /* (Un)reverse the line_entry list starting from H. */
314 static struct line_entry
*
315 reverse_line_entry_list (struct line_entry
*h
)
317 struct line_entry
*p
= NULL
, *e
, *n
;
319 for (e
= h
; e
; e
= n
)
328 /* Compute the view for E based on the previous entry P. If we
329 introduce an (undefined) view symbol for P, and H is given (P must
330 be the tail in this case), introduce view symbols for earlier list
331 entries as well, until one of them is constant. */
334 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
335 struct line_entry
*h
)
339 memset (&viewx
, 0, sizeof (viewx
));
340 viewx
.X_unsigned
= 1;
342 /* First, compute !(E->label > P->label), to tell whether or not
343 we're to reset the view number. If we can't resolve it to a
344 constant, keep it symbolic. */
345 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
347 viewx
.X_op
= O_constant
;
348 viewx
.X_add_number
= 0;
349 viewx
.X_add_symbol
= NULL
;
350 viewx
.X_op_symbol
= NULL
;
355 viewx
.X_add_number
= 0;
356 viewx
.X_add_symbol
= e
->label
;
357 viewx
.X_op_symbol
= p
->label
;
358 resolve_expression (&viewx
);
359 if (viewx
.X_op
== O_constant
)
360 viewx
.X_add_number
= !viewx
.X_add_number
;
363 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
364 viewx
.X_add_number
= 0;
365 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_op
= O_logical_not
;
370 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
372 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
373 /* We can't compare the view numbers at this point, because in
374 VIEWX we've only determined whether we're to reset it so
376 if (viewx
.X_op
== O_constant
)
378 if (!value
->X_add_number
!= !viewx
.X_add_number
)
379 as_bad (_("view number mismatch"));
381 /* Record the expression to check it later. It is the result of
382 a logical not, thus 0 or 1. We just add up all such deferred
383 expressions, and resolve it at the end. */
384 else if (!value
->X_add_number
)
386 symbolS
*deferred
= make_expr_symbol (&viewx
);
387 if (view_assert_failed
)
391 memset (&chk
, 0, sizeof (chk
));
394 chk
.X_add_number
= 0;
395 chk
.X_add_symbol
= view_assert_failed
;
396 chk
.X_op_symbol
= deferred
;
397 deferred
= make_expr_symbol (&chk
);
399 view_assert_failed
= deferred
;
403 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
409 p
->loc
.view
= symbol_temp_make ();
410 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
413 memset (&incv
, 0, sizeof (incv
));
415 incv
.X_op
= O_symbol
;
416 incv
.X_add_symbol
= p
->loc
.view
;
417 incv
.X_add_number
= 1;
419 if (viewx
.X_op
== O_constant
)
421 gas_assert (viewx
.X_add_number
== 1);
426 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
427 viewx
.X_add_number
= 0;
428 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
429 viewx
.X_op
= O_multiply
;
433 if (!S_IS_DEFINED (e
->loc
.view
))
435 symbol_set_value_expression (e
->loc
.view
, &viewx
);
436 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
437 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
440 /* Define and attempt to simplify any earlier views needed to
442 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
444 struct line_entry
*h2
;
445 /* Reverse the list to avoid quadratic behavior going backwards
446 in a single-linked list. */
447 struct line_entry
*r
= reverse_line_entry_list (h
);
450 /* Set or check views until we find a defined or absent view. */
453 /* Do not define the head of a (sub?)segment view while
454 handling others. It would be defined too early, without
455 regard to the last view of other subsegments.
456 set_or_check_view will be called for every head segment
460 set_or_check_view (r
, r
->next
, NULL
);
462 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
465 /* Unreverse the list, so that we can go forward again. */
466 h2
= reverse_line_entry_list (p
);
467 gas_assert (h2
== h
);
469 /* Starting from the last view we just defined, attempt to
470 simplify the view expressions, until we do so to P. */
473 /* The head view of a subsegment may remain undefined while
474 handling other elements, before it is linked to the last
475 view of the previous subsegment. */
478 gas_assert (S_IS_DEFINED (r
->loc
.view
));
479 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
481 while (r
!= p
&& (r
= r
->next
));
483 /* Now that we've defined and computed all earlier views that might
484 be needed to compute E's, attempt to simplify it. */
485 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
489 /* Record an entry for LOC occurring at LABEL. */
492 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
494 struct line_subseg
*lss
;
495 struct line_entry
*e
;
496 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
498 /* PR 26850: Do not record LOCs in non-executable or non-loaded
499 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
500 obj_coff_section is careless in setting SEC_ALLOC. */
502 need_flags
|= SEC_ALLOC
;
503 if ((now_seg
->flags
& need_flags
) != need_flags
)
505 /* FIXME: Add code to suppress multiple warnings ? */
506 if (debug_type
!= DEBUG_DWARF2
)
507 as_warn ("dwarf line number information for %s ignored",
508 segment_name (now_seg
));
512 e
= XNEW (struct line_entry
);
517 lss
= get_line_subseg (now_seg
, now_subseg
, true);
519 /* Subseg heads are chained to previous subsegs in
521 if (loc
->view
&& lss
->head
)
522 set_or_check_view (e
,
523 (struct line_entry
*)lss
->ptail
,
527 lss
->ptail
= &e
->next
;
530 /* Record an entry for LOC occurring at OFS within the current fragment. */
533 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
535 static unsigned int line
= -1;
536 static unsigned int filenum
= -1;
540 /* Early out for as-yet incomplete location information. */
543 if (loc
->filenum
== 0)
547 if (DWARF2_LINE_VERSION
< 5)
551 /* Don't emit sequences of line symbols for the same line when the
552 symbols apply to assembler code. It is necessary to emit
553 duplicate line symbols when a compiler asks for them, because GDB
554 uses them to determine the end of the prologue. */
555 if (debug_type
== DEBUG_DWARF2
556 && line
== loc
->line
&& filenum
== loc
->filenum
)
560 filenum
= loc
->filenum
;
566 /* Use a non-fake name for the line number location,
567 so that it can be referred to by relocations. */
568 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
569 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
572 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
573 dwarf2_gen_line_info_1 (sym
, loc
);
577 get_basename (const char * pathname
)
581 file
= lbasename (pathname
);
582 /* Don't make empty string from / or A: from A:/ . */
583 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
584 if (file
<= pathname
+ 3)
587 if (file
== pathname
+ 1)
594 get_directory_table_entry (const char *dirname
,
603 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
604 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
612 for (d
= 0; d
< dirs_in_use
; ++d
)
615 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
616 && dirs
[d
][dirlen
] == '\0')
622 if (dirs
== NULL
|| dirs
[0] == NULL
)
628 if (d
>= dirs_allocated
)
630 unsigned int old
= dirs_allocated
;
632 dirs_allocated
= d
+ 32;
633 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
634 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
637 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
638 if (dirs_in_use
<= d
)
645 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
647 if (i
>= files_allocated
)
649 unsigned int old
= files_allocated
;
651 files_allocated
= i
+ 32;
652 /* Catch wraparound. */
653 if (files_allocated
<= old
)
655 as_bad (_("file number %lu is too big"), (unsigned long) i
);
659 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
660 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
663 files
[i
].filename
= file
;
665 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
667 if (files_in_use
< i
+ 1)
668 files_in_use
= i
+ 1;
673 /* Get a .debug_line file number for PATHNAME. If there is a
674 directory component to PATHNAME, then this will be stored
675 in the directory table, if it is not already present.
676 Returns the slot number allocated to that filename or -1
677 if there was a problem. */
680 allocate_filenum (const char * pathname
)
682 static signed int last_used
= -1, last_used_dir_len
= 0;
687 /* Short circuit the common case of adding the same pathname
691 const char * dirname
= NULL
;
694 dirname
= dirs
[files
[last_used
].dir
];
698 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
703 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
704 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
705 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
706 files
[last_used
].filename
) == 0)
711 file
= get_basename (pathname
);
712 dir_len
= file
- pathname
;
714 dir
= get_directory_table_entry (pathname
, dir_len
, false);
716 /* Do not use slot-0. That is specifically reserved for use by
717 the '.file 0 "name"' directive. */
718 for (i
= 1; i
< files_in_use
; ++i
)
719 if (files
[i
].dir
== dir
721 && filename_cmp (file
, files
[i
].filename
) == 0)
724 last_used_dir_len
= dir_len
;
728 if (!assign_file_to_slot (i
, file
, dir
))
731 num_of_auto_assigned
++;
734 last_used_dir_len
= dir_len
;
739 /* Allocate slot NUM in the .debug_line file table to FILENAME.
740 If DIRNAME is not NULL or there is a directory component to FILENAME
741 then this will be stored in the directory table, if not already present.
742 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
743 Returns TRUE if allocation succeeded, FALSE otherwise. */
746 allocate_filename_to_slot (const char *dirname
,
747 const char *filename
,
755 /* Short circuit the common case of adding the same pathname
757 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
759 const char * dir
= NULL
;
762 dir
= dirs
[files
[num
].dir
];
765 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
770 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
773 if (filename_cmp (filename
, files
[num
].filename
) != 0)
776 /* If the filenames match, but the directory table entry was
777 empty, then fill it with the provided directory name. */
782 dirs_allocated
= files
[num
].dir
+ 32;
783 dirs
= XCNEWVEC (char *, dirs_allocated
);
786 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
791 else if (dir
!= NULL
)
793 dirlen
= strlen (dir
);
794 if (filename_ncmp (filename
, dir
, dirlen
) == 0
795 && IS_DIR_SEPARATOR (filename
[dirlen
])
796 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
799 else /* dir == NULL */
801 file
= get_basename (filename
);
802 if (filename_cmp (file
, files
[num
].filename
) == 0)
804 /* The filenames match, but the directory table entry is empty.
805 Fill it with the provided directory name. */
810 dirs_allocated
= files
[num
].dir
+ 32;
811 dirs
= XCNEWVEC (char *, dirs_allocated
);
814 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
821 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
823 dir
== NULL
? "" : dir
,
824 dir
== NULL
? "" : "/",
826 dirname
== NULL
? "" : dirname
,
827 dirname
== NULL
? "" : "/",
835 file
= get_basename (filename
);
836 dirlen
= file
- filename
;
840 dirlen
= strlen (dirname
);
844 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
847 if (! assign_file_to_slot (i
, file
, d
))
852 if (target_big_endian
)
854 /* md5's are stored in litte endian format. */
855 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
856 unsigned int byte
= NUM_MD5_BYTES
;
857 unsigned int bignum_index
= 0;
859 while (bits_remaining
)
861 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
862 valueT bignum_value
= generic_bignum
[bignum_index
];
865 while (bignum_bits_remaining
)
867 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
869 bignum_bits_remaining
-= 8;
876 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
877 unsigned int byte
= 0;
878 unsigned int bignum_index
= 0;
880 while (bits_remaining
)
882 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
883 valueT bignum_value
= generic_bignum
[bignum_index
];
887 while (bignum_bits_remaining
)
889 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
891 bignum_bits_remaining
-= 8;
898 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
903 /* Returns the current source information. If .file directives have
904 been encountered, the info for the corresponding source file is
905 returned. Otherwise, the info for the assembly source file is
909 dwarf2_where (struct dwarf2_line_info
*line
)
911 if (debug_type
== DEBUG_DWARF2
)
913 const char *filename
;
915 memset (line
, 0, sizeof (*line
));
916 filename
= as_where (&line
->line
);
917 line
->filenum
= allocate_filenum (filename
);
918 /* FIXME: We should check the return value from allocate_filenum. */
920 line
->flags
= DWARF2_FLAG_IS_STMT
;
921 line
->isa
= current
.isa
;
922 line
->discriminator
= current
.discriminator
;
929 /* A hook to allow the target backend to inform the line number state
930 machine of isa changes when assembler debug info is enabled. */
933 dwarf2_set_isa (unsigned int isa
)
938 /* Called for each machine instruction, or relatively atomic group of
939 machine instructions (ie built-in macro). The instruction or group
940 is SIZE bytes in length. If dwarf2 line number generation is called
941 for, emit a line statement appropriately. */
944 dwarf2_emit_insn (int size
)
946 struct dwarf2_line_info loc
;
948 if (debug_type
!= DEBUG_DWARF2
949 ? !dwarf2_loc_directive_seen
950 : !seen_at_least_1_file ())
955 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
956 dwarf2_consume_line_info ();
959 /* Move all previously-emitted line entries for the current position by
960 DELTA bytes. This function cannot be used to move the same entries
964 dwarf2_move_insn (int delta
)
966 struct line_subseg
*lss
;
967 struct line_entry
*e
;
973 lss
= get_line_subseg (now_seg
, now_subseg
, false);
977 now
= frag_now_fix ();
978 while ((e
= *lss
->pmove_tail
))
980 if (S_GET_VALUE (e
->label
) == now
)
981 S_SET_VALUE (e
->label
, now
+ delta
);
982 lss
->pmove_tail
= &e
->next
;
986 /* Called after the current line information has been either used with
987 dwarf2_gen_line_info or saved with a machine instruction for later use.
988 This resets the state of the line number information to reflect that
992 dwarf2_consume_line_info (void)
994 /* Unless we generate DWARF2 debugging information for each
995 assembler line, we only emit one line symbol for one LOC. */
996 dwarf2_loc_directive_seen
= false;
998 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
999 | DWARF2_FLAG_PROLOGUE_END
1000 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1001 current
.discriminator
= 0;
1002 current
.view
= NULL
;
1005 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1006 is enabled, emit a basic block marker. */
1009 dwarf2_emit_label (symbolS
*label
)
1011 struct dwarf2_line_info loc
;
1013 if (!dwarf2_loc_mark_labels
)
1015 if (S_GET_SEGMENT (label
) != now_seg
)
1017 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1019 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1022 dwarf2_where (&loc
);
1024 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1026 dwarf2_gen_line_info_1 (label
, &loc
);
1027 dwarf2_consume_line_info ();
1030 /* Handle two forms of .file directive:
1031 - Pass .file "source.c" to s_app_file
1032 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1034 If an entry is added to the file table, return a pointer to the filename. */
1037 dwarf2_directive_filename (void)
1039 bool with_md5
= false;
1042 const char * dirname
= NULL
;
1046 /* Continue to accept a bare string and pass it off. */
1048 if (*input_line_pointer
== '"')
1054 num
= get_absolute_expression ();
1056 if ((offsetT
) num
< 1)
1058 if (num
== 0 && dwarf_level
< 5)
1060 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1062 as_bad (_("file number less than one"));
1063 ignore_rest_of_line ();
1068 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1069 "switch back to the already allocated file <N> as the current
1072 filename
= demand_copy_C_string (&filename_len
);
1073 if (filename
== NULL
)
1074 /* demand_copy_C_string will have already generated an error message. */
1077 /* For DWARF-5 support we also accept:
1078 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1079 if (DWARF2_LINE_VERSION
> 4)
1082 if (*input_line_pointer
== '"')
1085 filename
= demand_copy_C_string (&filename_len
);
1089 if (startswith (input_line_pointer
, "md5"))
1091 input_line_pointer
+= 3;
1095 expression_and_evaluate (& exp
);
1096 if (exp
.X_op
!= O_big
)
1097 as_bad (_("md5 value too small or not a constant"));
1103 demand_empty_rest_of_line ();
1105 /* A .file directive implies compiler generated debug information is
1106 being supplied. Turn off gas generated debug info. */
1107 debug_type
= DEBUG_NONE
;
1109 if (num
!= (unsigned int) num
1110 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1112 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1116 if (num_of_auto_assigned
)
1118 /* Clear slots auto-assigned before the first .file <NUMBER>
1119 directive was seen. */
1120 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1122 for (i
= 1; i
< files_in_use
; i
++)
1123 files
[i
].filename
= NULL
;
1125 num_of_auto_assigned
= 0;
1128 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1135 /* Calls dwarf2_directive_filename, but discards its result.
1136 Used in pseudo-op tables where the function result is ignored. */
1139 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1141 (void) dwarf2_directive_filename ();
1145 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1147 offsetT filenum
, line
;
1149 /* If we see two .loc directives in a row, force the first one to be
1151 if (dwarf2_loc_directive_seen
)
1152 dwarf2_emit_insn (0);
1154 filenum
= get_absolute_expression ();
1156 line
= get_absolute_expression ();
1160 if (filenum
== 0 && dwarf_level
< 5)
1162 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1164 as_bad (_("file number less than one"));
1169 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1171 as_bad (_("unassigned file number %ld"), (long) filenum
);
1175 current
.filenum
= filenum
;
1176 current
.line
= line
;
1177 current
.discriminator
= 0;
1182 if (files
[filenum
].dir
)
1184 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1185 size_t file_len
= strlen (files
[filenum
].filename
);
1186 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1188 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1189 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1190 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1191 cp
[dir_len
+ file_len
+ 1] = '\0';
1192 listing_source_file (cp
);
1196 listing_source_file (files
[filenum
].filename
);
1197 listing_source_line (line
);
1202 if (ISDIGIT (*input_line_pointer
))
1204 current
.column
= get_absolute_expression ();
1208 while (ISALPHA (*input_line_pointer
))
1213 c
= get_symbol_name (& p
);
1215 if (strcmp (p
, "basic_block") == 0)
1217 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1218 *input_line_pointer
= c
;
1220 else if (strcmp (p
, "prologue_end") == 0)
1222 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1223 *input_line_pointer
= c
;
1225 else if (strcmp (p
, "epilogue_begin") == 0)
1227 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1228 *input_line_pointer
= c
;
1230 else if (strcmp (p
, "is_stmt") == 0)
1232 (void) restore_line_pointer (c
);
1233 value
= get_absolute_expression ();
1235 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1236 else if (value
== 1)
1237 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1240 as_bad (_("is_stmt value not 0 or 1"));
1244 else if (strcmp (p
, "isa") == 0)
1246 (void) restore_line_pointer (c
);
1247 value
= get_absolute_expression ();
1249 current
.isa
= value
;
1252 as_bad (_("isa number less than zero"));
1256 else if (strcmp (p
, "discriminator") == 0)
1258 (void) restore_line_pointer (c
);
1259 value
= get_absolute_expression ();
1261 current
.discriminator
= value
;
1264 as_bad (_("discriminator less than zero"));
1268 else if (strcmp (p
, "view") == 0)
1272 (void) restore_line_pointer (c
);
1275 if (ISDIGIT (*input_line_pointer
)
1276 || *input_line_pointer
== '-')
1278 bool force_reset
= *input_line_pointer
== '-';
1280 value
= get_absolute_expression ();
1283 as_bad (_("numeric view can only be asserted to zero"));
1286 if (force_reset
&& force_reset_view
)
1287 sym
= force_reset_view
;
1290 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1293 force_reset_view
= sym
;
1298 char *name
= read_symbol_name ();
1302 sym
= symbol_find_or_make (name
);
1303 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1305 if (S_IS_VOLATILE (sym
))
1306 sym
= symbol_clone (sym
, 1);
1307 else if (!S_CAN_BE_REDEFINED (sym
))
1309 as_bad (_("symbol `%s' is already defined"), name
);
1313 S_SET_SEGMENT (sym
, undefined_section
);
1314 S_SET_VALUE (sym
, 0);
1315 symbol_set_frag (sym
, &zero_address_frag
);
1321 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1322 (void) restore_line_pointer (c
);
1326 SKIP_WHITESPACE_AFTER_NAME ();
1329 demand_empty_rest_of_line ();
1330 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= true;
1331 debug_type
= DEBUG_NONE
;
1333 /* If we were given a view id, emit the row right away. */
1335 dwarf2_emit_insn (0);
1339 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1341 offsetT value
= get_absolute_expression ();
1343 if (value
!= 0 && value
!= 1)
1345 as_bad (_("expected 0 or 1"));
1346 ignore_rest_of_line ();
1350 dwarf2_loc_mark_labels
= value
!= 0;
1351 demand_empty_rest_of_line ();
1355 static struct frag
*
1356 first_frag_for_seg (segT seg
)
1358 return seg_info (seg
)->frchainP
->frch_root
;
1361 static struct frag
*
1362 last_frag_for_seg (segT seg
)
1364 frchainS
*f
= seg_info (seg
)->frchainP
;
1366 while (f
->frch_next
!= NULL
)
1369 return f
->frch_last
;
1372 /* Emit a single byte into the current segment. */
1377 FRAG_APPEND_1_CHAR (byte
);
1380 /* Emit a statement program opcode into the current segment. */
1383 out_opcode (int opc
)
1388 /* Emit a two-byte word into the current segment. */
1393 md_number_to_chars (frag_more (2), data
, 2);
1396 /* Emit a four byte word into the current segment. */
1401 md_number_to_chars (frag_more (4), data
, 4);
1404 /* Emit an unsigned "little-endian base 128" number. */
1407 out_uleb128 (addressT value
)
1409 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1412 /* Emit a signed "little-endian base 128" number. */
1415 out_leb128 (addressT value
)
1417 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1420 /* Emit a tuple for .debug_abbrev. */
1423 out_abbrev (int name
, int form
)
1429 /* Get the size of a fragment. */
1432 get_frag_fix (fragS
*frag
, segT seg
)
1437 return frag
->fr_fix
;
1439 /* If a fragment is the last in the chain, special measures must be
1440 taken to find its size before relaxation, since it may be pending
1441 on some subsegment chain. */
1442 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1443 if (fr
->frch_last
== frag
)
1444 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1449 /* Set an absolute address (may result in a relocation entry). */
1452 out_set_addr (symbolS
*sym
)
1456 memset (&exp
, 0, sizeof exp
);
1457 out_opcode (DW_LNS_extended_op
);
1458 out_uleb128 (sizeof_address
+ 1);
1460 out_opcode (DW_LNE_set_address
);
1461 exp
.X_op
= O_symbol
;
1462 exp
.X_add_symbol
= sym
;
1463 exp
.X_add_number
= 0;
1464 emit_expr (&exp
, sizeof_address
);
1467 static void scale_addr_delta (addressT
*);
1470 scale_addr_delta (addressT
*addr_delta
)
1472 static int printed_this
= 0;
1473 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1475 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1477 as_bad("unaligned opcodes detected in executable segment");
1480 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1484 /* Encode a pair of line and address skips as efficiently as possible.
1485 Note that the line skip is signed, whereas the address skip is unsigned.
1487 The following two routines *must* be kept in sync. This is
1488 enforced by making emit_inc_line_addr abort if we do not emit
1489 exactly the expected number of bytes. */
1492 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1494 unsigned int tmp
, opcode
;
1497 /* Scale the address delta by the minimum instruction length. */
1498 scale_addr_delta (&addr_delta
);
1500 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1501 We cannot use special opcodes here, since we want the end_sequence
1502 to emit the matrix entry. */
1503 if (line_delta
== INT_MAX
)
1505 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1507 else if (addr_delta
)
1508 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1512 /* Bias the line delta by the base. */
1513 tmp
= line_delta
- DWARF2_LINE_BASE
;
1515 /* If the line increment is out of range of a special opcode, we
1516 must encode it with DW_LNS_advance_line. */
1517 if (tmp
>= DWARF2_LINE_RANGE
)
1519 len
= 1 + sizeof_leb128 (line_delta
, 1);
1521 tmp
= 0 - DWARF2_LINE_BASE
;
1524 /* Bias the opcode by the special opcode base. */
1525 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1527 /* Avoid overflow when addr_delta is large. */
1528 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1530 /* Try using a special opcode. */
1531 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1535 /* Try using DW_LNS_const_add_pc followed by special op. */
1536 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1541 /* Otherwise use DW_LNS_advance_pc. */
1542 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1544 /* DW_LNS_copy or special opcode. */
1551 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1553 unsigned int tmp
, opcode
;
1555 char *end
= p
+ len
;
1557 /* Line number sequences cannot go backward in addresses. This means
1558 we've incorrectly ordered the statements in the sequence. */
1559 gas_assert ((offsetT
) addr_delta
>= 0);
1561 /* Scale the address delta by the minimum instruction length. */
1562 scale_addr_delta (&addr_delta
);
1564 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1565 We cannot use special opcodes here, since we want the end_sequence
1566 to emit the matrix entry. */
1567 if (line_delta
== INT_MAX
)
1569 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1570 *p
++ = DW_LNS_const_add_pc
;
1571 else if (addr_delta
)
1573 *p
++ = DW_LNS_advance_pc
;
1574 p
+= output_leb128 (p
, addr_delta
, 0);
1577 *p
++ = DW_LNS_extended_op
;
1579 *p
++ = DW_LNE_end_sequence
;
1583 /* Bias the line delta by the base. */
1584 tmp
= line_delta
- DWARF2_LINE_BASE
;
1586 /* If the line increment is out of range of a special opcode, we
1587 must encode it with DW_LNS_advance_line. */
1588 if (tmp
>= DWARF2_LINE_RANGE
)
1590 *p
++ = DW_LNS_advance_line
;
1591 p
+= output_leb128 (p
, line_delta
, 1);
1594 tmp
= 0 - DWARF2_LINE_BASE
;
1598 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1600 if (line_delta
== 0 && addr_delta
== 0)
1606 /* Bias the opcode by the special opcode base. */
1607 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1609 /* Avoid overflow when addr_delta is large. */
1610 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1612 /* Try using a special opcode. */
1613 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1620 /* Try using DW_LNS_const_add_pc followed by special op. */
1621 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1624 *p
++ = DW_LNS_const_add_pc
;
1630 /* Otherwise use DW_LNS_advance_pc. */
1631 *p
++ = DW_LNS_advance_pc
;
1632 p
+= output_leb128 (p
, addr_delta
, 0);
1640 gas_assert (p
== end
);
1643 /* Handy routine to combine calls to the above two routines. */
1646 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1648 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1649 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1652 /* Write out an alternative form of line and address skips using
1653 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1654 line and address information, but it is required if linker relaxation
1655 could change the code offsets. The following two routines *must* be
1657 #define ADDR_DELTA_LIMIT 50000
1660 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1664 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1665 if (line_delta
!= INT_MAX
)
1666 len
= 1 + sizeof_leb128 (line_delta
, 1);
1668 if (addr_delta
> ADDR_DELTA_LIMIT
)
1670 /* DW_LNS_extended_op */
1671 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1672 /* DW_LNE_set_address */
1673 len
+= 1 + sizeof_address
;
1676 /* DW_LNS_fixed_advance_pc */
1679 if (line_delta
== INT_MAX
)
1680 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1690 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1694 char *end
= p
+ len
;
1696 /* Line number sequences cannot go backward in addresses. This means
1697 we've incorrectly ordered the statements in the sequence. */
1698 gas_assert ((offsetT
) addr_delta
>= 0);
1700 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1701 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1703 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1704 if (line_delta
!= INT_MAX
)
1706 *p
++ = DW_LNS_advance_line
;
1707 p
+= output_leb128 (p
, line_delta
, 1);
1710 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1712 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1713 advance the address by at most 64K. Linker relaxation (without
1714 which this function would not be used) could change the operand by
1715 an unknown amount. If the address increment is getting close to
1716 the limit, just reset the address. */
1717 if (addr_delta
> ADDR_DELTA_LIMIT
)
1722 memset (&exp
, 0, sizeof exp
);
1723 gas_assert (pexp
->X_op
== O_subtract
);
1724 to_sym
= pexp
->X_add_symbol
;
1726 *p
++ = DW_LNS_extended_op
;
1727 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1728 *p
++ = DW_LNE_set_address
;
1729 exp
.X_op
= O_symbol
;
1730 exp
.X_add_symbol
= to_sym
;
1731 exp
.X_add_number
= 0;
1732 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1733 p
+= sizeof_address
;
1737 *p
++ = DW_LNS_fixed_advance_pc
;
1738 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1742 if (line_delta
== INT_MAX
)
1744 *p
++ = DW_LNS_extended_op
;
1746 *p
++ = DW_LNE_end_sequence
;
1751 gas_assert (p
== end
);
1754 /* Generate a variant frag that we can use to relax address/line
1755 increments between fragments of the target segment. */
1758 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1763 memset (&exp
, 0, sizeof exp
);
1764 exp
.X_op
= O_subtract
;
1765 exp
.X_add_symbol
= to_sym
;
1766 exp
.X_op_symbol
= from_sym
;
1767 exp
.X_add_number
= 0;
1769 /* The maximum size of the frag is the line delta with a maximum
1770 sized address delta. */
1771 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1772 max_chars
= size_fixed_inc_line_addr (line_delta
,
1773 -DWARF2_LINE_MIN_INSN_LENGTH
);
1775 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1777 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1778 make_expr_symbol (&exp
), line_delta
, NULL
);
1781 /* The function estimates the size of a rs_dwarf2dbg variant frag
1782 based on the current values of the symbols. It is called before
1783 the relaxation loop. We set fr_subtype to the expected length. */
1786 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1791 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1792 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1793 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1795 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1797 frag
->fr_subtype
= size
;
1802 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1803 current values of the symbols. fr_subtype is the current length
1804 of the frag. This returns the change in frag length. */
1807 dwarf2dbg_relax_frag (fragS
*frag
)
1809 int old_size
, new_size
;
1811 old_size
= frag
->fr_subtype
;
1812 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1814 return new_size
- old_size
;
1817 /* This function converts a rs_dwarf2dbg variant frag into a normal
1818 fill frag. This is called after all relaxation has been done.
1819 fr_subtype will be the desired length of the frag. */
1822 dwarf2dbg_convert_frag (fragS
*frag
)
1826 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1828 /* If linker relaxation is enabled then the distance between the two
1829 symbols in the frag->fr_symbol expression might change. Hence we
1830 cannot rely upon the value computed by resolve_symbol_value.
1831 Instead we leave the expression unfinalized and allow
1832 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1833 relocation) that will allow the linker to correctly compute the
1834 actual address difference. We have to use a fixed line advance for
1835 this as we cannot (easily) relocate leb128 encoded values. */
1836 int saved_finalize_syms
= finalize_syms
;
1839 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1840 finalize_syms
= saved_finalize_syms
;
1843 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1845 /* fr_var carries the max_chars that we created the fragment with.
1846 fr_subtype carries the current expected length. We must, of
1847 course, have allocated enough memory earlier. */
1848 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1850 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1851 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1852 frag
->fr_literal
+ frag
->fr_fix
,
1855 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1856 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1858 frag
->fr_fix
+= frag
->fr_subtype
;
1859 frag
->fr_type
= rs_fill
;
1861 frag
->fr_offset
= 0;
1864 /* Generate .debug_line content for the chain of line number entries
1865 beginning at E, for segment SEG. */
1868 process_entries (segT seg
, struct line_entry
*e
)
1870 unsigned filenum
= 1;
1872 unsigned column
= 0;
1874 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1875 fragS
*last_frag
= NULL
, *frag
;
1876 addressT last_frag_ofs
= 0, frag_ofs
;
1877 symbolS
*last_lab
= NULL
, *lab
;
1878 struct line_entry
*next
;
1880 if (flag_dwarf_sections
)
1883 const char * sec_name
;
1885 /* Switch to the relevant sub-section before we start to emit
1886 the line number table.
1888 FIXME: These sub-sections do not have a normal Line Number
1889 Program Header, thus strictly speaking they are not valid
1890 DWARF sections. Unfortunately the DWARF standard assumes
1891 a one-to-one relationship between compilation units and
1892 line number tables. Thus we have to have a .debug_line
1893 section, as well as our sub-sections, and we have to ensure
1894 that all of the sub-sections are merged into a proper
1895 .debug_line section before a debugger sees them. */
1897 sec_name
= bfd_section_name (seg
);
1898 if (strcmp (sec_name
, ".text") != 0)
1900 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1901 subseg_set (subseg_get (name
, false), 0);
1904 /* Don't create a .debug_line.text section -
1905 that is redundant. Instead just switch back to the
1906 normal .debug_line section. */
1907 subseg_set (subseg_get (".debug_line", false), 0);
1914 if (filenum
!= e
->loc
.filenum
)
1916 filenum
= e
->loc
.filenum
;
1917 out_opcode (DW_LNS_set_file
);
1918 out_uleb128 (filenum
);
1921 if (column
!= e
->loc
.column
)
1923 column
= e
->loc
.column
;
1924 out_opcode (DW_LNS_set_column
);
1925 out_uleb128 (column
);
1928 if (e
->loc
.discriminator
!= 0)
1930 out_opcode (DW_LNS_extended_op
);
1931 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1932 out_opcode (DW_LNE_set_discriminator
);
1933 out_uleb128 (e
->loc
.discriminator
);
1936 if (isa
!= e
->loc
.isa
)
1939 out_opcode (DW_LNS_set_isa
);
1943 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1945 flags
= e
->loc
.flags
;
1946 out_opcode (DW_LNS_negate_stmt
);
1949 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1950 out_opcode (DW_LNS_set_basic_block
);
1952 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1953 out_opcode (DW_LNS_set_prologue_end
);
1955 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1956 out_opcode (DW_LNS_set_epilogue_begin
);
1958 /* Don't try to optimize away redundant entries; gdb wants two
1959 entries for a function where the code starts on the same line as
1960 the {, and there's no way to identify that case here. Trust gcc
1961 to optimize appropriately. */
1962 line_delta
= e
->loc
.line
- line
;
1964 frag
= symbol_get_frag (lab
);
1965 frag_ofs
= S_GET_VALUE (lab
);
1967 if (last_frag
== NULL
1968 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1969 /* If we're going to reset the view, but we know we're
1970 advancing the PC, we don't have to force with
1971 set_address. We know we do when we're at the same
1972 address of the same frag, and we know we might when
1973 we're in the beginning of a frag, and we were at the
1974 end of the previous frag. */
1975 && (frag
== last_frag
1976 ? (last_frag_ofs
== frag_ofs
)
1978 && ((offsetT
)last_frag_ofs
1979 >= get_frag_fix (last_frag
, seg
))))))
1982 out_inc_line_addr (line_delta
, 0);
1984 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1985 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1987 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1992 last_frag_ofs
= frag_ofs
;
2000 /* Emit a DW_LNE_end_sequence for the end of the section. */
2001 frag
= last_frag_for_seg (seg
);
2002 frag_ofs
= get_frag_fix (frag
, seg
);
2003 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2004 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2007 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2008 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2012 /* Switch to LINE_STR_SEG and output the given STR. Return the
2013 symbol pointing to the new string in the section. */
2016 add_line_strp (segT line_str_seg
, const char *str
)
2022 subseg_set (line_str_seg
, 0);
2024 sym
= symbol_temp_new_now_octets ();
2026 size
= strlen (str
) + 1;
2027 cp
= frag_more (size
);
2028 memcpy (cp
, str
, size
);
2034 /* Emit the directory and file tables for .debug_line. */
2037 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2043 bool emit_md5
= false;
2044 bool emit_timestamps
= true;
2045 bool emit_filesize
= true;
2046 segT line_str_seg
= NULL
;
2049 /* Output the Directory Table. */
2050 if (DWARF2_LINE_VERSION
>= 5)
2052 /* We only have one column in the directory table. */
2055 /* Describe the purpose and format of the column. */
2056 out_uleb128 (DW_LNCT_path
);
2057 /* Store these strings in the .debug_line_str section so they
2059 out_uleb128 (DW_FORM_line_strp
);
2061 /* Now state how many rows there are in the table. We need at
2062 least 1 if there is one or more file names to store the
2063 "working directory". */
2064 if (dirs_in_use
== 0 && files_in_use
> 0)
2067 out_uleb128 (dirs_in_use
);
2070 /* Emit directory list. */
2071 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2073 line_str_seg
= subseg_new (".debug_line_str", 0);
2074 bfd_set_section_flags (line_str_seg
,
2075 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2076 | SEC_MERGE
| SEC_STRINGS
);
2077 line_str_seg
->entsize
= 1;
2079 /* DWARF5 uses slot zero, but that is only set explicitly
2080 using a .file 0 directive. If that isn't used, but dir
2081 one is used, then use that as main file directory.
2082 Otherwise use pwd as main file directory. */
2083 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2084 dir
= remap_debug_filename (dirs
[0]);
2085 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2086 dir
= remap_debug_filename (dirs
[1]);
2088 dir
= remap_debug_filename (getpwd ());
2090 line_strp
= add_line_strp (line_str_seg
, dir
);
2091 subseg_set (line_seg
, 0);
2092 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2094 for (i
= 1; i
< dirs_in_use
; ++i
)
2096 dir
= remap_debug_filename (dirs
[i
]);
2097 if (DWARF2_LINE_VERSION
< 5)
2099 size
= strlen (dir
) + 1;
2100 cp
= frag_more (size
);
2101 memcpy (cp
, dir
, size
);
2105 line_strp
= add_line_strp (line_str_seg
, dir
);
2106 subseg_set (line_seg
, 0);
2107 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2111 if (DWARF2_LINE_VERSION
< 5)
2115 /* Output the File Name Table. */
2116 if (DWARF2_LINE_VERSION
>= 5)
2118 unsigned int columns
= 4;
2120 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2122 emit_timestamps
= false;
2126 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2128 emit_filesize
= false;
2132 for (i
= 0; i
< files_in_use
; ++i
)
2133 if (files
[i
].md5
[0] != 0)
2135 if (i
< files_in_use
)
2141 /* The number of format entries to follow. */
2143 /* The format of the file name. */
2144 out_uleb128 (DW_LNCT_path
);
2145 /* Store these strings in the .debug_line_str section so they
2147 out_uleb128 (DW_FORM_line_strp
);
2149 /* The format of the directory index. */
2150 out_uleb128 (DW_LNCT_directory_index
);
2151 out_uleb128 (DW_FORM_udata
);
2153 if (emit_timestamps
)
2155 /* The format of the timestamp. */
2156 out_uleb128 (DW_LNCT_timestamp
);
2157 out_uleb128 (DW_FORM_udata
);
2162 /* The format of the file size. */
2163 out_uleb128 (DW_LNCT_size
);
2164 out_uleb128 (DW_FORM_udata
);
2169 /* The format of the MD5 sum. */
2170 out_uleb128 (DW_LNCT_MD5
);
2171 out_uleb128 (DW_FORM_data16
);
2174 /* The number of entries in the table. */
2175 out_uleb128 (files_in_use
);
2178 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2180 const char *fullfilename
;
2182 if (files
[i
].filename
== NULL
)
2184 /* Prevent a crash later, particularly for file 1. DWARF5
2185 uses slot zero, but that is only set explicitly using a
2186 .file 0 directive. If that isn't used, but file 1 is,
2187 then use that as main file name. */
2188 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2189 files
[0].filename
= files
[1].filename
;
2191 files
[i
].filename
= "";
2192 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2194 as_bad (_("unassigned file number %ld"), (long) i
);
2199 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2200 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2201 if (DWARF2_LINE_VERSION
< 5)
2203 size
= strlen (fullfilename
) + 1;
2204 cp
= frag_more (size
);
2205 memcpy (cp
, fullfilename
, size
);
2209 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2210 subseg_set (line_seg
, 0);
2211 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2214 /* Directory number. */
2215 out_uleb128 (files
[i
].dir
);
2217 /* Output the last modification timestamp. */
2218 if (emit_timestamps
)
2222 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2223 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2224 if (timestamp
== -1)
2226 out_uleb128 (timestamp
);
2229 /* Output the filesize. */
2233 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2234 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2237 out_uleb128 (filesize
);
2240 /* Output the md5 sum. */
2245 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2246 out_byte (files
[i
].md5
[b
]);
2250 if (DWARF2_LINE_VERSION
< 5)
2251 /* Terminate filename list. */
2255 /* Switch to SEC and output a header length field. Return the size of
2256 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2257 to the end of the section. EXPR->X_add_number will be set to the
2258 negative size of the header. */
2261 out_header (asection
*sec
, expressionS
*exp
)
2266 subseg_set (sec
, 0);
2268 if (flag_dwarf_sections
)
2270 /* If we are going to put the start and end symbols in different
2271 sections, then we need real symbols, not just fake, local ones. */
2273 start_sym
= symbol_make (".Ldebug_line_start");
2274 end_sym
= symbol_make (".Ldebug_line_end");
2275 symbol_set_value_now (start_sym
);
2279 start_sym
= symbol_temp_new_now_octets ();
2280 end_sym
= symbol_temp_make ();
2283 /* Total length of the information. */
2284 exp
->X_op
= O_subtract
;
2285 exp
->X_add_symbol
= end_sym
;
2286 exp
->X_op_symbol
= start_sym
;
2288 switch (DWARF2_FORMAT (sec
))
2290 case dwarf2_format_32bit
:
2291 exp
->X_add_number
= -4;
2295 case dwarf2_format_64bit
:
2296 exp
->X_add_number
= -12;
2301 case dwarf2_format_64bit_irix
:
2302 exp
->X_add_number
= -8;
2307 as_fatal (_("internal error: unknown dwarf2 format"));
2311 /* Emit the collected .debug_line data. */
2314 out_debug_line (segT line_seg
)
2317 symbolS
*prologue_start
, *prologue_end
;
2322 memset (&exp
, 0, sizeof exp
);
2323 sizeof_offset
= out_header (line_seg
, &exp
);
2324 line_end
= exp
.X_add_symbol
;
2327 out_two (DWARF2_LINE_VERSION
);
2329 if (DWARF2_LINE_VERSION
>= 5)
2331 out_byte (sizeof_address
);
2332 out_byte (0); /* Segment Selector size. */
2334 /* Length of the prologue following this length. */
2335 prologue_start
= symbol_temp_make ();
2336 prologue_end
= symbol_temp_make ();
2337 exp
.X_op
= O_subtract
;
2338 exp
.X_add_symbol
= prologue_end
;
2339 exp
.X_op_symbol
= prologue_start
;
2340 exp
.X_add_number
= 0;
2341 emit_expr (&exp
, sizeof_offset
);
2342 symbol_set_value_now (prologue_start
);
2344 /* Parameters of the state machine. */
2345 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2346 if (DWARF2_LINE_VERSION
>= 4)
2347 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2348 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2349 out_byte (DWARF2_LINE_BASE
);
2350 out_byte (DWARF2_LINE_RANGE
);
2351 out_byte (DWARF2_LINE_OPCODE_BASE
);
2353 /* Standard opcode lengths. */
2354 out_byte (0); /* DW_LNS_copy */
2355 out_byte (1); /* DW_LNS_advance_pc */
2356 out_byte (1); /* DW_LNS_advance_line */
2357 out_byte (1); /* DW_LNS_set_file */
2358 out_byte (1); /* DW_LNS_set_column */
2359 out_byte (0); /* DW_LNS_negate_stmt */
2360 out_byte (0); /* DW_LNS_set_basic_block */
2361 out_byte (0); /* DW_LNS_const_add_pc */
2362 out_byte (1); /* DW_LNS_fixed_advance_pc */
2363 out_byte (0); /* DW_LNS_set_prologue_end */
2364 out_byte (0); /* DW_LNS_set_epilogue_begin */
2365 out_byte (1); /* DW_LNS_set_isa */
2366 /* We have emitted 12 opcode lengths, so make that this
2367 matches up to the opcode base value we have been using. */
2368 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2370 out_dir_and_file_list (line_seg
, sizeof_offset
);
2372 symbol_set_value_now (prologue_end
);
2374 /* For each section, emit a statement program. */
2375 for (s
= all_segs
; s
; s
= s
->next
)
2376 /* Paranoia - this check should have already have
2377 been handled in dwarf2_gen_line_info_1(). */
2378 if (SEG_NORMAL (s
->seg
))
2379 process_entries (s
->seg
, s
->head
->head
);
2381 if (flag_dwarf_sections
)
2382 /* We have to switch to the special .debug_line_end section
2383 before emitting the end-of-debug_line symbol. The linker
2384 script arranges for this section to be placed after all the
2385 (potentially garbage collected) .debug_line.<foo> sections.
2386 This section contains the line_end symbol which is used to
2387 compute the size of the linked .debug_line section, as seen
2388 in the DWARF Line Number header. */
2389 subseg_set (subseg_get (".debug_line_end", false), 0);
2391 symbol_set_value_now (line_end
);
2395 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2397 unsigned int addr_size
= sizeof_address
;
2402 memset (&exp
, 0, sizeof exp
);
2403 subseg_set (ranges_seg
, 0);
2405 /* For DW_AT_ranges to point at (there is no header, so really start
2406 of section, but see out_debug_rnglists). */
2407 *ranges_sym
= symbol_temp_new_now_octets ();
2409 /* Base Address Entry. */
2410 for (i
= 0; i
< addr_size
; i
++)
2412 for (i
= 0; i
< addr_size
; i
++)
2415 /* Range List Entry. */
2416 for (s
= all_segs
; s
; s
= s
->next
)
2421 frag
= first_frag_for_seg (s
->seg
);
2422 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2423 s
->text_start
= beg
;
2425 frag
= last_frag_for_seg (s
->seg
);
2426 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2429 exp
.X_op
= O_symbol
;
2430 exp
.X_add_symbol
= beg
;
2431 exp
.X_add_number
= 0;
2432 emit_expr (&exp
, addr_size
);
2434 exp
.X_op
= O_symbol
;
2435 exp
.X_add_symbol
= end
;
2436 exp
.X_add_number
= 0;
2437 emit_expr (&exp
, addr_size
);
2440 /* End of Range Entry. */
2441 for (i
= 0; i
< addr_size
; i
++)
2443 for (i
= 0; i
< addr_size
; i
++)
2448 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2451 symbolS
*ranges_end
;
2455 memset (&exp
, 0, sizeof exp
);
2456 out_header (ranges_seg
, &exp
);
2457 ranges_end
= exp
.X_add_symbol
;
2459 out_two (DWARF2_RNGLISTS_VERSION
);
2460 out_byte (sizeof_address
);
2461 out_byte (0); /* Segment Selector size. */
2462 out_four (0); /* Offset entry count. */
2464 /* For DW_AT_ranges to point at (must be after the header). */
2465 *ranges_sym
= symbol_temp_new_now_octets ();
2467 for (s
= all_segs
; s
; s
= s
->next
)
2472 out_byte (DW_RLE_start_length
);
2474 frag
= first_frag_for_seg (s
->seg
);
2475 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2476 s
->text_start
= beg
;
2478 frag
= last_frag_for_seg (s
->seg
);
2479 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2482 exp
.X_op
= O_symbol
;
2483 exp
.X_add_symbol
= beg
;
2484 exp
.X_add_number
= 0;
2485 emit_expr (&exp
, sizeof_address
);
2487 exp
.X_op
= O_symbol
;
2488 exp
.X_add_symbol
= end
;
2489 exp
.X_add_number
= 0;
2490 emit_leb128_expr (&exp
, 0);
2493 out_byte (DW_RLE_end_of_list
);
2495 symbol_set_value_now (ranges_end
);
2498 /* Emit data for .debug_aranges. */
2501 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2503 unsigned int addr_size
= sizeof_address
;
2507 symbolS
*aranges_end
;
2511 memset (&exp
, 0, sizeof exp
);
2512 sizeof_offset
= out_header (aranges_seg
, &exp
);
2513 aranges_end
= exp
.X_add_symbol
;
2514 size
= -exp
.X_add_number
;
2517 out_two (DWARF2_ARANGES_VERSION
);
2520 /* Offset to .debug_info. */
2521 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2522 size
+= sizeof_offset
;
2524 /* Size of an address (offset portion). */
2525 out_byte (addr_size
);
2528 /* Size of a segment descriptor. */
2532 /* Align the header. */
2533 while ((size
++ % (2 * addr_size
)) > 0)
2536 for (s
= all_segs
; s
; s
= s
->next
)
2541 frag
= first_frag_for_seg (s
->seg
);
2542 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2543 s
->text_start
= beg
;
2545 frag
= last_frag_for_seg (s
->seg
);
2546 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2549 exp
.X_op
= O_symbol
;
2550 exp
.X_add_symbol
= beg
;
2551 exp
.X_add_number
= 0;
2552 emit_expr (&exp
, addr_size
);
2554 exp
.X_op
= O_subtract
;
2555 exp
.X_add_symbol
= end
;
2556 exp
.X_op_symbol
= beg
;
2557 exp
.X_add_number
= 0;
2558 emit_expr (&exp
, addr_size
);
2561 p
= frag_more (2 * addr_size
);
2562 md_number_to_chars (p
, 0, addr_size
);
2563 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2565 symbol_set_value_now (aranges_end
);
2568 /* Emit data for .debug_abbrev. Note that this must be kept in
2569 sync with out_debug_info below. */
2572 out_debug_abbrev (segT abbrev_seg
,
2573 segT info_seg ATTRIBUTE_UNUSED
,
2574 segT line_seg ATTRIBUTE_UNUSED
)
2577 subseg_set (abbrev_seg
, 0);
2580 out_uleb128 (DW_TAG_compile_unit
);
2581 out_byte (DW_CHILDREN_no
);
2582 if (DWARF2_VERSION
< 4)
2584 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2585 secoff_form
= DW_FORM_data4
;
2587 secoff_form
= DW_FORM_data8
;
2590 secoff_form
= DW_FORM_sec_offset
;
2591 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2592 if (all_segs
->next
== NULL
)
2594 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2595 if (DWARF2_VERSION
< 4)
2596 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2598 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2601 out_abbrev (DW_AT_ranges
, secoff_form
);
2602 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2603 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2604 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2605 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2608 /* Terminate the abbreviations for this compilation unit. */
2612 /* Emit a description of this compilation unit for .debug_info. */
2615 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2616 symbolS
*ranges_sym
, symbolS
*name_sym
,
2617 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2623 memset (&exp
, 0, sizeof exp
);
2624 sizeof_offset
= out_header (info_seg
, &exp
);
2625 info_end
= exp
.X_add_symbol
;
2627 /* DWARF version. */
2628 out_two (DWARF2_VERSION
);
2630 if (DWARF2_VERSION
< 5)
2632 /* .debug_abbrev offset */
2633 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2637 /* unit (header) type */
2638 out_byte (DW_UT_compile
);
2641 /* Target address size. */
2642 out_byte (sizeof_address
);
2644 if (DWARF2_VERSION
>= 5)
2646 /* .debug_abbrev offset */
2647 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2650 /* DW_TAG_compile_unit DIE abbrev */
2653 /* DW_AT_stmt_list */
2654 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2655 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2658 /* These two attributes are emitted if all of the code is contiguous. */
2659 if (all_segs
->next
== NULL
)
2662 exp
.X_op
= O_symbol
;
2663 exp
.X_add_symbol
= all_segs
->text_start
;
2664 exp
.X_add_number
= 0;
2665 emit_expr (&exp
, sizeof_address
);
2668 if (DWARF2_VERSION
< 4)
2669 exp
.X_op
= O_symbol
;
2672 exp
.X_op
= O_subtract
;
2673 exp
.X_op_symbol
= all_segs
->text_start
;
2675 exp
.X_add_symbol
= all_segs
->text_end
;
2676 exp
.X_add_number
= 0;
2677 if (DWARF2_VERSION
< 4)
2678 emit_expr (&exp
, sizeof_address
);
2680 emit_leb128_expr (&exp
, 0);
2684 /* This attribute is emitted if the code is disjoint. */
2686 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2689 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2690 setup in out_debug_str below. */
2691 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2692 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2693 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2695 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2696 dwarf2 draft has no standard code for assembler. */
2697 out_two (DW_LANG_Mips_Assembler
);
2699 symbol_set_value_now (info_end
);
2702 /* Emit the three debug strings needed in .debug_str and setup symbols
2703 to them for use in out_debug_info. */
2705 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2706 symbolS
**producer_sym
)
2709 const char *comp_dir
;
2710 const char *dirname
;
2713 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2715 subseg_set (str_seg
, 0);
2717 /* DW_AT_name. We don't have the actual file name that was present
2718 on the command line, so assume files[first_file] is the main input file.
2719 We're not supposed to get called unless at least one line number
2720 entry was emitted, so this should always be defined. */
2721 *name_sym
= symbol_temp_new_now_octets ();
2722 if (files_in_use
== 0)
2724 if (files
[first_file
].dir
)
2726 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2727 len
= strlen (dirname
);
2729 /* Already has trailing slash. */
2730 p
= frag_more (len
);
2731 memcpy (p
, dirname
, len
);
2733 p
= frag_more (len
+ 1);
2734 memcpy (p
, dirname
, len
);
2735 INSERT_DIR_SEPARATOR (p
, len
);
2738 len
= strlen (files
[first_file
].filename
) + 1;
2739 p
= frag_more (len
);
2740 memcpy (p
, files
[first_file
].filename
, len
);
2742 /* DW_AT_comp_dir */
2743 *comp_dir_sym
= symbol_temp_new_now_octets ();
2744 comp_dir
= remap_debug_filename (getpwd ());
2745 len
= strlen (comp_dir
) + 1;
2746 p
= frag_more (len
);
2747 memcpy (p
, comp_dir
, len
);
2749 /* DW_AT_producer */
2750 *producer_sym
= symbol_temp_new_now_octets ();
2751 sprintf (producer
, "GNU AS %s", VERSION
);
2752 len
= strlen (producer
) + 1;
2753 p
= frag_more (len
);
2754 memcpy (p
, producer
, len
);
2760 last_seg_ptr
= &all_segs
;
2762 /* Select the default CIE version to produce here. The global
2763 starts with a value of -1 and will be modified to a valid value
2764 either by the user providing a command line option, or some
2765 targets will select their own default in md_after_parse_args. If
2766 we get here and the global still contains -1 then it is up to us
2767 to pick a sane default. The default we choose is 1, this is the
2768 CIE version gas has produced for a long time, and there seems no
2769 reason to change it yet. */
2770 if (flag_dwarf_cie_version
== -1)
2771 flag_dwarf_cie_version
= 1;
2774 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2775 were any .file/.loc directives, or --gdwarf2 was given, and if the
2776 file has a non-empty .debug_info section and an empty .debug_line
2777 section. If we emit .debug_line, and the .debug_info section is
2778 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2779 ALL_SEGS will be non-null if there were any .file/.loc directives,
2780 or --gdwarf2 was given and there were any located instructions
2784 dwarf2_finish (void)
2789 int emit_other_sections
= 0;
2790 int empty_debug_line
= 0;
2792 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2793 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2795 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2796 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2798 /* We can't construct a new debug_line section if we already have one.
2799 Give an error if we have seen any .loc, otherwise trust the user
2800 knows what they are doing and want to generate the .debug_line
2801 (and all other debug sections) themselves. */
2802 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2803 as_fatal ("duplicate .debug_line sections");
2805 if ((!all_segs
&& emit_other_sections
)
2806 || (!emit_other_sections
&& !empty_debug_line
))
2807 /* If there is no line information and no non-empty .debug_info
2808 section, or if there is both a non-empty .debug_info and a non-empty
2809 .debug_line, then we do nothing. */
2812 /* Calculate the size of an address for the target machine. */
2813 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2815 /* Create and switch to the line number section. */
2816 if (empty_debug_line
)
2818 line_seg
= subseg_new (".debug_line", 0);
2819 bfd_set_section_flags (line_seg
,
2820 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2823 /* For each subsection, chain the debug entries together. */
2824 for (s
= all_segs
; s
; s
= s
->next
)
2826 struct line_subseg
*lss
= s
->head
;
2827 struct line_entry
**ptail
= lss
->ptail
;
2829 /* Reset the initial view of the first subsection of the
2831 if (lss
->head
&& lss
->head
->loc
.view
)
2832 set_or_check_view (lss
->head
, NULL
, NULL
);
2834 while ((lss
= lss
->next
) != NULL
)
2836 /* Link the first view of subsequent subsections to the
2838 if (lss
->head
&& lss
->head
->loc
.view
)
2839 set_or_check_view (lss
->head
,
2840 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2841 s
->head
? s
->head
->head
: NULL
);
2847 if (empty_debug_line
)
2848 out_debug_line (line_seg
);
2850 /* If this is assembler generated line info, and there is no
2851 debug_info already, we need .debug_info, .debug_abbrev and
2852 .debug_str sections as well. */
2853 if (emit_other_sections
)
2858 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2860 gas_assert (all_segs
);
2862 info_seg
= subseg_new (".debug_info", 0);
2863 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2864 aranges_seg
= subseg_new (".debug_aranges", 0);
2865 str_seg
= subseg_new (".debug_str", 0);
2867 bfd_set_section_flags (info_seg
,
2868 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2869 bfd_set_section_flags (abbrev_seg
,
2870 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2871 bfd_set_section_flags (aranges_seg
,
2872 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2873 bfd_set_section_flags (str_seg
,
2874 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2875 | SEC_MERGE
| SEC_STRINGS
);
2876 str_seg
->entsize
= 1;
2878 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2880 if (all_segs
->next
== NULL
)
2884 if (DWARF2_VERSION
< 5)
2886 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2887 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2890 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2891 out_debug_ranges (ranges_seg
, &ranges_sym
);
2895 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2896 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2899 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2903 out_debug_aranges (aranges_seg
, info_seg
);
2904 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2905 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2906 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2907 name_sym
, comp_dir_sym
, producer_sym
);
2911 /* Perform any deferred checks pertaining to debug information. */
2914 dwarf2dbg_final_check (void)
2916 /* Perform reset-view checks. Don't evaluate view_assert_failed
2917 recursively: it could be very deep. It's a chain of adds, with
2918 each chain element pointing to the next in X_add_symbol, and
2919 holding the check value in X_op_symbol. */
2920 while (view_assert_failed
)
2926 gas_assert (!symbol_resolved_p (view_assert_failed
));
2928 exp
= symbol_get_value_expression (view_assert_failed
);
2929 sym
= view_assert_failed
;
2931 /* If view_assert_failed looks like a compound check in the
2932 chain, break it up. */
2933 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2935 view_assert_failed
= exp
->X_add_symbol
;
2936 sym
= exp
->X_op_symbol
;
2939 view_assert_failed
= NULL
;
2941 failed
= resolve_symbol_value (sym
);
2942 if (!symbol_resolved_p (sym
) || failed
)
2944 as_bad (_("view number mismatch"));