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)
109 /* Since we can't generate the prolog until the body is complete, we
110 use three different subsegments for .debug_line: one holding the
111 prolog, one for the directory and filename info, and one for the
112 body ("statement program"). */
117 /* If linker relaxation might change offsets in the code, the DWARF special
118 opcodes and variable-length operands cannot be used. If this macro is
119 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
120 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
121 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
124 /* First special line opcode - leave room for the standard opcodes.
125 Note: If you want to change this, you'll have to update the
126 "standard_opcode_lengths" table that is emitted below in
128 #define DWARF2_LINE_OPCODE_BASE 13
130 #ifndef DWARF2_LINE_BASE
131 /* Minimum line offset in a special line info. opcode. This value
132 was chosen to give a reasonable range of values. */
133 # define DWARF2_LINE_BASE -5
136 /* Range of line offsets in a special line info. opcode. */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE 14
141 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
142 /* Define the architecture-dependent minimum instruction length (in
143 bytes). This value should be rather too small than too big. */
144 # define DWARF2_LINE_MIN_INSN_LENGTH 1
147 /* Flag that indicates the initial value of the is_stmt_start flag. */
148 #define DWARF2_LINE_DEFAULT_IS_STMT 1
150 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
151 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
154 /* Given a special op, return the line skip amount. */
155 #define SPECIAL_LINE(op) \
156 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
158 /* Given a special op, return the address skip amount (in units of
159 DWARF2_LINE_MIN_INSN_LENGTH. */
160 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
162 /* The maximum address skip amount that can be encoded with a special op. */
163 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
165 #ifndef TC_PARSE_CONS_RETURN_NONE
166 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
171 struct line_entry
*next
;
173 struct dwarf2_line_info loc
;
176 /* Don't change the offset of next in line_entry. set_or_check_view
177 calls in dwarf2_gen_line_info_1 depend on it. */
178 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
183 struct line_subseg
*next
;
185 struct line_entry
*head
;
186 struct line_entry
**ptail
;
187 struct line_entry
**pmove_tail
;
192 struct line_seg
*next
;
194 struct line_subseg
*head
;
199 /* Collects data for all line table entries during assembly. */
200 static struct line_seg
*all_segs
;
201 static struct line_seg
**last_seg_ptr
;
203 #define NUM_MD5_BYTES 16
207 const char * filename
;
209 bfd_boolean auto_assigned
;
210 unsigned char md5
[NUM_MD5_BYTES
];
213 /* Table of files used by .debug_line. */
214 static struct file_entry
*files
;
215 static unsigned int files_in_use
;
216 static unsigned int files_allocated
;
218 /* Table of directories used by .debug_line. */
219 static char ** dirs
= NULL
;
220 static unsigned int dirs_in_use
= 0;
221 static unsigned int dirs_allocated
= 0;
223 /* TRUE when we've seen a .loc directive recently. Used to avoid
224 doing work when there's nothing to do. */
225 bfd_boolean dwarf2_loc_directive_seen
;
227 /* TRUE when we're supposed to set the basic block mark whenever a
229 bfd_boolean dwarf2_loc_mark_labels
;
231 /* Current location as indicated by the most recent .loc directive. */
232 static struct dwarf2_line_info current
=
235 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
239 /* This symbol is used to recognize view number forced resets in loc
241 static symbolS
*force_reset_view
;
243 /* This symbol evaluates to an expression that, if nonzero, indicates
244 some view assert check failed. */
245 static symbolS
*view_assert_failed
;
247 /* The size of an address on the target. */
248 static unsigned int sizeof_address
;
250 #ifndef TC_DWARF2_EMIT_OFFSET
251 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
253 /* Create an offset to .dwarf2_*. */
256 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
260 memset (&exp
, 0, sizeof exp
);
262 exp
.X_add_symbol
= symbol
;
263 exp
.X_add_number
= 0;
264 emit_expr (&exp
, size
);
268 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
270 static struct line_subseg
*
271 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
273 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
274 struct line_subseg
**pss
, *lss
;
281 s
= XNEW (struct line_seg
);
286 last_seg_ptr
= &s
->next
;
287 seg_info (seg
)->dwarf2_line_seg
= s
;
290 gas_assert (seg
== s
->seg
);
292 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
294 if (lss
->subseg
== subseg
)
296 if (lss
->subseg
> subseg
)
300 lss
= XNEW (struct line_subseg
);
302 lss
->subseg
= subseg
;
304 lss
->ptail
= &lss
->head
;
305 lss
->pmove_tail
= &lss
->head
;
312 /* (Un)reverse the line_entry list starting from H. */
314 static struct line_entry
*
315 reverse_line_entry_list (struct line_entry
*h
)
317 struct line_entry
*p
= NULL
, *e
, *n
;
319 for (e
= h
; e
; e
= n
)
328 /* Compute the view for E based on the previous entry P. If we
329 introduce an (undefined) view symbol for P, and H is given (P must
330 be the tail in this case), introduce view symbols for earlier list
331 entries as well, until one of them is constant. */
334 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
335 struct line_entry
*h
)
339 memset (&viewx
, 0, sizeof (viewx
));
340 viewx
.X_unsigned
= 1;
342 /* First, compute !(E->label > P->label), to tell whether or not
343 we're to reset the view number. If we can't resolve it to a
344 constant, keep it symbolic. */
345 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
347 viewx
.X_op
= O_constant
;
348 viewx
.X_add_number
= 0;
349 viewx
.X_add_symbol
= NULL
;
350 viewx
.X_op_symbol
= NULL
;
355 viewx
.X_add_number
= 0;
356 viewx
.X_add_symbol
= e
->label
;
357 viewx
.X_op_symbol
= p
->label
;
358 resolve_expression (&viewx
);
359 if (viewx
.X_op
== O_constant
)
360 viewx
.X_add_number
= !viewx
.X_add_number
;
363 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
364 viewx
.X_add_number
= 0;
365 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_op
= O_logical_not
;
370 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
372 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
373 /* We can't compare the view numbers at this point, because in
374 VIEWX we've only determined whether we're to reset it so
376 if (viewx
.X_op
== O_constant
)
378 if (!value
->X_add_number
!= !viewx
.X_add_number
)
379 as_bad (_("view number mismatch"));
381 /* Record the expression to check it later. It is the result of
382 a logical not, thus 0 or 1. We just add up all such deferred
383 expressions, and resolve it at the end. */
384 else if (!value
->X_add_number
)
386 symbolS
*deferred
= make_expr_symbol (&viewx
);
387 if (view_assert_failed
)
391 memset (&chk
, 0, sizeof (chk
));
394 chk
.X_add_number
= 0;
395 chk
.X_add_symbol
= view_assert_failed
;
396 chk
.X_op_symbol
= deferred
;
397 deferred
= make_expr_symbol (&chk
);
399 view_assert_failed
= deferred
;
403 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
409 p
->loc
.view
= symbol_temp_make ();
410 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
413 memset (&incv
, 0, sizeof (incv
));
415 incv
.X_op
= O_symbol
;
416 incv
.X_add_symbol
= p
->loc
.view
;
417 incv
.X_add_number
= 1;
419 if (viewx
.X_op
== O_constant
)
421 gas_assert (viewx
.X_add_number
== 1);
426 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
427 viewx
.X_add_number
= 0;
428 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
429 viewx
.X_op
= O_multiply
;
433 if (!S_IS_DEFINED (e
->loc
.view
))
435 symbol_set_value_expression (e
->loc
.view
, &viewx
);
436 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
437 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
440 /* Define and attempt to simplify any earlier views needed to
442 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
444 struct line_entry
*h2
;
445 /* Reverse the list to avoid quadratic behavior going backwards
446 in a single-linked list. */
447 struct line_entry
*r
= reverse_line_entry_list (h
);
450 /* Set or check views until we find a defined or absent view. */
453 /* Do not define the head of a (sub?)segment view while
454 handling others. It would be defined too early, without
455 regard to the last view of other subsegments.
456 set_or_check_view will be called for every head segment
460 set_or_check_view (r
, r
->next
, NULL
);
462 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
465 /* Unreverse the list, so that we can go forward again. */
466 h2
= reverse_line_entry_list (p
);
467 gas_assert (h2
== h
);
469 /* Starting from the last view we just defined, attempt to
470 simplify the view expressions, until we do so to P. */
473 /* The head view of a subsegment may remain undefined while
474 handling other elements, before it is linked to the last
475 view of the previous subsegment. */
478 gas_assert (S_IS_DEFINED (r
->loc
.view
));
479 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
481 while (r
!= p
&& (r
= r
->next
));
483 /* Now that we've defined and computed all earlier views that might
484 be needed to compute E's, attempt to simplify it. */
485 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
489 /* Record an entry for LOC occurring at LABEL. */
492 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
494 struct line_subseg
*lss
;
495 struct line_entry
*e
;
497 e
= XNEW (struct line_entry
);
502 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
504 /* Subseg heads are chained to previous subsegs in
506 if (loc
->view
&& lss
->head
)
507 set_or_check_view (e
,
508 (struct line_entry
*)lss
->ptail
,
512 lss
->ptail
= &e
->next
;
515 /* Record an entry for LOC occurring at OFS within the current fragment. */
518 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
520 static unsigned int line
= -1;
521 static unsigned int filenum
= -1;
525 /* Early out for as-yet incomplete location information. */
528 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
531 /* Don't emit sequences of line symbols for the same line when the
532 symbols apply to assembler code. It is necessary to emit
533 duplicate line symbols when a compiler asks for them, because GDB
534 uses them to determine the end of the prologue. */
535 if (debug_type
== DEBUG_DWARF2
536 && line
== loc
->line
&& filenum
== loc
->filenum
)
540 filenum
= loc
->filenum
;
546 /* Use a non-fake name for the line number location,
547 so that it can be referred to by relocations. */
548 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
549 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
552 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
553 dwarf2_gen_line_info_1 (sym
, loc
);
557 get_basename (const char * pathname
)
561 file
= lbasename (pathname
);
562 /* Don't make empty string from / or A: from A:/ . */
563 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
564 if (file
<= pathname
+ 3)
567 if (file
== pathname
+ 1)
574 get_directory_table_entry (const char * dirname
,
576 bfd_boolean can_use_zero
)
583 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
584 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
592 for (d
= 0; d
< dirs_in_use
; ++d
)
595 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
596 && dirs
[d
][dirlen
] == '\0')
602 if (dirs
== NULL
|| dirs
[0] == NULL
)
608 if (d
>= dirs_allocated
)
610 unsigned int old
= dirs_allocated
;
612 dirs_allocated
= d
+ 32;
613 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
614 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
617 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
618 if (dirs_in_use
<= d
)
625 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
, bfd_boolean auto_assign
)
627 if (i
>= files_allocated
)
629 unsigned int old
= files_allocated
;
631 files_allocated
= i
+ 32;
632 /* Catch wraparound. */
633 if (files_allocated
<= old
)
635 as_bad (_("file number %lu is too big"), (unsigned long) i
);
639 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
640 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
643 files
[i
].filename
= file
;
645 files
[i
].auto_assigned
= auto_assign
;
646 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
648 if (files_in_use
< i
+ 1)
649 files_in_use
= i
+ 1;
654 /* Get a .debug_line file number for PATHNAME. If there is a
655 directory component to PATHNAME, then this will be stored
656 in the directory table, if it is not already present.
657 Returns the slot number allocated to that filename or -1
658 if there was a problem. */
661 allocate_filenum (const char * pathname
)
663 static signed int last_used
= -1, last_used_dir_len
= 0;
668 /* Short circuit the common case of adding the same pathname
672 const char * dirname
= NULL
;
675 dirname
= dirs
[files
[last_used
].dir
];
679 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
684 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
685 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
686 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
687 files
[last_used
].filename
) == 0)
692 file
= get_basename (pathname
);
693 dir_len
= file
- pathname
;
695 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
697 /* Do not use slot-0. That is specifically reserved for use by
698 the '.file 0 "name"' directive. */
699 for (i
= 1; i
< files_in_use
; ++i
)
700 if (files
[i
].dir
== dir
702 && filename_cmp (file
, files
[i
].filename
) == 0)
705 last_used_dir_len
= dir_len
;
709 if (!assign_file_to_slot (i
, file
, dir
, TRUE
))
713 last_used_dir_len
= dir_len
;
718 /* Allocate slot NUM in the .debug_line file table to FILENAME.
719 If DIRNAME is not NULL or there is a directory component to FILENAME
720 then this will be stored in the directory table, if not already present.
721 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
722 Returns TRUE if allocation succeeded, FALSE otherwise. */
725 allocate_filename_to_slot (const char * dirname
,
726 const char * filename
,
728 bfd_boolean with_md5
)
734 /* Short circuit the common case of adding the same pathname
736 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
738 const char * dir
= NULL
;
741 dir
= dirs
[files
[num
].dir
];
744 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
749 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
752 if (filename_cmp (filename
, files
[num
].filename
) != 0)
755 /* If the filenames match, but the directory table entry was
756 empty, then fill it with the provided directory name. */
758 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
762 else if (dir
!= NULL
)
764 dirlen
= strlen (dir
);
765 if (filename_ncmp (filename
, dir
, dirlen
) == 0
766 && IS_DIR_SEPARATOR (filename
[dirlen
])
767 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
770 else /* dir == NULL */
772 file
= get_basename (filename
);
773 if (filename_cmp (file
, files
[num
].filename
) == 0)
776 /* The filenames match, but the directory table entry is empty.
777 Fill it with the provided directory name. */
778 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
784 /* If NUM was previously allocated automatically then
785 choose another slot for it, so that we can reuse NUM. */
786 if (files
[num
].auto_assigned
)
788 /* Find an unused slot. */
789 for (i
= 1; i
< files_in_use
; ++i
)
790 if (files
[i
].filename
== NULL
)
792 if (! assign_file_to_slot (i
, files
[num
].filename
, files
[num
].dir
, TRUE
))
794 files
[num
].filename
= NULL
;
798 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
800 dir
== NULL
? "" : dir
,
801 dir
== NULL
? "" : "/",
803 dirname
== NULL
? "" : dirname
,
804 dirname
== NULL
? "" : "/",
813 file
= get_basename (filename
);
814 dirlen
= file
- filename
;
818 dirlen
= strlen (dirname
);
822 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
825 if (! assign_file_to_slot (i
, file
, d
, FALSE
))
830 if (target_big_endian
)
832 /* md5's are stored in litte endian format. */
833 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
834 unsigned int byte
= NUM_MD5_BYTES
;
835 unsigned int bignum_index
= 0;
837 while (bits_remaining
)
839 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
840 valueT bignum_value
= generic_bignum
[bignum_index
];
843 while (bignum_bits_remaining
)
845 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
847 bignum_bits_remaining
-= 8;
854 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
855 unsigned int byte
= 0;
856 unsigned int bignum_index
= 0;
858 while (bits_remaining
)
860 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
861 valueT bignum_value
= generic_bignum
[bignum_index
];
865 while (bignum_bits_remaining
)
867 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
869 bignum_bits_remaining
-= 8;
876 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
881 /* Returns the current source information. If .file directives have
882 been encountered, the info for the corresponding source file is
883 returned. Otherwise, the info for the assembly source file is
887 dwarf2_where (struct dwarf2_line_info
*line
)
889 if (debug_type
== DEBUG_DWARF2
)
891 const char *filename
;
893 memset (line
, 0, sizeof (*line
));
894 filename
= as_where (&line
->line
);
895 line
->filenum
= allocate_filenum (filename
);
896 /* FIXME: We should check the return value from allocate_filenum. */
898 line
->flags
= DWARF2_FLAG_IS_STMT
;
899 line
->isa
= current
.isa
;
900 line
->discriminator
= current
.discriminator
;
907 /* A hook to allow the target backend to inform the line number state
908 machine of isa changes when assembler debug info is enabled. */
911 dwarf2_set_isa (unsigned int isa
)
916 /* Called for each machine instruction, or relatively atomic group of
917 machine instructions (ie built-in macro). The instruction or group
918 is SIZE bytes in length. If dwarf2 line number generation is called
919 for, emit a line statement appropriately. */
922 dwarf2_emit_insn (int size
)
924 struct dwarf2_line_info loc
;
926 if (debug_type
!= DEBUG_DWARF2
927 ? !dwarf2_loc_directive_seen
928 : !seen_at_least_1_file ())
933 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
934 dwarf2_consume_line_info ();
937 /* Move all previously-emitted line entries for the current position by
938 DELTA bytes. This function cannot be used to move the same entries
942 dwarf2_move_insn (int delta
)
944 struct line_subseg
*lss
;
945 struct line_entry
*e
;
951 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
955 now
= frag_now_fix ();
956 while ((e
= *lss
->pmove_tail
))
958 if (S_GET_VALUE (e
->label
) == now
)
959 S_SET_VALUE (e
->label
, now
+ delta
);
960 lss
->pmove_tail
= &e
->next
;
964 /* Called after the current line information has been either used with
965 dwarf2_gen_line_info or saved with a machine instruction for later use.
966 This resets the state of the line number information to reflect that
970 dwarf2_consume_line_info (void)
972 /* Unless we generate DWARF2 debugging information for each
973 assembler line, we only emit one line symbol for one LOC. */
974 dwarf2_loc_directive_seen
= FALSE
;
976 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
977 | DWARF2_FLAG_PROLOGUE_END
978 | DWARF2_FLAG_EPILOGUE_BEGIN
);
979 current
.discriminator
= 0;
983 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
984 is enabled, emit a basic block marker. */
987 dwarf2_emit_label (symbolS
*label
)
989 struct dwarf2_line_info loc
;
991 if (!dwarf2_loc_mark_labels
)
993 if (S_GET_SEGMENT (label
) != now_seg
)
995 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
997 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1000 dwarf2_where (&loc
);
1002 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1004 dwarf2_gen_line_info_1 (label
, &loc
);
1005 dwarf2_consume_line_info ();
1008 /* Handle two forms of .file directive:
1009 - Pass .file "source.c" to s_app_file
1010 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1012 If an entry is added to the file table, return a pointer to the filename. */
1015 dwarf2_directive_filename (void)
1017 bfd_boolean with_md5
= TRUE
;
1020 const char * dirname
= NULL
;
1023 /* Continue to accept a bare string and pass it off. */
1025 if (*input_line_pointer
== '"')
1031 num
= get_absolute_expression ();
1033 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1035 as_bad (_("file number less than one"));
1036 ignore_rest_of_line ();
1040 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1041 "switch back to the already allocated file <N> as the current
1044 filename
= demand_copy_C_string (&filename_len
);
1045 if (filename
== NULL
)
1046 /* demand_copy_C_string will have already generated an error message. */
1049 /* For DWARF-5 support we also accept:
1050 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1051 if (DWARF2_LINE_VERSION
> 4)
1054 if (*input_line_pointer
== '"')
1057 filename
= demand_copy_C_string (&filename_len
);
1061 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1063 input_line_pointer
+= 3;
1067 expression_and_evaluate (& exp
);
1068 if (exp
.X_op
!= O_big
)
1069 as_bad (_("md5 value too small or not a constant"));
1075 demand_empty_rest_of_line ();
1077 /* A .file directive implies compiler generated debug information is
1078 being supplied. Turn off gas generated debug info. */
1079 debug_type
= DEBUG_NONE
;
1081 if (num
!= (unsigned int) num
1082 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1084 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1088 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1095 /* Calls dwarf2_directive_filename, but discards its result.
1096 Used in pseudo-op tables where the function result is ignored. */
1099 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1101 (void) dwarf2_directive_filename ();
1105 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1107 offsetT filenum
, line
;
1109 /* If we see two .loc directives in a row, force the first one to be
1111 if (dwarf2_loc_directive_seen
)
1112 dwarf2_emit_insn (0);
1114 filenum
= get_absolute_expression ();
1116 line
= get_absolute_expression ();
1120 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1122 as_bad (_("file number less than one"));
1127 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1129 as_bad (_("unassigned file number %ld"), (long) filenum
);
1133 current
.filenum
= filenum
;
1134 current
.line
= line
;
1135 current
.discriminator
= 0;
1140 if (files
[filenum
].dir
)
1142 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1143 size_t file_len
= strlen (files
[filenum
].filename
);
1144 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1146 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1147 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1148 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1149 cp
[dir_len
+ file_len
+ 1] = '\0';
1150 listing_source_file (cp
);
1154 listing_source_file (files
[filenum
].filename
);
1155 listing_source_line (line
);
1160 if (ISDIGIT (*input_line_pointer
))
1162 current
.column
= get_absolute_expression ();
1166 while (ISALPHA (*input_line_pointer
))
1171 c
= get_symbol_name (& p
);
1173 if (strcmp (p
, "basic_block") == 0)
1175 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1176 *input_line_pointer
= c
;
1178 else if (strcmp (p
, "prologue_end") == 0)
1180 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1181 *input_line_pointer
= c
;
1183 else if (strcmp (p
, "epilogue_begin") == 0)
1185 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1186 *input_line_pointer
= c
;
1188 else if (strcmp (p
, "is_stmt") == 0)
1190 (void) restore_line_pointer (c
);
1191 value
= get_absolute_expression ();
1193 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1194 else if (value
== 1)
1195 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1198 as_bad (_("is_stmt value not 0 or 1"));
1202 else if (strcmp (p
, "isa") == 0)
1204 (void) restore_line_pointer (c
);
1205 value
= get_absolute_expression ();
1207 current
.isa
= value
;
1210 as_bad (_("isa number less than zero"));
1214 else if (strcmp (p
, "discriminator") == 0)
1216 (void) restore_line_pointer (c
);
1217 value
= get_absolute_expression ();
1219 current
.discriminator
= value
;
1222 as_bad (_("discriminator less than zero"));
1226 else if (strcmp (p
, "view") == 0)
1230 (void) restore_line_pointer (c
);
1233 if (ISDIGIT (*input_line_pointer
)
1234 || *input_line_pointer
== '-')
1236 bfd_boolean force_reset
= *input_line_pointer
== '-';
1238 value
= get_absolute_expression ();
1241 as_bad (_("numeric view can only be asserted to zero"));
1244 if (force_reset
&& force_reset_view
)
1245 sym
= force_reset_view
;
1248 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1251 force_reset_view
= sym
;
1256 char *name
= read_symbol_name ();
1260 sym
= symbol_find_or_make (name
);
1261 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1263 if (S_IS_VOLATILE (sym
))
1264 sym
= symbol_clone (sym
, 1);
1265 else if (!S_CAN_BE_REDEFINED (sym
))
1267 as_bad (_("symbol `%s' is already defined"), name
);
1271 S_SET_SEGMENT (sym
, undefined_section
);
1272 S_SET_VALUE (sym
, 0);
1273 symbol_set_frag (sym
, &zero_address_frag
);
1279 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1280 (void) restore_line_pointer (c
);
1284 SKIP_WHITESPACE_AFTER_NAME ();
1287 demand_empty_rest_of_line ();
1288 dwarf2_loc_directive_seen
= TRUE
;
1289 debug_type
= DEBUG_NONE
;
1291 /* If we were given a view id, emit the row right away. */
1293 dwarf2_emit_insn (0);
1297 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1299 offsetT value
= get_absolute_expression ();
1301 if (value
!= 0 && value
!= 1)
1303 as_bad (_("expected 0 or 1"));
1304 ignore_rest_of_line ();
1308 dwarf2_loc_mark_labels
= value
!= 0;
1309 demand_empty_rest_of_line ();
1313 static struct frag
*
1314 first_frag_for_seg (segT seg
)
1316 return seg_info (seg
)->frchainP
->frch_root
;
1319 static struct frag
*
1320 last_frag_for_seg (segT seg
)
1322 frchainS
*f
= seg_info (seg
)->frchainP
;
1324 while (f
->frch_next
!= NULL
)
1327 return f
->frch_last
;
1330 /* Emit a single byte into the current segment. */
1335 FRAG_APPEND_1_CHAR (byte
);
1338 /* Emit a statement program opcode into the current segment. */
1341 out_opcode (int opc
)
1346 /* Emit a two-byte word into the current segment. */
1351 md_number_to_chars (frag_more (2), data
, 2);
1354 /* Emit a four byte word into the current segment. */
1359 md_number_to_chars (frag_more (4), data
, 4);
1362 /* Emit an unsigned "little-endian base 128" number. */
1365 out_uleb128 (addressT value
)
1367 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1370 /* Emit a signed "little-endian base 128" number. */
1373 out_leb128 (addressT value
)
1375 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1378 /* Emit a tuple for .debug_abbrev. */
1381 out_abbrev (int name
, int form
)
1387 /* Get the size of a fragment. */
1390 get_frag_fix (fragS
*frag
, segT seg
)
1395 return frag
->fr_fix
;
1397 /* If a fragment is the last in the chain, special measures must be
1398 taken to find its size before relaxation, since it may be pending
1399 on some subsegment chain. */
1400 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1401 if (fr
->frch_last
== frag
)
1402 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1407 /* Set an absolute address (may result in a relocation entry). */
1410 out_set_addr (symbolS
*sym
)
1414 memset (&exp
, 0, sizeof exp
);
1415 out_opcode (DW_LNS_extended_op
);
1416 out_uleb128 (sizeof_address
+ 1);
1418 out_opcode (DW_LNE_set_address
);
1419 exp
.X_op
= O_symbol
;
1420 exp
.X_add_symbol
= sym
;
1421 exp
.X_add_number
= 0;
1422 emit_expr (&exp
, sizeof_address
);
1425 static void scale_addr_delta (addressT
*);
1428 scale_addr_delta (addressT
*addr_delta
)
1430 static int printed_this
= 0;
1431 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1433 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1435 as_bad("unaligned opcodes detected in executable segment");
1438 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1442 /* Encode a pair of line and address skips as efficiently as possible.
1443 Note that the line skip is signed, whereas the address skip is unsigned.
1445 The following two routines *must* be kept in sync. This is
1446 enforced by making emit_inc_line_addr abort if we do not emit
1447 exactly the expected number of bytes. */
1450 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1452 unsigned int tmp
, opcode
;
1455 /* Scale the address delta by the minimum instruction length. */
1456 scale_addr_delta (&addr_delta
);
1458 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1459 We cannot use special opcodes here, since we want the end_sequence
1460 to emit the matrix entry. */
1461 if (line_delta
== INT_MAX
)
1463 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1465 else if (addr_delta
)
1466 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1470 /* Bias the line delta by the base. */
1471 tmp
= line_delta
- DWARF2_LINE_BASE
;
1473 /* If the line increment is out of range of a special opcode, we
1474 must encode it with DW_LNS_advance_line. */
1475 if (tmp
>= DWARF2_LINE_RANGE
)
1477 len
= 1 + sizeof_leb128 (line_delta
, 1);
1479 tmp
= 0 - DWARF2_LINE_BASE
;
1482 /* Bias the opcode by the special opcode base. */
1483 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1485 /* Avoid overflow when addr_delta is large. */
1486 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1488 /* Try using a special opcode. */
1489 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1493 /* Try using DW_LNS_const_add_pc followed by special op. */
1494 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1499 /* Otherwise use DW_LNS_advance_pc. */
1500 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1502 /* DW_LNS_copy or special opcode. */
1509 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1511 unsigned int tmp
, opcode
;
1513 char *end
= p
+ len
;
1515 /* Line number sequences cannot go backward in addresses. This means
1516 we've incorrectly ordered the statements in the sequence. */
1517 gas_assert ((offsetT
) addr_delta
>= 0);
1519 /* Scale the address delta by the minimum instruction length. */
1520 scale_addr_delta (&addr_delta
);
1522 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1523 We cannot use special opcodes here, since we want the end_sequence
1524 to emit the matrix entry. */
1525 if (line_delta
== INT_MAX
)
1527 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1528 *p
++ = DW_LNS_const_add_pc
;
1529 else if (addr_delta
)
1531 *p
++ = DW_LNS_advance_pc
;
1532 p
+= output_leb128 (p
, addr_delta
, 0);
1535 *p
++ = DW_LNS_extended_op
;
1537 *p
++ = DW_LNE_end_sequence
;
1541 /* Bias the line delta by the base. */
1542 tmp
= line_delta
- DWARF2_LINE_BASE
;
1544 /* If the line increment is out of range of a special opcode, we
1545 must encode it with DW_LNS_advance_line. */
1546 if (tmp
>= DWARF2_LINE_RANGE
)
1548 *p
++ = DW_LNS_advance_line
;
1549 p
+= output_leb128 (p
, line_delta
, 1);
1552 tmp
= 0 - DWARF2_LINE_BASE
;
1556 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1558 if (line_delta
== 0 && addr_delta
== 0)
1564 /* Bias the opcode by the special opcode base. */
1565 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1567 /* Avoid overflow when addr_delta is large. */
1568 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1570 /* Try using a special opcode. */
1571 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1578 /* Try using DW_LNS_const_add_pc followed by special op. */
1579 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1582 *p
++ = DW_LNS_const_add_pc
;
1588 /* Otherwise use DW_LNS_advance_pc. */
1589 *p
++ = DW_LNS_advance_pc
;
1590 p
+= output_leb128 (p
, addr_delta
, 0);
1598 gas_assert (p
== end
);
1601 /* Handy routine to combine calls to the above two routines. */
1604 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1606 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1607 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1610 /* Write out an alternative form of line and address skips using
1611 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1612 line and address information, but it is required if linker relaxation
1613 could change the code offsets. The following two routines *must* be
1615 #define ADDR_DELTA_LIMIT 50000
1618 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1622 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1623 if (line_delta
!= INT_MAX
)
1624 len
= 1 + sizeof_leb128 (line_delta
, 1);
1626 if (addr_delta
> ADDR_DELTA_LIMIT
)
1628 /* DW_LNS_extended_op */
1629 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1630 /* DW_LNE_set_address */
1631 len
+= 1 + sizeof_address
;
1634 /* DW_LNS_fixed_advance_pc */
1637 if (line_delta
== INT_MAX
)
1638 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1648 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1652 char *end
= p
+ len
;
1654 /* Line number sequences cannot go backward in addresses. This means
1655 we've incorrectly ordered the statements in the sequence. */
1656 gas_assert ((offsetT
) addr_delta
>= 0);
1658 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1659 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1661 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1662 if (line_delta
!= INT_MAX
)
1664 *p
++ = DW_LNS_advance_line
;
1665 p
+= output_leb128 (p
, line_delta
, 1);
1668 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1670 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1671 advance the address by at most 64K. Linker relaxation (without
1672 which this function would not be used) could change the operand by
1673 an unknown amount. If the address increment is getting close to
1674 the limit, just reset the address. */
1675 if (addr_delta
> ADDR_DELTA_LIMIT
)
1680 memset (&exp
, 0, sizeof exp
);
1681 gas_assert (pexp
->X_op
== O_subtract
);
1682 to_sym
= pexp
->X_add_symbol
;
1684 *p
++ = DW_LNS_extended_op
;
1685 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1686 *p
++ = DW_LNE_set_address
;
1687 exp
.X_op
= O_symbol
;
1688 exp
.X_add_symbol
= to_sym
;
1689 exp
.X_add_number
= 0;
1690 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1691 p
+= sizeof_address
;
1695 *p
++ = DW_LNS_fixed_advance_pc
;
1696 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1700 if (line_delta
== INT_MAX
)
1702 *p
++ = DW_LNS_extended_op
;
1704 *p
++ = DW_LNE_end_sequence
;
1709 gas_assert (p
== end
);
1712 /* Generate a variant frag that we can use to relax address/line
1713 increments between fragments of the target segment. */
1716 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1721 memset (&exp
, 0, sizeof exp
);
1722 exp
.X_op
= O_subtract
;
1723 exp
.X_add_symbol
= to_sym
;
1724 exp
.X_op_symbol
= from_sym
;
1725 exp
.X_add_number
= 0;
1727 /* The maximum size of the frag is the line delta with a maximum
1728 sized address delta. */
1729 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1730 max_chars
= size_fixed_inc_line_addr (line_delta
,
1731 -DWARF2_LINE_MIN_INSN_LENGTH
);
1733 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1735 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1736 make_expr_symbol (&exp
), line_delta
, NULL
);
1739 /* The function estimates the size of a rs_dwarf2dbg variant frag
1740 based on the current values of the symbols. It is called before
1741 the relaxation loop. We set fr_subtype to the expected length. */
1744 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1749 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1750 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1751 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1753 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1755 frag
->fr_subtype
= size
;
1760 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1761 current values of the symbols. fr_subtype is the current length
1762 of the frag. This returns the change in frag length. */
1765 dwarf2dbg_relax_frag (fragS
*frag
)
1767 int old_size
, new_size
;
1769 old_size
= frag
->fr_subtype
;
1770 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1772 return new_size
- old_size
;
1775 /* This function converts a rs_dwarf2dbg variant frag into a normal
1776 fill frag. This is called after all relaxation has been done.
1777 fr_subtype will be the desired length of the frag. */
1780 dwarf2dbg_convert_frag (fragS
*frag
)
1784 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1786 /* If linker relaxation is enabled then the distance between the two
1787 symbols in the frag->fr_symbol expression might change. Hence we
1788 cannot rely upon the value computed by resolve_symbol_value.
1789 Instead we leave the expression unfinalized and allow
1790 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1791 relocation) that will allow the linker to correctly compute the
1792 actual address difference. We have to use a fixed line advance for
1793 this as we cannot (easily) relocate leb128 encoded values. */
1794 int saved_finalize_syms
= finalize_syms
;
1797 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1798 finalize_syms
= saved_finalize_syms
;
1801 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1803 /* fr_var carries the max_chars that we created the fragment with.
1804 fr_subtype carries the current expected length. We must, of
1805 course, have allocated enough memory earlier. */
1806 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1808 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1809 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1810 frag
->fr_literal
+ frag
->fr_fix
,
1813 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1814 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1816 frag
->fr_fix
+= frag
->fr_subtype
;
1817 frag
->fr_type
= rs_fill
;
1819 frag
->fr_offset
= 0;
1822 /* Generate .debug_line content for the chain of line number entries
1823 beginning at E, for segment SEG. */
1826 process_entries (segT seg
, struct line_entry
*e
)
1828 unsigned filenum
= 1;
1830 unsigned column
= 0;
1832 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1833 fragS
*last_frag
= NULL
, *frag
;
1834 addressT last_frag_ofs
= 0, frag_ofs
;
1835 symbolS
*last_lab
= NULL
, *lab
;
1836 struct line_entry
*next
;
1838 if (flag_dwarf_sections
)
1841 const char * sec_name
;
1843 /* Switch to the relevant sub-section before we start to emit
1844 the line number table.
1846 FIXME: These sub-sections do not have a normal Line Number
1847 Program Header, thus strictly speaking they are not valid
1848 DWARF sections. Unfortunately the DWARF standard assumes
1849 a one-to-one relationship between compilation units and
1850 line number tables. Thus we have to have a .debug_line
1851 section, as well as our sub-sections, and we have to ensure
1852 that all of the sub-sections are merged into a proper
1853 .debug_line section before a debugger sees them. */
1855 sec_name
= bfd_section_name (seg
);
1856 if (strcmp (sec_name
, ".text") != 0)
1858 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1859 subseg_set (subseg_get (name
, FALSE
), 0);
1862 /* Don't create a .debug_line.text section -
1863 that is redundant. Instead just switch back to the
1864 normal .debug_line section. */
1865 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1872 if (filenum
!= e
->loc
.filenum
)
1874 filenum
= e
->loc
.filenum
;
1875 out_opcode (DW_LNS_set_file
);
1876 out_uleb128 (filenum
);
1879 if (column
!= e
->loc
.column
)
1881 column
= e
->loc
.column
;
1882 out_opcode (DW_LNS_set_column
);
1883 out_uleb128 (column
);
1886 if (e
->loc
.discriminator
!= 0)
1888 out_opcode (DW_LNS_extended_op
);
1889 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1890 out_opcode (DW_LNE_set_discriminator
);
1891 out_uleb128 (e
->loc
.discriminator
);
1894 if (isa
!= e
->loc
.isa
)
1897 out_opcode (DW_LNS_set_isa
);
1901 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1903 flags
= e
->loc
.flags
;
1904 out_opcode (DW_LNS_negate_stmt
);
1907 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1908 out_opcode (DW_LNS_set_basic_block
);
1910 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1911 out_opcode (DW_LNS_set_prologue_end
);
1913 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1914 out_opcode (DW_LNS_set_epilogue_begin
);
1916 /* Don't try to optimize away redundant entries; gdb wants two
1917 entries for a function where the code starts on the same line as
1918 the {, and there's no way to identify that case here. Trust gcc
1919 to optimize appropriately. */
1920 line_delta
= e
->loc
.line
- line
;
1922 frag
= symbol_get_frag (lab
);
1923 frag_ofs
= S_GET_VALUE (lab
);
1925 if (last_frag
== NULL
1926 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1927 /* If we're going to reset the view, but we know we're
1928 advancing the PC, we don't have to force with
1929 set_address. We know we do when we're at the same
1930 address of the same frag, and we know we might when
1931 we're in the beginning of a frag, and we were at the
1932 end of the previous frag. */
1933 && (frag
== last_frag
1934 ? (last_frag_ofs
== frag_ofs
)
1936 && ((offsetT
)last_frag_ofs
1937 >= get_frag_fix (last_frag
, seg
))))))
1940 out_inc_line_addr (line_delta
, 0);
1942 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1943 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1945 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1950 last_frag_ofs
= frag_ofs
;
1958 /* Emit a DW_LNE_end_sequence for the end of the section. */
1959 frag
= last_frag_for_seg (seg
);
1960 frag_ofs
= get_frag_fix (frag
, seg
);
1961 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1962 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1965 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1966 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1970 /* Emit the directory and file tables for .debug_line. */
1973 out_dir_and_file_list (void)
1979 bfd_boolean emit_md5
= FALSE
;
1980 bfd_boolean emit_timestamps
= TRUE
;
1981 bfd_boolean emit_filesize
= TRUE
;
1983 /* Output the Directory Table. */
1984 if (DWARF2_LINE_VERSION
>= 5)
1986 /* We only have one column in the directory table. */
1989 /* Describe the purpose and format of the column. */
1990 out_uleb128 (DW_LNCT_path
);
1991 /* FIXME: it would be better to store these strings in
1992 the .debug_line_str section and reference them here. */
1993 out_uleb128 (DW_FORM_string
);
1995 /* Now state how many rows there are in the table. We need at
1996 least 1 if there is one or more file names to store the
1997 "working directory". */
1998 if (dirs_in_use
== 0 && files_in_use
> 0)
2001 out_uleb128 (dirs_in_use
);
2004 /* Emit directory list. */
2005 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2007 /* DWARF5 uses slot zero, but that is only set explicitly
2008 using a .file 0 directive. If that isn't used, but dir
2009 one is used, then use that as main file directory.
2010 Otherwise use pwd as main file directory. */
2011 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2012 dir
= remap_debug_filename (dirs
[0]);
2013 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2014 dir
= remap_debug_filename (dirs
[1]);
2016 dir
= remap_debug_filename (getpwd ());
2018 size
= strlen (dir
) + 1;
2019 cp
= frag_more (size
);
2020 memcpy (cp
, dir
, size
);
2022 for (i
= 1; i
< dirs_in_use
; ++i
)
2024 dir
= remap_debug_filename (dirs
[i
]);
2025 size
= strlen (dir
) + 1;
2026 cp
= frag_more (size
);
2027 memcpy (cp
, dir
, size
);
2030 if (DWARF2_LINE_VERSION
< 5)
2034 /* Output the File Name Table. */
2035 if (DWARF2_LINE_VERSION
>= 5)
2037 unsigned int columns
= 4;
2039 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2041 emit_timestamps
= FALSE
;
2045 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2047 emit_filesize
= FALSE
;
2051 for (i
= 0; i
< files_in_use
; ++i
)
2052 if (files
[i
].md5
[0] != 0)
2054 if (i
< files_in_use
)
2060 /* The number of format entries to follow. */
2062 /* The format of the file name. */
2063 out_uleb128 (DW_LNCT_path
);
2064 /* FIXME: it would be better to store these strings in
2065 the .debug_line_str section and reference them here. */
2066 out_uleb128 (DW_FORM_string
);
2068 /* The format of the directory index. */
2069 out_uleb128 (DW_LNCT_directory_index
);
2070 out_uleb128 (DW_FORM_udata
);
2072 if (emit_timestamps
)
2074 /* The format of the timestamp. */
2075 out_uleb128 (DW_LNCT_timestamp
);
2076 out_uleb128 (DW_FORM_udata
);
2081 /* The format of the file size. */
2082 out_uleb128 (DW_LNCT_size
);
2083 out_uleb128 (DW_FORM_udata
);
2088 /* The format of the MD5 sum. */
2089 out_uleb128 (DW_LNCT_MD5
);
2090 out_uleb128 (DW_FORM_data16
);
2093 /* The number of entries in the table. */
2094 out_uleb128 (files_in_use
);
2097 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2099 const char *fullfilename
;
2101 if (files
[i
].filename
== NULL
)
2103 /* Prevent a crash later, particularly for file 1. DWARF5
2104 uses slot zero, but that is only set explicitly using a
2105 .file 0 directive. If that isn't used, but file 1 is,
2106 then use that as main file name. */
2107 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2108 files
[0].filename
= files
[1].filename
;
2110 files
[i
].filename
= "";
2111 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2113 as_bad (_("unassigned file number %ld"), (long) i
);
2118 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2119 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2120 size
= strlen (fullfilename
) + 1;
2121 cp
= frag_more (size
);
2122 memcpy (cp
, fullfilename
, size
);
2124 /* Directory number. */
2125 out_uleb128 (files
[i
].dir
);
2127 /* Output the last modification timestamp. */
2128 if (emit_timestamps
)
2132 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2133 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2134 if (timestamp
== -1)
2136 out_uleb128 (timestamp
);
2139 /* Output the filesize. */
2143 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2144 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2147 out_uleb128 (filesize
);
2150 /* Output the md5 sum. */
2155 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2156 out_byte (files
[i
].md5
[b
]);
2160 if (DWARF2_LINE_VERSION
< 5)
2161 /* Terminate filename list. */
2165 /* Switch to SEC and output a header length field. Return the size of
2166 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2167 to the end of the section. EXPR->X_add_number will be set to the
2168 negative size of the header. */
2171 out_header (asection
*sec
, expressionS
*exp
)
2176 subseg_set (sec
, 0);
2178 if (flag_dwarf_sections
)
2180 /* If we are going to put the start and end symbols in different
2181 sections, then we need real symbols, not just fake, local ones. */
2183 start_sym
= symbol_make (".Ldebug_line_start");
2184 end_sym
= symbol_make (".Ldebug_line_end");
2185 symbol_set_value_now (start_sym
);
2189 start_sym
= symbol_temp_new_now_octets ();
2190 end_sym
= symbol_temp_make ();
2193 /* Total length of the information. */
2194 exp
->X_op
= O_subtract
;
2195 exp
->X_add_symbol
= end_sym
;
2196 exp
->X_op_symbol
= start_sym
;
2198 switch (DWARF2_FORMAT (sec
))
2200 case dwarf2_format_32bit
:
2201 exp
->X_add_number
= -4;
2205 case dwarf2_format_64bit
:
2206 exp
->X_add_number
= -12;
2211 case dwarf2_format_64bit_irix
:
2212 exp
->X_add_number
= -8;
2217 as_fatal (_("internal error: unknown dwarf2 format"));
2221 /* Emit the collected .debug_line data. */
2224 out_debug_line (segT line_seg
)
2227 symbolS
*prologue_start
, *prologue_end
;
2232 memset (&exp
, 0, sizeof exp
);
2233 sizeof_offset
= out_header (line_seg
, &exp
);
2234 line_end
= exp
.X_add_symbol
;
2237 out_two (DWARF2_LINE_VERSION
);
2239 if (DWARF2_LINE_VERSION
>= 5)
2241 out_byte (sizeof_address
);
2242 out_byte (0); /* Segment Selector size. */
2244 /* Length of the prologue following this length. */
2245 prologue_start
= symbol_temp_make ();
2246 prologue_end
= symbol_temp_make ();
2247 exp
.X_op
= O_subtract
;
2248 exp
.X_add_symbol
= prologue_end
;
2249 exp
.X_op_symbol
= prologue_start
;
2250 exp
.X_add_number
= 0;
2251 emit_expr (&exp
, sizeof_offset
);
2252 symbol_set_value_now (prologue_start
);
2254 /* Parameters of the state machine. */
2255 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2256 if (DWARF2_LINE_VERSION
>= 4)
2257 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2258 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2259 out_byte (DWARF2_LINE_BASE
);
2260 out_byte (DWARF2_LINE_RANGE
);
2261 out_byte (DWARF2_LINE_OPCODE_BASE
);
2263 /* Standard opcode lengths. */
2264 out_byte (0); /* DW_LNS_copy */
2265 out_byte (1); /* DW_LNS_advance_pc */
2266 out_byte (1); /* DW_LNS_advance_line */
2267 out_byte (1); /* DW_LNS_set_file */
2268 out_byte (1); /* DW_LNS_set_column */
2269 out_byte (0); /* DW_LNS_negate_stmt */
2270 out_byte (0); /* DW_LNS_set_basic_block */
2271 out_byte (0); /* DW_LNS_const_add_pc */
2272 out_byte (1); /* DW_LNS_fixed_advance_pc */
2273 out_byte (0); /* DW_LNS_set_prologue_end */
2274 out_byte (0); /* DW_LNS_set_epilogue_begin */
2275 out_byte (1); /* DW_LNS_set_isa */
2276 /* We have emitted 12 opcode lengths, so make that this
2277 matches up to the opcode base value we have been using. */
2278 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2280 out_dir_and_file_list ();
2282 symbol_set_value_now (prologue_end
);
2284 /* For each section, emit a statement program. */
2285 for (s
= all_segs
; s
; s
= s
->next
)
2286 if (SEG_NORMAL (s
->seg
))
2287 process_entries (s
->seg
, s
->head
->head
);
2289 as_warn ("dwarf line number information for %s ignored",
2290 segment_name (s
->seg
));
2292 if (flag_dwarf_sections
)
2293 /* We have to switch to the special .debug_line_end section
2294 before emitting the end-of-debug_line symbol. The linker
2295 script arranges for this section to be placed after all the
2296 (potentially garbage collected) .debug_line.<foo> sections.
2297 This section contains the line_end symbol which is used to
2298 compute the size of the linked .debug_line section, as seen
2299 in the DWARF Line Number header. */
2300 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2302 symbol_set_value_now (line_end
);
2306 out_debug_ranges (segT ranges_seg
)
2308 unsigned int addr_size
= sizeof_address
;
2313 memset (&exp
, 0, sizeof exp
);
2314 subseg_set (ranges_seg
, 0);
2316 /* Base Address Entry. */
2317 for (i
= 0; i
< addr_size
; i
++)
2319 for (i
= 0; i
< addr_size
; i
++)
2322 /* Range List Entry. */
2323 for (s
= all_segs
; s
; s
= s
->next
)
2328 frag
= first_frag_for_seg (s
->seg
);
2329 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2330 s
->text_start
= beg
;
2332 frag
= last_frag_for_seg (s
->seg
);
2333 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2336 exp
.X_op
= O_symbol
;
2337 exp
.X_add_symbol
= beg
;
2338 exp
.X_add_number
= 0;
2339 emit_expr (&exp
, addr_size
);
2341 exp
.X_op
= O_symbol
;
2342 exp
.X_add_symbol
= end
;
2343 exp
.X_add_number
= 0;
2344 emit_expr (&exp
, addr_size
);
2347 /* End of Range Entry. */
2348 for (i
= 0; i
< addr_size
; i
++)
2350 for (i
= 0; i
< addr_size
; i
++)
2354 /* Emit data for .debug_aranges. */
2357 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2359 unsigned int addr_size
= sizeof_address
;
2363 symbolS
*aranges_end
;
2367 memset (&exp
, 0, sizeof exp
);
2368 sizeof_offset
= out_header (aranges_seg
, &exp
);
2369 aranges_end
= exp
.X_add_symbol
;
2370 size
= -exp
.X_add_number
;
2373 out_two (DWARF2_ARANGES_VERSION
);
2376 /* Offset to .debug_info. */
2377 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2378 size
+= sizeof_offset
;
2380 /* Size of an address (offset portion). */
2381 out_byte (addr_size
);
2384 /* Size of a segment descriptor. */
2388 /* Align the header. */
2389 while ((size
++ % (2 * addr_size
)) > 0)
2392 for (s
= all_segs
; s
; s
= s
->next
)
2397 frag
= first_frag_for_seg (s
->seg
);
2398 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2399 s
->text_start
= beg
;
2401 frag
= last_frag_for_seg (s
->seg
);
2402 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2405 exp
.X_op
= O_symbol
;
2406 exp
.X_add_symbol
= beg
;
2407 exp
.X_add_number
= 0;
2408 emit_expr (&exp
, addr_size
);
2410 exp
.X_op
= O_subtract
;
2411 exp
.X_add_symbol
= end
;
2412 exp
.X_op_symbol
= beg
;
2413 exp
.X_add_number
= 0;
2414 emit_expr (&exp
, addr_size
);
2417 p
= frag_more (2 * addr_size
);
2418 md_number_to_chars (p
, 0, addr_size
);
2419 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2421 symbol_set_value_now (aranges_end
);
2424 /* Emit data for .debug_abbrev. Note that this must be kept in
2425 sync with out_debug_info below. */
2428 out_debug_abbrev (segT abbrev_seg
,
2429 segT info_seg ATTRIBUTE_UNUSED
,
2430 segT line_seg ATTRIBUTE_UNUSED
)
2432 subseg_set (abbrev_seg
, 0);
2435 out_uleb128 (DW_TAG_compile_unit
);
2436 out_byte (DW_CHILDREN_no
);
2437 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2438 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
2440 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
2441 if (all_segs
->next
== NULL
)
2443 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2444 if (DWARF2_VERSION
< 4)
2445 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2447 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2451 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
2452 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
2454 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
2456 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2457 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2458 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2459 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2462 /* Terminate the abbreviations for this compilation unit. */
2466 /* Emit a description of this compilation unit for .debug_info. */
2469 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
2470 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2476 memset (&exp
, 0, sizeof exp
);
2477 sizeof_offset
= out_header (info_seg
, &exp
);
2478 info_end
= exp
.X_add_symbol
;
2480 /* DWARF version. */
2481 out_two (DWARF2_VERSION
);
2483 if (DWARF2_VERSION
< 5)
2485 /* .debug_abbrev offset */
2486 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2490 /* unit (header) type */
2491 out_byte (DW_UT_compile
);
2494 /* Target address size. */
2495 out_byte (sizeof_address
);
2497 if (DWARF2_VERSION
>= 5)
2499 /* .debug_abbrev offset */
2500 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2503 /* DW_TAG_compile_unit DIE abbrev */
2506 /* DW_AT_stmt_list */
2507 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2508 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2511 /* These two attributes are emitted if all of the code is contiguous. */
2512 if (all_segs
->next
== NULL
)
2515 exp
.X_op
= O_symbol
;
2516 exp
.X_add_symbol
= all_segs
->text_start
;
2517 exp
.X_add_number
= 0;
2518 emit_expr (&exp
, sizeof_address
);
2521 if (DWARF2_VERSION
< 4)
2522 exp
.X_op
= O_symbol
;
2525 exp
.X_op
= O_subtract
;
2526 exp
.X_op_symbol
= all_segs
->text_start
;
2528 exp
.X_add_symbol
= all_segs
->text_end
;
2529 exp
.X_add_number
= 0;
2530 if (DWARF2_VERSION
< 4)
2531 emit_expr (&exp
, sizeof_address
);
2533 emit_leb128_expr (&exp
, 0);
2537 /* This attribute is emitted if the code is disjoint. */
2539 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2542 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2543 setup in out_debug_str below. */
2544 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2545 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2546 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2548 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2549 dwarf2 draft has no standard code for assembler. */
2550 out_two (DW_LANG_Mips_Assembler
);
2552 symbol_set_value_now (info_end
);
2555 /* Emit the three debug strings needed in .debug_str and setup symbols
2556 to them for use in out_debug_info. */
2558 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2559 symbolS
**producer_sym
)
2562 const char *comp_dir
;
2563 const char *dirname
;
2566 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2568 subseg_set (str_seg
, 0);
2570 /* DW_AT_name. We don't have the actual file name that was present
2571 on the command line, so assume files[first_file] is the main input file.
2572 We're not supposed to get called unless at least one line number
2573 entry was emitted, so this should always be defined. */
2574 *name_sym
= symbol_temp_new_now_octets ();
2575 if (files_in_use
== 0)
2577 if (files
[first_file
].dir
)
2579 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2580 len
= strlen (dirname
);
2582 /* Already has trailing slash. */
2583 p
= frag_more (len
);
2584 memcpy (p
, dirname
, len
);
2586 p
= frag_more (len
+ 1);
2587 memcpy (p
, dirname
, len
);
2588 INSERT_DIR_SEPARATOR (p
, len
);
2591 len
= strlen (files
[first_file
].filename
) + 1;
2592 p
= frag_more (len
);
2593 memcpy (p
, files
[first_file
].filename
, len
);
2595 /* DW_AT_comp_dir */
2596 *comp_dir_sym
= symbol_temp_new_now_octets ();
2597 comp_dir
= remap_debug_filename (getpwd ());
2598 len
= strlen (comp_dir
) + 1;
2599 p
= frag_more (len
);
2600 memcpy (p
, comp_dir
, len
);
2602 /* DW_AT_producer */
2603 *producer_sym
= symbol_temp_new_now_octets ();
2604 sprintf (producer
, "GNU AS %s", VERSION
);
2605 len
= strlen (producer
) + 1;
2606 p
= frag_more (len
);
2607 memcpy (p
, producer
, len
);
2613 last_seg_ptr
= &all_segs
;
2615 /* Select the default CIE version to produce here. The global
2616 starts with a value of -1 and will be modified to a valid value
2617 either by the user providing a command line option, or some
2618 targets will select their own default in md_after_parse_args. If
2619 we get here and the global still contains -1 then it is up to us
2620 to pick a sane default. The default we choose is 1, this is the
2621 CIE version gas has produced for a long time, and there seems no
2622 reason to change it yet. */
2623 if (flag_dwarf_cie_version
== -1)
2624 flag_dwarf_cie_version
= 1;
2628 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2629 were any .file/.loc directives, or --gdwarf2 was given, or if the
2630 file has a non-empty .debug_info section and an empty .debug_line
2631 section. If we emit .debug_line, and the .debug_info section is
2632 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2633 ALL_SEGS will be non-null if there were any .file/.loc directives,
2634 or --gdwarf2 was given and there were any located instructions
2638 dwarf2_finish (void)
2643 int emit_other_sections
= 0;
2644 int empty_debug_line
= 0;
2646 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2647 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2649 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2650 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2652 /* We can't construct a new debug_line section if we already have one.
2654 if (all_segs
&& !empty_debug_line
)
2655 as_fatal ("duplicate .debug_line sections");
2657 if ((!all_segs
&& emit_other_sections
)
2658 || (!emit_other_sections
&& !empty_debug_line
))
2659 /* If there is no line information and no non-empty .debug_info
2660 section, or if there is both a non-empty .debug_info and a non-empty
2661 .debug_line, then we do nothing. */
2664 /* Calculate the size of an address for the target machine. */
2665 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2667 /* Create and switch to the line number section. */
2668 line_seg
= subseg_new (".debug_line", 0);
2669 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2671 /* For each subsection, chain the debug entries together. */
2672 for (s
= all_segs
; s
; s
= s
->next
)
2674 struct line_subseg
*lss
= s
->head
;
2675 struct line_entry
**ptail
= lss
->ptail
;
2677 /* Reset the initial view of the first subsection of the
2679 if (lss
->head
&& lss
->head
->loc
.view
)
2680 set_or_check_view (lss
->head
, NULL
, NULL
);
2682 while ((lss
= lss
->next
) != NULL
)
2684 /* Link the first view of subsequent subsections to the
2686 if (lss
->head
&& lss
->head
->loc
.view
)
2687 set_or_check_view (lss
->head
,
2688 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2689 s
->head
? s
->head
->head
: NULL
);
2695 out_debug_line (line_seg
);
2697 /* If this is assembler generated line info, and there is no
2698 debug_info already, we need .debug_info, .debug_abbrev and
2699 .debug_str sections as well. */
2700 if (emit_other_sections
)
2706 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2708 gas_assert (all_segs
);
2710 info_seg
= subseg_new (".debug_info", 0);
2711 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2712 aranges_seg
= subseg_new (".debug_aranges", 0);
2713 str_seg
= subseg_new (".debug_str", 0);
2715 bfd_set_section_flags (info_seg
,
2716 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2717 bfd_set_section_flags (abbrev_seg
,
2718 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2719 bfd_set_section_flags (aranges_seg
,
2720 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2721 bfd_set_section_flags (str_seg
,
2722 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2723 | SEC_MERGE
| SEC_STRINGS
);
2724 str_seg
->entsize
= 1;
2726 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2728 if (all_segs
->next
== NULL
)
2732 ranges_seg
= subseg_new (".debug_ranges", 0);
2733 bfd_set_section_flags (ranges_seg
,
2734 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2735 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2736 out_debug_ranges (ranges_seg
);
2739 out_debug_aranges (aranges_seg
, info_seg
);
2740 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2741 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2742 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2743 name_sym
, comp_dir_sym
, producer_sym
);
2747 /* Perform any deferred checks pertaining to debug information. */
2750 dwarf2dbg_final_check (void)
2752 /* Perform reset-view checks. Don't evaluate view_assert_failed
2753 recursively: it could be very deep. It's a chain of adds, with
2754 each chain element pointing to the next in X_add_symbol, and
2755 holding the check value in X_op_symbol. */
2756 while (view_assert_failed
)
2762 gas_assert (!symbol_resolved_p (view_assert_failed
));
2764 exp
= symbol_get_value_expression (view_assert_failed
);
2765 sym
= view_assert_failed
;
2767 /* If view_assert_failed looks like a compound check in the
2768 chain, break it up. */
2769 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2771 view_assert_failed
= exp
->X_add_symbol
;
2772 sym
= exp
->X_op_symbol
;
2775 view_assert_failed
= NULL
;
2777 failed
= resolve_symbol_value (sym
);
2778 if (!symbol_resolved_p (sym
) || failed
)
2780 as_bad (_("view number mismatch"));