1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2020 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
;
508 e
= XNEW (struct line_entry
);
513 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
515 /* Subseg heads are chained to previous subsegs in
517 if (loc
->view
&& lss
->head
)
518 set_or_check_view (e
,
519 (struct line_entry
*)lss
->ptail
,
523 lss
->ptail
= &e
->next
;
526 /* Record an entry for LOC occurring at OFS within the current fragment. */
529 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
531 static unsigned int line
= -1;
532 static unsigned int filenum
= -1;
536 /* Early out for as-yet incomplete location information. */
539 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
542 /* Don't emit sequences of line symbols for the same line when the
543 symbols apply to assembler code. It is necessary to emit
544 duplicate line symbols when a compiler asks for them, because GDB
545 uses them to determine the end of the prologue. */
546 if (debug_type
== DEBUG_DWARF2
547 && line
== loc
->line
&& filenum
== loc
->filenum
)
551 filenum
= loc
->filenum
;
557 /* Use a non-fake name for the line number location,
558 so that it can be referred to by relocations. */
559 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
560 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
563 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
564 dwarf2_gen_line_info_1 (sym
, loc
);
568 get_basename (const char * pathname
)
572 file
= lbasename (pathname
);
573 /* Don't make empty string from / or A: from A:/ . */
574 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
575 if (file
<= pathname
+ 3)
578 if (file
== pathname
+ 1)
585 get_directory_table_entry (const char * dirname
,
587 bfd_boolean can_use_zero
)
594 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
595 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
603 for (d
= 0; d
< dirs_in_use
; ++d
)
606 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
607 && dirs
[d
][dirlen
] == '\0')
613 if (dirs
== NULL
|| dirs
[0] == NULL
)
619 if (d
>= dirs_allocated
)
621 unsigned int old
= dirs_allocated
;
623 dirs_allocated
= d
+ 32;
624 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
625 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
628 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
629 if (dirs_in_use
<= d
)
636 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
638 if (i
>= files_allocated
)
640 unsigned int old
= files_allocated
;
642 files_allocated
= i
+ 32;
643 /* Catch wraparound. */
644 if (files_allocated
<= old
)
646 as_bad (_("file number %lu is too big"), (unsigned long) i
);
650 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
651 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
654 files
[i
].filename
= file
;
656 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
658 if (files_in_use
< i
+ 1)
659 files_in_use
= i
+ 1;
664 /* Get a .debug_line file number for PATHNAME. If there is a
665 directory component to PATHNAME, then this will be stored
666 in the directory table, if it is not already present.
667 Returns the slot number allocated to that filename or -1
668 if there was a problem. */
671 allocate_filenum (const char * pathname
)
673 static signed int last_used
= -1, last_used_dir_len
= 0;
678 /* Short circuit the common case of adding the same pathname
682 const char * dirname
= NULL
;
685 dirname
= dirs
[files
[last_used
].dir
];
689 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
694 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
695 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
696 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
697 files
[last_used
].filename
) == 0)
702 file
= get_basename (pathname
);
703 dir_len
= file
- pathname
;
705 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
707 /* Do not use slot-0. That is specifically reserved for use by
708 the '.file 0 "name"' directive. */
709 for (i
= 1; i
< files_in_use
; ++i
)
710 if (files
[i
].dir
== dir
712 && filename_cmp (file
, files
[i
].filename
) == 0)
715 last_used_dir_len
= dir_len
;
719 if (!assign_file_to_slot (i
, file
, dir
))
722 num_of_auto_assigned
++;
725 last_used_dir_len
= dir_len
;
730 /* Allocate slot NUM in the .debug_line file table to FILENAME.
731 If DIRNAME is not NULL or there is a directory component to FILENAME
732 then this will be stored in the directory table, if not already present.
733 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
734 Returns TRUE if allocation succeeded, FALSE otherwise. */
737 allocate_filename_to_slot (const char * dirname
,
738 const char * filename
,
740 bfd_boolean with_md5
)
746 /* Short circuit the common case of adding the same pathname
748 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
750 const char * dir
= NULL
;
753 dir
= dirs
[files
[num
].dir
];
756 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
761 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
764 if (filename_cmp (filename
, files
[num
].filename
) != 0)
767 /* If the filenames match, but the directory table entry was
768 empty, then fill it with the provided directory name. */
770 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
774 else if (dir
!= NULL
)
776 dirlen
= strlen (dir
);
777 if (filename_ncmp (filename
, dir
, dirlen
) == 0
778 && IS_DIR_SEPARATOR (filename
[dirlen
])
779 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
782 else /* dir == NULL */
784 file
= get_basename (filename
);
785 if (filename_cmp (file
, files
[num
].filename
) == 0)
788 /* The filenames match, but the directory table entry is empty.
789 Fill it with the provided directory name. */
790 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
796 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
798 dir
== NULL
? "" : dir
,
799 dir
== NULL
? "" : "/",
801 dirname
== NULL
? "" : dirname
,
802 dirname
== NULL
? "" : "/",
810 file
= get_basename (filename
);
811 dirlen
= file
- filename
;
815 dirlen
= strlen (dirname
);
819 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
822 if (! assign_file_to_slot (i
, file
, d
))
827 if (target_big_endian
)
829 /* md5's are stored in litte endian format. */
830 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
831 unsigned int byte
= NUM_MD5_BYTES
;
832 unsigned int bignum_index
= 0;
834 while (bits_remaining
)
836 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
837 valueT bignum_value
= generic_bignum
[bignum_index
];
840 while (bignum_bits_remaining
)
842 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
844 bignum_bits_remaining
-= 8;
851 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
852 unsigned int byte
= 0;
853 unsigned int bignum_index
= 0;
855 while (bits_remaining
)
857 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
858 valueT bignum_value
= generic_bignum
[bignum_index
];
862 while (bignum_bits_remaining
)
864 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
866 bignum_bits_remaining
-= 8;
873 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
878 /* Returns the current source information. If .file directives have
879 been encountered, the info for the corresponding source file is
880 returned. Otherwise, the info for the assembly source file is
884 dwarf2_where (struct dwarf2_line_info
*line
)
886 if (debug_type
== DEBUG_DWARF2
)
888 const char *filename
;
890 memset (line
, 0, sizeof (*line
));
891 filename
= as_where (&line
->line
);
892 line
->filenum
= allocate_filenum (filename
);
893 /* FIXME: We should check the return value from allocate_filenum. */
895 line
->flags
= DWARF2_FLAG_IS_STMT
;
896 line
->isa
= current
.isa
;
897 line
->discriminator
= current
.discriminator
;
904 /* A hook to allow the target backend to inform the line number state
905 machine of isa changes when assembler debug info is enabled. */
908 dwarf2_set_isa (unsigned int isa
)
913 /* Called for each machine instruction, or relatively atomic group of
914 machine instructions (ie built-in macro). The instruction or group
915 is SIZE bytes in length. If dwarf2 line number generation is called
916 for, emit a line statement appropriately. */
919 dwarf2_emit_insn (int size
)
921 struct dwarf2_line_info loc
;
923 if (debug_type
!= DEBUG_DWARF2
924 ? !dwarf2_loc_directive_seen
925 : !seen_at_least_1_file ())
930 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
931 dwarf2_consume_line_info ();
934 /* Move all previously-emitted line entries for the current position by
935 DELTA bytes. This function cannot be used to move the same entries
939 dwarf2_move_insn (int delta
)
941 struct line_subseg
*lss
;
942 struct line_entry
*e
;
948 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
952 now
= frag_now_fix ();
953 while ((e
= *lss
->pmove_tail
))
955 if (S_GET_VALUE (e
->label
) == now
)
956 S_SET_VALUE (e
->label
, now
+ delta
);
957 lss
->pmove_tail
= &e
->next
;
961 /* Called after the current line information has been either used with
962 dwarf2_gen_line_info or saved with a machine instruction for later use.
963 This resets the state of the line number information to reflect that
967 dwarf2_consume_line_info (void)
969 /* Unless we generate DWARF2 debugging information for each
970 assembler line, we only emit one line symbol for one LOC. */
971 dwarf2_loc_directive_seen
= FALSE
;
973 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
974 | DWARF2_FLAG_PROLOGUE_END
975 | DWARF2_FLAG_EPILOGUE_BEGIN
);
976 current
.discriminator
= 0;
980 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
981 is enabled, emit a basic block marker. */
984 dwarf2_emit_label (symbolS
*label
)
986 struct dwarf2_line_info loc
;
988 if (!dwarf2_loc_mark_labels
)
990 if (S_GET_SEGMENT (label
) != now_seg
)
992 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
994 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
999 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1001 dwarf2_gen_line_info_1 (label
, &loc
);
1002 dwarf2_consume_line_info ();
1005 /* Handle two forms of .file directive:
1006 - Pass .file "source.c" to s_app_file
1007 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1009 If an entry is added to the file table, return a pointer to the filename. */
1012 dwarf2_directive_filename (void)
1014 bfd_boolean with_md5
= FALSE
;
1017 const char * dirname
= NULL
;
1021 /* Continue to accept a bare string and pass it off. */
1023 if (*input_line_pointer
== '"')
1029 num
= get_absolute_expression ();
1031 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1033 as_bad (_("file number less than one"));
1034 ignore_rest_of_line ();
1038 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1039 "switch back to the already allocated file <N> as the current
1042 filename
= demand_copy_C_string (&filename_len
);
1043 if (filename
== NULL
)
1044 /* demand_copy_C_string will have already generated an error message. */
1047 /* For DWARF-5 support we also accept:
1048 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1049 if (DWARF2_LINE_VERSION
> 4)
1052 if (*input_line_pointer
== '"')
1055 filename
= demand_copy_C_string (&filename_len
);
1059 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1061 input_line_pointer
+= 3;
1065 expression_and_evaluate (& exp
);
1066 if (exp
.X_op
!= O_big
)
1067 as_bad (_("md5 value too small or not a constant"));
1073 demand_empty_rest_of_line ();
1075 /* A .file directive implies compiler generated debug information is
1076 being supplied. Turn off gas generated debug info. */
1077 debug_type
= DEBUG_NONE
;
1079 if (num
!= (unsigned int) num
1080 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1082 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1086 if (num_of_auto_assigned
)
1088 /* Clear slots auto-assigned before the first .file <NUMBER>
1089 directive was seen. */
1090 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1092 for (i
= 1; i
< files_in_use
; i
++)
1093 files
[i
].filename
= NULL
;
1095 num_of_auto_assigned
= 0;
1098 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1105 /* Calls dwarf2_directive_filename, but discards its result.
1106 Used in pseudo-op tables where the function result is ignored. */
1109 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1111 (void) dwarf2_directive_filename ();
1115 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1117 offsetT filenum
, line
;
1119 /* If we see two .loc directives in a row, force the first one to be
1121 if (dwarf2_loc_directive_seen
)
1122 dwarf2_emit_insn (0);
1124 filenum
= get_absolute_expression ();
1126 line
= get_absolute_expression ();
1130 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1132 as_bad (_("file number less than one"));
1137 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1139 as_bad (_("unassigned file number %ld"), (long) filenum
);
1143 current
.filenum
= filenum
;
1144 current
.line
= line
;
1145 current
.discriminator
= 0;
1150 if (files
[filenum
].dir
)
1152 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1153 size_t file_len
= strlen (files
[filenum
].filename
);
1154 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1156 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1157 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1158 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1159 cp
[dir_len
+ file_len
+ 1] = '\0';
1160 listing_source_file (cp
);
1164 listing_source_file (files
[filenum
].filename
);
1165 listing_source_line (line
);
1170 if (ISDIGIT (*input_line_pointer
))
1172 current
.column
= get_absolute_expression ();
1176 while (ISALPHA (*input_line_pointer
))
1181 c
= get_symbol_name (& p
);
1183 if (strcmp (p
, "basic_block") == 0)
1185 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1186 *input_line_pointer
= c
;
1188 else if (strcmp (p
, "prologue_end") == 0)
1190 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1191 *input_line_pointer
= c
;
1193 else if (strcmp (p
, "epilogue_begin") == 0)
1195 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1196 *input_line_pointer
= c
;
1198 else if (strcmp (p
, "is_stmt") == 0)
1200 (void) restore_line_pointer (c
);
1201 value
= get_absolute_expression ();
1203 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1204 else if (value
== 1)
1205 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1208 as_bad (_("is_stmt value not 0 or 1"));
1212 else if (strcmp (p
, "isa") == 0)
1214 (void) restore_line_pointer (c
);
1215 value
= get_absolute_expression ();
1217 current
.isa
= value
;
1220 as_bad (_("isa number less than zero"));
1224 else if (strcmp (p
, "discriminator") == 0)
1226 (void) restore_line_pointer (c
);
1227 value
= get_absolute_expression ();
1229 current
.discriminator
= value
;
1232 as_bad (_("discriminator less than zero"));
1236 else if (strcmp (p
, "view") == 0)
1240 (void) restore_line_pointer (c
);
1243 if (ISDIGIT (*input_line_pointer
)
1244 || *input_line_pointer
== '-')
1246 bfd_boolean force_reset
= *input_line_pointer
== '-';
1248 value
= get_absolute_expression ();
1251 as_bad (_("numeric view can only be asserted to zero"));
1254 if (force_reset
&& force_reset_view
)
1255 sym
= force_reset_view
;
1258 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1261 force_reset_view
= sym
;
1266 char *name
= read_symbol_name ();
1270 sym
= symbol_find_or_make (name
);
1271 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1273 if (S_IS_VOLATILE (sym
))
1274 sym
= symbol_clone (sym
, 1);
1275 else if (!S_CAN_BE_REDEFINED (sym
))
1277 as_bad (_("symbol `%s' is already defined"), name
);
1281 S_SET_SEGMENT (sym
, undefined_section
);
1282 S_SET_VALUE (sym
, 0);
1283 symbol_set_frag (sym
, &zero_address_frag
);
1289 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1290 (void) restore_line_pointer (c
);
1294 SKIP_WHITESPACE_AFTER_NAME ();
1297 demand_empty_rest_of_line ();
1298 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1299 debug_type
= DEBUG_NONE
;
1301 /* If we were given a view id, emit the row right away. */
1303 dwarf2_emit_insn (0);
1307 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1309 offsetT value
= get_absolute_expression ();
1311 if (value
!= 0 && value
!= 1)
1313 as_bad (_("expected 0 or 1"));
1314 ignore_rest_of_line ();
1318 dwarf2_loc_mark_labels
= value
!= 0;
1319 demand_empty_rest_of_line ();
1323 static struct frag
*
1324 first_frag_for_seg (segT seg
)
1326 return seg_info (seg
)->frchainP
->frch_root
;
1329 static struct frag
*
1330 last_frag_for_seg (segT seg
)
1332 frchainS
*f
= seg_info (seg
)->frchainP
;
1334 while (f
->frch_next
!= NULL
)
1337 return f
->frch_last
;
1340 /* Emit a single byte into the current segment. */
1345 FRAG_APPEND_1_CHAR (byte
);
1348 /* Emit a statement program opcode into the current segment. */
1351 out_opcode (int opc
)
1356 /* Emit a two-byte word into the current segment. */
1361 md_number_to_chars (frag_more (2), data
, 2);
1364 /* Emit a four byte word into the current segment. */
1369 md_number_to_chars (frag_more (4), data
, 4);
1372 /* Emit an unsigned "little-endian base 128" number. */
1375 out_uleb128 (addressT value
)
1377 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1380 /* Emit a signed "little-endian base 128" number. */
1383 out_leb128 (addressT value
)
1385 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1388 /* Emit a tuple for .debug_abbrev. */
1391 out_abbrev (int name
, int form
)
1397 /* Get the size of a fragment. */
1400 get_frag_fix (fragS
*frag
, segT seg
)
1405 return frag
->fr_fix
;
1407 /* If a fragment is the last in the chain, special measures must be
1408 taken to find its size before relaxation, since it may be pending
1409 on some subsegment chain. */
1410 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1411 if (fr
->frch_last
== frag
)
1412 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1417 /* Set an absolute address (may result in a relocation entry). */
1420 out_set_addr (symbolS
*sym
)
1424 memset (&exp
, 0, sizeof exp
);
1425 out_opcode (DW_LNS_extended_op
);
1426 out_uleb128 (sizeof_address
+ 1);
1428 out_opcode (DW_LNE_set_address
);
1429 exp
.X_op
= O_symbol
;
1430 exp
.X_add_symbol
= sym
;
1431 exp
.X_add_number
= 0;
1432 emit_expr (&exp
, sizeof_address
);
1435 static void scale_addr_delta (addressT
*);
1438 scale_addr_delta (addressT
*addr_delta
)
1440 static int printed_this
= 0;
1441 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1443 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1445 as_bad("unaligned opcodes detected in executable segment");
1448 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1452 /* Encode a pair of line and address skips as efficiently as possible.
1453 Note that the line skip is signed, whereas the address skip is unsigned.
1455 The following two routines *must* be kept in sync. This is
1456 enforced by making emit_inc_line_addr abort if we do not emit
1457 exactly the expected number of bytes. */
1460 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1462 unsigned int tmp
, opcode
;
1465 /* Scale the address delta by the minimum instruction length. */
1466 scale_addr_delta (&addr_delta
);
1468 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1469 We cannot use special opcodes here, since we want the end_sequence
1470 to emit the matrix entry. */
1471 if (line_delta
== INT_MAX
)
1473 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1475 else if (addr_delta
)
1476 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1480 /* Bias the line delta by the base. */
1481 tmp
= line_delta
- DWARF2_LINE_BASE
;
1483 /* If the line increment is out of range of a special opcode, we
1484 must encode it with DW_LNS_advance_line. */
1485 if (tmp
>= DWARF2_LINE_RANGE
)
1487 len
= 1 + sizeof_leb128 (line_delta
, 1);
1489 tmp
= 0 - DWARF2_LINE_BASE
;
1492 /* Bias the opcode by the special opcode base. */
1493 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1495 /* Avoid overflow when addr_delta is large. */
1496 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1498 /* Try using a special opcode. */
1499 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1503 /* Try using DW_LNS_const_add_pc followed by special op. */
1504 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1509 /* Otherwise use DW_LNS_advance_pc. */
1510 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1512 /* DW_LNS_copy or special opcode. */
1519 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1521 unsigned int tmp
, opcode
;
1523 char *end
= p
+ len
;
1525 /* Line number sequences cannot go backward in addresses. This means
1526 we've incorrectly ordered the statements in the sequence. */
1527 gas_assert ((offsetT
) addr_delta
>= 0);
1529 /* Scale the address delta by the minimum instruction length. */
1530 scale_addr_delta (&addr_delta
);
1532 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1533 We cannot use special opcodes here, since we want the end_sequence
1534 to emit the matrix entry. */
1535 if (line_delta
== INT_MAX
)
1537 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1538 *p
++ = DW_LNS_const_add_pc
;
1539 else if (addr_delta
)
1541 *p
++ = DW_LNS_advance_pc
;
1542 p
+= output_leb128 (p
, addr_delta
, 0);
1545 *p
++ = DW_LNS_extended_op
;
1547 *p
++ = DW_LNE_end_sequence
;
1551 /* Bias the line delta by the base. */
1552 tmp
= line_delta
- DWARF2_LINE_BASE
;
1554 /* If the line increment is out of range of a special opcode, we
1555 must encode it with DW_LNS_advance_line. */
1556 if (tmp
>= DWARF2_LINE_RANGE
)
1558 *p
++ = DW_LNS_advance_line
;
1559 p
+= output_leb128 (p
, line_delta
, 1);
1562 tmp
= 0 - DWARF2_LINE_BASE
;
1566 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1568 if (line_delta
== 0 && addr_delta
== 0)
1574 /* Bias the opcode by the special opcode base. */
1575 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1577 /* Avoid overflow when addr_delta is large. */
1578 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1580 /* Try using a special opcode. */
1581 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1588 /* Try using DW_LNS_const_add_pc followed by special op. */
1589 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1592 *p
++ = DW_LNS_const_add_pc
;
1598 /* Otherwise use DW_LNS_advance_pc. */
1599 *p
++ = DW_LNS_advance_pc
;
1600 p
+= output_leb128 (p
, addr_delta
, 0);
1608 gas_assert (p
== end
);
1611 /* Handy routine to combine calls to the above two routines. */
1614 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1616 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1617 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1620 /* Write out an alternative form of line and address skips using
1621 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1622 line and address information, but it is required if linker relaxation
1623 could change the code offsets. The following two routines *must* be
1625 #define ADDR_DELTA_LIMIT 50000
1628 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1632 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1633 if (line_delta
!= INT_MAX
)
1634 len
= 1 + sizeof_leb128 (line_delta
, 1);
1636 if (addr_delta
> ADDR_DELTA_LIMIT
)
1638 /* DW_LNS_extended_op */
1639 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1640 /* DW_LNE_set_address */
1641 len
+= 1 + sizeof_address
;
1644 /* DW_LNS_fixed_advance_pc */
1647 if (line_delta
== INT_MAX
)
1648 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1658 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1662 char *end
= p
+ len
;
1664 /* Line number sequences cannot go backward in addresses. This means
1665 we've incorrectly ordered the statements in the sequence. */
1666 gas_assert ((offsetT
) addr_delta
>= 0);
1668 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1669 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1671 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1672 if (line_delta
!= INT_MAX
)
1674 *p
++ = DW_LNS_advance_line
;
1675 p
+= output_leb128 (p
, line_delta
, 1);
1678 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1680 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1681 advance the address by at most 64K. Linker relaxation (without
1682 which this function would not be used) could change the operand by
1683 an unknown amount. If the address increment is getting close to
1684 the limit, just reset the address. */
1685 if (addr_delta
> ADDR_DELTA_LIMIT
)
1690 memset (&exp
, 0, sizeof exp
);
1691 gas_assert (pexp
->X_op
== O_subtract
);
1692 to_sym
= pexp
->X_add_symbol
;
1694 *p
++ = DW_LNS_extended_op
;
1695 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1696 *p
++ = DW_LNE_set_address
;
1697 exp
.X_op
= O_symbol
;
1698 exp
.X_add_symbol
= to_sym
;
1699 exp
.X_add_number
= 0;
1700 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1701 p
+= sizeof_address
;
1705 *p
++ = DW_LNS_fixed_advance_pc
;
1706 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1710 if (line_delta
== INT_MAX
)
1712 *p
++ = DW_LNS_extended_op
;
1714 *p
++ = DW_LNE_end_sequence
;
1719 gas_assert (p
== end
);
1722 /* Generate a variant frag that we can use to relax address/line
1723 increments between fragments of the target segment. */
1726 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1731 memset (&exp
, 0, sizeof exp
);
1732 exp
.X_op
= O_subtract
;
1733 exp
.X_add_symbol
= to_sym
;
1734 exp
.X_op_symbol
= from_sym
;
1735 exp
.X_add_number
= 0;
1737 /* The maximum size of the frag is the line delta with a maximum
1738 sized address delta. */
1739 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1740 max_chars
= size_fixed_inc_line_addr (line_delta
,
1741 -DWARF2_LINE_MIN_INSN_LENGTH
);
1743 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1745 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1746 make_expr_symbol (&exp
), line_delta
, NULL
);
1749 /* The function estimates the size of a rs_dwarf2dbg variant frag
1750 based on the current values of the symbols. It is called before
1751 the relaxation loop. We set fr_subtype to the expected length. */
1754 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1759 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1760 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1761 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1763 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1765 frag
->fr_subtype
= size
;
1770 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1771 current values of the symbols. fr_subtype is the current length
1772 of the frag. This returns the change in frag length. */
1775 dwarf2dbg_relax_frag (fragS
*frag
)
1777 int old_size
, new_size
;
1779 old_size
= frag
->fr_subtype
;
1780 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1782 return new_size
- old_size
;
1785 /* This function converts a rs_dwarf2dbg variant frag into a normal
1786 fill frag. This is called after all relaxation has been done.
1787 fr_subtype will be the desired length of the frag. */
1790 dwarf2dbg_convert_frag (fragS
*frag
)
1794 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1796 /* If linker relaxation is enabled then the distance between the two
1797 symbols in the frag->fr_symbol expression might change. Hence we
1798 cannot rely upon the value computed by resolve_symbol_value.
1799 Instead we leave the expression unfinalized and allow
1800 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1801 relocation) that will allow the linker to correctly compute the
1802 actual address difference. We have to use a fixed line advance for
1803 this as we cannot (easily) relocate leb128 encoded values. */
1804 int saved_finalize_syms
= finalize_syms
;
1807 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1808 finalize_syms
= saved_finalize_syms
;
1811 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1813 /* fr_var carries the max_chars that we created the fragment with.
1814 fr_subtype carries the current expected length. We must, of
1815 course, have allocated enough memory earlier. */
1816 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1818 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1819 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1820 frag
->fr_literal
+ frag
->fr_fix
,
1823 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1824 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1826 frag
->fr_fix
+= frag
->fr_subtype
;
1827 frag
->fr_type
= rs_fill
;
1829 frag
->fr_offset
= 0;
1832 /* Generate .debug_line content for the chain of line number entries
1833 beginning at E, for segment SEG. */
1836 process_entries (segT seg
, struct line_entry
*e
)
1838 unsigned filenum
= 1;
1840 unsigned column
= 0;
1842 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1843 fragS
*last_frag
= NULL
, *frag
;
1844 addressT last_frag_ofs
= 0, frag_ofs
;
1845 symbolS
*last_lab
= NULL
, *lab
;
1846 struct line_entry
*next
;
1848 if (flag_dwarf_sections
)
1851 const char * sec_name
;
1853 /* Switch to the relevant sub-section before we start to emit
1854 the line number table.
1856 FIXME: These sub-sections do not have a normal Line Number
1857 Program Header, thus strictly speaking they are not valid
1858 DWARF sections. Unfortunately the DWARF standard assumes
1859 a one-to-one relationship between compilation units and
1860 line number tables. Thus we have to have a .debug_line
1861 section, as well as our sub-sections, and we have to ensure
1862 that all of the sub-sections are merged into a proper
1863 .debug_line section before a debugger sees them. */
1865 sec_name
= bfd_section_name (seg
);
1866 if (strcmp (sec_name
, ".text") != 0)
1868 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1869 subseg_set (subseg_get (name
, FALSE
), 0);
1872 /* Don't create a .debug_line.text section -
1873 that is redundant. Instead just switch back to the
1874 normal .debug_line section. */
1875 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1882 if (filenum
!= e
->loc
.filenum
)
1884 filenum
= e
->loc
.filenum
;
1885 out_opcode (DW_LNS_set_file
);
1886 out_uleb128 (filenum
);
1889 if (column
!= e
->loc
.column
)
1891 column
= e
->loc
.column
;
1892 out_opcode (DW_LNS_set_column
);
1893 out_uleb128 (column
);
1896 if (e
->loc
.discriminator
!= 0)
1898 out_opcode (DW_LNS_extended_op
);
1899 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1900 out_opcode (DW_LNE_set_discriminator
);
1901 out_uleb128 (e
->loc
.discriminator
);
1904 if (isa
!= e
->loc
.isa
)
1907 out_opcode (DW_LNS_set_isa
);
1911 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1913 flags
= e
->loc
.flags
;
1914 out_opcode (DW_LNS_negate_stmt
);
1917 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1918 out_opcode (DW_LNS_set_basic_block
);
1920 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1921 out_opcode (DW_LNS_set_prologue_end
);
1923 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1924 out_opcode (DW_LNS_set_epilogue_begin
);
1926 /* Don't try to optimize away redundant entries; gdb wants two
1927 entries for a function where the code starts on the same line as
1928 the {, and there's no way to identify that case here. Trust gcc
1929 to optimize appropriately. */
1930 line_delta
= e
->loc
.line
- line
;
1932 frag
= symbol_get_frag (lab
);
1933 frag_ofs
= S_GET_VALUE (lab
);
1935 if (last_frag
== NULL
1936 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1937 /* If we're going to reset the view, but we know we're
1938 advancing the PC, we don't have to force with
1939 set_address. We know we do when we're at the same
1940 address of the same frag, and we know we might when
1941 we're in the beginning of a frag, and we were at the
1942 end of the previous frag. */
1943 && (frag
== last_frag
1944 ? (last_frag_ofs
== frag_ofs
)
1946 && ((offsetT
)last_frag_ofs
1947 >= get_frag_fix (last_frag
, seg
))))))
1950 out_inc_line_addr (line_delta
, 0);
1952 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1953 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1955 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1960 last_frag_ofs
= frag_ofs
;
1968 /* Emit a DW_LNE_end_sequence for the end of the section. */
1969 frag
= last_frag_for_seg (seg
);
1970 frag_ofs
= get_frag_fix (frag
, seg
);
1971 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1972 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1975 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1976 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1980 /* Switch to LINE_STR_SEG and output the given STR. Return the
1981 symbol pointing to the new string in the section. */
1984 add_line_strp (segT line_str_seg
, const char *str
)
1990 subseg_set (line_str_seg
, 0);
1992 sym
= symbol_temp_new_now_octets ();
1994 size
= strlen (str
) + 1;
1995 cp
= frag_more (size
);
1996 memcpy (cp
, str
, size
);
2002 /* Emit the directory and file tables for .debug_line. */
2005 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2011 bfd_boolean emit_md5
= FALSE
;
2012 bfd_boolean emit_timestamps
= TRUE
;
2013 bfd_boolean emit_filesize
= TRUE
;
2014 segT line_str_seg
= NULL
;
2017 /* Output the Directory Table. */
2018 if (DWARF2_LINE_VERSION
>= 5)
2020 /* We only have one column in the directory table. */
2023 /* Describe the purpose and format of the column. */
2024 out_uleb128 (DW_LNCT_path
);
2025 /* Store these strings in the .debug_line_str section so they
2027 out_uleb128 (DW_FORM_line_strp
);
2029 /* Now state how many rows there are in the table. We need at
2030 least 1 if there is one or more file names to store the
2031 "working directory". */
2032 if (dirs_in_use
== 0 && files_in_use
> 0)
2035 out_uleb128 (dirs_in_use
);
2038 /* Emit directory list. */
2039 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2041 line_str_seg
= subseg_new (".debug_line_str", 0);
2042 bfd_set_section_flags (line_str_seg
,
2043 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2044 | SEC_MERGE
| SEC_STRINGS
);
2045 line_str_seg
->entsize
= 1;
2047 /* DWARF5 uses slot zero, but that is only set explicitly
2048 using a .file 0 directive. If that isn't used, but dir
2049 one is used, then use that as main file directory.
2050 Otherwise use pwd as main file directory. */
2051 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2052 dir
= remap_debug_filename (dirs
[0]);
2053 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2054 dir
= remap_debug_filename (dirs
[1]);
2056 dir
= remap_debug_filename (getpwd ());
2058 line_strp
= add_line_strp (line_str_seg
, dir
);
2059 subseg_set (line_seg
, 0);
2060 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2062 for (i
= 1; i
< dirs_in_use
; ++i
)
2064 dir
= remap_debug_filename (dirs
[i
]);
2065 if (DWARF2_LINE_VERSION
< 5)
2067 size
= strlen (dir
) + 1;
2068 cp
= frag_more (size
);
2069 memcpy (cp
, dir
, size
);
2073 line_strp
= add_line_strp (line_str_seg
, dir
);
2074 subseg_set (line_seg
, 0);
2075 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2079 if (DWARF2_LINE_VERSION
< 5)
2083 /* Output the File Name Table. */
2084 if (DWARF2_LINE_VERSION
>= 5)
2086 unsigned int columns
= 4;
2088 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2090 emit_timestamps
= FALSE
;
2094 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2096 emit_filesize
= FALSE
;
2100 for (i
= 0; i
< files_in_use
; ++i
)
2101 if (files
[i
].md5
[0] != 0)
2103 if (i
< files_in_use
)
2109 /* The number of format entries to follow. */
2111 /* The format of the file name. */
2112 out_uleb128 (DW_LNCT_path
);
2113 /* Store these strings in the .debug_line_str section so they
2115 out_uleb128 (DW_FORM_line_strp
);
2117 /* The format of the directory index. */
2118 out_uleb128 (DW_LNCT_directory_index
);
2119 out_uleb128 (DW_FORM_udata
);
2121 if (emit_timestamps
)
2123 /* The format of the timestamp. */
2124 out_uleb128 (DW_LNCT_timestamp
);
2125 out_uleb128 (DW_FORM_udata
);
2130 /* The format of the file size. */
2131 out_uleb128 (DW_LNCT_size
);
2132 out_uleb128 (DW_FORM_udata
);
2137 /* The format of the MD5 sum. */
2138 out_uleb128 (DW_LNCT_MD5
);
2139 out_uleb128 (DW_FORM_data16
);
2142 /* The number of entries in the table. */
2143 out_uleb128 (files_in_use
);
2146 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2148 const char *fullfilename
;
2150 if (files
[i
].filename
== NULL
)
2152 /* Prevent a crash later, particularly for file 1. DWARF5
2153 uses slot zero, but that is only set explicitly using a
2154 .file 0 directive. If that isn't used, but file 1 is,
2155 then use that as main file name. */
2156 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2157 files
[0].filename
= files
[1].filename
;
2159 files
[i
].filename
= "";
2160 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2162 as_bad (_("unassigned file number %ld"), (long) i
);
2167 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2168 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2169 if (DWARF2_LINE_VERSION
< 5)
2171 size
= strlen (fullfilename
) + 1;
2172 cp
= frag_more (size
);
2173 memcpy (cp
, fullfilename
, size
);
2177 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2178 subseg_set (line_seg
, 0);
2179 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2182 /* Directory number. */
2183 out_uleb128 (files
[i
].dir
);
2185 /* Output the last modification timestamp. */
2186 if (emit_timestamps
)
2190 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2191 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2192 if (timestamp
== -1)
2194 out_uleb128 (timestamp
);
2197 /* Output the filesize. */
2201 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2202 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2205 out_uleb128 (filesize
);
2208 /* Output the md5 sum. */
2213 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2214 out_byte (files
[i
].md5
[b
]);
2218 if (DWARF2_LINE_VERSION
< 5)
2219 /* Terminate filename list. */
2223 /* Switch to SEC and output a header length field. Return the size of
2224 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2225 to the end of the section. EXPR->X_add_number will be set to the
2226 negative size of the header. */
2229 out_header (asection
*sec
, expressionS
*exp
)
2234 subseg_set (sec
, 0);
2236 if (flag_dwarf_sections
)
2238 /* If we are going to put the start and end symbols in different
2239 sections, then we need real symbols, not just fake, local ones. */
2241 start_sym
= symbol_make (".Ldebug_line_start");
2242 end_sym
= symbol_make (".Ldebug_line_end");
2243 symbol_set_value_now (start_sym
);
2247 start_sym
= symbol_temp_new_now_octets ();
2248 end_sym
= symbol_temp_make ();
2251 /* Total length of the information. */
2252 exp
->X_op
= O_subtract
;
2253 exp
->X_add_symbol
= end_sym
;
2254 exp
->X_op_symbol
= start_sym
;
2256 switch (DWARF2_FORMAT (sec
))
2258 case dwarf2_format_32bit
:
2259 exp
->X_add_number
= -4;
2263 case dwarf2_format_64bit
:
2264 exp
->X_add_number
= -12;
2269 case dwarf2_format_64bit_irix
:
2270 exp
->X_add_number
= -8;
2275 as_fatal (_("internal error: unknown dwarf2 format"));
2279 /* Emit the collected .debug_line data. */
2282 out_debug_line (segT line_seg
)
2285 symbolS
*prologue_start
, *prologue_end
;
2290 memset (&exp
, 0, sizeof exp
);
2291 sizeof_offset
= out_header (line_seg
, &exp
);
2292 line_end
= exp
.X_add_symbol
;
2295 out_two (DWARF2_LINE_VERSION
);
2297 if (DWARF2_LINE_VERSION
>= 5)
2299 out_byte (sizeof_address
);
2300 out_byte (0); /* Segment Selector size. */
2302 /* Length of the prologue following this length. */
2303 prologue_start
= symbol_temp_make ();
2304 prologue_end
= symbol_temp_make ();
2305 exp
.X_op
= O_subtract
;
2306 exp
.X_add_symbol
= prologue_end
;
2307 exp
.X_op_symbol
= prologue_start
;
2308 exp
.X_add_number
= 0;
2309 emit_expr (&exp
, sizeof_offset
);
2310 symbol_set_value_now (prologue_start
);
2312 /* Parameters of the state machine. */
2313 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2314 if (DWARF2_LINE_VERSION
>= 4)
2315 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2316 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2317 out_byte (DWARF2_LINE_BASE
);
2318 out_byte (DWARF2_LINE_RANGE
);
2319 out_byte (DWARF2_LINE_OPCODE_BASE
);
2321 /* Standard opcode lengths. */
2322 out_byte (0); /* DW_LNS_copy */
2323 out_byte (1); /* DW_LNS_advance_pc */
2324 out_byte (1); /* DW_LNS_advance_line */
2325 out_byte (1); /* DW_LNS_set_file */
2326 out_byte (1); /* DW_LNS_set_column */
2327 out_byte (0); /* DW_LNS_negate_stmt */
2328 out_byte (0); /* DW_LNS_set_basic_block */
2329 out_byte (0); /* DW_LNS_const_add_pc */
2330 out_byte (1); /* DW_LNS_fixed_advance_pc */
2331 out_byte (0); /* DW_LNS_set_prologue_end */
2332 out_byte (0); /* DW_LNS_set_epilogue_begin */
2333 out_byte (1); /* DW_LNS_set_isa */
2334 /* We have emitted 12 opcode lengths, so make that this
2335 matches up to the opcode base value we have been using. */
2336 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2338 out_dir_and_file_list (line_seg
, sizeof_offset
);
2340 symbol_set_value_now (prologue_end
);
2342 /* For each section, emit a statement program. */
2343 for (s
= all_segs
; s
; s
= s
->next
)
2344 if (SEG_NORMAL (s
->seg
))
2345 process_entries (s
->seg
, s
->head
->head
);
2347 as_warn ("dwarf line number information for %s ignored",
2348 segment_name (s
->seg
));
2350 if (flag_dwarf_sections
)
2351 /* We have to switch to the special .debug_line_end section
2352 before emitting the end-of-debug_line symbol. The linker
2353 script arranges for this section to be placed after all the
2354 (potentially garbage collected) .debug_line.<foo> sections.
2355 This section contains the line_end symbol which is used to
2356 compute the size of the linked .debug_line section, as seen
2357 in the DWARF Line Number header. */
2358 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2360 symbol_set_value_now (line_end
);
2364 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2366 unsigned int addr_size
= sizeof_address
;
2371 memset (&exp
, 0, sizeof exp
);
2372 subseg_set (ranges_seg
, 0);
2374 /* For DW_AT_ranges to point at (there is no header, so really start
2375 of section, but see out_debug_rnglists). */
2376 *ranges_sym
= symbol_temp_new_now_octets ();
2378 /* Base Address Entry. */
2379 for (i
= 0; i
< addr_size
; i
++)
2381 for (i
= 0; i
< addr_size
; i
++)
2384 /* Range List Entry. */
2385 for (s
= all_segs
; s
; s
= s
->next
)
2390 frag
= first_frag_for_seg (s
->seg
);
2391 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2392 s
->text_start
= beg
;
2394 frag
= last_frag_for_seg (s
->seg
);
2395 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2398 exp
.X_op
= O_symbol
;
2399 exp
.X_add_symbol
= beg
;
2400 exp
.X_add_number
= 0;
2401 emit_expr (&exp
, addr_size
);
2403 exp
.X_op
= O_symbol
;
2404 exp
.X_add_symbol
= end
;
2405 exp
.X_add_number
= 0;
2406 emit_expr (&exp
, addr_size
);
2409 /* End of Range Entry. */
2410 for (i
= 0; i
< addr_size
; i
++)
2412 for (i
= 0; i
< addr_size
; i
++)
2417 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2420 symbolS
*ranges_end
;
2424 memset (&exp
, 0, sizeof exp
);
2425 out_header (ranges_seg
, &exp
);
2426 ranges_end
= exp
.X_add_symbol
;
2428 out_two (DWARF2_RNGLISTS_VERSION
);
2429 out_byte (sizeof_address
);
2430 out_byte (0); /* Segment Selector size. */
2431 out_four (0); /* Offset entry count. */
2433 /* For DW_AT_ranges to point at (must be after the header). */
2434 *ranges_sym
= symbol_temp_new_now_octets ();
2436 for (s
= all_segs
; s
; s
= s
->next
)
2441 out_byte (DW_RLE_start_length
);
2443 frag
= first_frag_for_seg (s
->seg
);
2444 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2445 s
->text_start
= beg
;
2447 frag
= last_frag_for_seg (s
->seg
);
2448 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2451 exp
.X_op
= O_symbol
;
2452 exp
.X_add_symbol
= beg
;
2453 exp
.X_add_number
= 0;
2454 emit_expr (&exp
, sizeof_address
);
2456 exp
.X_op
= O_symbol
;
2457 exp
.X_add_symbol
= end
;
2458 exp
.X_add_number
= 0;
2459 emit_leb128_expr (&exp
, 0);
2462 out_byte (DW_RLE_end_of_list
);
2464 symbol_set_value_now (ranges_end
);
2467 /* Emit data for .debug_aranges. */
2470 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2472 unsigned int addr_size
= sizeof_address
;
2476 symbolS
*aranges_end
;
2480 memset (&exp
, 0, sizeof exp
);
2481 sizeof_offset
= out_header (aranges_seg
, &exp
);
2482 aranges_end
= exp
.X_add_symbol
;
2483 size
= -exp
.X_add_number
;
2486 out_two (DWARF2_ARANGES_VERSION
);
2489 /* Offset to .debug_info. */
2490 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2491 size
+= sizeof_offset
;
2493 /* Size of an address (offset portion). */
2494 out_byte (addr_size
);
2497 /* Size of a segment descriptor. */
2501 /* Align the header. */
2502 while ((size
++ % (2 * addr_size
)) > 0)
2505 for (s
= all_segs
; s
; s
= s
->next
)
2510 frag
= first_frag_for_seg (s
->seg
);
2511 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2512 s
->text_start
= beg
;
2514 frag
= last_frag_for_seg (s
->seg
);
2515 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2518 exp
.X_op
= O_symbol
;
2519 exp
.X_add_symbol
= beg
;
2520 exp
.X_add_number
= 0;
2521 emit_expr (&exp
, addr_size
);
2523 exp
.X_op
= O_subtract
;
2524 exp
.X_add_symbol
= end
;
2525 exp
.X_op_symbol
= beg
;
2526 exp
.X_add_number
= 0;
2527 emit_expr (&exp
, addr_size
);
2530 p
= frag_more (2 * addr_size
);
2531 md_number_to_chars (p
, 0, addr_size
);
2532 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2534 symbol_set_value_now (aranges_end
);
2537 /* Emit data for .debug_abbrev. Note that this must be kept in
2538 sync with out_debug_info below. */
2541 out_debug_abbrev (segT abbrev_seg
,
2542 segT info_seg ATTRIBUTE_UNUSED
,
2543 segT line_seg ATTRIBUTE_UNUSED
)
2546 subseg_set (abbrev_seg
, 0);
2549 out_uleb128 (DW_TAG_compile_unit
);
2550 out_byte (DW_CHILDREN_no
);
2551 if (DWARF2_VERSION
< 4)
2553 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2554 secoff_form
= DW_FORM_data4
;
2556 secoff_form
= DW_FORM_data8
;
2559 secoff_form
= DW_FORM_sec_offset
;
2560 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2561 if (all_segs
->next
== NULL
)
2563 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2564 if (DWARF2_VERSION
< 4)
2565 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2567 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2570 out_abbrev (DW_AT_ranges
, secoff_form
);
2571 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2572 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2573 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2574 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2577 /* Terminate the abbreviations for this compilation unit. */
2581 /* Emit a description of this compilation unit for .debug_info. */
2584 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2585 symbolS
*ranges_sym
, symbolS
*name_sym
,
2586 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2592 memset (&exp
, 0, sizeof exp
);
2593 sizeof_offset
= out_header (info_seg
, &exp
);
2594 info_end
= exp
.X_add_symbol
;
2596 /* DWARF version. */
2597 out_two (DWARF2_VERSION
);
2599 if (DWARF2_VERSION
< 5)
2601 /* .debug_abbrev offset */
2602 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2606 /* unit (header) type */
2607 out_byte (DW_UT_compile
);
2610 /* Target address size. */
2611 out_byte (sizeof_address
);
2613 if (DWARF2_VERSION
>= 5)
2615 /* .debug_abbrev offset */
2616 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2619 /* DW_TAG_compile_unit DIE abbrev */
2622 /* DW_AT_stmt_list */
2623 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2624 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2627 /* These two attributes are emitted if all of the code is contiguous. */
2628 if (all_segs
->next
== NULL
)
2631 exp
.X_op
= O_symbol
;
2632 exp
.X_add_symbol
= all_segs
->text_start
;
2633 exp
.X_add_number
= 0;
2634 emit_expr (&exp
, sizeof_address
);
2637 if (DWARF2_VERSION
< 4)
2638 exp
.X_op
= O_symbol
;
2641 exp
.X_op
= O_subtract
;
2642 exp
.X_op_symbol
= all_segs
->text_start
;
2644 exp
.X_add_symbol
= all_segs
->text_end
;
2645 exp
.X_add_number
= 0;
2646 if (DWARF2_VERSION
< 4)
2647 emit_expr (&exp
, sizeof_address
);
2649 emit_leb128_expr (&exp
, 0);
2653 /* This attribute is emitted if the code is disjoint. */
2655 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2658 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2659 setup in out_debug_str below. */
2660 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2661 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2662 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2664 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2665 dwarf2 draft has no standard code for assembler. */
2666 out_two (DW_LANG_Mips_Assembler
);
2668 symbol_set_value_now (info_end
);
2671 /* Emit the three debug strings needed in .debug_str and setup symbols
2672 to them for use in out_debug_info. */
2674 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2675 symbolS
**producer_sym
)
2678 const char *comp_dir
;
2679 const char *dirname
;
2682 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2684 subseg_set (str_seg
, 0);
2686 /* DW_AT_name. We don't have the actual file name that was present
2687 on the command line, so assume files[first_file] is the main input file.
2688 We're not supposed to get called unless at least one line number
2689 entry was emitted, so this should always be defined. */
2690 *name_sym
= symbol_temp_new_now_octets ();
2691 if (files_in_use
== 0)
2693 if (files
[first_file
].dir
)
2695 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2696 len
= strlen (dirname
);
2698 /* Already has trailing slash. */
2699 p
= frag_more (len
);
2700 memcpy (p
, dirname
, len
);
2702 p
= frag_more (len
+ 1);
2703 memcpy (p
, dirname
, len
);
2704 INSERT_DIR_SEPARATOR (p
, len
);
2707 len
= strlen (files
[first_file
].filename
) + 1;
2708 p
= frag_more (len
);
2709 memcpy (p
, files
[first_file
].filename
, len
);
2711 /* DW_AT_comp_dir */
2712 *comp_dir_sym
= symbol_temp_new_now_octets ();
2713 comp_dir
= remap_debug_filename (getpwd ());
2714 len
= strlen (comp_dir
) + 1;
2715 p
= frag_more (len
);
2716 memcpy (p
, comp_dir
, len
);
2718 /* DW_AT_producer */
2719 *producer_sym
= symbol_temp_new_now_octets ();
2720 sprintf (producer
, "GNU AS %s", VERSION
);
2721 len
= strlen (producer
) + 1;
2722 p
= frag_more (len
);
2723 memcpy (p
, producer
, len
);
2729 last_seg_ptr
= &all_segs
;
2731 /* Select the default CIE version to produce here. The global
2732 starts with a value of -1 and will be modified to a valid value
2733 either by the user providing a command line option, or some
2734 targets will select their own default in md_after_parse_args. If
2735 we get here and the global still contains -1 then it is up to us
2736 to pick a sane default. The default we choose is 1, this is the
2737 CIE version gas has produced for a long time, and there seems no
2738 reason to change it yet. */
2739 if (flag_dwarf_cie_version
== -1)
2740 flag_dwarf_cie_version
= 1;
2744 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2745 were any .file/.loc directives, or --gdwarf2 was given, and if the
2746 file has a non-empty .debug_info section and an empty .debug_line
2747 section. If we emit .debug_line, and the .debug_info section is
2748 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2749 ALL_SEGS will be non-null if there were any .file/.loc directives,
2750 or --gdwarf2 was given and there were any located instructions
2754 dwarf2_finish (void)
2759 int emit_other_sections
= 0;
2760 int empty_debug_line
= 0;
2762 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2763 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2765 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2766 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2768 /* We can't construct a new debug_line section if we already have one.
2769 Give an error if we have seen any .loc, otherwise trust the user
2770 knows what they are doing and want to generate the .debug_line
2771 (and all other debug sections) themselves. */
2772 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2773 as_fatal ("duplicate .debug_line sections");
2775 if ((!all_segs
&& emit_other_sections
)
2776 || (!emit_other_sections
&& !empty_debug_line
))
2777 /* If there is no line information and no non-empty .debug_info
2778 section, or if there is both a non-empty .debug_info and a non-empty
2779 .debug_line, then we do nothing. */
2782 /* Calculate the size of an address for the target machine. */
2783 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2785 /* Create and switch to the line number section. */
2786 if (empty_debug_line
)
2788 line_seg
= subseg_new (".debug_line", 0);
2789 bfd_set_section_flags (line_seg
,
2790 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2793 /* For each subsection, chain the debug entries together. */
2794 for (s
= all_segs
; s
; s
= s
->next
)
2796 struct line_subseg
*lss
= s
->head
;
2797 struct line_entry
**ptail
= lss
->ptail
;
2799 /* Reset the initial view of the first subsection of the
2801 if (lss
->head
&& lss
->head
->loc
.view
)
2802 set_or_check_view (lss
->head
, NULL
, NULL
);
2804 while ((lss
= lss
->next
) != NULL
)
2806 /* Link the first view of subsequent subsections to the
2808 if (lss
->head
&& lss
->head
->loc
.view
)
2809 set_or_check_view (lss
->head
,
2810 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2811 s
->head
? s
->head
->head
: NULL
);
2817 if (empty_debug_line
)
2818 out_debug_line (line_seg
);
2820 /* If this is assembler generated line info, and there is no
2821 debug_info already, we need .debug_info, .debug_abbrev and
2822 .debug_str sections as well. */
2823 if (emit_other_sections
)
2828 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2830 gas_assert (all_segs
);
2832 info_seg
= subseg_new (".debug_info", 0);
2833 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2834 aranges_seg
= subseg_new (".debug_aranges", 0);
2835 str_seg
= subseg_new (".debug_str", 0);
2837 bfd_set_section_flags (info_seg
,
2838 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2839 bfd_set_section_flags (abbrev_seg
,
2840 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2841 bfd_set_section_flags (aranges_seg
,
2842 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2843 bfd_set_section_flags (str_seg
,
2844 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2845 | SEC_MERGE
| SEC_STRINGS
);
2846 str_seg
->entsize
= 1;
2848 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2850 if (all_segs
->next
== NULL
)
2854 if (DWARF2_VERSION
< 5)
2856 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2857 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2860 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2861 out_debug_ranges (ranges_seg
, &ranges_sym
);
2865 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2866 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2869 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2873 out_debug_aranges (aranges_seg
, info_seg
);
2874 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2875 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2876 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2877 name_sym
, comp_dir_sym
, producer_sym
);
2881 /* Perform any deferred checks pertaining to debug information. */
2884 dwarf2dbg_final_check (void)
2886 /* Perform reset-view checks. Don't evaluate view_assert_failed
2887 recursively: it could be very deep. It's a chain of adds, with
2888 each chain element pointing to the next in X_add_symbol, and
2889 holding the check value in X_op_symbol. */
2890 while (view_assert_failed
)
2896 gas_assert (!symbol_resolved_p (view_assert_failed
));
2898 exp
= symbol_get_value_expression (view_assert_failed
);
2899 sym
= view_assert_failed
;
2901 /* If view_assert_failed looks like a compound check in the
2902 chain, break it up. */
2903 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2905 view_assert_failed
= exp
->X_add_symbol
;
2906 sym
= exp
->X_op_symbol
;
2909 view_assert_failed
= NULL
;
2911 failed
= resolve_symbol_value (sym
);
2912 if (!symbol_resolved_p (sym
) || failed
)
2914 as_bad (_("view number mismatch"));