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)
1987 out_uleb128 (DW_LNCT_path
);
1988 /* FIXME: it would be better to store these strings in
1989 the .debug_line_str section and reference them here. */
1990 out_uleb128 (DW_FORM_string
);
1991 out_uleb128 (dirs_in_use
);
1994 /* Emit directory list. */
1995 if (DWARF2_LINE_VERSION
>= 5 && dirs_in_use
> 0)
1997 if (dirs
== NULL
|| dirs
[0] == NULL
)
1998 dir
= remap_debug_filename (".");
2000 dir
= remap_debug_filename (dirs
[0]);
2002 size
= strlen (dir
) + 1;
2003 cp
= frag_more (size
);
2004 memcpy (cp
, dir
, size
);
2006 for (i
= 1; i
< dirs_in_use
; ++i
)
2008 dir
= remap_debug_filename (dirs
[i
]);
2009 size
= strlen (dir
) + 1;
2010 cp
= frag_more (size
);
2011 memcpy (cp
, dir
, size
);
2014 if (DWARF2_LINE_VERSION
< 5)
2018 /* Output the File Name Table. */
2019 if (DWARF2_LINE_VERSION
>= 5)
2021 unsigned int columns
= 4;
2023 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2025 emit_timestamps
= FALSE
;
2029 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2031 emit_filesize
= FALSE
;
2035 for (i
= 0; i
< files_in_use
; ++i
)
2036 if (files
[i
].md5
[0] != 0)
2038 if (i
< files_in_use
)
2044 /* The number of format entries to follow. */
2046 /* The format of the file name. */
2047 out_uleb128 (DW_LNCT_path
);
2048 /* FIXME: it would be better to store these strings in
2049 the .debug_line_str section and reference them here. */
2050 out_uleb128 (DW_FORM_string
);
2052 /* The format of the directory index. */
2053 out_uleb128 (DW_LNCT_directory_index
);
2054 out_uleb128 (DW_FORM_udata
);
2056 if (emit_timestamps
)
2058 /* The format of the timestamp. */
2059 out_uleb128 (DW_LNCT_timestamp
);
2060 out_uleb128 (DW_FORM_udata
);
2065 /* The format of the file size. */
2066 out_uleb128 (DW_LNCT_size
);
2067 out_uleb128 (DW_FORM_udata
);
2072 /* The format of the MD5 sum. */
2073 out_uleb128 (DW_LNCT_MD5
);
2074 out_uleb128 (DW_FORM_data16
);
2077 /* The number of entries in the table. */
2078 out_uleb128 (files_in_use
);
2081 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2083 const char *fullfilename
;
2085 if (files
[i
].filename
== NULL
)
2087 /* Prevent a crash later, particularly for file 1. */
2088 files
[i
].filename
= "";
2089 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2091 as_bad (_("unassigned file number %ld"), (long) i
);
2096 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2097 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2098 size
= strlen (fullfilename
) + 1;
2099 cp
= frag_more (size
);
2100 memcpy (cp
, fullfilename
, size
);
2102 /* Directory number. */
2103 out_uleb128 (files
[i
].dir
);
2105 /* Output the last modification timestamp. */
2106 if (emit_timestamps
)
2110 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2111 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2112 if (timestamp
== -1)
2114 out_uleb128 (timestamp
);
2117 /* Output the filesize. */
2121 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2122 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2125 out_uleb128 (filesize
);
2128 /* Output the md5 sum. */
2133 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2134 out_byte (files
[i
].md5
[b
]);
2138 if (DWARF2_LINE_VERSION
< 5)
2139 /* Terminate filename list. */
2143 /* Switch to SEC and output a header length field. Return the size of
2144 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2145 to the end of the section. EXPR->X_add_number will be set to the
2146 negative size of the header. */
2149 out_header (asection
*sec
, expressionS
*exp
)
2154 subseg_set (sec
, 0);
2156 if (flag_dwarf_sections
)
2158 /* If we are going to put the start and end symbols in different
2159 sections, then we need real symbols, not just fake, local ones. */
2161 start_sym
= symbol_make (".Ldebug_line_start");
2162 end_sym
= symbol_make (".Ldebug_line_end");
2163 symbol_set_value_now (start_sym
);
2167 start_sym
= symbol_temp_new_now_octets ();
2168 end_sym
= symbol_temp_make ();
2171 /* Total length of the information. */
2172 exp
->X_op
= O_subtract
;
2173 exp
->X_add_symbol
= end_sym
;
2174 exp
->X_op_symbol
= start_sym
;
2176 switch (DWARF2_FORMAT (sec
))
2178 case dwarf2_format_32bit
:
2179 exp
->X_add_number
= -4;
2183 case dwarf2_format_64bit
:
2184 exp
->X_add_number
= -12;
2189 case dwarf2_format_64bit_irix
:
2190 exp
->X_add_number
= -8;
2195 as_fatal (_("internal error: unknown dwarf2 format"));
2199 /* Emit the collected .debug_line data. */
2202 out_debug_line (segT line_seg
)
2205 symbolS
*prologue_start
, *prologue_end
;
2210 memset (&exp
, 0, sizeof exp
);
2211 sizeof_offset
= out_header (line_seg
, &exp
);
2212 line_end
= exp
.X_add_symbol
;
2215 out_two (DWARF2_LINE_VERSION
);
2217 if (DWARF2_LINE_VERSION
>= 5)
2219 out_byte (sizeof_address
);
2220 out_byte (0); /* Segment Selector size. */
2222 /* Length of the prologue following this length. */
2223 prologue_start
= symbol_temp_make ();
2224 prologue_end
= symbol_temp_make ();
2225 exp
.X_op
= O_subtract
;
2226 exp
.X_add_symbol
= prologue_end
;
2227 exp
.X_op_symbol
= prologue_start
;
2228 exp
.X_add_number
= 0;
2229 emit_expr (&exp
, sizeof_offset
);
2230 symbol_set_value_now (prologue_start
);
2232 /* Parameters of the state machine. */
2233 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2234 if (DWARF2_LINE_VERSION
>= 4)
2235 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2236 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2237 out_byte (DWARF2_LINE_BASE
);
2238 out_byte (DWARF2_LINE_RANGE
);
2239 out_byte (DWARF2_LINE_OPCODE_BASE
);
2241 /* Standard opcode lengths. */
2242 out_byte (0); /* DW_LNS_copy */
2243 out_byte (1); /* DW_LNS_advance_pc */
2244 out_byte (1); /* DW_LNS_advance_line */
2245 out_byte (1); /* DW_LNS_set_file */
2246 out_byte (1); /* DW_LNS_set_column */
2247 out_byte (0); /* DW_LNS_negate_stmt */
2248 out_byte (0); /* DW_LNS_set_basic_block */
2249 out_byte (0); /* DW_LNS_const_add_pc */
2250 out_byte (1); /* DW_LNS_fixed_advance_pc */
2251 out_byte (0); /* DW_LNS_set_prologue_end */
2252 out_byte (0); /* DW_LNS_set_epilogue_begin */
2253 out_byte (1); /* DW_LNS_set_isa */
2254 /* We have emitted 12 opcode lengths, so make that this
2255 matches up to the opcode base value we have been using. */
2256 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2258 out_dir_and_file_list ();
2260 symbol_set_value_now (prologue_end
);
2262 /* For each section, emit a statement program. */
2263 for (s
= all_segs
; s
; s
= s
->next
)
2264 if (SEG_NORMAL (s
->seg
))
2265 process_entries (s
->seg
, s
->head
->head
);
2267 as_warn ("dwarf line number information for %s ignored",
2268 segment_name (s
->seg
));
2270 if (flag_dwarf_sections
)
2271 /* We have to switch to the special .debug_line_end section
2272 before emitting the end-of-debug_line symbol. The linker
2273 script arranges for this section to be placed after all the
2274 (potentially garbage collected) .debug_line.<foo> sections.
2275 This section contains the line_end symbol which is used to
2276 compute the size of the linked .debug_line section, as seen
2277 in the DWARF Line Number header. */
2278 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2280 symbol_set_value_now (line_end
);
2284 out_debug_ranges (segT ranges_seg
)
2286 unsigned int addr_size
= sizeof_address
;
2291 memset (&exp
, 0, sizeof exp
);
2292 subseg_set (ranges_seg
, 0);
2294 /* Base Address Entry. */
2295 for (i
= 0; i
< addr_size
; i
++)
2297 for (i
= 0; i
< addr_size
; i
++)
2300 /* Range List Entry. */
2301 for (s
= all_segs
; s
; s
= s
->next
)
2306 frag
= first_frag_for_seg (s
->seg
);
2307 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2308 s
->text_start
= beg
;
2310 frag
= last_frag_for_seg (s
->seg
);
2311 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2314 exp
.X_op
= O_symbol
;
2315 exp
.X_add_symbol
= beg
;
2316 exp
.X_add_number
= 0;
2317 emit_expr (&exp
, addr_size
);
2319 exp
.X_op
= O_symbol
;
2320 exp
.X_add_symbol
= end
;
2321 exp
.X_add_number
= 0;
2322 emit_expr (&exp
, addr_size
);
2325 /* End of Range Entry. */
2326 for (i
= 0; i
< addr_size
; i
++)
2328 for (i
= 0; i
< addr_size
; i
++)
2332 /* Emit data for .debug_aranges. */
2335 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2337 unsigned int addr_size
= sizeof_address
;
2341 symbolS
*aranges_end
;
2345 memset (&exp
, 0, sizeof exp
);
2346 sizeof_offset
= out_header (aranges_seg
, &exp
);
2347 aranges_end
= exp
.X_add_symbol
;
2348 size
= -exp
.X_add_number
;
2351 out_two (DWARF2_ARANGES_VERSION
);
2354 /* Offset to .debug_info. */
2355 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2356 size
+= sizeof_offset
;
2358 /* Size of an address (offset portion). */
2359 out_byte (addr_size
);
2362 /* Size of a segment descriptor. */
2366 /* Align the header. */
2367 while ((size
++ % (2 * addr_size
)) > 0)
2370 for (s
= all_segs
; s
; s
= s
->next
)
2375 frag
= first_frag_for_seg (s
->seg
);
2376 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2377 s
->text_start
= beg
;
2379 frag
= last_frag_for_seg (s
->seg
);
2380 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2383 exp
.X_op
= O_symbol
;
2384 exp
.X_add_symbol
= beg
;
2385 exp
.X_add_number
= 0;
2386 emit_expr (&exp
, addr_size
);
2388 exp
.X_op
= O_subtract
;
2389 exp
.X_add_symbol
= end
;
2390 exp
.X_op_symbol
= beg
;
2391 exp
.X_add_number
= 0;
2392 emit_expr (&exp
, addr_size
);
2395 p
= frag_more (2 * addr_size
);
2396 md_number_to_chars (p
, 0, addr_size
);
2397 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2399 symbol_set_value_now (aranges_end
);
2402 /* Emit data for .debug_abbrev. Note that this must be kept in
2403 sync with out_debug_info below. */
2406 out_debug_abbrev (segT abbrev_seg
,
2407 segT info_seg ATTRIBUTE_UNUSED
,
2408 segT line_seg ATTRIBUTE_UNUSED
)
2410 subseg_set (abbrev_seg
, 0);
2413 out_uleb128 (DW_TAG_compile_unit
);
2414 out_byte (DW_CHILDREN_no
);
2415 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2416 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
2418 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
2419 if (all_segs
->next
== NULL
)
2421 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2422 if (DWARF2_VERSION
< 4)
2423 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2425 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
2426 ? DW_FORM_data4
: DW_FORM_data8
));
2430 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
2431 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
2433 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
2435 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2436 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2437 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2438 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2441 /* Terminate the abbreviations for this compilation unit. */
2445 /* Emit a description of this compilation unit for .debug_info. */
2448 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
2449 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2455 memset (&exp
, 0, sizeof exp
);
2456 sizeof_offset
= out_header (info_seg
, &exp
);
2457 info_end
= exp
.X_add_symbol
;
2459 /* DWARF version. */
2460 out_two (DWARF2_VERSION
);
2462 /* .debug_abbrev offset */
2463 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2465 /* Target address size. */
2466 out_byte (sizeof_address
);
2468 /* DW_TAG_compile_unit DIE abbrev */
2471 /* DW_AT_stmt_list */
2472 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2473 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2476 /* These two attributes are emitted if all of the code is contiguous. */
2477 if (all_segs
->next
== NULL
)
2480 exp
.X_op
= O_symbol
;
2481 exp
.X_add_symbol
= all_segs
->text_start
;
2482 exp
.X_add_number
= 0;
2483 emit_expr (&exp
, sizeof_address
);
2486 if (DWARF2_VERSION
< 4)
2487 exp
.X_op
= O_symbol
;
2490 exp
.X_op
= O_subtract
;
2491 exp
.X_op_symbol
= all_segs
->text_start
;
2493 exp
.X_add_symbol
= all_segs
->text_end
;
2494 exp
.X_add_number
= 0;
2495 emit_expr (&exp
, sizeof_address
);
2499 /* This attribute is emitted if the code is disjoint. */
2501 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2504 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2505 setup in out_debug_str below. */
2506 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2507 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2508 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2510 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2511 dwarf2 draft has no standard code for assembler. */
2512 out_two (DW_LANG_Mips_Assembler
);
2514 symbol_set_value_now (info_end
);
2517 /* Emit the three debug strings needed in .debug_str and setup symbols
2518 to them for use in out_debug_info. */
2520 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2521 symbolS
**producer_sym
)
2524 const char *comp_dir
;
2525 const char *dirname
;
2528 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2530 subseg_set (str_seg
, 0);
2532 /* DW_AT_name. We don't have the actual file name that was present
2533 on the command line, so assume files[first_file] is the main input file.
2534 We're not supposed to get called unless at least one line number
2535 entry was emitted, so this should always be defined. */
2536 *name_sym
= symbol_temp_new_now_octets ();
2537 if (files_in_use
== 0)
2539 if (files
[first_file
].dir
)
2541 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2542 len
= strlen (dirname
);
2544 /* Already has trailing slash. */
2545 p
= frag_more (len
);
2546 memcpy (p
, dirname
, len
);
2548 p
= frag_more (len
+ 1);
2549 memcpy (p
, dirname
, len
);
2550 INSERT_DIR_SEPARATOR (p
, len
);
2553 len
= strlen (files
[first_file
].filename
) + 1;
2554 p
= frag_more (len
);
2555 memcpy (p
, files
[first_file
].filename
, len
);
2557 /* DW_AT_comp_dir */
2558 *comp_dir_sym
= symbol_temp_new_now_octets ();
2559 comp_dir
= remap_debug_filename (getpwd ());
2560 len
= strlen (comp_dir
) + 1;
2561 p
= frag_more (len
);
2562 memcpy (p
, comp_dir
, len
);
2564 /* DW_AT_producer */
2565 *producer_sym
= symbol_temp_new_now_octets ();
2566 sprintf (producer
, "GNU AS %s", VERSION
);
2567 len
= strlen (producer
) + 1;
2568 p
= frag_more (len
);
2569 memcpy (p
, producer
, len
);
2575 last_seg_ptr
= &all_segs
;
2577 /* Select the default CIE version to produce here. The global
2578 starts with a value of -1 and will be modified to a valid value
2579 either by the user providing a command line option, or some
2580 targets will select their own default in md_after_parse_args. If
2581 we get here and the global still contains -1 then it is up to us
2582 to pick a sane default. The default we choose is 1, this is the
2583 CIE version gas has produced for a long time, and there seems no
2584 reason to change it yet. */
2585 if (flag_dwarf_cie_version
== -1)
2586 flag_dwarf_cie_version
= 1;
2590 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2591 were any .file/.loc directives, or --gdwarf2 was given, or if the
2592 file has a non-empty .debug_info section and an empty .debug_line
2593 section. If we emit .debug_line, and the .debug_info section is
2594 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2595 ALL_SEGS will be non-null if there were any .file/.loc directives,
2596 or --gdwarf2 was given and there were any located instructions
2600 dwarf2_finish (void)
2605 int emit_other_sections
= 0;
2606 int empty_debug_line
= 0;
2608 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2609 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2611 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2612 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2614 /* We can't construct a new debug_line section if we already have one.
2616 if (all_segs
&& !empty_debug_line
)
2617 as_fatal ("duplicate .debug_line sections");
2619 if ((!all_segs
&& emit_other_sections
)
2620 || (!emit_other_sections
&& !empty_debug_line
))
2621 /* If there is no line information and no non-empty .debug_info
2622 section, or if there is both a non-empty .debug_info and a non-empty
2623 .debug_line, then we do nothing. */
2626 /* Calculate the size of an address for the target machine. */
2627 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2629 /* Create and switch to the line number section. */
2630 line_seg
= subseg_new (".debug_line", 0);
2631 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2633 /* For each subsection, chain the debug entries together. */
2634 for (s
= all_segs
; s
; s
= s
->next
)
2636 struct line_subseg
*lss
= s
->head
;
2637 struct line_entry
**ptail
= lss
->ptail
;
2639 /* Reset the initial view of the first subsection of the
2641 if (lss
->head
&& lss
->head
->loc
.view
)
2642 set_or_check_view (lss
->head
, NULL
, NULL
);
2644 while ((lss
= lss
->next
) != NULL
)
2646 /* Link the first view of subsequent subsections to the
2648 if (lss
->head
&& lss
->head
->loc
.view
)
2649 set_or_check_view (lss
->head
,
2650 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2651 s
->head
? s
->head
->head
: NULL
);
2657 out_debug_line (line_seg
);
2659 /* If this is assembler generated line info, and there is no
2660 debug_info already, we need .debug_info, .debug_abbrev and
2661 .debug_str sections as well. */
2662 if (emit_other_sections
)
2668 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2670 gas_assert (all_segs
);
2672 info_seg
= subseg_new (".debug_info", 0);
2673 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2674 aranges_seg
= subseg_new (".debug_aranges", 0);
2675 str_seg
= subseg_new (".debug_str", 0);
2677 bfd_set_section_flags (info_seg
,
2678 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2679 bfd_set_section_flags (abbrev_seg
,
2680 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2681 bfd_set_section_flags (aranges_seg
,
2682 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2683 bfd_set_section_flags (str_seg
,
2684 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2685 | SEC_MERGE
| SEC_STRINGS
);
2686 str_seg
->entsize
= 1;
2688 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2690 if (all_segs
->next
== NULL
)
2694 ranges_seg
= subseg_new (".debug_ranges", 0);
2695 bfd_set_section_flags (ranges_seg
,
2696 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2697 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2698 out_debug_ranges (ranges_seg
);
2701 out_debug_aranges (aranges_seg
, info_seg
);
2702 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2703 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2704 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2705 name_sym
, comp_dir_sym
, producer_sym
);
2709 /* Perform any deferred checks pertaining to debug information. */
2712 dwarf2dbg_final_check (void)
2714 /* Perform reset-view checks. Don't evaluate view_assert_failed
2715 recursively: it could be very deep. It's a chain of adds, with
2716 each chain element pointing to the next in X_add_symbol, and
2717 holding the check value in X_op_symbol. */
2718 while (view_assert_failed
)
2724 gas_assert (!symbol_resolved_p (view_assert_failed
));
2726 exp
= symbol_get_value_expression (view_assert_failed
);
2727 sym
= view_assert_failed
;
2729 /* If view_assert_failed looks like a compound check in the
2730 chain, break it up. */
2731 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2733 view_assert_failed
= exp
->X_add_symbol
;
2734 sym
= exp
->X_op_symbol
;
2737 view_assert_failed
= NULL
;
2739 failed
= resolve_symbol_value (sym
);
2740 if (!symbol_resolved_p (sym
) || failed
)
2742 as_bad (_("view number mismatch"));