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"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION dwarf_level
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation outputs version 3 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
105 /* The .debug_rnglists has only been in DWARF version 5. */
106 #ifndef DWARF2_RNGLISTS_VERSION
107 #define DWARF2_RNGLISTS_VERSION 5
114 /* Since we can't generate the prolog until the body is complete, we
115 use three different subsegments for .debug_line: one holding the
116 prolog, one for the directory and filename info, and one for the
117 body ("statement program"). */
122 /* If linker relaxation might change offsets in the code, the DWARF special
123 opcodes and variable-length operands cannot be used. If this macro is
124 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
125 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
126 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
129 /* First special line opcode - leave room for the standard opcodes.
130 Note: If you want to change this, you'll have to update the
131 "standard_opcode_lengths" table that is emitted below in
133 #define DWARF2_LINE_OPCODE_BASE 13
135 #ifndef DWARF2_LINE_BASE
136 /* Minimum line offset in a special line info. opcode. This value
137 was chosen to give a reasonable range of values. */
138 # define DWARF2_LINE_BASE -5
141 /* Range of line offsets in a special line info. opcode. */
142 #ifndef DWARF2_LINE_RANGE
143 # define DWARF2_LINE_RANGE 14
146 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
147 /* Define the architecture-dependent minimum instruction length (in
148 bytes). This value should be rather too small than too big. */
149 # define DWARF2_LINE_MIN_INSN_LENGTH 1
152 /* Flag that indicates the initial value of the is_stmt_start flag. */
153 #define DWARF2_LINE_DEFAULT_IS_STMT 1
155 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
156 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
159 /* Given a special op, return the line skip amount. */
160 #define SPECIAL_LINE(op) \
161 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
163 /* Given a special op, return the address skip amount (in units of
164 DWARF2_LINE_MIN_INSN_LENGTH. */
165 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
167 /* The maximum address skip amount that can be encoded with a special op. */
168 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
170 #ifndef TC_PARSE_CONS_RETURN_NONE
171 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
176 struct line_entry
*next
;
178 struct dwarf2_line_info loc
;
181 /* Don't change the offset of next in line_entry. set_or_check_view
182 calls in dwarf2_gen_line_info_1 depend on it. */
183 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
188 struct line_subseg
*next
;
190 struct line_entry
*head
;
191 struct line_entry
**ptail
;
192 struct line_entry
**pmove_tail
;
197 struct line_seg
*next
;
199 struct line_subseg
*head
;
204 /* Collects data for all line table entries during assembly. */
205 static struct line_seg
*all_segs
;
206 static struct line_seg
**last_seg_ptr
;
208 #define NUM_MD5_BYTES 16
212 const char * filename
;
214 unsigned char md5
[NUM_MD5_BYTES
];
217 /* Table of files used by .debug_line. */
218 static struct file_entry
*files
;
219 static unsigned int files_in_use
;
220 static unsigned int files_allocated
;
221 static unsigned int num_of_auto_assigned
;
223 /* Table of directories used by .debug_line. */
224 static char ** dirs
= NULL
;
225 static unsigned int dirs_in_use
= 0;
226 static unsigned int dirs_allocated
= 0;
228 /* TRUE when we've seen a .loc directive recently. Used to avoid
229 doing work when there's nothing to do. Will be reset by
230 dwarf2_consume_line_info. */
231 bfd_boolean dwarf2_loc_directive_seen
;
233 /* TRUE when we've seen any .loc directive at any time during parsing.
234 Indicates the user wants us to generate a .debug_line section.
235 Used in dwarf2_finish as sanity check. */
236 static bfd_boolean dwarf2_any_loc_directive_seen
;
238 /* TRUE when we're supposed to set the basic block mark whenever a
240 bfd_boolean dwarf2_loc_mark_labels
;
242 /* Current location as indicated by the most recent .loc directive. */
243 static struct dwarf2_line_info current
=
246 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
250 /* This symbol is used to recognize view number forced resets in loc
252 static symbolS
*force_reset_view
;
254 /* This symbol evaluates to an expression that, if nonzero, indicates
255 some view assert check failed. */
256 static symbolS
*view_assert_failed
;
258 /* The size of an address on the target. */
259 static unsigned int sizeof_address
;
261 #ifndef TC_DWARF2_EMIT_OFFSET
262 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
264 /* Create an offset to .dwarf2_*. */
267 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
271 memset (&exp
, 0, sizeof exp
);
273 exp
.X_add_symbol
= symbol
;
274 exp
.X_add_number
= 0;
275 emit_expr (&exp
, size
);
279 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
281 static struct line_subseg
*
282 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
284 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
285 struct line_subseg
**pss
, *lss
;
292 s
= XNEW (struct line_seg
);
297 last_seg_ptr
= &s
->next
;
298 seg_info (seg
)->dwarf2_line_seg
= s
;
301 gas_assert (seg
== s
->seg
);
303 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
305 if (lss
->subseg
== subseg
)
307 if (lss
->subseg
> subseg
)
311 lss
= XNEW (struct line_subseg
);
313 lss
->subseg
= subseg
;
315 lss
->ptail
= &lss
->head
;
316 lss
->pmove_tail
= &lss
->head
;
323 /* (Un)reverse the line_entry list starting from H. */
325 static struct line_entry
*
326 reverse_line_entry_list (struct line_entry
*h
)
328 struct line_entry
*p
= NULL
, *e
, *n
;
330 for (e
= h
; e
; e
= n
)
339 /* Compute the view for E based on the previous entry P. If we
340 introduce an (undefined) view symbol for P, and H is given (P must
341 be the tail in this case), introduce view symbols for earlier list
342 entries as well, until one of them is constant. */
345 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
346 struct line_entry
*h
)
350 memset (&viewx
, 0, sizeof (viewx
));
351 viewx
.X_unsigned
= 1;
353 /* First, compute !(E->label > P->label), to tell whether or not
354 we're to reset the view number. If we can't resolve it to a
355 constant, keep it symbolic. */
356 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
358 viewx
.X_op
= O_constant
;
359 viewx
.X_add_number
= 0;
360 viewx
.X_add_symbol
= NULL
;
361 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_add_number
= 0;
367 viewx
.X_add_symbol
= e
->label
;
368 viewx
.X_op_symbol
= p
->label
;
369 resolve_expression (&viewx
);
370 if (viewx
.X_op
== O_constant
)
371 viewx
.X_add_number
= !viewx
.X_add_number
;
374 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
375 viewx
.X_add_number
= 0;
376 viewx
.X_op_symbol
= NULL
;
377 viewx
.X_op
= O_logical_not
;
381 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
383 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
384 /* We can't compare the view numbers at this point, because in
385 VIEWX we've only determined whether we're to reset it so
387 if (viewx
.X_op
== O_constant
)
389 if (!value
->X_add_number
!= !viewx
.X_add_number
)
390 as_bad (_("view number mismatch"));
392 /* Record the expression to check it later. It is the result of
393 a logical not, thus 0 or 1. We just add up all such deferred
394 expressions, and resolve it at the end. */
395 else if (!value
->X_add_number
)
397 symbolS
*deferred
= make_expr_symbol (&viewx
);
398 if (view_assert_failed
)
402 memset (&chk
, 0, sizeof (chk
));
405 chk
.X_add_number
= 0;
406 chk
.X_add_symbol
= view_assert_failed
;
407 chk
.X_op_symbol
= deferred
;
408 deferred
= make_expr_symbol (&chk
);
410 view_assert_failed
= deferred
;
414 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
420 p
->loc
.view
= symbol_temp_make ();
421 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
424 memset (&incv
, 0, sizeof (incv
));
426 incv
.X_op
= O_symbol
;
427 incv
.X_add_symbol
= p
->loc
.view
;
428 incv
.X_add_number
= 1;
430 if (viewx
.X_op
== O_constant
)
432 gas_assert (viewx
.X_add_number
== 1);
437 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
438 viewx
.X_add_number
= 0;
439 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
440 viewx
.X_op
= O_multiply
;
444 if (!S_IS_DEFINED (e
->loc
.view
))
446 symbol_set_value_expression (e
->loc
.view
, &viewx
);
447 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
448 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
451 /* Define and attempt to simplify any earlier views needed to
453 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
455 struct line_entry
*h2
;
456 /* Reverse the list to avoid quadratic behavior going backwards
457 in a single-linked list. */
458 struct line_entry
*r
= reverse_line_entry_list (h
);
461 /* Set or check views until we find a defined or absent view. */
464 /* Do not define the head of a (sub?)segment view while
465 handling others. It would be defined too early, without
466 regard to the last view of other subsegments.
467 set_or_check_view will be called for every head segment
471 set_or_check_view (r
, r
->next
, NULL
);
473 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
476 /* Unreverse the list, so that we can go forward again. */
477 h2
= reverse_line_entry_list (p
);
478 gas_assert (h2
== h
);
480 /* Starting from the last view we just defined, attempt to
481 simplify the view expressions, until we do so to P. */
484 /* The head view of a subsegment may remain undefined while
485 handling other elements, before it is linked to the last
486 view of the previous subsegment. */
489 gas_assert (S_IS_DEFINED (r
->loc
.view
));
490 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
492 while (r
!= p
&& (r
= r
->next
));
494 /* Now that we've defined and computed all earlier views that might
495 be needed to compute E's, attempt to simplify it. */
496 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
500 /* Record an entry for LOC occurring at LABEL. */
503 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
505 struct line_subseg
*lss
;
506 struct line_entry
*e
;
507 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
509 /* PR 26850: Do not record LOCs in non-executable or non-loaded
510 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
511 obj_coff_section is careless in setting SEC_ALLOC. */
513 need_flags
|= SEC_ALLOC
;
514 if ((now_seg
->flags
& need_flags
) != need_flags
)
516 /* FIXME: Add code to suppress multiple warnings ? */
517 if (debug_type
!= DEBUG_DWARF2
)
518 as_warn ("dwarf line number information for %s ignored",
519 segment_name (now_seg
));
523 e
= XNEW (struct line_entry
);
528 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
530 /* Subseg heads are chained to previous subsegs in
532 if (loc
->view
&& lss
->head
)
533 set_or_check_view (e
,
534 (struct line_entry
*)lss
->ptail
,
538 lss
->ptail
= &e
->next
;
541 /* Record an entry for LOC occurring at OFS within the current fragment. */
544 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
546 static unsigned int line
= -1;
547 static unsigned int filenum
= -1;
551 /* Early out for as-yet incomplete location information. */
554 if (loc
->filenum
== 0)
558 if (DWARF2_LINE_VERSION
< 5)
562 /* Don't emit sequences of line symbols for the same line when the
563 symbols apply to assembler code. It is necessary to emit
564 duplicate line symbols when a compiler asks for them, because GDB
565 uses them to determine the end of the prologue. */
566 if (debug_type
== DEBUG_DWARF2
567 && line
== loc
->line
&& filenum
== loc
->filenum
)
571 filenum
= loc
->filenum
;
577 /* Use a non-fake name for the line number location,
578 so that it can be referred to by relocations. */
579 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
580 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
583 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
584 dwarf2_gen_line_info_1 (sym
, loc
);
588 get_basename (const char * pathname
)
592 file
= lbasename (pathname
);
593 /* Don't make empty string from / or A: from A:/ . */
594 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
595 if (file
<= pathname
+ 3)
598 if (file
== pathname
+ 1)
605 get_directory_table_entry (const char * dirname
,
607 bfd_boolean can_use_zero
)
614 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
615 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
623 for (d
= 0; d
< dirs_in_use
; ++d
)
626 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
627 && dirs
[d
][dirlen
] == '\0')
633 if (dirs
== NULL
|| dirs
[0] == NULL
)
639 if (d
>= dirs_allocated
)
641 unsigned int old
= dirs_allocated
;
643 dirs_allocated
= d
+ 32;
644 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
645 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
648 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
649 if (dirs_in_use
<= d
)
656 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
658 if (i
>= files_allocated
)
660 unsigned int old
= files_allocated
;
662 files_allocated
= i
+ 32;
663 /* Catch wraparound. */
664 if (files_allocated
<= old
)
666 as_bad (_("file number %lu is too big"), (unsigned long) i
);
670 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
671 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
674 files
[i
].filename
= file
;
676 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
678 if (files_in_use
< i
+ 1)
679 files_in_use
= i
+ 1;
684 /* Get a .debug_line file number for PATHNAME. If there is a
685 directory component to PATHNAME, then this will be stored
686 in the directory table, if it is not already present.
687 Returns the slot number allocated to that filename or -1
688 if there was a problem. */
691 allocate_filenum (const char * pathname
)
693 static signed int last_used
= -1, last_used_dir_len
= 0;
698 /* Short circuit the common case of adding the same pathname
702 const char * dirname
= NULL
;
705 dirname
= dirs
[files
[last_used
].dir
];
709 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
714 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
715 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
716 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
717 files
[last_used
].filename
) == 0)
722 file
= get_basename (pathname
);
723 dir_len
= file
- pathname
;
725 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
727 /* Do not use slot-0. That is specifically reserved for use by
728 the '.file 0 "name"' directive. */
729 for (i
= 1; i
< files_in_use
; ++i
)
730 if (files
[i
].dir
== dir
732 && filename_cmp (file
, files
[i
].filename
) == 0)
735 last_used_dir_len
= dir_len
;
739 if (!assign_file_to_slot (i
, file
, dir
))
742 num_of_auto_assigned
++;
745 last_used_dir_len
= dir_len
;
750 /* Allocate slot NUM in the .debug_line file table to FILENAME.
751 If DIRNAME is not NULL or there is a directory component to FILENAME
752 then this will be stored in the directory table, if not already present.
753 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
754 Returns TRUE if allocation succeeded, FALSE otherwise. */
757 allocate_filename_to_slot (const char * dirname
,
758 const char * filename
,
760 bfd_boolean with_md5
)
766 /* Short circuit the common case of adding the same pathname
768 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
770 const char * dir
= NULL
;
773 dir
= dirs
[files
[num
].dir
];
776 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
781 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
784 if (filename_cmp (filename
, files
[num
].filename
) != 0)
787 /* If the filenames match, but the directory table entry was
788 empty, then fill it with the provided directory name. */
790 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
794 else if (dir
!= NULL
)
796 dirlen
= strlen (dir
);
797 if (filename_ncmp (filename
, dir
, dirlen
) == 0
798 && IS_DIR_SEPARATOR (filename
[dirlen
])
799 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
802 else /* dir == NULL */
804 file
= get_basename (filename
);
805 if (filename_cmp (file
, files
[num
].filename
) == 0)
808 /* The filenames match, but the directory table entry is empty.
809 Fill it with the provided directory name. */
810 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
816 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
818 dir
== NULL
? "" : dir
,
819 dir
== NULL
? "" : "/",
821 dirname
== NULL
? "" : dirname
,
822 dirname
== NULL
? "" : "/",
830 file
= get_basename (filename
);
831 dirlen
= file
- filename
;
835 dirlen
= strlen (dirname
);
839 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
842 if (! assign_file_to_slot (i
, file
, d
))
847 if (target_big_endian
)
849 /* md5's are stored in litte endian format. */
850 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
851 unsigned int byte
= NUM_MD5_BYTES
;
852 unsigned int bignum_index
= 0;
854 while (bits_remaining
)
856 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
857 valueT bignum_value
= generic_bignum
[bignum_index
];
860 while (bignum_bits_remaining
)
862 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
864 bignum_bits_remaining
-= 8;
871 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
872 unsigned int byte
= 0;
873 unsigned int bignum_index
= 0;
875 while (bits_remaining
)
877 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
878 valueT bignum_value
= generic_bignum
[bignum_index
];
882 while (bignum_bits_remaining
)
884 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
886 bignum_bits_remaining
-= 8;
893 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
898 /* Returns the current source information. If .file directives have
899 been encountered, the info for the corresponding source file is
900 returned. Otherwise, the info for the assembly source file is
904 dwarf2_where (struct dwarf2_line_info
*line
)
906 if (debug_type
== DEBUG_DWARF2
)
908 const char *filename
;
910 memset (line
, 0, sizeof (*line
));
911 filename
= as_where (&line
->line
);
912 line
->filenum
= allocate_filenum (filename
);
913 /* FIXME: We should check the return value from allocate_filenum. */
915 line
->flags
= DWARF2_FLAG_IS_STMT
;
916 line
->isa
= current
.isa
;
917 line
->discriminator
= current
.discriminator
;
924 /* A hook to allow the target backend to inform the line number state
925 machine of isa changes when assembler debug info is enabled. */
928 dwarf2_set_isa (unsigned int isa
)
933 /* Called for each machine instruction, or relatively atomic group of
934 machine instructions (ie built-in macro). The instruction or group
935 is SIZE bytes in length. If dwarf2 line number generation is called
936 for, emit a line statement appropriately. */
939 dwarf2_emit_insn (int size
)
941 struct dwarf2_line_info loc
;
943 if (debug_type
!= DEBUG_DWARF2
944 ? !dwarf2_loc_directive_seen
945 : !seen_at_least_1_file ())
950 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
951 dwarf2_consume_line_info ();
954 /* Move all previously-emitted line entries for the current position by
955 DELTA bytes. This function cannot be used to move the same entries
959 dwarf2_move_insn (int delta
)
961 struct line_subseg
*lss
;
962 struct line_entry
*e
;
968 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
972 now
= frag_now_fix ();
973 while ((e
= *lss
->pmove_tail
))
975 if (S_GET_VALUE (e
->label
) == now
)
976 S_SET_VALUE (e
->label
, now
+ delta
);
977 lss
->pmove_tail
= &e
->next
;
981 /* Called after the current line information has been either used with
982 dwarf2_gen_line_info or saved with a machine instruction for later use.
983 This resets the state of the line number information to reflect that
987 dwarf2_consume_line_info (void)
989 /* Unless we generate DWARF2 debugging information for each
990 assembler line, we only emit one line symbol for one LOC. */
991 dwarf2_loc_directive_seen
= FALSE
;
993 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
994 | DWARF2_FLAG_PROLOGUE_END
995 | DWARF2_FLAG_EPILOGUE_BEGIN
);
996 current
.discriminator
= 0;
1000 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1001 is enabled, emit a basic block marker. */
1004 dwarf2_emit_label (symbolS
*label
)
1006 struct dwarf2_line_info loc
;
1008 if (!dwarf2_loc_mark_labels
)
1010 if (S_GET_SEGMENT (label
) != now_seg
)
1012 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1014 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1017 dwarf2_where (&loc
);
1019 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1021 dwarf2_gen_line_info_1 (label
, &loc
);
1022 dwarf2_consume_line_info ();
1025 /* Handle two forms of .file directive:
1026 - Pass .file "source.c" to s_app_file
1027 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1029 If an entry is added to the file table, return a pointer to the filename. */
1032 dwarf2_directive_filename (void)
1034 bfd_boolean with_md5
= FALSE
;
1037 const char * dirname
= NULL
;
1041 /* Continue to accept a bare string and pass it off. */
1043 if (*input_line_pointer
== '"')
1049 num
= get_absolute_expression ();
1051 if ((offsetT
) num
< 1)
1053 if (num
== 0 && dwarf_level
< 5)
1055 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1057 as_bad (_("file number less than one"));
1058 ignore_rest_of_line ();
1063 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1064 "switch back to the already allocated file <N> as the current
1067 filename
= demand_copy_C_string (&filename_len
);
1068 if (filename
== NULL
)
1069 /* demand_copy_C_string will have already generated an error message. */
1072 /* For DWARF-5 support we also accept:
1073 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1074 if (DWARF2_LINE_VERSION
> 4)
1077 if (*input_line_pointer
== '"')
1080 filename
= demand_copy_C_string (&filename_len
);
1084 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1086 input_line_pointer
+= 3;
1090 expression_and_evaluate (& exp
);
1091 if (exp
.X_op
!= O_big
)
1092 as_bad (_("md5 value too small or not a constant"));
1098 demand_empty_rest_of_line ();
1100 /* A .file directive implies compiler generated debug information is
1101 being supplied. Turn off gas generated debug info. */
1102 debug_type
= DEBUG_NONE
;
1104 if (num
!= (unsigned int) num
1105 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1107 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1111 if (num_of_auto_assigned
)
1113 /* Clear slots auto-assigned before the first .file <NUMBER>
1114 directive was seen. */
1115 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1117 for (i
= 1; i
< files_in_use
; i
++)
1118 files
[i
].filename
= NULL
;
1120 num_of_auto_assigned
= 0;
1123 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1130 /* Calls dwarf2_directive_filename, but discards its result.
1131 Used in pseudo-op tables where the function result is ignored. */
1134 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1136 (void) dwarf2_directive_filename ();
1140 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1142 offsetT filenum
, line
;
1144 /* If we see two .loc directives in a row, force the first one to be
1146 if (dwarf2_loc_directive_seen
)
1147 dwarf2_emit_insn (0);
1149 filenum
= get_absolute_expression ();
1151 line
= get_absolute_expression ();
1155 if (filenum
== 0 && dwarf_level
< 5)
1157 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1159 as_bad (_("file number less than one"));
1164 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1166 as_bad (_("unassigned file number %ld"), (long) filenum
);
1170 current
.filenum
= filenum
;
1171 current
.line
= line
;
1172 current
.discriminator
= 0;
1177 if (files
[filenum
].dir
)
1179 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1180 size_t file_len
= strlen (files
[filenum
].filename
);
1181 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1183 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1184 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1185 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1186 cp
[dir_len
+ file_len
+ 1] = '\0';
1187 listing_source_file (cp
);
1191 listing_source_file (files
[filenum
].filename
);
1192 listing_source_line (line
);
1197 if (ISDIGIT (*input_line_pointer
))
1199 current
.column
= get_absolute_expression ();
1203 while (ISALPHA (*input_line_pointer
))
1208 c
= get_symbol_name (& p
);
1210 if (strcmp (p
, "basic_block") == 0)
1212 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1213 *input_line_pointer
= c
;
1215 else if (strcmp (p
, "prologue_end") == 0)
1217 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1218 *input_line_pointer
= c
;
1220 else if (strcmp (p
, "epilogue_begin") == 0)
1222 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1223 *input_line_pointer
= c
;
1225 else if (strcmp (p
, "is_stmt") == 0)
1227 (void) restore_line_pointer (c
);
1228 value
= get_absolute_expression ();
1230 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1231 else if (value
== 1)
1232 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1235 as_bad (_("is_stmt value not 0 or 1"));
1239 else if (strcmp (p
, "isa") == 0)
1241 (void) restore_line_pointer (c
);
1242 value
= get_absolute_expression ();
1244 current
.isa
= value
;
1247 as_bad (_("isa number less than zero"));
1251 else if (strcmp (p
, "discriminator") == 0)
1253 (void) restore_line_pointer (c
);
1254 value
= get_absolute_expression ();
1256 current
.discriminator
= value
;
1259 as_bad (_("discriminator less than zero"));
1263 else if (strcmp (p
, "view") == 0)
1267 (void) restore_line_pointer (c
);
1270 if (ISDIGIT (*input_line_pointer
)
1271 || *input_line_pointer
== '-')
1273 bfd_boolean force_reset
= *input_line_pointer
== '-';
1275 value
= get_absolute_expression ();
1278 as_bad (_("numeric view can only be asserted to zero"));
1281 if (force_reset
&& force_reset_view
)
1282 sym
= force_reset_view
;
1285 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1288 force_reset_view
= sym
;
1293 char *name
= read_symbol_name ();
1297 sym
= symbol_find_or_make (name
);
1298 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1300 if (S_IS_VOLATILE (sym
))
1301 sym
= symbol_clone (sym
, 1);
1302 else if (!S_CAN_BE_REDEFINED (sym
))
1304 as_bad (_("symbol `%s' is already defined"), name
);
1308 S_SET_SEGMENT (sym
, undefined_section
);
1309 S_SET_VALUE (sym
, 0);
1310 symbol_set_frag (sym
, &zero_address_frag
);
1316 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1317 (void) restore_line_pointer (c
);
1321 SKIP_WHITESPACE_AFTER_NAME ();
1324 demand_empty_rest_of_line ();
1325 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1326 debug_type
= DEBUG_NONE
;
1328 /* If we were given a view id, emit the row right away. */
1330 dwarf2_emit_insn (0);
1334 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1336 offsetT value
= get_absolute_expression ();
1338 if (value
!= 0 && value
!= 1)
1340 as_bad (_("expected 0 or 1"));
1341 ignore_rest_of_line ();
1345 dwarf2_loc_mark_labels
= value
!= 0;
1346 demand_empty_rest_of_line ();
1350 static struct frag
*
1351 first_frag_for_seg (segT seg
)
1353 return seg_info (seg
)->frchainP
->frch_root
;
1356 static struct frag
*
1357 last_frag_for_seg (segT seg
)
1359 frchainS
*f
= seg_info (seg
)->frchainP
;
1361 while (f
->frch_next
!= NULL
)
1364 return f
->frch_last
;
1367 /* Emit a single byte into the current segment. */
1372 FRAG_APPEND_1_CHAR (byte
);
1375 /* Emit a statement program opcode into the current segment. */
1378 out_opcode (int opc
)
1383 /* Emit a two-byte word into the current segment. */
1388 md_number_to_chars (frag_more (2), data
, 2);
1391 /* Emit a four byte word into the current segment. */
1396 md_number_to_chars (frag_more (4), data
, 4);
1399 /* Emit an unsigned "little-endian base 128" number. */
1402 out_uleb128 (addressT value
)
1404 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1407 /* Emit a signed "little-endian base 128" number. */
1410 out_leb128 (addressT value
)
1412 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1415 /* Emit a tuple for .debug_abbrev. */
1418 out_abbrev (int name
, int form
)
1424 /* Get the size of a fragment. */
1427 get_frag_fix (fragS
*frag
, segT seg
)
1432 return frag
->fr_fix
;
1434 /* If a fragment is the last in the chain, special measures must be
1435 taken to find its size before relaxation, since it may be pending
1436 on some subsegment chain. */
1437 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1438 if (fr
->frch_last
== frag
)
1439 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1444 /* Set an absolute address (may result in a relocation entry). */
1447 out_set_addr (symbolS
*sym
)
1451 memset (&exp
, 0, sizeof exp
);
1452 out_opcode (DW_LNS_extended_op
);
1453 out_uleb128 (sizeof_address
+ 1);
1455 out_opcode (DW_LNE_set_address
);
1456 exp
.X_op
= O_symbol
;
1457 exp
.X_add_symbol
= sym
;
1458 exp
.X_add_number
= 0;
1459 emit_expr (&exp
, sizeof_address
);
1462 static void scale_addr_delta (addressT
*);
1465 scale_addr_delta (addressT
*addr_delta
)
1467 static int printed_this
= 0;
1468 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1470 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1472 as_bad("unaligned opcodes detected in executable segment");
1475 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1479 /* Encode a pair of line and address skips as efficiently as possible.
1480 Note that the line skip is signed, whereas the address skip is unsigned.
1482 The following two routines *must* be kept in sync. This is
1483 enforced by making emit_inc_line_addr abort if we do not emit
1484 exactly the expected number of bytes. */
1487 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1489 unsigned int tmp
, opcode
;
1492 /* Scale the address delta by the minimum instruction length. */
1493 scale_addr_delta (&addr_delta
);
1495 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1496 We cannot use special opcodes here, since we want the end_sequence
1497 to emit the matrix entry. */
1498 if (line_delta
== INT_MAX
)
1500 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1502 else if (addr_delta
)
1503 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1507 /* Bias the line delta by the base. */
1508 tmp
= line_delta
- DWARF2_LINE_BASE
;
1510 /* If the line increment is out of range of a special opcode, we
1511 must encode it with DW_LNS_advance_line. */
1512 if (tmp
>= DWARF2_LINE_RANGE
)
1514 len
= 1 + sizeof_leb128 (line_delta
, 1);
1516 tmp
= 0 - DWARF2_LINE_BASE
;
1519 /* Bias the opcode by the special opcode base. */
1520 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1522 /* Avoid overflow when addr_delta is large. */
1523 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1525 /* Try using a special opcode. */
1526 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1530 /* Try using DW_LNS_const_add_pc followed by special op. */
1531 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1536 /* Otherwise use DW_LNS_advance_pc. */
1537 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1539 /* DW_LNS_copy or special opcode. */
1546 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1548 unsigned int tmp
, opcode
;
1550 char *end
= p
+ len
;
1552 /* Line number sequences cannot go backward in addresses. This means
1553 we've incorrectly ordered the statements in the sequence. */
1554 gas_assert ((offsetT
) addr_delta
>= 0);
1556 /* Scale the address delta by the minimum instruction length. */
1557 scale_addr_delta (&addr_delta
);
1559 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1560 We cannot use special opcodes here, since we want the end_sequence
1561 to emit the matrix entry. */
1562 if (line_delta
== INT_MAX
)
1564 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1565 *p
++ = DW_LNS_const_add_pc
;
1566 else if (addr_delta
)
1568 *p
++ = DW_LNS_advance_pc
;
1569 p
+= output_leb128 (p
, addr_delta
, 0);
1572 *p
++ = DW_LNS_extended_op
;
1574 *p
++ = DW_LNE_end_sequence
;
1578 /* Bias the line delta by the base. */
1579 tmp
= line_delta
- DWARF2_LINE_BASE
;
1581 /* If the line increment is out of range of a special opcode, we
1582 must encode it with DW_LNS_advance_line. */
1583 if (tmp
>= DWARF2_LINE_RANGE
)
1585 *p
++ = DW_LNS_advance_line
;
1586 p
+= output_leb128 (p
, line_delta
, 1);
1589 tmp
= 0 - DWARF2_LINE_BASE
;
1593 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1595 if (line_delta
== 0 && addr_delta
== 0)
1601 /* Bias the opcode by the special opcode base. */
1602 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1604 /* Avoid overflow when addr_delta is large. */
1605 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1607 /* Try using a special opcode. */
1608 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1615 /* Try using DW_LNS_const_add_pc followed by special op. */
1616 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1619 *p
++ = DW_LNS_const_add_pc
;
1625 /* Otherwise use DW_LNS_advance_pc. */
1626 *p
++ = DW_LNS_advance_pc
;
1627 p
+= output_leb128 (p
, addr_delta
, 0);
1635 gas_assert (p
== end
);
1638 /* Handy routine to combine calls to the above two routines. */
1641 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1643 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1644 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1647 /* Write out an alternative form of line and address skips using
1648 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1649 line and address information, but it is required if linker relaxation
1650 could change the code offsets. The following two routines *must* be
1652 #define ADDR_DELTA_LIMIT 50000
1655 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1659 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1660 if (line_delta
!= INT_MAX
)
1661 len
= 1 + sizeof_leb128 (line_delta
, 1);
1663 if (addr_delta
> ADDR_DELTA_LIMIT
)
1665 /* DW_LNS_extended_op */
1666 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1667 /* DW_LNE_set_address */
1668 len
+= 1 + sizeof_address
;
1671 /* DW_LNS_fixed_advance_pc */
1674 if (line_delta
== INT_MAX
)
1675 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1685 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1689 char *end
= p
+ len
;
1691 /* Line number sequences cannot go backward in addresses. This means
1692 we've incorrectly ordered the statements in the sequence. */
1693 gas_assert ((offsetT
) addr_delta
>= 0);
1695 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1696 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1698 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1699 if (line_delta
!= INT_MAX
)
1701 *p
++ = DW_LNS_advance_line
;
1702 p
+= output_leb128 (p
, line_delta
, 1);
1705 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1707 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1708 advance the address by at most 64K. Linker relaxation (without
1709 which this function would not be used) could change the operand by
1710 an unknown amount. If the address increment is getting close to
1711 the limit, just reset the address. */
1712 if (addr_delta
> ADDR_DELTA_LIMIT
)
1717 memset (&exp
, 0, sizeof exp
);
1718 gas_assert (pexp
->X_op
== O_subtract
);
1719 to_sym
= pexp
->X_add_symbol
;
1721 *p
++ = DW_LNS_extended_op
;
1722 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1723 *p
++ = DW_LNE_set_address
;
1724 exp
.X_op
= O_symbol
;
1725 exp
.X_add_symbol
= to_sym
;
1726 exp
.X_add_number
= 0;
1727 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1728 p
+= sizeof_address
;
1732 *p
++ = DW_LNS_fixed_advance_pc
;
1733 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1737 if (line_delta
== INT_MAX
)
1739 *p
++ = DW_LNS_extended_op
;
1741 *p
++ = DW_LNE_end_sequence
;
1746 gas_assert (p
== end
);
1749 /* Generate a variant frag that we can use to relax address/line
1750 increments between fragments of the target segment. */
1753 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1758 memset (&exp
, 0, sizeof exp
);
1759 exp
.X_op
= O_subtract
;
1760 exp
.X_add_symbol
= to_sym
;
1761 exp
.X_op_symbol
= from_sym
;
1762 exp
.X_add_number
= 0;
1764 /* The maximum size of the frag is the line delta with a maximum
1765 sized address delta. */
1766 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1767 max_chars
= size_fixed_inc_line_addr (line_delta
,
1768 -DWARF2_LINE_MIN_INSN_LENGTH
);
1770 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1772 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1773 make_expr_symbol (&exp
), line_delta
, NULL
);
1776 /* The function estimates the size of a rs_dwarf2dbg variant frag
1777 based on the current values of the symbols. It is called before
1778 the relaxation loop. We set fr_subtype to the expected length. */
1781 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1786 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1787 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1788 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1790 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1792 frag
->fr_subtype
= size
;
1797 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1798 current values of the symbols. fr_subtype is the current length
1799 of the frag. This returns the change in frag length. */
1802 dwarf2dbg_relax_frag (fragS
*frag
)
1804 int old_size
, new_size
;
1806 old_size
= frag
->fr_subtype
;
1807 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1809 return new_size
- old_size
;
1812 /* This function converts a rs_dwarf2dbg variant frag into a normal
1813 fill frag. This is called after all relaxation has been done.
1814 fr_subtype will be the desired length of the frag. */
1817 dwarf2dbg_convert_frag (fragS
*frag
)
1821 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1823 /* If linker relaxation is enabled then the distance between the two
1824 symbols in the frag->fr_symbol expression might change. Hence we
1825 cannot rely upon the value computed by resolve_symbol_value.
1826 Instead we leave the expression unfinalized and allow
1827 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1828 relocation) that will allow the linker to correctly compute the
1829 actual address difference. We have to use a fixed line advance for
1830 this as we cannot (easily) relocate leb128 encoded values. */
1831 int saved_finalize_syms
= finalize_syms
;
1834 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1835 finalize_syms
= saved_finalize_syms
;
1838 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1840 /* fr_var carries the max_chars that we created the fragment with.
1841 fr_subtype carries the current expected length. We must, of
1842 course, have allocated enough memory earlier. */
1843 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1845 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1846 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1847 frag
->fr_literal
+ frag
->fr_fix
,
1850 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1851 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1853 frag
->fr_fix
+= frag
->fr_subtype
;
1854 frag
->fr_type
= rs_fill
;
1856 frag
->fr_offset
= 0;
1859 /* Generate .debug_line content for the chain of line number entries
1860 beginning at E, for segment SEG. */
1863 process_entries (segT seg
, struct line_entry
*e
)
1865 unsigned filenum
= 1;
1867 unsigned column
= 0;
1869 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1870 fragS
*last_frag
= NULL
, *frag
;
1871 addressT last_frag_ofs
= 0, frag_ofs
;
1872 symbolS
*last_lab
= NULL
, *lab
;
1873 struct line_entry
*next
;
1875 if (flag_dwarf_sections
)
1878 const char * sec_name
;
1880 /* Switch to the relevant sub-section before we start to emit
1881 the line number table.
1883 FIXME: These sub-sections do not have a normal Line Number
1884 Program Header, thus strictly speaking they are not valid
1885 DWARF sections. Unfortunately the DWARF standard assumes
1886 a one-to-one relationship between compilation units and
1887 line number tables. Thus we have to have a .debug_line
1888 section, as well as our sub-sections, and we have to ensure
1889 that all of the sub-sections are merged into a proper
1890 .debug_line section before a debugger sees them. */
1892 sec_name
= bfd_section_name (seg
);
1893 if (strcmp (sec_name
, ".text") != 0)
1895 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1896 subseg_set (subseg_get (name
, FALSE
), 0);
1899 /* Don't create a .debug_line.text section -
1900 that is redundant. Instead just switch back to the
1901 normal .debug_line section. */
1902 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1909 if (filenum
!= e
->loc
.filenum
)
1911 filenum
= e
->loc
.filenum
;
1912 out_opcode (DW_LNS_set_file
);
1913 out_uleb128 (filenum
);
1916 if (column
!= e
->loc
.column
)
1918 column
= e
->loc
.column
;
1919 out_opcode (DW_LNS_set_column
);
1920 out_uleb128 (column
);
1923 if (e
->loc
.discriminator
!= 0)
1925 out_opcode (DW_LNS_extended_op
);
1926 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1927 out_opcode (DW_LNE_set_discriminator
);
1928 out_uleb128 (e
->loc
.discriminator
);
1931 if (isa
!= e
->loc
.isa
)
1934 out_opcode (DW_LNS_set_isa
);
1938 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1940 flags
= e
->loc
.flags
;
1941 out_opcode (DW_LNS_negate_stmt
);
1944 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1945 out_opcode (DW_LNS_set_basic_block
);
1947 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1948 out_opcode (DW_LNS_set_prologue_end
);
1950 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1951 out_opcode (DW_LNS_set_epilogue_begin
);
1953 /* Don't try to optimize away redundant entries; gdb wants two
1954 entries for a function where the code starts on the same line as
1955 the {, and there's no way to identify that case here. Trust gcc
1956 to optimize appropriately. */
1957 line_delta
= e
->loc
.line
- line
;
1959 frag
= symbol_get_frag (lab
);
1960 frag_ofs
= S_GET_VALUE (lab
);
1962 if (last_frag
== NULL
1963 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1964 /* If we're going to reset the view, but we know we're
1965 advancing the PC, we don't have to force with
1966 set_address. We know we do when we're at the same
1967 address of the same frag, and we know we might when
1968 we're in the beginning of a frag, and we were at the
1969 end of the previous frag. */
1970 && (frag
== last_frag
1971 ? (last_frag_ofs
== frag_ofs
)
1973 && ((offsetT
)last_frag_ofs
1974 >= get_frag_fix (last_frag
, seg
))))))
1977 out_inc_line_addr (line_delta
, 0);
1979 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1980 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1982 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1987 last_frag_ofs
= frag_ofs
;
1995 /* Emit a DW_LNE_end_sequence for the end of the section. */
1996 frag
= last_frag_for_seg (seg
);
1997 frag_ofs
= get_frag_fix (frag
, seg
);
1998 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1999 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2002 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2003 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2007 /* Switch to LINE_STR_SEG and output the given STR. Return the
2008 symbol pointing to the new string in the section. */
2011 add_line_strp (segT line_str_seg
, const char *str
)
2017 subseg_set (line_str_seg
, 0);
2019 sym
= symbol_temp_new_now_octets ();
2021 size
= strlen (str
) + 1;
2022 cp
= frag_more (size
);
2023 memcpy (cp
, str
, size
);
2029 /* Emit the directory and file tables for .debug_line. */
2032 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2038 bfd_boolean emit_md5
= FALSE
;
2039 bfd_boolean emit_timestamps
= TRUE
;
2040 bfd_boolean emit_filesize
= TRUE
;
2041 segT line_str_seg
= NULL
;
2044 /* Output the Directory Table. */
2045 if (DWARF2_LINE_VERSION
>= 5)
2047 /* We only have one column in the directory table. */
2050 /* Describe the purpose and format of the column. */
2051 out_uleb128 (DW_LNCT_path
);
2052 /* Store these strings in the .debug_line_str section so they
2054 out_uleb128 (DW_FORM_line_strp
);
2056 /* Now state how many rows there are in the table. We need at
2057 least 1 if there is one or more file names to store the
2058 "working directory". */
2059 if (dirs_in_use
== 0 && files_in_use
> 0)
2062 out_uleb128 (dirs_in_use
);
2065 /* Emit directory list. */
2066 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2068 line_str_seg
= subseg_new (".debug_line_str", 0);
2069 bfd_set_section_flags (line_str_seg
,
2070 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2071 | SEC_MERGE
| SEC_STRINGS
);
2072 line_str_seg
->entsize
= 1;
2074 /* DWARF5 uses slot zero, but that is only set explicitly
2075 using a .file 0 directive. If that isn't used, but dir
2076 one is used, then use that as main file directory.
2077 Otherwise use pwd as main file directory. */
2078 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2079 dir
= remap_debug_filename (dirs
[0]);
2080 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2081 dir
= remap_debug_filename (dirs
[1]);
2083 dir
= remap_debug_filename (getpwd ());
2085 line_strp
= add_line_strp (line_str_seg
, dir
);
2086 subseg_set (line_seg
, 0);
2087 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2089 for (i
= 1; i
< dirs_in_use
; ++i
)
2091 dir
= remap_debug_filename (dirs
[i
]);
2092 if (DWARF2_LINE_VERSION
< 5)
2094 size
= strlen (dir
) + 1;
2095 cp
= frag_more (size
);
2096 memcpy (cp
, dir
, size
);
2100 line_strp
= add_line_strp (line_str_seg
, dir
);
2101 subseg_set (line_seg
, 0);
2102 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2106 if (DWARF2_LINE_VERSION
< 5)
2110 /* Output the File Name Table. */
2111 if (DWARF2_LINE_VERSION
>= 5)
2113 unsigned int columns
= 4;
2115 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2117 emit_timestamps
= FALSE
;
2121 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2123 emit_filesize
= FALSE
;
2127 for (i
= 0; i
< files_in_use
; ++i
)
2128 if (files
[i
].md5
[0] != 0)
2130 if (i
< files_in_use
)
2136 /* The number of format entries to follow. */
2138 /* The format of the file name. */
2139 out_uleb128 (DW_LNCT_path
);
2140 /* Store these strings in the .debug_line_str section so they
2142 out_uleb128 (DW_FORM_line_strp
);
2144 /* The format of the directory index. */
2145 out_uleb128 (DW_LNCT_directory_index
);
2146 out_uleb128 (DW_FORM_udata
);
2148 if (emit_timestamps
)
2150 /* The format of the timestamp. */
2151 out_uleb128 (DW_LNCT_timestamp
);
2152 out_uleb128 (DW_FORM_udata
);
2157 /* The format of the file size. */
2158 out_uleb128 (DW_LNCT_size
);
2159 out_uleb128 (DW_FORM_udata
);
2164 /* The format of the MD5 sum. */
2165 out_uleb128 (DW_LNCT_MD5
);
2166 out_uleb128 (DW_FORM_data16
);
2169 /* The number of entries in the table. */
2170 out_uleb128 (files_in_use
);
2173 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2175 const char *fullfilename
;
2177 if (files
[i
].filename
== NULL
)
2179 /* Prevent a crash later, particularly for file 1. DWARF5
2180 uses slot zero, but that is only set explicitly using a
2181 .file 0 directive. If that isn't used, but file 1 is,
2182 then use that as main file name. */
2183 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2184 files
[0].filename
= files
[1].filename
;
2186 files
[i
].filename
= "";
2187 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2189 as_bad (_("unassigned file number %ld"), (long) i
);
2194 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2195 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2196 if (DWARF2_LINE_VERSION
< 5)
2198 size
= strlen (fullfilename
) + 1;
2199 cp
= frag_more (size
);
2200 memcpy (cp
, fullfilename
, size
);
2204 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2205 subseg_set (line_seg
, 0);
2206 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2209 /* Directory number. */
2210 out_uleb128 (files
[i
].dir
);
2212 /* Output the last modification timestamp. */
2213 if (emit_timestamps
)
2217 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2218 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2219 if (timestamp
== -1)
2221 out_uleb128 (timestamp
);
2224 /* Output the filesize. */
2228 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2229 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2232 out_uleb128 (filesize
);
2235 /* Output the md5 sum. */
2240 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2241 out_byte (files
[i
].md5
[b
]);
2245 if (DWARF2_LINE_VERSION
< 5)
2246 /* Terminate filename list. */
2250 /* Switch to SEC and output a header length field. Return the size of
2251 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2252 to the end of the section. EXPR->X_add_number will be set to the
2253 negative size of the header. */
2256 out_header (asection
*sec
, expressionS
*exp
)
2261 subseg_set (sec
, 0);
2263 if (flag_dwarf_sections
)
2265 /* If we are going to put the start and end symbols in different
2266 sections, then we need real symbols, not just fake, local ones. */
2268 start_sym
= symbol_make (".Ldebug_line_start");
2269 end_sym
= symbol_make (".Ldebug_line_end");
2270 symbol_set_value_now (start_sym
);
2274 start_sym
= symbol_temp_new_now_octets ();
2275 end_sym
= symbol_temp_make ();
2278 /* Total length of the information. */
2279 exp
->X_op
= O_subtract
;
2280 exp
->X_add_symbol
= end_sym
;
2281 exp
->X_op_symbol
= start_sym
;
2283 switch (DWARF2_FORMAT (sec
))
2285 case dwarf2_format_32bit
:
2286 exp
->X_add_number
= -4;
2290 case dwarf2_format_64bit
:
2291 exp
->X_add_number
= -12;
2296 case dwarf2_format_64bit_irix
:
2297 exp
->X_add_number
= -8;
2302 as_fatal (_("internal error: unknown dwarf2 format"));
2306 /* Emit the collected .debug_line data. */
2309 out_debug_line (segT line_seg
)
2312 symbolS
*prologue_start
, *prologue_end
;
2317 memset (&exp
, 0, sizeof exp
);
2318 sizeof_offset
= out_header (line_seg
, &exp
);
2319 line_end
= exp
.X_add_symbol
;
2322 out_two (DWARF2_LINE_VERSION
);
2324 if (DWARF2_LINE_VERSION
>= 5)
2326 out_byte (sizeof_address
);
2327 out_byte (0); /* Segment Selector size. */
2329 /* Length of the prologue following this length. */
2330 prologue_start
= symbol_temp_make ();
2331 prologue_end
= symbol_temp_make ();
2332 exp
.X_op
= O_subtract
;
2333 exp
.X_add_symbol
= prologue_end
;
2334 exp
.X_op_symbol
= prologue_start
;
2335 exp
.X_add_number
= 0;
2336 emit_expr (&exp
, sizeof_offset
);
2337 symbol_set_value_now (prologue_start
);
2339 /* Parameters of the state machine. */
2340 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2341 if (DWARF2_LINE_VERSION
>= 4)
2342 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2343 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2344 out_byte (DWARF2_LINE_BASE
);
2345 out_byte (DWARF2_LINE_RANGE
);
2346 out_byte (DWARF2_LINE_OPCODE_BASE
);
2348 /* Standard opcode lengths. */
2349 out_byte (0); /* DW_LNS_copy */
2350 out_byte (1); /* DW_LNS_advance_pc */
2351 out_byte (1); /* DW_LNS_advance_line */
2352 out_byte (1); /* DW_LNS_set_file */
2353 out_byte (1); /* DW_LNS_set_column */
2354 out_byte (0); /* DW_LNS_negate_stmt */
2355 out_byte (0); /* DW_LNS_set_basic_block */
2356 out_byte (0); /* DW_LNS_const_add_pc */
2357 out_byte (1); /* DW_LNS_fixed_advance_pc */
2358 out_byte (0); /* DW_LNS_set_prologue_end */
2359 out_byte (0); /* DW_LNS_set_epilogue_begin */
2360 out_byte (1); /* DW_LNS_set_isa */
2361 /* We have emitted 12 opcode lengths, so make that this
2362 matches up to the opcode base value we have been using. */
2363 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2365 out_dir_and_file_list (line_seg
, sizeof_offset
);
2367 symbol_set_value_now (prologue_end
);
2369 /* For each section, emit a statement program. */
2370 for (s
= all_segs
; s
; s
= s
->next
)
2371 /* Paranoia - this check should have already have
2372 been handled in dwarf2_gen_line_info_1(). */
2373 if (SEG_NORMAL (s
->seg
))
2374 process_entries (s
->seg
, s
->head
->head
);
2376 if (flag_dwarf_sections
)
2377 /* We have to switch to the special .debug_line_end section
2378 before emitting the end-of-debug_line symbol. The linker
2379 script arranges for this section to be placed after all the
2380 (potentially garbage collected) .debug_line.<foo> sections.
2381 This section contains the line_end symbol which is used to
2382 compute the size of the linked .debug_line section, as seen
2383 in the DWARF Line Number header. */
2384 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2386 symbol_set_value_now (line_end
);
2390 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2392 unsigned int addr_size
= sizeof_address
;
2397 memset (&exp
, 0, sizeof exp
);
2398 subseg_set (ranges_seg
, 0);
2400 /* For DW_AT_ranges to point at (there is no header, so really start
2401 of section, but see out_debug_rnglists). */
2402 *ranges_sym
= symbol_temp_new_now_octets ();
2404 /* Base Address Entry. */
2405 for (i
= 0; i
< addr_size
; i
++)
2407 for (i
= 0; i
< addr_size
; i
++)
2410 /* Range List Entry. */
2411 for (s
= all_segs
; s
; s
= s
->next
)
2416 frag
= first_frag_for_seg (s
->seg
);
2417 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2418 s
->text_start
= beg
;
2420 frag
= last_frag_for_seg (s
->seg
);
2421 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2424 exp
.X_op
= O_symbol
;
2425 exp
.X_add_symbol
= beg
;
2426 exp
.X_add_number
= 0;
2427 emit_expr (&exp
, addr_size
);
2429 exp
.X_op
= O_symbol
;
2430 exp
.X_add_symbol
= end
;
2431 exp
.X_add_number
= 0;
2432 emit_expr (&exp
, addr_size
);
2435 /* End of Range Entry. */
2436 for (i
= 0; i
< addr_size
; i
++)
2438 for (i
= 0; i
< addr_size
; i
++)
2443 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2446 symbolS
*ranges_end
;
2450 memset (&exp
, 0, sizeof exp
);
2451 out_header (ranges_seg
, &exp
);
2452 ranges_end
= exp
.X_add_symbol
;
2454 out_two (DWARF2_RNGLISTS_VERSION
);
2455 out_byte (sizeof_address
);
2456 out_byte (0); /* Segment Selector size. */
2457 out_four (0); /* Offset entry count. */
2459 /* For DW_AT_ranges to point at (must be after the header). */
2460 *ranges_sym
= symbol_temp_new_now_octets ();
2462 for (s
= all_segs
; s
; s
= s
->next
)
2467 out_byte (DW_RLE_start_length
);
2469 frag
= first_frag_for_seg (s
->seg
);
2470 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2471 s
->text_start
= beg
;
2473 frag
= last_frag_for_seg (s
->seg
);
2474 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2477 exp
.X_op
= O_symbol
;
2478 exp
.X_add_symbol
= beg
;
2479 exp
.X_add_number
= 0;
2480 emit_expr (&exp
, sizeof_address
);
2482 exp
.X_op
= O_symbol
;
2483 exp
.X_add_symbol
= end
;
2484 exp
.X_add_number
= 0;
2485 emit_leb128_expr (&exp
, 0);
2488 out_byte (DW_RLE_end_of_list
);
2490 symbol_set_value_now (ranges_end
);
2493 /* Emit data for .debug_aranges. */
2496 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2498 unsigned int addr_size
= sizeof_address
;
2502 symbolS
*aranges_end
;
2506 memset (&exp
, 0, sizeof exp
);
2507 sizeof_offset
= out_header (aranges_seg
, &exp
);
2508 aranges_end
= exp
.X_add_symbol
;
2509 size
= -exp
.X_add_number
;
2512 out_two (DWARF2_ARANGES_VERSION
);
2515 /* Offset to .debug_info. */
2516 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2517 size
+= sizeof_offset
;
2519 /* Size of an address (offset portion). */
2520 out_byte (addr_size
);
2523 /* Size of a segment descriptor. */
2527 /* Align the header. */
2528 while ((size
++ % (2 * addr_size
)) > 0)
2531 for (s
= all_segs
; s
; s
= s
->next
)
2536 frag
= first_frag_for_seg (s
->seg
);
2537 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2538 s
->text_start
= beg
;
2540 frag
= last_frag_for_seg (s
->seg
);
2541 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2544 exp
.X_op
= O_symbol
;
2545 exp
.X_add_symbol
= beg
;
2546 exp
.X_add_number
= 0;
2547 emit_expr (&exp
, addr_size
);
2549 exp
.X_op
= O_subtract
;
2550 exp
.X_add_symbol
= end
;
2551 exp
.X_op_symbol
= beg
;
2552 exp
.X_add_number
= 0;
2553 emit_expr (&exp
, addr_size
);
2556 p
= frag_more (2 * addr_size
);
2557 md_number_to_chars (p
, 0, addr_size
);
2558 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2560 symbol_set_value_now (aranges_end
);
2563 /* Emit data for .debug_abbrev. Note that this must be kept in
2564 sync with out_debug_info below. */
2567 out_debug_abbrev (segT abbrev_seg
,
2568 segT info_seg ATTRIBUTE_UNUSED
,
2569 segT line_seg ATTRIBUTE_UNUSED
)
2572 subseg_set (abbrev_seg
, 0);
2575 out_uleb128 (DW_TAG_compile_unit
);
2576 out_byte (DW_CHILDREN_no
);
2577 if (DWARF2_VERSION
< 4)
2579 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2580 secoff_form
= DW_FORM_data4
;
2582 secoff_form
= DW_FORM_data8
;
2585 secoff_form
= DW_FORM_sec_offset
;
2586 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2587 if (all_segs
->next
== NULL
)
2589 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2590 if (DWARF2_VERSION
< 4)
2591 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2593 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2596 out_abbrev (DW_AT_ranges
, secoff_form
);
2597 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2598 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2599 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2600 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2603 /* Terminate the abbreviations for this compilation unit. */
2607 /* Emit a description of this compilation unit for .debug_info. */
2610 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2611 symbolS
*ranges_sym
, symbolS
*name_sym
,
2612 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2618 memset (&exp
, 0, sizeof exp
);
2619 sizeof_offset
= out_header (info_seg
, &exp
);
2620 info_end
= exp
.X_add_symbol
;
2622 /* DWARF version. */
2623 out_two (DWARF2_VERSION
);
2625 if (DWARF2_VERSION
< 5)
2627 /* .debug_abbrev offset */
2628 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2632 /* unit (header) type */
2633 out_byte (DW_UT_compile
);
2636 /* Target address size. */
2637 out_byte (sizeof_address
);
2639 if (DWARF2_VERSION
>= 5)
2641 /* .debug_abbrev offset */
2642 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2645 /* DW_TAG_compile_unit DIE abbrev */
2648 /* DW_AT_stmt_list */
2649 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2650 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2653 /* These two attributes are emitted if all of the code is contiguous. */
2654 if (all_segs
->next
== NULL
)
2657 exp
.X_op
= O_symbol
;
2658 exp
.X_add_symbol
= all_segs
->text_start
;
2659 exp
.X_add_number
= 0;
2660 emit_expr (&exp
, sizeof_address
);
2663 if (DWARF2_VERSION
< 4)
2664 exp
.X_op
= O_symbol
;
2667 exp
.X_op
= O_subtract
;
2668 exp
.X_op_symbol
= all_segs
->text_start
;
2670 exp
.X_add_symbol
= all_segs
->text_end
;
2671 exp
.X_add_number
= 0;
2672 if (DWARF2_VERSION
< 4)
2673 emit_expr (&exp
, sizeof_address
);
2675 emit_leb128_expr (&exp
, 0);
2679 /* This attribute is emitted if the code is disjoint. */
2681 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2684 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2685 setup in out_debug_str below. */
2686 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2687 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2688 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2690 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2691 dwarf2 draft has no standard code for assembler. */
2692 out_two (DW_LANG_Mips_Assembler
);
2694 symbol_set_value_now (info_end
);
2697 /* Emit the three debug strings needed in .debug_str and setup symbols
2698 to them for use in out_debug_info. */
2700 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2701 symbolS
**producer_sym
)
2704 const char *comp_dir
;
2705 const char *dirname
;
2708 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2710 subseg_set (str_seg
, 0);
2712 /* DW_AT_name. We don't have the actual file name that was present
2713 on the command line, so assume files[first_file] is the main input file.
2714 We're not supposed to get called unless at least one line number
2715 entry was emitted, so this should always be defined. */
2716 *name_sym
= symbol_temp_new_now_octets ();
2717 if (files_in_use
== 0)
2719 if (files
[first_file
].dir
)
2721 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2722 len
= strlen (dirname
);
2724 /* Already has trailing slash. */
2725 p
= frag_more (len
);
2726 memcpy (p
, dirname
, len
);
2728 p
= frag_more (len
+ 1);
2729 memcpy (p
, dirname
, len
);
2730 INSERT_DIR_SEPARATOR (p
, len
);
2733 len
= strlen (files
[first_file
].filename
) + 1;
2734 p
= frag_more (len
);
2735 memcpy (p
, files
[first_file
].filename
, len
);
2737 /* DW_AT_comp_dir */
2738 *comp_dir_sym
= symbol_temp_new_now_octets ();
2739 comp_dir
= remap_debug_filename (getpwd ());
2740 len
= strlen (comp_dir
) + 1;
2741 p
= frag_more (len
);
2742 memcpy (p
, comp_dir
, len
);
2744 /* DW_AT_producer */
2745 *producer_sym
= symbol_temp_new_now_octets ();
2746 sprintf (producer
, "GNU AS %s", VERSION
);
2747 len
= strlen (producer
) + 1;
2748 p
= frag_more (len
);
2749 memcpy (p
, producer
, len
);
2755 last_seg_ptr
= &all_segs
;
2757 /* Select the default CIE version to produce here. The global
2758 starts with a value of -1 and will be modified to a valid value
2759 either by the user providing a command line option, or some
2760 targets will select their own default in md_after_parse_args. If
2761 we get here and the global still contains -1 then it is up to us
2762 to pick a sane default. The default we choose is 1, this is the
2763 CIE version gas has produced for a long time, and there seems no
2764 reason to change it yet. */
2765 if (flag_dwarf_cie_version
== -1)
2766 flag_dwarf_cie_version
= 1;
2769 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2770 were any .file/.loc directives, or --gdwarf2 was given, and if the
2771 file has a non-empty .debug_info section and an empty .debug_line
2772 section. If we emit .debug_line, and the .debug_info section is
2773 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2774 ALL_SEGS will be non-null if there were any .file/.loc directives,
2775 or --gdwarf2 was given and there were any located instructions
2779 dwarf2_finish (void)
2784 int emit_other_sections
= 0;
2785 int empty_debug_line
= 0;
2787 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2788 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2790 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2791 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2793 /* We can't construct a new debug_line section if we already have one.
2794 Give an error if we have seen any .loc, otherwise trust the user
2795 knows what they are doing and want to generate the .debug_line
2796 (and all other debug sections) themselves. */
2797 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2798 as_fatal ("duplicate .debug_line sections");
2800 if ((!all_segs
&& emit_other_sections
)
2801 || (!emit_other_sections
&& !empty_debug_line
))
2802 /* If there is no line information and no non-empty .debug_info
2803 section, or if there is both a non-empty .debug_info and a non-empty
2804 .debug_line, then we do nothing. */
2807 /* Calculate the size of an address for the target machine. */
2808 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2810 /* Create and switch to the line number section. */
2811 if (empty_debug_line
)
2813 line_seg
= subseg_new (".debug_line", 0);
2814 bfd_set_section_flags (line_seg
,
2815 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2818 /* For each subsection, chain the debug entries together. */
2819 for (s
= all_segs
; s
; s
= s
->next
)
2821 struct line_subseg
*lss
= s
->head
;
2822 struct line_entry
**ptail
= lss
->ptail
;
2824 /* Reset the initial view of the first subsection of the
2826 if (lss
->head
&& lss
->head
->loc
.view
)
2827 set_or_check_view (lss
->head
, NULL
, NULL
);
2829 while ((lss
= lss
->next
) != NULL
)
2831 /* Link the first view of subsequent subsections to the
2833 if (lss
->head
&& lss
->head
->loc
.view
)
2834 set_or_check_view (lss
->head
,
2835 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2836 s
->head
? s
->head
->head
: NULL
);
2842 if (empty_debug_line
)
2843 out_debug_line (line_seg
);
2845 /* If this is assembler generated line info, and there is no
2846 debug_info already, we need .debug_info, .debug_abbrev and
2847 .debug_str sections as well. */
2848 if (emit_other_sections
)
2853 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2855 gas_assert (all_segs
);
2857 info_seg
= subseg_new (".debug_info", 0);
2858 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2859 aranges_seg
= subseg_new (".debug_aranges", 0);
2860 str_seg
= subseg_new (".debug_str", 0);
2862 bfd_set_section_flags (info_seg
,
2863 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2864 bfd_set_section_flags (abbrev_seg
,
2865 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2866 bfd_set_section_flags (aranges_seg
,
2867 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2868 bfd_set_section_flags (str_seg
,
2869 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2870 | SEC_MERGE
| SEC_STRINGS
);
2871 str_seg
->entsize
= 1;
2873 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2875 if (all_segs
->next
== NULL
)
2879 if (DWARF2_VERSION
< 5)
2881 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2882 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2885 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2886 out_debug_ranges (ranges_seg
, &ranges_sym
);
2890 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2891 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2894 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2898 out_debug_aranges (aranges_seg
, info_seg
);
2899 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2900 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2901 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2902 name_sym
, comp_dir_sym
, producer_sym
);
2906 /* Perform any deferred checks pertaining to debug information. */
2909 dwarf2dbg_final_check (void)
2911 /* Perform reset-view checks. Don't evaluate view_assert_failed
2912 recursively: it could be very deep. It's a chain of adds, with
2913 each chain element pointing to the next in X_add_symbol, and
2914 holding the check value in X_op_symbol. */
2915 while (view_assert_failed
)
2921 gas_assert (!symbol_resolved_p (view_assert_failed
));
2923 exp
= symbol_get_value_expression (view_assert_failed
);
2924 sym
= view_assert_failed
;
2926 /* If view_assert_failed looks like a compound check in the
2927 chain, break it up. */
2928 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2930 view_assert_failed
= exp
->X_add_symbol
;
2931 sym
= exp
->X_op_symbol
;
2934 view_assert_failed
= NULL
;
2936 failed
= resolve_symbol_value (sym
);
2937 if (!symbol_resolved_p (sym
) || failed
)
2939 as_bad (_("view number mismatch"));