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
, ofs
, frag_now
);
552 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
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
, value
,
1249 &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_ofs
, frag
);
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. */
1996 out_uleb128 (dirs_in_use
);
1999 /* Emit directory list. */
2000 if (DWARF2_LINE_VERSION
>= 5 && dirs_in_use
> 0)
2002 if (dirs
== NULL
|| dirs
[0] == NULL
)
2003 dir
= remap_debug_filename (".");
2005 dir
= remap_debug_filename (dirs
[0]);
2007 size
= strlen (dir
) + 1;
2008 cp
= frag_more (size
);
2009 memcpy (cp
, dir
, size
);
2011 for (i
= 1; i
< dirs_in_use
; ++i
)
2013 dir
= remap_debug_filename (dirs
[i
]);
2014 size
= strlen (dir
) + 1;
2015 cp
= frag_more (size
);
2016 memcpy (cp
, dir
, size
);
2019 if (DWARF2_LINE_VERSION
< 5)
2023 /* Output the File Name Table. */
2024 if (DWARF2_LINE_VERSION
>= 5)
2026 unsigned int columns
= 4;
2028 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2030 emit_timestamps
= FALSE
;
2034 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2036 emit_filesize
= FALSE
;
2040 for (i
= 0; i
< files_in_use
; ++i
)
2041 if (files
[i
].md5
[0] != 0)
2043 if (i
< files_in_use
)
2049 /* The number of format entries to follow. */
2051 /* The format of the file name. */
2052 out_uleb128 (DW_LNCT_path
);
2053 /* FIXME: it would be better to store these strings in
2054 the .debug_line_str section and reference them here. */
2055 out_uleb128 (DW_FORM_string
);
2057 /* The format of the directory index. */
2058 out_uleb128 (DW_LNCT_directory_index
);
2059 out_uleb128 (DW_FORM_udata
);
2061 if (emit_timestamps
)
2063 /* The format of the timestamp. */
2064 out_uleb128 (DW_LNCT_timestamp
);
2065 out_uleb128 (DW_FORM_udata
);
2070 /* The format of the file size. */
2071 out_uleb128 (DW_LNCT_size
);
2072 out_uleb128 (DW_FORM_udata
);
2077 /* The format of the MD5 sum. */
2078 out_uleb128 (DW_LNCT_MD5
);
2079 out_uleb128 (DW_FORM_data16
);
2082 /* The number of entries in the table. */
2083 out_uleb128 (files_in_use
);
2086 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2088 const char *fullfilename
;
2090 if (files
[i
].filename
== NULL
)
2092 /* Prevent a crash later, particularly for file 1. */
2093 files
[i
].filename
= "";
2094 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2096 as_bad (_("unassigned file number %ld"), (long) i
);
2101 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2102 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2103 size
= strlen (fullfilename
) + 1;
2104 cp
= frag_more (size
);
2105 memcpy (cp
, fullfilename
, size
);
2107 /* Directory number. */
2108 out_uleb128 (files
[i
].dir
);
2110 /* Output the last modification timestamp. */
2111 if (emit_timestamps
)
2115 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2116 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2117 if (timestamp
== -1)
2119 out_uleb128 (timestamp
);
2122 /* Output the filesize. */
2126 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2127 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2130 out_uleb128 (filesize
);
2133 /* Output the md5 sum. */
2138 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2139 out_byte (files
[i
].md5
[b
]);
2143 if (DWARF2_LINE_VERSION
< 5)
2144 /* Terminate filename list. */
2148 /* Switch to SEC and output a header length field. Return the size of
2149 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2150 to the end of the section. EXPR->X_add_number will be set to the
2151 negative size of the header. */
2154 out_header (asection
*sec
, expressionS
*exp
)
2159 subseg_set (sec
, 0);
2161 if (flag_dwarf_sections
)
2163 /* If we are going to put the start and end symbols in different
2164 sections, then we need real symbols, not just fake, local ones. */
2166 start_sym
= symbol_make (".Ldebug_line_start");
2167 end_sym
= symbol_make (".Ldebug_line_end");
2168 symbol_set_value_now (start_sym
);
2172 start_sym
= symbol_temp_new_now_octets ();
2173 end_sym
= symbol_temp_make ();
2176 /* Total length of the information. */
2177 exp
->X_op
= O_subtract
;
2178 exp
->X_add_symbol
= end_sym
;
2179 exp
->X_op_symbol
= start_sym
;
2181 switch (DWARF2_FORMAT (sec
))
2183 case dwarf2_format_32bit
:
2184 exp
->X_add_number
= -4;
2188 case dwarf2_format_64bit
:
2189 exp
->X_add_number
= -12;
2194 case dwarf2_format_64bit_irix
:
2195 exp
->X_add_number
= -8;
2200 as_fatal (_("internal error: unknown dwarf2 format"));
2204 /* Emit the collected .debug_line data. */
2207 out_debug_line (segT line_seg
)
2210 symbolS
*prologue_start
, *prologue_end
;
2215 memset (&exp
, 0, sizeof exp
);
2216 sizeof_offset
= out_header (line_seg
, &exp
);
2217 line_end
= exp
.X_add_symbol
;
2220 out_two (DWARF2_LINE_VERSION
);
2222 if (DWARF2_LINE_VERSION
>= 5)
2224 out_byte (sizeof_address
);
2225 out_byte (0); /* Segment Selector size. */
2227 /* Length of the prologue following this length. */
2228 prologue_start
= symbol_temp_make ();
2229 prologue_end
= symbol_temp_make ();
2230 exp
.X_op
= O_subtract
;
2231 exp
.X_add_symbol
= prologue_end
;
2232 exp
.X_op_symbol
= prologue_start
;
2233 exp
.X_add_number
= 0;
2234 emit_expr (&exp
, sizeof_offset
);
2235 symbol_set_value_now (prologue_start
);
2237 /* Parameters of the state machine. */
2238 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2239 if (DWARF2_LINE_VERSION
>= 4)
2240 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2241 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2242 out_byte (DWARF2_LINE_BASE
);
2243 out_byte (DWARF2_LINE_RANGE
);
2244 out_byte (DWARF2_LINE_OPCODE_BASE
);
2246 /* Standard opcode lengths. */
2247 out_byte (0); /* DW_LNS_copy */
2248 out_byte (1); /* DW_LNS_advance_pc */
2249 out_byte (1); /* DW_LNS_advance_line */
2250 out_byte (1); /* DW_LNS_set_file */
2251 out_byte (1); /* DW_LNS_set_column */
2252 out_byte (0); /* DW_LNS_negate_stmt */
2253 out_byte (0); /* DW_LNS_set_basic_block */
2254 out_byte (0); /* DW_LNS_const_add_pc */
2255 out_byte (1); /* DW_LNS_fixed_advance_pc */
2256 out_byte (0); /* DW_LNS_set_prologue_end */
2257 out_byte (0); /* DW_LNS_set_epilogue_begin */
2258 out_byte (1); /* DW_LNS_set_isa */
2259 /* We have emitted 12 opcode lengths, so make that this
2260 matches up to the opcode base value we have been using. */
2261 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2263 out_dir_and_file_list ();
2265 symbol_set_value_now (prologue_end
);
2267 /* For each section, emit a statement program. */
2268 for (s
= all_segs
; s
; s
= s
->next
)
2269 if (SEG_NORMAL (s
->seg
))
2270 process_entries (s
->seg
, s
->head
->head
);
2272 as_warn ("dwarf line number information for %s ignored",
2273 segment_name (s
->seg
));
2275 if (flag_dwarf_sections
)
2276 /* We have to switch to the special .debug_line_end section
2277 before emitting the end-of-debug_line symbol. The linker
2278 script arranges for this section to be placed after all the
2279 (potentially garbage collected) .debug_line.<foo> sections.
2280 This section contains the line_end symbol which is used to
2281 compute the size of the linked .debug_line section, as seen
2282 in the DWARF Line Number header. */
2283 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2285 symbol_set_value_now (line_end
);
2289 out_debug_ranges (segT ranges_seg
)
2291 unsigned int addr_size
= sizeof_address
;
2296 memset (&exp
, 0, sizeof exp
);
2297 subseg_set (ranges_seg
, 0);
2299 /* Base Address Entry. */
2300 for (i
= 0; i
< addr_size
; i
++)
2302 for (i
= 0; i
< addr_size
; i
++)
2305 /* Range List Entry. */
2306 for (s
= all_segs
; s
; s
= s
->next
)
2311 frag
= first_frag_for_seg (s
->seg
);
2312 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2313 s
->text_start
= beg
;
2315 frag
= last_frag_for_seg (s
->seg
);
2316 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2319 exp
.X_op
= O_symbol
;
2320 exp
.X_add_symbol
= beg
;
2321 exp
.X_add_number
= 0;
2322 emit_expr (&exp
, addr_size
);
2324 exp
.X_op
= O_symbol
;
2325 exp
.X_add_symbol
= end
;
2326 exp
.X_add_number
= 0;
2327 emit_expr (&exp
, addr_size
);
2330 /* End of Range Entry. */
2331 for (i
= 0; i
< addr_size
; i
++)
2333 for (i
= 0; i
< addr_size
; i
++)
2337 /* Emit data for .debug_aranges. */
2340 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2342 unsigned int addr_size
= sizeof_address
;
2346 symbolS
*aranges_end
;
2350 memset (&exp
, 0, sizeof exp
);
2351 sizeof_offset
= out_header (aranges_seg
, &exp
);
2352 aranges_end
= exp
.X_add_symbol
;
2353 size
= -exp
.X_add_number
;
2356 out_two (DWARF2_ARANGES_VERSION
);
2359 /* Offset to .debug_info. */
2360 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2361 size
+= sizeof_offset
;
2363 /* Size of an address (offset portion). */
2364 out_byte (addr_size
);
2367 /* Size of a segment descriptor. */
2371 /* Align the header. */
2372 while ((size
++ % (2 * addr_size
)) > 0)
2375 for (s
= all_segs
; s
; s
= s
->next
)
2380 frag
= first_frag_for_seg (s
->seg
);
2381 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2382 s
->text_start
= beg
;
2384 frag
= last_frag_for_seg (s
->seg
);
2385 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2388 exp
.X_op
= O_symbol
;
2389 exp
.X_add_symbol
= beg
;
2390 exp
.X_add_number
= 0;
2391 emit_expr (&exp
, addr_size
);
2393 exp
.X_op
= O_subtract
;
2394 exp
.X_add_symbol
= end
;
2395 exp
.X_op_symbol
= beg
;
2396 exp
.X_add_number
= 0;
2397 emit_expr (&exp
, addr_size
);
2400 p
= frag_more (2 * addr_size
);
2401 md_number_to_chars (p
, 0, addr_size
);
2402 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2404 symbol_set_value_now (aranges_end
);
2407 /* Emit data for .debug_abbrev. Note that this must be kept in
2408 sync with out_debug_info below. */
2411 out_debug_abbrev (segT abbrev_seg
,
2412 segT info_seg ATTRIBUTE_UNUSED
,
2413 segT line_seg ATTRIBUTE_UNUSED
)
2415 subseg_set (abbrev_seg
, 0);
2418 out_uleb128 (DW_TAG_compile_unit
);
2419 out_byte (DW_CHILDREN_no
);
2420 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2421 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
2423 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
2424 if (all_segs
->next
== NULL
)
2426 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2427 if (DWARF2_VERSION
< 4)
2428 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2430 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
2431 ? DW_FORM_data4
: DW_FORM_data8
));
2435 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
2436 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
2438 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
2440 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2441 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2442 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2443 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2446 /* Terminate the abbreviations for this compilation unit. */
2450 /* Emit a description of this compilation unit for .debug_info. */
2453 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
2454 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2460 memset (&exp
, 0, sizeof exp
);
2461 sizeof_offset
= out_header (info_seg
, &exp
);
2462 info_end
= exp
.X_add_symbol
;
2464 /* DWARF version. */
2465 out_two (DWARF2_VERSION
);
2467 /* .debug_abbrev offset */
2468 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2470 /* Target address size. */
2471 out_byte (sizeof_address
);
2473 /* DW_TAG_compile_unit DIE abbrev */
2476 /* DW_AT_stmt_list */
2477 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2478 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2481 /* These two attributes are emitted if all of the code is contiguous. */
2482 if (all_segs
->next
== NULL
)
2485 exp
.X_op
= O_symbol
;
2486 exp
.X_add_symbol
= all_segs
->text_start
;
2487 exp
.X_add_number
= 0;
2488 emit_expr (&exp
, sizeof_address
);
2491 if (DWARF2_VERSION
< 4)
2492 exp
.X_op
= O_symbol
;
2495 exp
.X_op
= O_subtract
;
2496 exp
.X_op_symbol
= all_segs
->text_start
;
2498 exp
.X_add_symbol
= all_segs
->text_end
;
2499 exp
.X_add_number
= 0;
2500 emit_expr (&exp
, sizeof_address
);
2504 /* This attribute is emitted if the code is disjoint. */
2506 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2509 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2510 setup in out_debug_str below. */
2511 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2512 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2513 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2515 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2516 dwarf2 draft has no standard code for assembler. */
2517 out_two (DW_LANG_Mips_Assembler
);
2519 symbol_set_value_now (info_end
);
2522 /* Emit the three debug strings needed in .debug_str and setup symbols
2523 to them for use in out_debug_info. */
2525 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2526 symbolS
**producer_sym
)
2529 const char *comp_dir
;
2530 const char *dirname
;
2533 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2535 subseg_set (str_seg
, 0);
2537 /* DW_AT_name. We don't have the actual file name that was present
2538 on the command line, so assume files[first_file] is the main input file.
2539 We're not supposed to get called unless at least one line number
2540 entry was emitted, so this should always be defined. */
2541 *name_sym
= symbol_temp_new_now_octets ();
2542 if (files_in_use
== 0)
2544 if (files
[first_file
].dir
)
2546 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2547 len
= strlen (dirname
);
2549 /* Already has trailing slash. */
2550 p
= frag_more (len
);
2551 memcpy (p
, dirname
, len
);
2553 p
= frag_more (len
+ 1);
2554 memcpy (p
, dirname
, len
);
2555 INSERT_DIR_SEPARATOR (p
, len
);
2558 len
= strlen (files
[first_file
].filename
) + 1;
2559 p
= frag_more (len
);
2560 memcpy (p
, files
[first_file
].filename
, len
);
2562 /* DW_AT_comp_dir */
2563 *comp_dir_sym
= symbol_temp_new_now_octets ();
2564 comp_dir
= remap_debug_filename (getpwd ());
2565 len
= strlen (comp_dir
) + 1;
2566 p
= frag_more (len
);
2567 memcpy (p
, comp_dir
, len
);
2569 /* DW_AT_producer */
2570 *producer_sym
= symbol_temp_new_now_octets ();
2571 sprintf (producer
, "GNU AS %s", VERSION
);
2572 len
= strlen (producer
) + 1;
2573 p
= frag_more (len
);
2574 memcpy (p
, producer
, len
);
2580 last_seg_ptr
= &all_segs
;
2582 /* Select the default CIE version to produce here. The global
2583 starts with a value of -1 and will be modified to a valid value
2584 either by the user providing a command line option, or some
2585 targets will select their own default in md_after_parse_args. If
2586 we get here and the global still contains -1 then it is up to us
2587 to pick a sane default. The default we choose is 1, this is the
2588 CIE version gas has produced for a long time, and there seems no
2589 reason to change it yet. */
2590 if (flag_dwarf_cie_version
== -1)
2591 flag_dwarf_cie_version
= 1;
2595 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2596 were any .file/.loc directives, or --gdwarf2 was given, or if the
2597 file has a non-empty .debug_info section and an empty .debug_line
2598 section. If we emit .debug_line, and the .debug_info section is
2599 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2600 ALL_SEGS will be non-null if there were any .file/.loc directives,
2601 or --gdwarf2 was given and there were any located instructions
2605 dwarf2_finish (void)
2610 int emit_other_sections
= 0;
2611 int empty_debug_line
= 0;
2613 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2614 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2616 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2617 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2619 /* We can't construct a new debug_line section if we already have one.
2621 if (all_segs
&& !empty_debug_line
)
2622 as_fatal ("duplicate .debug_line sections");
2624 if ((!all_segs
&& emit_other_sections
)
2625 || (!emit_other_sections
&& !empty_debug_line
))
2626 /* If there is no line information and no non-empty .debug_info
2627 section, or if there is both a non-empty .debug_info and a non-empty
2628 .debug_line, then we do nothing. */
2631 /* Calculate the size of an address for the target machine. */
2632 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2634 /* Create and switch to the line number section. */
2635 line_seg
= subseg_new (".debug_line", 0);
2636 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2638 /* For each subsection, chain the debug entries together. */
2639 for (s
= all_segs
; s
; s
= s
->next
)
2641 struct line_subseg
*lss
= s
->head
;
2642 struct line_entry
**ptail
= lss
->ptail
;
2644 /* Reset the initial view of the first subsection of the
2646 if (lss
->head
&& lss
->head
->loc
.view
)
2647 set_or_check_view (lss
->head
, NULL
, NULL
);
2649 while ((lss
= lss
->next
) != NULL
)
2651 /* Link the first view of subsequent subsections to the
2653 if (lss
->head
&& lss
->head
->loc
.view
)
2654 set_or_check_view (lss
->head
,
2655 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2656 s
->head
? s
->head
->head
: NULL
);
2662 out_debug_line (line_seg
);
2664 /* If this is assembler generated line info, and there is no
2665 debug_info already, we need .debug_info, .debug_abbrev and
2666 .debug_str sections as well. */
2667 if (emit_other_sections
)
2673 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2675 gas_assert (all_segs
);
2677 info_seg
= subseg_new (".debug_info", 0);
2678 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2679 aranges_seg
= subseg_new (".debug_aranges", 0);
2680 str_seg
= subseg_new (".debug_str", 0);
2682 bfd_set_section_flags (info_seg
,
2683 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2684 bfd_set_section_flags (abbrev_seg
,
2685 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2686 bfd_set_section_flags (aranges_seg
,
2687 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2688 bfd_set_section_flags (str_seg
,
2689 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2690 | SEC_MERGE
| SEC_STRINGS
);
2691 str_seg
->entsize
= 1;
2693 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2695 if (all_segs
->next
== NULL
)
2699 ranges_seg
= subseg_new (".debug_ranges", 0);
2700 bfd_set_section_flags (ranges_seg
,
2701 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2702 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2703 out_debug_ranges (ranges_seg
);
2706 out_debug_aranges (aranges_seg
, info_seg
);
2707 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2708 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2709 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2710 name_sym
, comp_dir_sym
, producer_sym
);
2714 /* Perform any deferred checks pertaining to debug information. */
2717 dwarf2dbg_final_check (void)
2719 /* Perform reset-view checks. Don't evaluate view_assert_failed
2720 recursively: it could be very deep. It's a chain of adds, with
2721 each chain element pointing to the next in X_add_symbol, and
2722 holding the check value in X_op_symbol. */
2723 while (view_assert_failed
)
2729 gas_assert (!symbol_resolved_p (view_assert_failed
));
2731 exp
= symbol_get_value_expression (view_assert_failed
);
2732 sym
= view_assert_failed
;
2734 /* If view_assert_failed looks like a compound check in the
2735 chain, break it up. */
2736 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2738 view_assert_failed
= exp
->X_add_symbol
;
2739 sym
= exp
->X_op_symbol
;
2742 view_assert_failed
= NULL
;
2744 failed
= resolve_symbol_value (sym
);
2745 if (!symbol_resolved_p (sym
) || failed
)
2747 as_bad (_("view number mismatch"));