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 bfd_boolean auto_assigned
;
215 unsigned char md5
[NUM_MD5_BYTES
];
218 /* Table of files used by .debug_line. */
219 static struct file_entry
*files
;
220 static unsigned int files_in_use
;
221 static unsigned int files_allocated
;
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
, bfd_boolean auto_assign
)
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 files
[i
].auto_assigned
= auto_assign
;
657 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
659 if (files_in_use
< i
+ 1)
660 files_in_use
= i
+ 1;
665 /* Get a .debug_line file number for PATHNAME. If there is a
666 directory component to PATHNAME, then this will be stored
667 in the directory table, if it is not already present.
668 Returns the slot number allocated to that filename or -1
669 if there was a problem. */
672 allocate_filenum (const char * pathname
)
674 static signed int last_used
= -1, last_used_dir_len
= 0;
679 /* Short circuit the common case of adding the same pathname
683 const char * dirname
= NULL
;
686 dirname
= dirs
[files
[last_used
].dir
];
690 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
695 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
696 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
697 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
698 files
[last_used
].filename
) == 0)
703 file
= get_basename (pathname
);
704 dir_len
= file
- pathname
;
706 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
708 /* Do not use slot-0. That is specifically reserved for use by
709 the '.file 0 "name"' directive. */
710 for (i
= 1; i
< files_in_use
; ++i
)
711 if (files
[i
].dir
== dir
713 && filename_cmp (file
, files
[i
].filename
) == 0)
716 last_used_dir_len
= dir_len
;
720 if (!assign_file_to_slot (i
, file
, dir
, TRUE
))
724 last_used_dir_len
= dir_len
;
729 /* Allocate slot NUM in the .debug_line file table to FILENAME.
730 If DIRNAME is not NULL or there is a directory component to FILENAME
731 then this will be stored in the directory table, if not already present.
732 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
733 Returns TRUE if allocation succeeded, FALSE otherwise. */
736 allocate_filename_to_slot (const char * dirname
,
737 const char * filename
,
739 bfd_boolean with_md5
)
745 /* Short circuit the common case of adding the same pathname
747 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
749 const char * dir
= NULL
;
752 dir
= dirs
[files
[num
].dir
];
755 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
760 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
763 if (filename_cmp (filename
, files
[num
].filename
) != 0)
766 /* If the filenames match, but the directory table entry was
767 empty, then fill it with the provided directory name. */
769 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
773 else if (dir
!= NULL
)
775 dirlen
= strlen (dir
);
776 if (filename_ncmp (filename
, dir
, dirlen
) == 0
777 && IS_DIR_SEPARATOR (filename
[dirlen
])
778 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
781 else /* dir == NULL */
783 file
= get_basename (filename
);
784 if (filename_cmp (file
, files
[num
].filename
) == 0)
787 /* The filenames match, but the directory table entry is empty.
788 Fill it with the provided directory name. */
789 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
795 /* If NUM was previously allocated automatically then
796 choose another slot for it, so that we can reuse NUM. */
797 if (files
[num
].auto_assigned
)
799 /* Find an unused slot. */
800 for (i
= 1; i
< files_in_use
; ++i
)
801 if (files
[i
].filename
== NULL
)
803 if (! assign_file_to_slot (i
, files
[num
].filename
, files
[num
].dir
, TRUE
))
805 files
[num
].filename
= NULL
;
809 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
811 dir
== NULL
? "" : dir
,
812 dir
== NULL
? "" : "/",
814 dirname
== NULL
? "" : dirname
,
815 dirname
== NULL
? "" : "/",
824 file
= get_basename (filename
);
825 dirlen
= file
- filename
;
829 dirlen
= strlen (dirname
);
833 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
836 if (! assign_file_to_slot (i
, file
, d
, FALSE
))
841 if (target_big_endian
)
843 /* md5's are stored in litte endian format. */
844 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
845 unsigned int byte
= NUM_MD5_BYTES
;
846 unsigned int bignum_index
= 0;
848 while (bits_remaining
)
850 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
851 valueT bignum_value
= generic_bignum
[bignum_index
];
854 while (bignum_bits_remaining
)
856 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
858 bignum_bits_remaining
-= 8;
865 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
866 unsigned int byte
= 0;
867 unsigned int bignum_index
= 0;
869 while (bits_remaining
)
871 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
872 valueT bignum_value
= generic_bignum
[bignum_index
];
876 while (bignum_bits_remaining
)
878 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
880 bignum_bits_remaining
-= 8;
887 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
892 /* Returns the current source information. If .file directives have
893 been encountered, the info for the corresponding source file is
894 returned. Otherwise, the info for the assembly source file is
898 dwarf2_where (struct dwarf2_line_info
*line
)
900 if (debug_type
== DEBUG_DWARF2
)
902 const char *filename
;
904 memset (line
, 0, sizeof (*line
));
905 filename
= as_where (&line
->line
);
906 line
->filenum
= allocate_filenum (filename
);
907 /* FIXME: We should check the return value from allocate_filenum. */
909 line
->flags
= DWARF2_FLAG_IS_STMT
;
910 line
->isa
= current
.isa
;
911 line
->discriminator
= current
.discriminator
;
918 /* A hook to allow the target backend to inform the line number state
919 machine of isa changes when assembler debug info is enabled. */
922 dwarf2_set_isa (unsigned int isa
)
927 /* Called for each machine instruction, or relatively atomic group of
928 machine instructions (ie built-in macro). The instruction or group
929 is SIZE bytes in length. If dwarf2 line number generation is called
930 for, emit a line statement appropriately. */
933 dwarf2_emit_insn (int size
)
935 struct dwarf2_line_info loc
;
937 if (debug_type
!= DEBUG_DWARF2
938 ? !dwarf2_loc_directive_seen
939 : !seen_at_least_1_file ())
944 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
945 dwarf2_consume_line_info ();
948 /* Move all previously-emitted line entries for the current position by
949 DELTA bytes. This function cannot be used to move the same entries
953 dwarf2_move_insn (int delta
)
955 struct line_subseg
*lss
;
956 struct line_entry
*e
;
962 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
966 now
= frag_now_fix ();
967 while ((e
= *lss
->pmove_tail
))
969 if (S_GET_VALUE (e
->label
) == now
)
970 S_SET_VALUE (e
->label
, now
+ delta
);
971 lss
->pmove_tail
= &e
->next
;
975 /* Called after the current line information has been either used with
976 dwarf2_gen_line_info or saved with a machine instruction for later use.
977 This resets the state of the line number information to reflect that
981 dwarf2_consume_line_info (void)
983 /* Unless we generate DWARF2 debugging information for each
984 assembler line, we only emit one line symbol for one LOC. */
985 dwarf2_loc_directive_seen
= FALSE
;
987 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
988 | DWARF2_FLAG_PROLOGUE_END
989 | DWARF2_FLAG_EPILOGUE_BEGIN
);
990 current
.discriminator
= 0;
994 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
995 is enabled, emit a basic block marker. */
998 dwarf2_emit_label (symbolS
*label
)
1000 struct dwarf2_line_info loc
;
1002 if (!dwarf2_loc_mark_labels
)
1004 if (S_GET_SEGMENT (label
) != now_seg
)
1006 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1008 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1011 dwarf2_where (&loc
);
1013 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1015 dwarf2_gen_line_info_1 (label
, &loc
);
1016 dwarf2_consume_line_info ();
1019 /* Handle two forms of .file directive:
1020 - Pass .file "source.c" to s_app_file
1021 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1023 If an entry is added to the file table, return a pointer to the filename. */
1026 dwarf2_directive_filename (void)
1028 bfd_boolean with_md5
= FALSE
;
1031 const char * dirname
= NULL
;
1034 /* Continue to accept a bare string and pass it off. */
1036 if (*input_line_pointer
== '"')
1042 num
= get_absolute_expression ();
1044 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1046 as_bad (_("file number less than one"));
1047 ignore_rest_of_line ();
1051 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1052 "switch back to the already allocated file <N> as the current
1055 filename
= demand_copy_C_string (&filename_len
);
1056 if (filename
== NULL
)
1057 /* demand_copy_C_string will have already generated an error message. */
1060 /* For DWARF-5 support we also accept:
1061 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1062 if (DWARF2_LINE_VERSION
> 4)
1065 if (*input_line_pointer
== '"')
1068 filename
= demand_copy_C_string (&filename_len
);
1072 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1074 input_line_pointer
+= 3;
1078 expression_and_evaluate (& exp
);
1079 if (exp
.X_op
!= O_big
)
1080 as_bad (_("md5 value too small or not a constant"));
1086 demand_empty_rest_of_line ();
1088 /* A .file directive implies compiler generated debug information is
1089 being supplied. Turn off gas generated debug info. */
1090 debug_type
= DEBUG_NONE
;
1092 if (num
!= (unsigned int) num
1093 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1095 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1099 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1106 /* Calls dwarf2_directive_filename, but discards its result.
1107 Used in pseudo-op tables where the function result is ignored. */
1110 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1112 (void) dwarf2_directive_filename ();
1116 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1118 offsetT filenum
, line
;
1120 /* If we see two .loc directives in a row, force the first one to be
1122 if (dwarf2_loc_directive_seen
)
1123 dwarf2_emit_insn (0);
1125 filenum
= get_absolute_expression ();
1127 line
= get_absolute_expression ();
1131 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1133 as_bad (_("file number less than one"));
1138 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1140 as_bad (_("unassigned file number %ld"), (long) filenum
);
1144 current
.filenum
= filenum
;
1145 current
.line
= line
;
1146 current
.discriminator
= 0;
1151 if (files
[filenum
].dir
)
1153 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1154 size_t file_len
= strlen (files
[filenum
].filename
);
1155 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1157 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1158 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1159 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1160 cp
[dir_len
+ file_len
+ 1] = '\0';
1161 listing_source_file (cp
);
1165 listing_source_file (files
[filenum
].filename
);
1166 listing_source_line (line
);
1171 if (ISDIGIT (*input_line_pointer
))
1173 current
.column
= get_absolute_expression ();
1177 while (ISALPHA (*input_line_pointer
))
1182 c
= get_symbol_name (& p
);
1184 if (strcmp (p
, "basic_block") == 0)
1186 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1187 *input_line_pointer
= c
;
1189 else if (strcmp (p
, "prologue_end") == 0)
1191 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1192 *input_line_pointer
= c
;
1194 else if (strcmp (p
, "epilogue_begin") == 0)
1196 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1197 *input_line_pointer
= c
;
1199 else if (strcmp (p
, "is_stmt") == 0)
1201 (void) restore_line_pointer (c
);
1202 value
= get_absolute_expression ();
1204 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1205 else if (value
== 1)
1206 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1209 as_bad (_("is_stmt value not 0 or 1"));
1213 else if (strcmp (p
, "isa") == 0)
1215 (void) restore_line_pointer (c
);
1216 value
= get_absolute_expression ();
1218 current
.isa
= value
;
1221 as_bad (_("isa number less than zero"));
1225 else if (strcmp (p
, "discriminator") == 0)
1227 (void) restore_line_pointer (c
);
1228 value
= get_absolute_expression ();
1230 current
.discriminator
= value
;
1233 as_bad (_("discriminator less than zero"));
1237 else if (strcmp (p
, "view") == 0)
1241 (void) restore_line_pointer (c
);
1244 if (ISDIGIT (*input_line_pointer
)
1245 || *input_line_pointer
== '-')
1247 bfd_boolean force_reset
= *input_line_pointer
== '-';
1249 value
= get_absolute_expression ();
1252 as_bad (_("numeric view can only be asserted to zero"));
1255 if (force_reset
&& force_reset_view
)
1256 sym
= force_reset_view
;
1259 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1262 force_reset_view
= sym
;
1267 char *name
= read_symbol_name ();
1271 sym
= symbol_find_or_make (name
);
1272 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1274 if (S_IS_VOLATILE (sym
))
1275 sym
= symbol_clone (sym
, 1);
1276 else if (!S_CAN_BE_REDEFINED (sym
))
1278 as_bad (_("symbol `%s' is already defined"), name
);
1282 S_SET_SEGMENT (sym
, undefined_section
);
1283 S_SET_VALUE (sym
, 0);
1284 symbol_set_frag (sym
, &zero_address_frag
);
1290 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1291 (void) restore_line_pointer (c
);
1295 SKIP_WHITESPACE_AFTER_NAME ();
1298 demand_empty_rest_of_line ();
1299 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1300 debug_type
= DEBUG_NONE
;
1302 /* If we were given a view id, emit the row right away. */
1304 dwarf2_emit_insn (0);
1308 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1310 offsetT value
= get_absolute_expression ();
1312 if (value
!= 0 && value
!= 1)
1314 as_bad (_("expected 0 or 1"));
1315 ignore_rest_of_line ();
1319 dwarf2_loc_mark_labels
= value
!= 0;
1320 demand_empty_rest_of_line ();
1324 static struct frag
*
1325 first_frag_for_seg (segT seg
)
1327 return seg_info (seg
)->frchainP
->frch_root
;
1330 static struct frag
*
1331 last_frag_for_seg (segT seg
)
1333 frchainS
*f
= seg_info (seg
)->frchainP
;
1335 while (f
->frch_next
!= NULL
)
1338 return f
->frch_last
;
1341 /* Emit a single byte into the current segment. */
1346 FRAG_APPEND_1_CHAR (byte
);
1349 /* Emit a statement program opcode into the current segment. */
1352 out_opcode (int opc
)
1357 /* Emit a two-byte word into the current segment. */
1362 md_number_to_chars (frag_more (2), data
, 2);
1365 /* Emit a four byte word into the current segment. */
1370 md_number_to_chars (frag_more (4), data
, 4);
1373 /* Emit an unsigned "little-endian base 128" number. */
1376 out_uleb128 (addressT value
)
1378 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1381 /* Emit a signed "little-endian base 128" number. */
1384 out_leb128 (addressT value
)
1386 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1389 /* Emit a tuple for .debug_abbrev. */
1392 out_abbrev (int name
, int form
)
1398 /* Get the size of a fragment. */
1401 get_frag_fix (fragS
*frag
, segT seg
)
1406 return frag
->fr_fix
;
1408 /* If a fragment is the last in the chain, special measures must be
1409 taken to find its size before relaxation, since it may be pending
1410 on some subsegment chain. */
1411 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1412 if (fr
->frch_last
== frag
)
1413 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1418 /* Set an absolute address (may result in a relocation entry). */
1421 out_set_addr (symbolS
*sym
)
1425 memset (&exp
, 0, sizeof exp
);
1426 out_opcode (DW_LNS_extended_op
);
1427 out_uleb128 (sizeof_address
+ 1);
1429 out_opcode (DW_LNE_set_address
);
1430 exp
.X_op
= O_symbol
;
1431 exp
.X_add_symbol
= sym
;
1432 exp
.X_add_number
= 0;
1433 emit_expr (&exp
, sizeof_address
);
1436 static void scale_addr_delta (addressT
*);
1439 scale_addr_delta (addressT
*addr_delta
)
1441 static int printed_this
= 0;
1442 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1444 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1446 as_bad("unaligned opcodes detected in executable segment");
1449 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1453 /* Encode a pair of line and address skips as efficiently as possible.
1454 Note that the line skip is signed, whereas the address skip is unsigned.
1456 The following two routines *must* be kept in sync. This is
1457 enforced by making emit_inc_line_addr abort if we do not emit
1458 exactly the expected number of bytes. */
1461 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1463 unsigned int tmp
, opcode
;
1466 /* Scale the address delta by the minimum instruction length. */
1467 scale_addr_delta (&addr_delta
);
1469 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1470 We cannot use special opcodes here, since we want the end_sequence
1471 to emit the matrix entry. */
1472 if (line_delta
== INT_MAX
)
1474 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1476 else if (addr_delta
)
1477 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1481 /* Bias the line delta by the base. */
1482 tmp
= line_delta
- DWARF2_LINE_BASE
;
1484 /* If the line increment is out of range of a special opcode, we
1485 must encode it with DW_LNS_advance_line. */
1486 if (tmp
>= DWARF2_LINE_RANGE
)
1488 len
= 1 + sizeof_leb128 (line_delta
, 1);
1490 tmp
= 0 - DWARF2_LINE_BASE
;
1493 /* Bias the opcode by the special opcode base. */
1494 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1496 /* Avoid overflow when addr_delta is large. */
1497 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1499 /* Try using a special opcode. */
1500 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1504 /* Try using DW_LNS_const_add_pc followed by special op. */
1505 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1510 /* Otherwise use DW_LNS_advance_pc. */
1511 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1513 /* DW_LNS_copy or special opcode. */
1520 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1522 unsigned int tmp
, opcode
;
1524 char *end
= p
+ len
;
1526 /* Line number sequences cannot go backward in addresses. This means
1527 we've incorrectly ordered the statements in the sequence. */
1528 gas_assert ((offsetT
) addr_delta
>= 0);
1530 /* Scale the address delta by the minimum instruction length. */
1531 scale_addr_delta (&addr_delta
);
1533 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1534 We cannot use special opcodes here, since we want the end_sequence
1535 to emit the matrix entry. */
1536 if (line_delta
== INT_MAX
)
1538 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1539 *p
++ = DW_LNS_const_add_pc
;
1540 else if (addr_delta
)
1542 *p
++ = DW_LNS_advance_pc
;
1543 p
+= output_leb128 (p
, addr_delta
, 0);
1546 *p
++ = DW_LNS_extended_op
;
1548 *p
++ = DW_LNE_end_sequence
;
1552 /* Bias the line delta by the base. */
1553 tmp
= line_delta
- DWARF2_LINE_BASE
;
1555 /* If the line increment is out of range of a special opcode, we
1556 must encode it with DW_LNS_advance_line. */
1557 if (tmp
>= DWARF2_LINE_RANGE
)
1559 *p
++ = DW_LNS_advance_line
;
1560 p
+= output_leb128 (p
, line_delta
, 1);
1563 tmp
= 0 - DWARF2_LINE_BASE
;
1567 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1569 if (line_delta
== 0 && addr_delta
== 0)
1575 /* Bias the opcode by the special opcode base. */
1576 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1578 /* Avoid overflow when addr_delta is large. */
1579 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1581 /* Try using a special opcode. */
1582 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1589 /* Try using DW_LNS_const_add_pc followed by special op. */
1590 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1593 *p
++ = DW_LNS_const_add_pc
;
1599 /* Otherwise use DW_LNS_advance_pc. */
1600 *p
++ = DW_LNS_advance_pc
;
1601 p
+= output_leb128 (p
, addr_delta
, 0);
1609 gas_assert (p
== end
);
1612 /* Handy routine to combine calls to the above two routines. */
1615 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1617 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1618 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1621 /* Write out an alternative form of line and address skips using
1622 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1623 line and address information, but it is required if linker relaxation
1624 could change the code offsets. The following two routines *must* be
1626 #define ADDR_DELTA_LIMIT 50000
1629 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1633 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1634 if (line_delta
!= INT_MAX
)
1635 len
= 1 + sizeof_leb128 (line_delta
, 1);
1637 if (addr_delta
> ADDR_DELTA_LIMIT
)
1639 /* DW_LNS_extended_op */
1640 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1641 /* DW_LNE_set_address */
1642 len
+= 1 + sizeof_address
;
1645 /* DW_LNS_fixed_advance_pc */
1648 if (line_delta
== INT_MAX
)
1649 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1659 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1663 char *end
= p
+ len
;
1665 /* Line number sequences cannot go backward in addresses. This means
1666 we've incorrectly ordered the statements in the sequence. */
1667 gas_assert ((offsetT
) addr_delta
>= 0);
1669 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1670 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1672 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1673 if (line_delta
!= INT_MAX
)
1675 *p
++ = DW_LNS_advance_line
;
1676 p
+= output_leb128 (p
, line_delta
, 1);
1679 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1681 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1682 advance the address by at most 64K. Linker relaxation (without
1683 which this function would not be used) could change the operand by
1684 an unknown amount. If the address increment is getting close to
1685 the limit, just reset the address. */
1686 if (addr_delta
> ADDR_DELTA_LIMIT
)
1691 memset (&exp
, 0, sizeof exp
);
1692 gas_assert (pexp
->X_op
== O_subtract
);
1693 to_sym
= pexp
->X_add_symbol
;
1695 *p
++ = DW_LNS_extended_op
;
1696 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1697 *p
++ = DW_LNE_set_address
;
1698 exp
.X_op
= O_symbol
;
1699 exp
.X_add_symbol
= to_sym
;
1700 exp
.X_add_number
= 0;
1701 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1702 p
+= sizeof_address
;
1706 *p
++ = DW_LNS_fixed_advance_pc
;
1707 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1711 if (line_delta
== INT_MAX
)
1713 *p
++ = DW_LNS_extended_op
;
1715 *p
++ = DW_LNE_end_sequence
;
1720 gas_assert (p
== end
);
1723 /* Generate a variant frag that we can use to relax address/line
1724 increments between fragments of the target segment. */
1727 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1732 memset (&exp
, 0, sizeof exp
);
1733 exp
.X_op
= O_subtract
;
1734 exp
.X_add_symbol
= to_sym
;
1735 exp
.X_op_symbol
= from_sym
;
1736 exp
.X_add_number
= 0;
1738 /* The maximum size of the frag is the line delta with a maximum
1739 sized address delta. */
1740 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1741 max_chars
= size_fixed_inc_line_addr (line_delta
,
1742 -DWARF2_LINE_MIN_INSN_LENGTH
);
1744 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1746 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1747 make_expr_symbol (&exp
), line_delta
, NULL
);
1750 /* The function estimates the size of a rs_dwarf2dbg variant frag
1751 based on the current values of the symbols. It is called before
1752 the relaxation loop. We set fr_subtype to the expected length. */
1755 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1760 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1761 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1762 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1764 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1766 frag
->fr_subtype
= size
;
1771 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1772 current values of the symbols. fr_subtype is the current length
1773 of the frag. This returns the change in frag length. */
1776 dwarf2dbg_relax_frag (fragS
*frag
)
1778 int old_size
, new_size
;
1780 old_size
= frag
->fr_subtype
;
1781 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1783 return new_size
- old_size
;
1786 /* This function converts a rs_dwarf2dbg variant frag into a normal
1787 fill frag. This is called after all relaxation has been done.
1788 fr_subtype will be the desired length of the frag. */
1791 dwarf2dbg_convert_frag (fragS
*frag
)
1795 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1797 /* If linker relaxation is enabled then the distance between the two
1798 symbols in the frag->fr_symbol expression might change. Hence we
1799 cannot rely upon the value computed by resolve_symbol_value.
1800 Instead we leave the expression unfinalized and allow
1801 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1802 relocation) that will allow the linker to correctly compute the
1803 actual address difference. We have to use a fixed line advance for
1804 this as we cannot (easily) relocate leb128 encoded values. */
1805 int saved_finalize_syms
= finalize_syms
;
1808 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1809 finalize_syms
= saved_finalize_syms
;
1812 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1814 /* fr_var carries the max_chars that we created the fragment with.
1815 fr_subtype carries the current expected length. We must, of
1816 course, have allocated enough memory earlier. */
1817 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1819 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1820 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1821 frag
->fr_literal
+ frag
->fr_fix
,
1824 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1825 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1827 frag
->fr_fix
+= frag
->fr_subtype
;
1828 frag
->fr_type
= rs_fill
;
1830 frag
->fr_offset
= 0;
1833 /* Generate .debug_line content for the chain of line number entries
1834 beginning at E, for segment SEG. */
1837 process_entries (segT seg
, struct line_entry
*e
)
1839 unsigned filenum
= 1;
1841 unsigned column
= 0;
1843 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1844 fragS
*last_frag
= NULL
, *frag
;
1845 addressT last_frag_ofs
= 0, frag_ofs
;
1846 symbolS
*last_lab
= NULL
, *lab
;
1847 struct line_entry
*next
;
1849 if (flag_dwarf_sections
)
1852 const char * sec_name
;
1854 /* Switch to the relevant sub-section before we start to emit
1855 the line number table.
1857 FIXME: These sub-sections do not have a normal Line Number
1858 Program Header, thus strictly speaking they are not valid
1859 DWARF sections. Unfortunately the DWARF standard assumes
1860 a one-to-one relationship between compilation units and
1861 line number tables. Thus we have to have a .debug_line
1862 section, as well as our sub-sections, and we have to ensure
1863 that all of the sub-sections are merged into a proper
1864 .debug_line section before a debugger sees them. */
1866 sec_name
= bfd_section_name (seg
);
1867 if (strcmp (sec_name
, ".text") != 0)
1869 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1870 subseg_set (subseg_get (name
, FALSE
), 0);
1873 /* Don't create a .debug_line.text section -
1874 that is redundant. Instead just switch back to the
1875 normal .debug_line section. */
1876 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1883 if (filenum
!= e
->loc
.filenum
)
1885 filenum
= e
->loc
.filenum
;
1886 out_opcode (DW_LNS_set_file
);
1887 out_uleb128 (filenum
);
1890 if (column
!= e
->loc
.column
)
1892 column
= e
->loc
.column
;
1893 out_opcode (DW_LNS_set_column
);
1894 out_uleb128 (column
);
1897 if (e
->loc
.discriminator
!= 0)
1899 out_opcode (DW_LNS_extended_op
);
1900 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1901 out_opcode (DW_LNE_set_discriminator
);
1902 out_uleb128 (e
->loc
.discriminator
);
1905 if (isa
!= e
->loc
.isa
)
1908 out_opcode (DW_LNS_set_isa
);
1912 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1914 flags
= e
->loc
.flags
;
1915 out_opcode (DW_LNS_negate_stmt
);
1918 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1919 out_opcode (DW_LNS_set_basic_block
);
1921 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1922 out_opcode (DW_LNS_set_prologue_end
);
1924 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1925 out_opcode (DW_LNS_set_epilogue_begin
);
1927 /* Don't try to optimize away redundant entries; gdb wants two
1928 entries for a function where the code starts on the same line as
1929 the {, and there's no way to identify that case here. Trust gcc
1930 to optimize appropriately. */
1931 line_delta
= e
->loc
.line
- line
;
1933 frag
= symbol_get_frag (lab
);
1934 frag_ofs
= S_GET_VALUE (lab
);
1936 if (last_frag
== NULL
1937 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1938 /* If we're going to reset the view, but we know we're
1939 advancing the PC, we don't have to force with
1940 set_address. We know we do when we're at the same
1941 address of the same frag, and we know we might when
1942 we're in the beginning of a frag, and we were at the
1943 end of the previous frag. */
1944 && (frag
== last_frag
1945 ? (last_frag_ofs
== frag_ofs
)
1947 && ((offsetT
)last_frag_ofs
1948 >= get_frag_fix (last_frag
, seg
))))))
1951 out_inc_line_addr (line_delta
, 0);
1953 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1954 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1956 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1961 last_frag_ofs
= frag_ofs
;
1969 /* Emit a DW_LNE_end_sequence for the end of the section. */
1970 frag
= last_frag_for_seg (seg
);
1971 frag_ofs
= get_frag_fix (frag
, seg
);
1972 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1973 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1976 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1977 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1981 /* Switch to LINE_STR_SEG and output the given STR. Return the
1982 symbol pointing to the new string in the section. */
1985 add_line_strp (segT line_str_seg
, const char *str
)
1991 subseg_set (line_str_seg
, 0);
1993 sym
= symbol_temp_new_now_octets ();
1995 size
= strlen (str
) + 1;
1996 cp
= frag_more (size
);
1997 memcpy (cp
, str
, size
);
2003 /* Emit the directory and file tables for .debug_line. */
2006 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2012 bfd_boolean emit_md5
= FALSE
;
2013 bfd_boolean emit_timestamps
= TRUE
;
2014 bfd_boolean emit_filesize
= TRUE
;
2015 segT line_str_seg
= NULL
;
2018 /* Output the Directory Table. */
2019 if (DWARF2_LINE_VERSION
>= 5)
2021 /* We only have one column in the directory table. */
2024 /* Describe the purpose and format of the column. */
2025 out_uleb128 (DW_LNCT_path
);
2026 /* Store these strings in the .debug_line_str section so they
2028 out_uleb128 (DW_FORM_line_strp
);
2030 /* Now state how many rows there are in the table. We need at
2031 least 1 if there is one or more file names to store the
2032 "working directory". */
2033 if (dirs_in_use
== 0 && files_in_use
> 0)
2036 out_uleb128 (dirs_in_use
);
2039 /* Emit directory list. */
2040 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2042 line_str_seg
= subseg_new (".debug_line_str", 0);
2043 bfd_set_section_flags (line_str_seg
,
2044 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2045 | SEC_MERGE
| SEC_STRINGS
);
2046 line_str_seg
->entsize
= 1;
2048 /* DWARF5 uses slot zero, but that is only set explicitly
2049 using a .file 0 directive. If that isn't used, but dir
2050 one is used, then use that as main file directory.
2051 Otherwise use pwd as main file directory. */
2052 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2053 dir
= remap_debug_filename (dirs
[0]);
2054 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2055 dir
= remap_debug_filename (dirs
[1]);
2057 dir
= remap_debug_filename (getpwd ());
2059 line_strp
= add_line_strp (line_str_seg
, dir
);
2060 subseg_set (line_seg
, 0);
2061 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2063 for (i
= 1; i
< dirs_in_use
; ++i
)
2065 dir
= remap_debug_filename (dirs
[i
]);
2066 if (DWARF2_LINE_VERSION
< 5)
2068 size
= strlen (dir
) + 1;
2069 cp
= frag_more (size
);
2070 memcpy (cp
, dir
, size
);
2074 line_strp
= add_line_strp (line_str_seg
, dir
);
2075 subseg_set (line_seg
, 0);
2076 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2080 if (DWARF2_LINE_VERSION
< 5)
2084 /* Output the File Name Table. */
2085 if (DWARF2_LINE_VERSION
>= 5)
2087 unsigned int columns
= 4;
2089 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2091 emit_timestamps
= FALSE
;
2095 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2097 emit_filesize
= FALSE
;
2101 for (i
= 0; i
< files_in_use
; ++i
)
2102 if (files
[i
].md5
[0] != 0)
2104 if (i
< files_in_use
)
2110 /* The number of format entries to follow. */
2112 /* The format of the file name. */
2113 out_uleb128 (DW_LNCT_path
);
2114 /* Store these strings in the .debug_line_str section so they
2116 out_uleb128 (DW_FORM_line_strp
);
2118 /* The format of the directory index. */
2119 out_uleb128 (DW_LNCT_directory_index
);
2120 out_uleb128 (DW_FORM_udata
);
2122 if (emit_timestamps
)
2124 /* The format of the timestamp. */
2125 out_uleb128 (DW_LNCT_timestamp
);
2126 out_uleb128 (DW_FORM_udata
);
2131 /* The format of the file size. */
2132 out_uleb128 (DW_LNCT_size
);
2133 out_uleb128 (DW_FORM_udata
);
2138 /* The format of the MD5 sum. */
2139 out_uleb128 (DW_LNCT_MD5
);
2140 out_uleb128 (DW_FORM_data16
);
2143 /* The number of entries in the table. */
2144 out_uleb128 (files_in_use
);
2147 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2149 const char *fullfilename
;
2151 if (files
[i
].filename
== NULL
)
2153 /* Prevent a crash later, particularly for file 1. DWARF5
2154 uses slot zero, but that is only set explicitly using a
2155 .file 0 directive. If that isn't used, but file 1 is,
2156 then use that as main file name. */
2157 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2158 files
[0].filename
= files
[1].filename
;
2160 files
[i
].filename
= "";
2161 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2163 as_bad (_("unassigned file number %ld"), (long) i
);
2168 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2169 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2170 if (DWARF2_LINE_VERSION
< 5)
2172 size
= strlen (fullfilename
) + 1;
2173 cp
= frag_more (size
);
2174 memcpy (cp
, fullfilename
, size
);
2178 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2179 subseg_set (line_seg
, 0);
2180 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2183 /* Directory number. */
2184 out_uleb128 (files
[i
].dir
);
2186 /* Output the last modification timestamp. */
2187 if (emit_timestamps
)
2191 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2192 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2193 if (timestamp
== -1)
2195 out_uleb128 (timestamp
);
2198 /* Output the filesize. */
2202 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2203 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2206 out_uleb128 (filesize
);
2209 /* Output the md5 sum. */
2214 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2215 out_byte (files
[i
].md5
[b
]);
2219 if (DWARF2_LINE_VERSION
< 5)
2220 /* Terminate filename list. */
2224 /* Switch to SEC and output a header length field. Return the size of
2225 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2226 to the end of the section. EXPR->X_add_number will be set to the
2227 negative size of the header. */
2230 out_header (asection
*sec
, expressionS
*exp
)
2235 subseg_set (sec
, 0);
2237 if (flag_dwarf_sections
)
2239 /* If we are going to put the start and end symbols in different
2240 sections, then we need real symbols, not just fake, local ones. */
2242 start_sym
= symbol_make (".Ldebug_line_start");
2243 end_sym
= symbol_make (".Ldebug_line_end");
2244 symbol_set_value_now (start_sym
);
2248 start_sym
= symbol_temp_new_now_octets ();
2249 end_sym
= symbol_temp_make ();
2252 /* Total length of the information. */
2253 exp
->X_op
= O_subtract
;
2254 exp
->X_add_symbol
= end_sym
;
2255 exp
->X_op_symbol
= start_sym
;
2257 switch (DWARF2_FORMAT (sec
))
2259 case dwarf2_format_32bit
:
2260 exp
->X_add_number
= -4;
2264 case dwarf2_format_64bit
:
2265 exp
->X_add_number
= -12;
2270 case dwarf2_format_64bit_irix
:
2271 exp
->X_add_number
= -8;
2276 as_fatal (_("internal error: unknown dwarf2 format"));
2280 /* Emit the collected .debug_line data. */
2283 out_debug_line (segT line_seg
)
2286 symbolS
*prologue_start
, *prologue_end
;
2291 memset (&exp
, 0, sizeof exp
);
2292 sizeof_offset
= out_header (line_seg
, &exp
);
2293 line_end
= exp
.X_add_symbol
;
2296 out_two (DWARF2_LINE_VERSION
);
2298 if (DWARF2_LINE_VERSION
>= 5)
2300 out_byte (sizeof_address
);
2301 out_byte (0); /* Segment Selector size. */
2303 /* Length of the prologue following this length. */
2304 prologue_start
= symbol_temp_make ();
2305 prologue_end
= symbol_temp_make ();
2306 exp
.X_op
= O_subtract
;
2307 exp
.X_add_symbol
= prologue_end
;
2308 exp
.X_op_symbol
= prologue_start
;
2309 exp
.X_add_number
= 0;
2310 emit_expr (&exp
, sizeof_offset
);
2311 symbol_set_value_now (prologue_start
);
2313 /* Parameters of the state machine. */
2314 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2315 if (DWARF2_LINE_VERSION
>= 4)
2316 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2317 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2318 out_byte (DWARF2_LINE_BASE
);
2319 out_byte (DWARF2_LINE_RANGE
);
2320 out_byte (DWARF2_LINE_OPCODE_BASE
);
2322 /* Standard opcode lengths. */
2323 out_byte (0); /* DW_LNS_copy */
2324 out_byte (1); /* DW_LNS_advance_pc */
2325 out_byte (1); /* DW_LNS_advance_line */
2326 out_byte (1); /* DW_LNS_set_file */
2327 out_byte (1); /* DW_LNS_set_column */
2328 out_byte (0); /* DW_LNS_negate_stmt */
2329 out_byte (0); /* DW_LNS_set_basic_block */
2330 out_byte (0); /* DW_LNS_const_add_pc */
2331 out_byte (1); /* DW_LNS_fixed_advance_pc */
2332 out_byte (0); /* DW_LNS_set_prologue_end */
2333 out_byte (0); /* DW_LNS_set_epilogue_begin */
2334 out_byte (1); /* DW_LNS_set_isa */
2335 /* We have emitted 12 opcode lengths, so make that this
2336 matches up to the opcode base value we have been using. */
2337 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2339 out_dir_and_file_list (line_seg
, sizeof_offset
);
2341 symbol_set_value_now (prologue_end
);
2343 /* For each section, emit a statement program. */
2344 for (s
= all_segs
; s
; s
= s
->next
)
2345 if (SEG_NORMAL (s
->seg
))
2346 process_entries (s
->seg
, s
->head
->head
);
2348 as_warn ("dwarf line number information for %s ignored",
2349 segment_name (s
->seg
));
2351 if (flag_dwarf_sections
)
2352 /* We have to switch to the special .debug_line_end section
2353 before emitting the end-of-debug_line symbol. The linker
2354 script arranges for this section to be placed after all the
2355 (potentially garbage collected) .debug_line.<foo> sections.
2356 This section contains the line_end symbol which is used to
2357 compute the size of the linked .debug_line section, as seen
2358 in the DWARF Line Number header. */
2359 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2361 symbol_set_value_now (line_end
);
2365 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2367 unsigned int addr_size
= sizeof_address
;
2372 memset (&exp
, 0, sizeof exp
);
2373 subseg_set (ranges_seg
, 0);
2375 /* For DW_AT_ranges to point at (there is no header, so really start
2376 of section, but see out_debug_rnglists). */
2377 *ranges_sym
= symbol_temp_new_now_octets ();
2379 /* Base Address Entry. */
2380 for (i
= 0; i
< addr_size
; i
++)
2382 for (i
= 0; i
< addr_size
; i
++)
2385 /* Range List Entry. */
2386 for (s
= all_segs
; s
; s
= s
->next
)
2391 frag
= first_frag_for_seg (s
->seg
);
2392 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2393 s
->text_start
= beg
;
2395 frag
= last_frag_for_seg (s
->seg
);
2396 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2399 exp
.X_op
= O_symbol
;
2400 exp
.X_add_symbol
= beg
;
2401 exp
.X_add_number
= 0;
2402 emit_expr (&exp
, addr_size
);
2404 exp
.X_op
= O_symbol
;
2405 exp
.X_add_symbol
= end
;
2406 exp
.X_add_number
= 0;
2407 emit_expr (&exp
, addr_size
);
2410 /* End of Range Entry. */
2411 for (i
= 0; i
< addr_size
; i
++)
2413 for (i
= 0; i
< addr_size
; i
++)
2418 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2421 symbolS
*ranges_end
;
2425 memset (&exp
, 0, sizeof exp
);
2426 out_header (ranges_seg
, &exp
);
2427 ranges_end
= exp
.X_add_symbol
;
2429 out_two (DWARF2_RNGLISTS_VERSION
);
2430 out_byte (sizeof_address
);
2431 out_byte (0); /* Segment Selector size. */
2432 out_four (0); /* Offset entry count. */
2434 /* For DW_AT_ranges to point at (must be after the header). */
2435 *ranges_sym
= symbol_temp_new_now_octets ();
2437 for (s
= all_segs
; s
; s
= s
->next
)
2442 out_byte (DW_RLE_start_length
);
2444 frag
= first_frag_for_seg (s
->seg
);
2445 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2446 s
->text_start
= beg
;
2448 frag
= last_frag_for_seg (s
->seg
);
2449 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2452 exp
.X_op
= O_symbol
;
2453 exp
.X_add_symbol
= beg
;
2454 exp
.X_add_number
= 0;
2455 emit_expr (&exp
, sizeof_address
);
2457 exp
.X_op
= O_symbol
;
2458 exp
.X_add_symbol
= end
;
2459 exp
.X_add_number
= 0;
2460 emit_leb128_expr (&exp
, 0);
2463 out_byte (DW_RLE_end_of_list
);
2465 symbol_set_value_now (ranges_end
);
2468 /* Emit data for .debug_aranges. */
2471 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2473 unsigned int addr_size
= sizeof_address
;
2477 symbolS
*aranges_end
;
2481 memset (&exp
, 0, sizeof exp
);
2482 sizeof_offset
= out_header (aranges_seg
, &exp
);
2483 aranges_end
= exp
.X_add_symbol
;
2484 size
= -exp
.X_add_number
;
2487 out_two (DWARF2_ARANGES_VERSION
);
2490 /* Offset to .debug_info. */
2491 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2492 size
+= sizeof_offset
;
2494 /* Size of an address (offset portion). */
2495 out_byte (addr_size
);
2498 /* Size of a segment descriptor. */
2502 /* Align the header. */
2503 while ((size
++ % (2 * addr_size
)) > 0)
2506 for (s
= all_segs
; s
; s
= s
->next
)
2511 frag
= first_frag_for_seg (s
->seg
);
2512 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2513 s
->text_start
= beg
;
2515 frag
= last_frag_for_seg (s
->seg
);
2516 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2519 exp
.X_op
= O_symbol
;
2520 exp
.X_add_symbol
= beg
;
2521 exp
.X_add_number
= 0;
2522 emit_expr (&exp
, addr_size
);
2524 exp
.X_op
= O_subtract
;
2525 exp
.X_add_symbol
= end
;
2526 exp
.X_op_symbol
= beg
;
2527 exp
.X_add_number
= 0;
2528 emit_expr (&exp
, addr_size
);
2531 p
= frag_more (2 * addr_size
);
2532 md_number_to_chars (p
, 0, addr_size
);
2533 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2535 symbol_set_value_now (aranges_end
);
2538 /* Emit data for .debug_abbrev. Note that this must be kept in
2539 sync with out_debug_info below. */
2542 out_debug_abbrev (segT abbrev_seg
,
2543 segT info_seg ATTRIBUTE_UNUSED
,
2544 segT line_seg ATTRIBUTE_UNUSED
)
2547 subseg_set (abbrev_seg
, 0);
2550 out_uleb128 (DW_TAG_compile_unit
);
2551 out_byte (DW_CHILDREN_no
);
2552 if (DWARF2_VERSION
< 4)
2554 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2555 secoff_form
= DW_FORM_data4
;
2557 secoff_form
= DW_FORM_data8
;
2560 secoff_form
= DW_FORM_sec_offset
;
2561 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2562 if (all_segs
->next
== NULL
)
2564 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2565 if (DWARF2_VERSION
< 4)
2566 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2568 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2571 out_abbrev (DW_AT_ranges
, secoff_form
);
2572 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2573 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2574 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2575 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2578 /* Terminate the abbreviations for this compilation unit. */
2582 /* Emit a description of this compilation unit for .debug_info. */
2585 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2586 symbolS
*ranges_sym
, symbolS
*name_sym
,
2587 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2593 memset (&exp
, 0, sizeof exp
);
2594 sizeof_offset
= out_header (info_seg
, &exp
);
2595 info_end
= exp
.X_add_symbol
;
2597 /* DWARF version. */
2598 out_two (DWARF2_VERSION
);
2600 if (DWARF2_VERSION
< 5)
2602 /* .debug_abbrev offset */
2603 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2607 /* unit (header) type */
2608 out_byte (DW_UT_compile
);
2611 /* Target address size. */
2612 out_byte (sizeof_address
);
2614 if (DWARF2_VERSION
>= 5)
2616 /* .debug_abbrev offset */
2617 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2620 /* DW_TAG_compile_unit DIE abbrev */
2623 /* DW_AT_stmt_list */
2624 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2625 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2628 /* These two attributes are emitted if all of the code is contiguous. */
2629 if (all_segs
->next
== NULL
)
2632 exp
.X_op
= O_symbol
;
2633 exp
.X_add_symbol
= all_segs
->text_start
;
2634 exp
.X_add_number
= 0;
2635 emit_expr (&exp
, sizeof_address
);
2638 if (DWARF2_VERSION
< 4)
2639 exp
.X_op
= O_symbol
;
2642 exp
.X_op
= O_subtract
;
2643 exp
.X_op_symbol
= all_segs
->text_start
;
2645 exp
.X_add_symbol
= all_segs
->text_end
;
2646 exp
.X_add_number
= 0;
2647 if (DWARF2_VERSION
< 4)
2648 emit_expr (&exp
, sizeof_address
);
2650 emit_leb128_expr (&exp
, 0);
2654 /* This attribute is emitted if the code is disjoint. */
2656 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2659 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2660 setup in out_debug_str below. */
2661 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2662 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2663 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2665 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2666 dwarf2 draft has no standard code for assembler. */
2667 out_two (DW_LANG_Mips_Assembler
);
2669 symbol_set_value_now (info_end
);
2672 /* Emit the three debug strings needed in .debug_str and setup symbols
2673 to them for use in out_debug_info. */
2675 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2676 symbolS
**producer_sym
)
2679 const char *comp_dir
;
2680 const char *dirname
;
2683 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2685 subseg_set (str_seg
, 0);
2687 /* DW_AT_name. We don't have the actual file name that was present
2688 on the command line, so assume files[first_file] is the main input file.
2689 We're not supposed to get called unless at least one line number
2690 entry was emitted, so this should always be defined. */
2691 *name_sym
= symbol_temp_new_now_octets ();
2692 if (files_in_use
== 0)
2694 if (files
[first_file
].dir
)
2696 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2697 len
= strlen (dirname
);
2699 /* Already has trailing slash. */
2700 p
= frag_more (len
);
2701 memcpy (p
, dirname
, len
);
2703 p
= frag_more (len
+ 1);
2704 memcpy (p
, dirname
, len
);
2705 INSERT_DIR_SEPARATOR (p
, len
);
2708 len
= strlen (files
[first_file
].filename
) + 1;
2709 p
= frag_more (len
);
2710 memcpy (p
, files
[first_file
].filename
, len
);
2712 /* DW_AT_comp_dir */
2713 *comp_dir_sym
= symbol_temp_new_now_octets ();
2714 comp_dir
= remap_debug_filename (getpwd ());
2715 len
= strlen (comp_dir
) + 1;
2716 p
= frag_more (len
);
2717 memcpy (p
, comp_dir
, len
);
2719 /* DW_AT_producer */
2720 *producer_sym
= symbol_temp_new_now_octets ();
2721 sprintf (producer
, "GNU AS %s", VERSION
);
2722 len
= strlen (producer
) + 1;
2723 p
= frag_more (len
);
2724 memcpy (p
, producer
, len
);
2730 last_seg_ptr
= &all_segs
;
2732 /* Select the default CIE version to produce here. The global
2733 starts with a value of -1 and will be modified to a valid value
2734 either by the user providing a command line option, or some
2735 targets will select their own default in md_after_parse_args. If
2736 we get here and the global still contains -1 then it is up to us
2737 to pick a sane default. The default we choose is 1, this is the
2738 CIE version gas has produced for a long time, and there seems no
2739 reason to change it yet. */
2740 if (flag_dwarf_cie_version
== -1)
2741 flag_dwarf_cie_version
= 1;
2745 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2746 were any .file/.loc directives, or --gdwarf2 was given, and if the
2747 file has a non-empty .debug_info section and an empty .debug_line
2748 section. If we emit .debug_line, and the .debug_info section is
2749 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2750 ALL_SEGS will be non-null if there were any .file/.loc directives,
2751 or --gdwarf2 was given and there were any located instructions
2755 dwarf2_finish (void)
2760 int emit_other_sections
= 0;
2761 int empty_debug_line
= 0;
2763 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2764 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2766 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2767 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2769 /* We can't construct a new debug_line section if we already have one.
2770 Give an error if we have seen any .loc, otherwise trust the user
2771 knows what they are doing and want to generate the .debug_line
2772 (and all other debug sections) themselves. */
2773 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2774 as_fatal ("duplicate .debug_line sections");
2776 if ((!all_segs
&& emit_other_sections
)
2777 || (!emit_other_sections
&& !empty_debug_line
))
2778 /* If there is no line information and no non-empty .debug_info
2779 section, or if there is both a non-empty .debug_info and a non-empty
2780 .debug_line, then we do nothing. */
2783 /* Calculate the size of an address for the target machine. */
2784 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2786 /* Create and switch to the line number section. */
2787 if (empty_debug_line
)
2789 line_seg
= subseg_new (".debug_line", 0);
2790 bfd_set_section_flags (line_seg
,
2791 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2794 /* For each subsection, chain the debug entries together. */
2795 for (s
= all_segs
; s
; s
= s
->next
)
2797 struct line_subseg
*lss
= s
->head
;
2798 struct line_entry
**ptail
= lss
->ptail
;
2800 /* Reset the initial view of the first subsection of the
2802 if (lss
->head
&& lss
->head
->loc
.view
)
2803 set_or_check_view (lss
->head
, NULL
, NULL
);
2805 while ((lss
= lss
->next
) != NULL
)
2807 /* Link the first view of subsequent subsections to the
2809 if (lss
->head
&& lss
->head
->loc
.view
)
2810 set_or_check_view (lss
->head
,
2811 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2812 s
->head
? s
->head
->head
: NULL
);
2818 if (empty_debug_line
)
2819 out_debug_line (line_seg
);
2821 /* If this is assembler generated line info, and there is no
2822 debug_info already, we need .debug_info, .debug_abbrev and
2823 .debug_str sections as well. */
2824 if (emit_other_sections
)
2829 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2831 gas_assert (all_segs
);
2833 info_seg
= subseg_new (".debug_info", 0);
2834 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2835 aranges_seg
= subseg_new (".debug_aranges", 0);
2836 str_seg
= subseg_new (".debug_str", 0);
2838 bfd_set_section_flags (info_seg
,
2839 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2840 bfd_set_section_flags (abbrev_seg
,
2841 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2842 bfd_set_section_flags (aranges_seg
,
2843 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2844 bfd_set_section_flags (str_seg
,
2845 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2846 | SEC_MERGE
| SEC_STRINGS
);
2847 str_seg
->entsize
= 1;
2849 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2851 if (all_segs
->next
== NULL
)
2855 if (DWARF2_VERSION
< 5)
2857 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2858 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2861 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2862 out_debug_ranges (ranges_seg
, &ranges_sym
);
2866 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2867 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2870 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2874 out_debug_aranges (aranges_seg
, info_seg
);
2875 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2876 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2877 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2878 name_sym
, comp_dir_sym
, producer_sym
);
2882 /* Perform any deferred checks pertaining to debug information. */
2885 dwarf2dbg_final_check (void)
2887 /* Perform reset-view checks. Don't evaluate view_assert_failed
2888 recursively: it could be very deep. It's a chain of adds, with
2889 each chain element pointing to the next in X_add_symbol, and
2890 holding the check value in X_op_symbol. */
2891 while (view_assert_failed
)
2897 gas_assert (!symbol_resolved_p (view_assert_failed
));
2899 exp
= symbol_get_value_expression (view_assert_failed
);
2900 sym
= view_assert_failed
;
2902 /* If view_assert_failed looks like a compound check in the
2903 chain, break it up. */
2904 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2906 view_assert_failed
= exp
->X_add_symbol
;
2907 sym
= exp
->X_op_symbol
;
2910 view_assert_failed
= NULL
;
2912 failed
= resolve_symbol_value (sym
);
2913 if (!symbol_resolved_p (sym
) || failed
)
2915 as_bad (_("view number mismatch"));