1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2020 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION dwarf_level
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation outputs version 3 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
105 /* The .debug_rnglists has only been in DWARF version 5. */
106 #ifndef DWARF2_RNGLISTS_VERSION
107 #define DWARF2_RNGLISTS_VERSION 5
114 /* Since we can't generate the prolog until the body is complete, we
115 use three different subsegments for .debug_line: one holding the
116 prolog, one for the directory and filename info, and one for the
117 body ("statement program"). */
122 /* If linker relaxation might change offsets in the code, the DWARF special
123 opcodes and variable-length operands cannot be used. If this macro is
124 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
125 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
126 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
129 /* First special line opcode - leave room for the standard opcodes.
130 Note: If you want to change this, you'll have to update the
131 "standard_opcode_lengths" table that is emitted below in
133 #define DWARF2_LINE_OPCODE_BASE 13
135 #ifndef DWARF2_LINE_BASE
136 /* Minimum line offset in a special line info. opcode. This value
137 was chosen to give a reasonable range of values. */
138 # define DWARF2_LINE_BASE -5
141 /* Range of line offsets in a special line info. opcode. */
142 #ifndef DWARF2_LINE_RANGE
143 # define DWARF2_LINE_RANGE 14
146 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
147 /* Define the architecture-dependent minimum instruction length (in
148 bytes). This value should be rather too small than too big. */
149 # define DWARF2_LINE_MIN_INSN_LENGTH 1
152 /* Flag that indicates the initial value of the is_stmt_start flag. */
153 #define DWARF2_LINE_DEFAULT_IS_STMT 1
155 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
156 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
159 /* Given a special op, return the line skip amount. */
160 #define SPECIAL_LINE(op) \
161 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
163 /* Given a special op, return the address skip amount (in units of
164 DWARF2_LINE_MIN_INSN_LENGTH. */
165 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
167 /* The maximum address skip amount that can be encoded with a special op. */
168 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
170 #ifndef TC_PARSE_CONS_RETURN_NONE
171 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
176 struct line_entry
*next
;
178 struct dwarf2_line_info loc
;
181 /* Don't change the offset of next in line_entry. set_or_check_view
182 calls in dwarf2_gen_line_info_1 depend on it. */
183 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
188 struct line_subseg
*next
;
190 struct line_entry
*head
;
191 struct line_entry
**ptail
;
192 struct line_entry
**pmove_tail
;
197 struct line_seg
*next
;
199 struct line_subseg
*head
;
204 /* Collects data for all line table entries during assembly. */
205 static struct line_seg
*all_segs
;
206 static struct line_seg
**last_seg_ptr
;
208 #define NUM_MD5_BYTES 16
212 const char * filename
;
214 unsigned char md5
[NUM_MD5_BYTES
];
217 /* Table of files used by .debug_line. */
218 static struct file_entry
*files
;
219 static unsigned int files_in_use
;
220 static unsigned int files_allocated
;
222 /* Table of directories used by .debug_line. */
223 static char ** dirs
= NULL
;
224 static unsigned int dirs_in_use
= 0;
225 static unsigned int dirs_allocated
= 0;
227 /* TRUE when we've seen a .loc directive recently. Used to avoid
228 doing work when there's nothing to do. Will be reset by
229 dwarf2_consume_line_info. */
230 bfd_boolean dwarf2_loc_directive_seen
;
232 /* TRUE when we've seen any .loc directive at any time during parsing.
233 Indicates the user wants us to generate a .debug_line section.
234 Used in dwarf2_finish as sanity check. */
235 static bfd_boolean dwarf2_any_loc_directive_seen
;
237 /* TRUE when we're supposed to set the basic block mark whenever a
239 bfd_boolean dwarf2_loc_mark_labels
;
241 /* Current location as indicated by the most recent .loc directive. */
242 static struct dwarf2_line_info current
=
245 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
249 /* This symbol is used to recognize view number forced resets in loc
251 static symbolS
*force_reset_view
;
253 /* This symbol evaluates to an expression that, if nonzero, indicates
254 some view assert check failed. */
255 static symbolS
*view_assert_failed
;
257 /* The size of an address on the target. */
258 static unsigned int sizeof_address
;
260 #ifndef TC_DWARF2_EMIT_OFFSET
261 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
263 /* Create an offset to .dwarf2_*. */
266 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
270 memset (&exp
, 0, sizeof exp
);
272 exp
.X_add_symbol
= symbol
;
273 exp
.X_add_number
= 0;
274 emit_expr (&exp
, size
);
278 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
280 static struct line_subseg
*
281 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
283 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
284 struct line_subseg
**pss
, *lss
;
291 s
= XNEW (struct line_seg
);
296 last_seg_ptr
= &s
->next
;
297 seg_info (seg
)->dwarf2_line_seg
= s
;
300 gas_assert (seg
== s
->seg
);
302 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
304 if (lss
->subseg
== subseg
)
306 if (lss
->subseg
> subseg
)
310 lss
= XNEW (struct line_subseg
);
312 lss
->subseg
= subseg
;
314 lss
->ptail
= &lss
->head
;
315 lss
->pmove_tail
= &lss
->head
;
322 /* (Un)reverse the line_entry list starting from H. */
324 static struct line_entry
*
325 reverse_line_entry_list (struct line_entry
*h
)
327 struct line_entry
*p
= NULL
, *e
, *n
;
329 for (e
= h
; e
; e
= n
)
338 /* Compute the view for E based on the previous entry P. If we
339 introduce an (undefined) view symbol for P, and H is given (P must
340 be the tail in this case), introduce view symbols for earlier list
341 entries as well, until one of them is constant. */
344 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
345 struct line_entry
*h
)
349 memset (&viewx
, 0, sizeof (viewx
));
350 viewx
.X_unsigned
= 1;
352 /* First, compute !(E->label > P->label), to tell whether or not
353 we're to reset the view number. If we can't resolve it to a
354 constant, keep it symbolic. */
355 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
357 viewx
.X_op
= O_constant
;
358 viewx
.X_add_number
= 0;
359 viewx
.X_add_symbol
= NULL
;
360 viewx
.X_op_symbol
= NULL
;
365 viewx
.X_add_number
= 0;
366 viewx
.X_add_symbol
= e
->label
;
367 viewx
.X_op_symbol
= p
->label
;
368 resolve_expression (&viewx
);
369 if (viewx
.X_op
== O_constant
)
370 viewx
.X_add_number
= !viewx
.X_add_number
;
373 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
374 viewx
.X_add_number
= 0;
375 viewx
.X_op_symbol
= NULL
;
376 viewx
.X_op
= O_logical_not
;
380 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
382 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
383 /* We can't compare the view numbers at this point, because in
384 VIEWX we've only determined whether we're to reset it so
386 if (viewx
.X_op
== O_constant
)
388 if (!value
->X_add_number
!= !viewx
.X_add_number
)
389 as_bad (_("view number mismatch"));
391 /* Record the expression to check it later. It is the result of
392 a logical not, thus 0 or 1. We just add up all such deferred
393 expressions, and resolve it at the end. */
394 else if (!value
->X_add_number
)
396 symbolS
*deferred
= make_expr_symbol (&viewx
);
397 if (view_assert_failed
)
401 memset (&chk
, 0, sizeof (chk
));
404 chk
.X_add_number
= 0;
405 chk
.X_add_symbol
= view_assert_failed
;
406 chk
.X_op_symbol
= deferred
;
407 deferred
= make_expr_symbol (&chk
);
409 view_assert_failed
= deferred
;
413 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
419 p
->loc
.view
= symbol_temp_make ();
420 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
423 memset (&incv
, 0, sizeof (incv
));
425 incv
.X_op
= O_symbol
;
426 incv
.X_add_symbol
= p
->loc
.view
;
427 incv
.X_add_number
= 1;
429 if (viewx
.X_op
== O_constant
)
431 gas_assert (viewx
.X_add_number
== 1);
436 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
437 viewx
.X_add_number
= 0;
438 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
439 viewx
.X_op
= O_multiply
;
443 if (!S_IS_DEFINED (e
->loc
.view
))
445 symbol_set_value_expression (e
->loc
.view
, &viewx
);
446 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
447 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
450 /* Define and attempt to simplify any earlier views needed to
452 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
454 struct line_entry
*h2
;
455 /* Reverse the list to avoid quadratic behavior going backwards
456 in a single-linked list. */
457 struct line_entry
*r
= reverse_line_entry_list (h
);
460 /* Set or check views until we find a defined or absent view. */
463 /* Do not define the head of a (sub?)segment view while
464 handling others. It would be defined too early, without
465 regard to the last view of other subsegments.
466 set_or_check_view will be called for every head segment
470 set_or_check_view (r
, r
->next
, NULL
);
472 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
475 /* Unreverse the list, so that we can go forward again. */
476 h2
= reverse_line_entry_list (p
);
477 gas_assert (h2
== h
);
479 /* Starting from the last view we just defined, attempt to
480 simplify the view expressions, until we do so to P. */
483 /* The head view of a subsegment may remain undefined while
484 handling other elements, before it is linked to the last
485 view of the previous subsegment. */
488 gas_assert (S_IS_DEFINED (r
->loc
.view
));
489 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
491 while (r
!= p
&& (r
= r
->next
));
493 /* Now that we've defined and computed all earlier views that might
494 be needed to compute E's, attempt to simplify it. */
495 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
499 /* Record an entry for LOC occurring at LABEL. */
502 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
504 struct line_subseg
*lss
;
505 struct line_entry
*e
;
507 e
= XNEW (struct line_entry
);
512 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
514 /* Subseg heads are chained to previous subsegs in
516 if (loc
->view
&& lss
->head
)
517 set_or_check_view (e
,
518 (struct line_entry
*)lss
->ptail
,
522 lss
->ptail
= &e
->next
;
525 /* Record an entry for LOC occurring at OFS within the current fragment. */
528 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
530 static unsigned int line
= -1;
531 static unsigned int filenum
= -1;
535 /* Early out for as-yet incomplete location information. */
538 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
541 /* Don't emit sequences of line symbols for the same line when the
542 symbols apply to assembler code. It is necessary to emit
543 duplicate line symbols when a compiler asks for them, because GDB
544 uses them to determine the end of the prologue. */
545 if (debug_type
== DEBUG_DWARF2
546 && line
== loc
->line
&& filenum
== loc
->filenum
)
550 filenum
= loc
->filenum
;
556 /* Use a non-fake name for the line number location,
557 so that it can be referred to by relocations. */
558 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
559 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
562 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
563 dwarf2_gen_line_info_1 (sym
, loc
);
567 get_basename (const char * pathname
)
571 file
= lbasename (pathname
);
572 /* Don't make empty string from / or A: from A:/ . */
573 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
574 if (file
<= pathname
+ 3)
577 if (file
== pathname
+ 1)
584 get_directory_table_entry (const char * dirname
,
586 bfd_boolean can_use_zero
)
593 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
594 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
602 for (d
= 0; d
< dirs_in_use
; ++d
)
605 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
606 && dirs
[d
][dirlen
] == '\0')
612 if (dirs
== NULL
|| dirs
[0] == NULL
)
618 if (d
>= dirs_allocated
)
620 unsigned int old
= dirs_allocated
;
622 dirs_allocated
= d
+ 32;
623 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
624 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
627 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
628 if (dirs_in_use
<= d
)
635 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
637 if (i
>= files_allocated
)
639 unsigned int old
= files_allocated
;
641 files_allocated
= i
+ 32;
642 /* Catch wraparound. */
643 if (files_allocated
<= old
)
645 as_bad (_("file number %lu is too big"), (unsigned long) i
);
649 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
650 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
653 files
[i
].filename
= file
;
655 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
657 if (files_in_use
< i
+ 1)
658 files_in_use
= i
+ 1;
663 /* Get a .debug_line file number for PATHNAME. If there is a
664 directory component to PATHNAME, then this will be stored
665 in the directory table, if it is not already present.
666 Returns the slot number allocated to that filename or -1
667 if there was a problem. */
670 allocate_filenum (const char * pathname
)
672 static signed int last_used
= -1, last_used_dir_len
= 0;
677 /* Short circuit the common case of adding the same pathname
681 const char * dirname
= NULL
;
684 dirname
= dirs
[files
[last_used
].dir
];
688 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
693 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
694 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
695 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
696 files
[last_used
].filename
) == 0)
701 file
= get_basename (pathname
);
702 dir_len
= file
- pathname
;
704 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
706 /* Do not use slot-0. That is specifically reserved for use by
707 the '.file 0 "name"' directive. */
708 for (i
= 1; i
< files_in_use
; ++i
)
709 if (files
[i
].dir
== dir
711 && filename_cmp (file
, files
[i
].filename
) == 0)
714 last_used_dir_len
= dir_len
;
718 if (!assign_file_to_slot (i
, file
, dir
))
722 last_used_dir_len
= dir_len
;
727 /* Allocate slot NUM in the .debug_line file table to FILENAME.
728 If DIRNAME is not NULL or there is a directory component to FILENAME
729 then this will be stored in the directory table, if not already present.
730 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
731 Returns TRUE if allocation succeeded, FALSE otherwise. */
734 allocate_filename_to_slot (const char * dirname
,
735 const char * filename
,
737 bfd_boolean with_md5
)
743 /* Short circuit the common case of adding the same pathname
745 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
747 const char * dir
= NULL
;
750 dir
= dirs
[files
[num
].dir
];
753 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
758 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
761 if (filename_cmp (filename
, files
[num
].filename
) != 0)
764 /* If the filenames match, but the directory table entry was
765 empty, then fill it with the provided directory name. */
767 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
771 else if (dir
!= NULL
)
773 dirlen
= strlen (dir
);
774 if (filename_ncmp (filename
, dir
, dirlen
) == 0
775 && IS_DIR_SEPARATOR (filename
[dirlen
])
776 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
779 else /* dir == NULL */
781 file
= get_basename (filename
);
782 if (filename_cmp (file
, files
[num
].filename
) == 0)
785 /* The filenames match, but the directory table entry is empty.
786 Fill it with the provided directory name. */
787 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
793 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
795 dir
== NULL
? "" : dir
,
796 dir
== NULL
? "" : "/",
798 dirname
== NULL
? "" : dirname
,
799 dirname
== NULL
? "" : "/",
807 file
= get_basename (filename
);
808 dirlen
= file
- filename
;
812 dirlen
= strlen (dirname
);
816 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
819 if (! assign_file_to_slot (i
, file
, d
))
824 if (target_big_endian
)
826 /* md5's are stored in litte endian format. */
827 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
828 unsigned int byte
= NUM_MD5_BYTES
;
829 unsigned int bignum_index
= 0;
831 while (bits_remaining
)
833 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
834 valueT bignum_value
= generic_bignum
[bignum_index
];
837 while (bignum_bits_remaining
)
839 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
841 bignum_bits_remaining
-= 8;
848 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
849 unsigned int byte
= 0;
850 unsigned int bignum_index
= 0;
852 while (bits_remaining
)
854 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
855 valueT bignum_value
= generic_bignum
[bignum_index
];
859 while (bignum_bits_remaining
)
861 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
863 bignum_bits_remaining
-= 8;
870 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
875 /* Returns the current source information. If .file directives have
876 been encountered, the info for the corresponding source file is
877 returned. Otherwise, the info for the assembly source file is
881 dwarf2_where (struct dwarf2_line_info
*line
)
883 if (debug_type
== DEBUG_DWARF2
)
885 const char *filename
;
887 memset (line
, 0, sizeof (*line
));
888 filename
= as_where (&line
->line
);
889 line
->filenum
= allocate_filenum (filename
);
890 /* FIXME: We should check the return value from allocate_filenum. */
892 line
->flags
= DWARF2_FLAG_IS_STMT
;
893 line
->isa
= current
.isa
;
894 line
->discriminator
= current
.discriminator
;
901 /* A hook to allow the target backend to inform the line number state
902 machine of isa changes when assembler debug info is enabled. */
905 dwarf2_set_isa (unsigned int isa
)
910 /* Called for each machine instruction, or relatively atomic group of
911 machine instructions (ie built-in macro). The instruction or group
912 is SIZE bytes in length. If dwarf2 line number generation is called
913 for, emit a line statement appropriately. */
916 dwarf2_emit_insn (int size
)
918 struct dwarf2_line_info loc
;
920 if (debug_type
!= DEBUG_DWARF2
921 ? !dwarf2_loc_directive_seen
922 : !seen_at_least_1_file ())
927 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
928 dwarf2_consume_line_info ();
931 /* Move all previously-emitted line entries for the current position by
932 DELTA bytes. This function cannot be used to move the same entries
936 dwarf2_move_insn (int delta
)
938 struct line_subseg
*lss
;
939 struct line_entry
*e
;
945 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
949 now
= frag_now_fix ();
950 while ((e
= *lss
->pmove_tail
))
952 if (S_GET_VALUE (e
->label
) == now
)
953 S_SET_VALUE (e
->label
, now
+ delta
);
954 lss
->pmove_tail
= &e
->next
;
958 /* Called after the current line information has been either used with
959 dwarf2_gen_line_info or saved with a machine instruction for later use.
960 This resets the state of the line number information to reflect that
964 dwarf2_consume_line_info (void)
966 /* Unless we generate DWARF2 debugging information for each
967 assembler line, we only emit one line symbol for one LOC. */
968 dwarf2_loc_directive_seen
= FALSE
;
970 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
971 | DWARF2_FLAG_PROLOGUE_END
972 | DWARF2_FLAG_EPILOGUE_BEGIN
);
973 current
.discriminator
= 0;
977 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
978 is enabled, emit a basic block marker. */
981 dwarf2_emit_label (symbolS
*label
)
983 struct dwarf2_line_info loc
;
985 if (!dwarf2_loc_mark_labels
)
987 if (S_GET_SEGMENT (label
) != now_seg
)
989 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
991 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
996 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
998 dwarf2_gen_line_info_1 (label
, &loc
);
999 dwarf2_consume_line_info ();
1002 /* Handle two forms of .file directive:
1003 - Pass .file "source.c" to s_app_file
1004 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1006 If an entry is added to the file table, return a pointer to the filename. */
1009 dwarf2_directive_filename (void)
1011 bfd_boolean with_md5
= FALSE
;
1014 const char * dirname
= NULL
;
1017 /* Continue to accept a bare string and pass it off. */
1019 if (*input_line_pointer
== '"')
1025 num
= get_absolute_expression ();
1027 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1029 as_bad (_("file number less than one"));
1030 ignore_rest_of_line ();
1034 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1035 "switch back to the already allocated file <N> as the current
1038 filename
= demand_copy_C_string (&filename_len
);
1039 if (filename
== NULL
)
1040 /* demand_copy_C_string will have already generated an error message. */
1043 /* For DWARF-5 support we also accept:
1044 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1045 if (DWARF2_LINE_VERSION
> 4)
1048 if (*input_line_pointer
== '"')
1051 filename
= demand_copy_C_string (&filename_len
);
1055 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1057 input_line_pointer
+= 3;
1061 expression_and_evaluate (& exp
);
1062 if (exp
.X_op
!= O_big
)
1063 as_bad (_("md5 value too small or not a constant"));
1069 demand_empty_rest_of_line ();
1071 /* A .file directive implies compiler generated debug information is
1072 being supplied. Turn off gas generated debug info. */
1073 debug_type
= DEBUG_NONE
;
1075 if (num
!= (unsigned int) num
1076 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1078 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1082 if (files_in_use
== 2)
1084 /* Clear the slot 1 if it was assigned to the input file before
1085 the first .file <NUMBER> directive was seen. */
1086 unsigned int lineno
;
1087 const char *file
= as_where (&lineno
);
1088 file
= get_basename (file
);
1089 if (filename_cmp (file
, files
[1].filename
) == 0)
1091 files
[1].filename
= NULL
;
1096 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1103 /* Calls dwarf2_directive_filename, but discards its result.
1104 Used in pseudo-op tables where the function result is ignored. */
1107 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1109 (void) dwarf2_directive_filename ();
1113 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1115 offsetT filenum
, line
;
1117 /* If we see two .loc directives in a row, force the first one to be
1119 if (dwarf2_loc_directive_seen
)
1120 dwarf2_emit_insn (0);
1122 filenum
= get_absolute_expression ();
1124 line
= get_absolute_expression ();
1128 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1130 as_bad (_("file number less than one"));
1135 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1137 as_bad (_("unassigned file number %ld"), (long) filenum
);
1141 current
.filenum
= filenum
;
1142 current
.line
= line
;
1143 current
.discriminator
= 0;
1148 if (files
[filenum
].dir
)
1150 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1151 size_t file_len
= strlen (files
[filenum
].filename
);
1152 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1154 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1155 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1156 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1157 cp
[dir_len
+ file_len
+ 1] = '\0';
1158 listing_source_file (cp
);
1162 listing_source_file (files
[filenum
].filename
);
1163 listing_source_line (line
);
1168 if (ISDIGIT (*input_line_pointer
))
1170 current
.column
= get_absolute_expression ();
1174 while (ISALPHA (*input_line_pointer
))
1179 c
= get_symbol_name (& p
);
1181 if (strcmp (p
, "basic_block") == 0)
1183 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1184 *input_line_pointer
= c
;
1186 else if (strcmp (p
, "prologue_end") == 0)
1188 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1189 *input_line_pointer
= c
;
1191 else if (strcmp (p
, "epilogue_begin") == 0)
1193 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1194 *input_line_pointer
= c
;
1196 else if (strcmp (p
, "is_stmt") == 0)
1198 (void) restore_line_pointer (c
);
1199 value
= get_absolute_expression ();
1201 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1202 else if (value
== 1)
1203 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1206 as_bad (_("is_stmt value not 0 or 1"));
1210 else if (strcmp (p
, "isa") == 0)
1212 (void) restore_line_pointer (c
);
1213 value
= get_absolute_expression ();
1215 current
.isa
= value
;
1218 as_bad (_("isa number less than zero"));
1222 else if (strcmp (p
, "discriminator") == 0)
1224 (void) restore_line_pointer (c
);
1225 value
= get_absolute_expression ();
1227 current
.discriminator
= value
;
1230 as_bad (_("discriminator less than zero"));
1234 else if (strcmp (p
, "view") == 0)
1238 (void) restore_line_pointer (c
);
1241 if (ISDIGIT (*input_line_pointer
)
1242 || *input_line_pointer
== '-')
1244 bfd_boolean force_reset
= *input_line_pointer
== '-';
1246 value
= get_absolute_expression ();
1249 as_bad (_("numeric view can only be asserted to zero"));
1252 if (force_reset
&& force_reset_view
)
1253 sym
= force_reset_view
;
1256 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1259 force_reset_view
= sym
;
1264 char *name
= read_symbol_name ();
1268 sym
= symbol_find_or_make (name
);
1269 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1271 if (S_IS_VOLATILE (sym
))
1272 sym
= symbol_clone (sym
, 1);
1273 else if (!S_CAN_BE_REDEFINED (sym
))
1275 as_bad (_("symbol `%s' is already defined"), name
);
1279 S_SET_SEGMENT (sym
, undefined_section
);
1280 S_SET_VALUE (sym
, 0);
1281 symbol_set_frag (sym
, &zero_address_frag
);
1287 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1288 (void) restore_line_pointer (c
);
1292 SKIP_WHITESPACE_AFTER_NAME ();
1295 demand_empty_rest_of_line ();
1296 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1297 debug_type
= DEBUG_NONE
;
1299 /* If we were given a view id, emit the row right away. */
1301 dwarf2_emit_insn (0);
1305 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1307 offsetT value
= get_absolute_expression ();
1309 if (value
!= 0 && value
!= 1)
1311 as_bad (_("expected 0 or 1"));
1312 ignore_rest_of_line ();
1316 dwarf2_loc_mark_labels
= value
!= 0;
1317 demand_empty_rest_of_line ();
1321 static struct frag
*
1322 first_frag_for_seg (segT seg
)
1324 return seg_info (seg
)->frchainP
->frch_root
;
1327 static struct frag
*
1328 last_frag_for_seg (segT seg
)
1330 frchainS
*f
= seg_info (seg
)->frchainP
;
1332 while (f
->frch_next
!= NULL
)
1335 return f
->frch_last
;
1338 /* Emit a single byte into the current segment. */
1343 FRAG_APPEND_1_CHAR (byte
);
1346 /* Emit a statement program opcode into the current segment. */
1349 out_opcode (int opc
)
1354 /* Emit a two-byte word into the current segment. */
1359 md_number_to_chars (frag_more (2), data
, 2);
1362 /* Emit a four byte word into the current segment. */
1367 md_number_to_chars (frag_more (4), data
, 4);
1370 /* Emit an unsigned "little-endian base 128" number. */
1373 out_uleb128 (addressT value
)
1375 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1378 /* Emit a signed "little-endian base 128" number. */
1381 out_leb128 (addressT value
)
1383 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1386 /* Emit a tuple for .debug_abbrev. */
1389 out_abbrev (int name
, int form
)
1395 /* Get the size of a fragment. */
1398 get_frag_fix (fragS
*frag
, segT seg
)
1403 return frag
->fr_fix
;
1405 /* If a fragment is the last in the chain, special measures must be
1406 taken to find its size before relaxation, since it may be pending
1407 on some subsegment chain. */
1408 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1409 if (fr
->frch_last
== frag
)
1410 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1415 /* Set an absolute address (may result in a relocation entry). */
1418 out_set_addr (symbolS
*sym
)
1422 memset (&exp
, 0, sizeof exp
);
1423 out_opcode (DW_LNS_extended_op
);
1424 out_uleb128 (sizeof_address
+ 1);
1426 out_opcode (DW_LNE_set_address
);
1427 exp
.X_op
= O_symbol
;
1428 exp
.X_add_symbol
= sym
;
1429 exp
.X_add_number
= 0;
1430 emit_expr (&exp
, sizeof_address
);
1433 static void scale_addr_delta (addressT
*);
1436 scale_addr_delta (addressT
*addr_delta
)
1438 static int printed_this
= 0;
1439 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1441 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1443 as_bad("unaligned opcodes detected in executable segment");
1446 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1450 /* Encode a pair of line and address skips as efficiently as possible.
1451 Note that the line skip is signed, whereas the address skip is unsigned.
1453 The following two routines *must* be kept in sync. This is
1454 enforced by making emit_inc_line_addr abort if we do not emit
1455 exactly the expected number of bytes. */
1458 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1460 unsigned int tmp
, opcode
;
1463 /* Scale the address delta by the minimum instruction length. */
1464 scale_addr_delta (&addr_delta
);
1466 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1467 We cannot use special opcodes here, since we want the end_sequence
1468 to emit the matrix entry. */
1469 if (line_delta
== INT_MAX
)
1471 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1473 else if (addr_delta
)
1474 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1478 /* Bias the line delta by the base. */
1479 tmp
= line_delta
- DWARF2_LINE_BASE
;
1481 /* If the line increment is out of range of a special opcode, we
1482 must encode it with DW_LNS_advance_line. */
1483 if (tmp
>= DWARF2_LINE_RANGE
)
1485 len
= 1 + sizeof_leb128 (line_delta
, 1);
1487 tmp
= 0 - DWARF2_LINE_BASE
;
1490 /* Bias the opcode by the special opcode base. */
1491 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1493 /* Avoid overflow when addr_delta is large. */
1494 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1496 /* Try using a special opcode. */
1497 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1501 /* Try using DW_LNS_const_add_pc followed by special op. */
1502 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1507 /* Otherwise use DW_LNS_advance_pc. */
1508 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1510 /* DW_LNS_copy or special opcode. */
1517 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1519 unsigned int tmp
, opcode
;
1521 char *end
= p
+ len
;
1523 /* Line number sequences cannot go backward in addresses. This means
1524 we've incorrectly ordered the statements in the sequence. */
1525 gas_assert ((offsetT
) addr_delta
>= 0);
1527 /* Scale the address delta by the minimum instruction length. */
1528 scale_addr_delta (&addr_delta
);
1530 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1531 We cannot use special opcodes here, since we want the end_sequence
1532 to emit the matrix entry. */
1533 if (line_delta
== INT_MAX
)
1535 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1536 *p
++ = DW_LNS_const_add_pc
;
1537 else if (addr_delta
)
1539 *p
++ = DW_LNS_advance_pc
;
1540 p
+= output_leb128 (p
, addr_delta
, 0);
1543 *p
++ = DW_LNS_extended_op
;
1545 *p
++ = DW_LNE_end_sequence
;
1549 /* Bias the line delta by the base. */
1550 tmp
= line_delta
- DWARF2_LINE_BASE
;
1552 /* If the line increment is out of range of a special opcode, we
1553 must encode it with DW_LNS_advance_line. */
1554 if (tmp
>= DWARF2_LINE_RANGE
)
1556 *p
++ = DW_LNS_advance_line
;
1557 p
+= output_leb128 (p
, line_delta
, 1);
1560 tmp
= 0 - DWARF2_LINE_BASE
;
1564 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1566 if (line_delta
== 0 && addr_delta
== 0)
1572 /* Bias the opcode by the special opcode base. */
1573 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1575 /* Avoid overflow when addr_delta is large. */
1576 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1578 /* Try using a special opcode. */
1579 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1586 /* Try using DW_LNS_const_add_pc followed by special op. */
1587 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1590 *p
++ = DW_LNS_const_add_pc
;
1596 /* Otherwise use DW_LNS_advance_pc. */
1597 *p
++ = DW_LNS_advance_pc
;
1598 p
+= output_leb128 (p
, addr_delta
, 0);
1606 gas_assert (p
== end
);
1609 /* Handy routine to combine calls to the above two routines. */
1612 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1614 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1615 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1618 /* Write out an alternative form of line and address skips using
1619 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1620 line and address information, but it is required if linker relaxation
1621 could change the code offsets. The following two routines *must* be
1623 #define ADDR_DELTA_LIMIT 50000
1626 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1630 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1631 if (line_delta
!= INT_MAX
)
1632 len
= 1 + sizeof_leb128 (line_delta
, 1);
1634 if (addr_delta
> ADDR_DELTA_LIMIT
)
1636 /* DW_LNS_extended_op */
1637 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1638 /* DW_LNE_set_address */
1639 len
+= 1 + sizeof_address
;
1642 /* DW_LNS_fixed_advance_pc */
1645 if (line_delta
== INT_MAX
)
1646 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1656 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1660 char *end
= p
+ len
;
1662 /* Line number sequences cannot go backward in addresses. This means
1663 we've incorrectly ordered the statements in the sequence. */
1664 gas_assert ((offsetT
) addr_delta
>= 0);
1666 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1667 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1669 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1670 if (line_delta
!= INT_MAX
)
1672 *p
++ = DW_LNS_advance_line
;
1673 p
+= output_leb128 (p
, line_delta
, 1);
1676 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1678 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1679 advance the address by at most 64K. Linker relaxation (without
1680 which this function would not be used) could change the operand by
1681 an unknown amount. If the address increment is getting close to
1682 the limit, just reset the address. */
1683 if (addr_delta
> ADDR_DELTA_LIMIT
)
1688 memset (&exp
, 0, sizeof exp
);
1689 gas_assert (pexp
->X_op
== O_subtract
);
1690 to_sym
= pexp
->X_add_symbol
;
1692 *p
++ = DW_LNS_extended_op
;
1693 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1694 *p
++ = DW_LNE_set_address
;
1695 exp
.X_op
= O_symbol
;
1696 exp
.X_add_symbol
= to_sym
;
1697 exp
.X_add_number
= 0;
1698 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1699 p
+= sizeof_address
;
1703 *p
++ = DW_LNS_fixed_advance_pc
;
1704 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1708 if (line_delta
== INT_MAX
)
1710 *p
++ = DW_LNS_extended_op
;
1712 *p
++ = DW_LNE_end_sequence
;
1717 gas_assert (p
== end
);
1720 /* Generate a variant frag that we can use to relax address/line
1721 increments between fragments of the target segment. */
1724 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1729 memset (&exp
, 0, sizeof exp
);
1730 exp
.X_op
= O_subtract
;
1731 exp
.X_add_symbol
= to_sym
;
1732 exp
.X_op_symbol
= from_sym
;
1733 exp
.X_add_number
= 0;
1735 /* The maximum size of the frag is the line delta with a maximum
1736 sized address delta. */
1737 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1738 max_chars
= size_fixed_inc_line_addr (line_delta
,
1739 -DWARF2_LINE_MIN_INSN_LENGTH
);
1741 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1743 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1744 make_expr_symbol (&exp
), line_delta
, NULL
);
1747 /* The function estimates the size of a rs_dwarf2dbg variant frag
1748 based on the current values of the symbols. It is called before
1749 the relaxation loop. We set fr_subtype to the expected length. */
1752 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1757 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1758 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1759 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1761 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1763 frag
->fr_subtype
= size
;
1768 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1769 current values of the symbols. fr_subtype is the current length
1770 of the frag. This returns the change in frag length. */
1773 dwarf2dbg_relax_frag (fragS
*frag
)
1775 int old_size
, new_size
;
1777 old_size
= frag
->fr_subtype
;
1778 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1780 return new_size
- old_size
;
1783 /* This function converts a rs_dwarf2dbg variant frag into a normal
1784 fill frag. This is called after all relaxation has been done.
1785 fr_subtype will be the desired length of the frag. */
1788 dwarf2dbg_convert_frag (fragS
*frag
)
1792 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1794 /* If linker relaxation is enabled then the distance between the two
1795 symbols in the frag->fr_symbol expression might change. Hence we
1796 cannot rely upon the value computed by resolve_symbol_value.
1797 Instead we leave the expression unfinalized and allow
1798 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1799 relocation) that will allow the linker to correctly compute the
1800 actual address difference. We have to use a fixed line advance for
1801 this as we cannot (easily) relocate leb128 encoded values. */
1802 int saved_finalize_syms
= finalize_syms
;
1805 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1806 finalize_syms
= saved_finalize_syms
;
1809 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1811 /* fr_var carries the max_chars that we created the fragment with.
1812 fr_subtype carries the current expected length. We must, of
1813 course, have allocated enough memory earlier. */
1814 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1816 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1817 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1818 frag
->fr_literal
+ frag
->fr_fix
,
1821 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1822 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1824 frag
->fr_fix
+= frag
->fr_subtype
;
1825 frag
->fr_type
= rs_fill
;
1827 frag
->fr_offset
= 0;
1830 /* Generate .debug_line content for the chain of line number entries
1831 beginning at E, for segment SEG. */
1834 process_entries (segT seg
, struct line_entry
*e
)
1836 unsigned filenum
= 1;
1838 unsigned column
= 0;
1840 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1841 fragS
*last_frag
= NULL
, *frag
;
1842 addressT last_frag_ofs
= 0, frag_ofs
;
1843 symbolS
*last_lab
= NULL
, *lab
;
1844 struct line_entry
*next
;
1846 if (flag_dwarf_sections
)
1849 const char * sec_name
;
1851 /* Switch to the relevant sub-section before we start to emit
1852 the line number table.
1854 FIXME: These sub-sections do not have a normal Line Number
1855 Program Header, thus strictly speaking they are not valid
1856 DWARF sections. Unfortunately the DWARF standard assumes
1857 a one-to-one relationship between compilation units and
1858 line number tables. Thus we have to have a .debug_line
1859 section, as well as our sub-sections, and we have to ensure
1860 that all of the sub-sections are merged into a proper
1861 .debug_line section before a debugger sees them. */
1863 sec_name
= bfd_section_name (seg
);
1864 if (strcmp (sec_name
, ".text") != 0)
1866 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1867 subseg_set (subseg_get (name
, FALSE
), 0);
1870 /* Don't create a .debug_line.text section -
1871 that is redundant. Instead just switch back to the
1872 normal .debug_line section. */
1873 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1880 if (filenum
!= e
->loc
.filenum
)
1882 filenum
= e
->loc
.filenum
;
1883 out_opcode (DW_LNS_set_file
);
1884 out_uleb128 (filenum
);
1887 if (column
!= e
->loc
.column
)
1889 column
= e
->loc
.column
;
1890 out_opcode (DW_LNS_set_column
);
1891 out_uleb128 (column
);
1894 if (e
->loc
.discriminator
!= 0)
1896 out_opcode (DW_LNS_extended_op
);
1897 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1898 out_opcode (DW_LNE_set_discriminator
);
1899 out_uleb128 (e
->loc
.discriminator
);
1902 if (isa
!= e
->loc
.isa
)
1905 out_opcode (DW_LNS_set_isa
);
1909 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1911 flags
= e
->loc
.flags
;
1912 out_opcode (DW_LNS_negate_stmt
);
1915 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1916 out_opcode (DW_LNS_set_basic_block
);
1918 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1919 out_opcode (DW_LNS_set_prologue_end
);
1921 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1922 out_opcode (DW_LNS_set_epilogue_begin
);
1924 /* Don't try to optimize away redundant entries; gdb wants two
1925 entries for a function where the code starts on the same line as
1926 the {, and there's no way to identify that case here. Trust gcc
1927 to optimize appropriately. */
1928 line_delta
= e
->loc
.line
- line
;
1930 frag
= symbol_get_frag (lab
);
1931 frag_ofs
= S_GET_VALUE (lab
);
1933 if (last_frag
== NULL
1934 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1935 /* If we're going to reset the view, but we know we're
1936 advancing the PC, we don't have to force with
1937 set_address. We know we do when we're at the same
1938 address of the same frag, and we know we might when
1939 we're in the beginning of a frag, and we were at the
1940 end of the previous frag. */
1941 && (frag
== last_frag
1942 ? (last_frag_ofs
== frag_ofs
)
1944 && ((offsetT
)last_frag_ofs
1945 >= get_frag_fix (last_frag
, seg
))))))
1948 out_inc_line_addr (line_delta
, 0);
1950 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1951 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1953 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1958 last_frag_ofs
= frag_ofs
;
1966 /* Emit a DW_LNE_end_sequence for the end of the section. */
1967 frag
= last_frag_for_seg (seg
);
1968 frag_ofs
= get_frag_fix (frag
, seg
);
1969 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1970 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1973 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1974 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1978 /* Switch to LINE_STR_SEG and output the given STR. Return the
1979 symbol pointing to the new string in the section. */
1982 add_line_strp (segT line_str_seg
, const char *str
)
1988 subseg_set (line_str_seg
, 0);
1990 sym
= symbol_temp_new_now_octets ();
1992 size
= strlen (str
) + 1;
1993 cp
= frag_more (size
);
1994 memcpy (cp
, str
, size
);
2000 /* Emit the directory and file tables for .debug_line. */
2003 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2009 bfd_boolean emit_md5
= FALSE
;
2010 bfd_boolean emit_timestamps
= TRUE
;
2011 bfd_boolean emit_filesize
= TRUE
;
2012 segT line_str_seg
= NULL
;
2015 /* Output the Directory Table. */
2016 if (DWARF2_LINE_VERSION
>= 5)
2018 /* We only have one column in the directory table. */
2021 /* Describe the purpose and format of the column. */
2022 out_uleb128 (DW_LNCT_path
);
2023 /* Store these strings in the .debug_line_str section so they
2025 out_uleb128 (DW_FORM_line_strp
);
2027 /* Now state how many rows there are in the table. We need at
2028 least 1 if there is one or more file names to store the
2029 "working directory". */
2030 if (dirs_in_use
== 0 && files_in_use
> 0)
2033 out_uleb128 (dirs_in_use
);
2036 /* Emit directory list. */
2037 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2039 line_str_seg
= subseg_new (".debug_line_str", 0);
2040 bfd_set_section_flags (line_str_seg
,
2041 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2042 | SEC_MERGE
| SEC_STRINGS
);
2043 line_str_seg
->entsize
= 1;
2045 /* DWARF5 uses slot zero, but that is only set explicitly
2046 using a .file 0 directive. If that isn't used, but dir
2047 one is used, then use that as main file directory.
2048 Otherwise use pwd as main file directory. */
2049 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2050 dir
= remap_debug_filename (dirs
[0]);
2051 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2052 dir
= remap_debug_filename (dirs
[1]);
2054 dir
= remap_debug_filename (getpwd ());
2056 line_strp
= add_line_strp (line_str_seg
, dir
);
2057 subseg_set (line_seg
, 0);
2058 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2060 for (i
= 1; i
< dirs_in_use
; ++i
)
2062 dir
= remap_debug_filename (dirs
[i
]);
2063 if (DWARF2_LINE_VERSION
< 5)
2065 size
= strlen (dir
) + 1;
2066 cp
= frag_more (size
);
2067 memcpy (cp
, dir
, size
);
2071 line_strp
= add_line_strp (line_str_seg
, dir
);
2072 subseg_set (line_seg
, 0);
2073 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2077 if (DWARF2_LINE_VERSION
< 5)
2081 /* Output the File Name Table. */
2082 if (DWARF2_LINE_VERSION
>= 5)
2084 unsigned int columns
= 4;
2086 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2088 emit_timestamps
= FALSE
;
2092 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2094 emit_filesize
= FALSE
;
2098 for (i
= 0; i
< files_in_use
; ++i
)
2099 if (files
[i
].md5
[0] != 0)
2101 if (i
< files_in_use
)
2107 /* The number of format entries to follow. */
2109 /* The format of the file name. */
2110 out_uleb128 (DW_LNCT_path
);
2111 /* Store these strings in the .debug_line_str section so they
2113 out_uleb128 (DW_FORM_line_strp
);
2115 /* The format of the directory index. */
2116 out_uleb128 (DW_LNCT_directory_index
);
2117 out_uleb128 (DW_FORM_udata
);
2119 if (emit_timestamps
)
2121 /* The format of the timestamp. */
2122 out_uleb128 (DW_LNCT_timestamp
);
2123 out_uleb128 (DW_FORM_udata
);
2128 /* The format of the file size. */
2129 out_uleb128 (DW_LNCT_size
);
2130 out_uleb128 (DW_FORM_udata
);
2135 /* The format of the MD5 sum. */
2136 out_uleb128 (DW_LNCT_MD5
);
2137 out_uleb128 (DW_FORM_data16
);
2140 /* The number of entries in the table. */
2141 out_uleb128 (files_in_use
);
2144 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2146 const char *fullfilename
;
2148 if (files
[i
].filename
== NULL
)
2150 /* Prevent a crash later, particularly for file 1. DWARF5
2151 uses slot zero, but that is only set explicitly using a
2152 .file 0 directive. If that isn't used, but file 1 is,
2153 then use that as main file name. */
2154 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2155 files
[0].filename
= files
[1].filename
;
2157 files
[i
].filename
= "";
2158 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2160 as_bad (_("unassigned file number %ld"), (long) i
);
2165 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2166 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2167 if (DWARF2_LINE_VERSION
< 5)
2169 size
= strlen (fullfilename
) + 1;
2170 cp
= frag_more (size
);
2171 memcpy (cp
, fullfilename
, size
);
2175 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2176 subseg_set (line_seg
, 0);
2177 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2180 /* Directory number. */
2181 out_uleb128 (files
[i
].dir
);
2183 /* Output the last modification timestamp. */
2184 if (emit_timestamps
)
2188 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2189 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2190 if (timestamp
== -1)
2192 out_uleb128 (timestamp
);
2195 /* Output the filesize. */
2199 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2200 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2203 out_uleb128 (filesize
);
2206 /* Output the md5 sum. */
2211 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2212 out_byte (files
[i
].md5
[b
]);
2216 if (DWARF2_LINE_VERSION
< 5)
2217 /* Terminate filename list. */
2221 /* Switch to SEC and output a header length field. Return the size of
2222 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2223 to the end of the section. EXPR->X_add_number will be set to the
2224 negative size of the header. */
2227 out_header (asection
*sec
, expressionS
*exp
)
2232 subseg_set (sec
, 0);
2234 if (flag_dwarf_sections
)
2236 /* If we are going to put the start and end symbols in different
2237 sections, then we need real symbols, not just fake, local ones. */
2239 start_sym
= symbol_make (".Ldebug_line_start");
2240 end_sym
= symbol_make (".Ldebug_line_end");
2241 symbol_set_value_now (start_sym
);
2245 start_sym
= symbol_temp_new_now_octets ();
2246 end_sym
= symbol_temp_make ();
2249 /* Total length of the information. */
2250 exp
->X_op
= O_subtract
;
2251 exp
->X_add_symbol
= end_sym
;
2252 exp
->X_op_symbol
= start_sym
;
2254 switch (DWARF2_FORMAT (sec
))
2256 case dwarf2_format_32bit
:
2257 exp
->X_add_number
= -4;
2261 case dwarf2_format_64bit
:
2262 exp
->X_add_number
= -12;
2267 case dwarf2_format_64bit_irix
:
2268 exp
->X_add_number
= -8;
2273 as_fatal (_("internal error: unknown dwarf2 format"));
2277 /* Emit the collected .debug_line data. */
2280 out_debug_line (segT line_seg
)
2283 symbolS
*prologue_start
, *prologue_end
;
2288 memset (&exp
, 0, sizeof exp
);
2289 sizeof_offset
= out_header (line_seg
, &exp
);
2290 line_end
= exp
.X_add_symbol
;
2293 out_two (DWARF2_LINE_VERSION
);
2295 if (DWARF2_LINE_VERSION
>= 5)
2297 out_byte (sizeof_address
);
2298 out_byte (0); /* Segment Selector size. */
2300 /* Length of the prologue following this length. */
2301 prologue_start
= symbol_temp_make ();
2302 prologue_end
= symbol_temp_make ();
2303 exp
.X_op
= O_subtract
;
2304 exp
.X_add_symbol
= prologue_end
;
2305 exp
.X_op_symbol
= prologue_start
;
2306 exp
.X_add_number
= 0;
2307 emit_expr (&exp
, sizeof_offset
);
2308 symbol_set_value_now (prologue_start
);
2310 /* Parameters of the state machine. */
2311 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2312 if (DWARF2_LINE_VERSION
>= 4)
2313 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2314 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2315 out_byte (DWARF2_LINE_BASE
);
2316 out_byte (DWARF2_LINE_RANGE
);
2317 out_byte (DWARF2_LINE_OPCODE_BASE
);
2319 /* Standard opcode lengths. */
2320 out_byte (0); /* DW_LNS_copy */
2321 out_byte (1); /* DW_LNS_advance_pc */
2322 out_byte (1); /* DW_LNS_advance_line */
2323 out_byte (1); /* DW_LNS_set_file */
2324 out_byte (1); /* DW_LNS_set_column */
2325 out_byte (0); /* DW_LNS_negate_stmt */
2326 out_byte (0); /* DW_LNS_set_basic_block */
2327 out_byte (0); /* DW_LNS_const_add_pc */
2328 out_byte (1); /* DW_LNS_fixed_advance_pc */
2329 out_byte (0); /* DW_LNS_set_prologue_end */
2330 out_byte (0); /* DW_LNS_set_epilogue_begin */
2331 out_byte (1); /* DW_LNS_set_isa */
2332 /* We have emitted 12 opcode lengths, so make that this
2333 matches up to the opcode base value we have been using. */
2334 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2336 out_dir_and_file_list (line_seg
, sizeof_offset
);
2338 symbol_set_value_now (prologue_end
);
2340 /* For each section, emit a statement program. */
2341 for (s
= all_segs
; s
; s
= s
->next
)
2342 if (SEG_NORMAL (s
->seg
))
2343 process_entries (s
->seg
, s
->head
->head
);
2345 as_warn ("dwarf line number information for %s ignored",
2346 segment_name (s
->seg
));
2348 if (flag_dwarf_sections
)
2349 /* We have to switch to the special .debug_line_end section
2350 before emitting the end-of-debug_line symbol. The linker
2351 script arranges for this section to be placed after all the
2352 (potentially garbage collected) .debug_line.<foo> sections.
2353 This section contains the line_end symbol which is used to
2354 compute the size of the linked .debug_line section, as seen
2355 in the DWARF Line Number header. */
2356 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2358 symbol_set_value_now (line_end
);
2362 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2364 unsigned int addr_size
= sizeof_address
;
2369 memset (&exp
, 0, sizeof exp
);
2370 subseg_set (ranges_seg
, 0);
2372 /* For DW_AT_ranges to point at (there is no header, so really start
2373 of section, but see out_debug_rnglists). */
2374 *ranges_sym
= symbol_temp_new_now_octets ();
2376 /* Base Address Entry. */
2377 for (i
= 0; i
< addr_size
; i
++)
2379 for (i
= 0; i
< addr_size
; i
++)
2382 /* Range List Entry. */
2383 for (s
= all_segs
; s
; s
= s
->next
)
2388 frag
= first_frag_for_seg (s
->seg
);
2389 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2390 s
->text_start
= beg
;
2392 frag
= last_frag_for_seg (s
->seg
);
2393 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2396 exp
.X_op
= O_symbol
;
2397 exp
.X_add_symbol
= beg
;
2398 exp
.X_add_number
= 0;
2399 emit_expr (&exp
, addr_size
);
2401 exp
.X_op
= O_symbol
;
2402 exp
.X_add_symbol
= end
;
2403 exp
.X_add_number
= 0;
2404 emit_expr (&exp
, addr_size
);
2407 /* End of Range Entry. */
2408 for (i
= 0; i
< addr_size
; i
++)
2410 for (i
= 0; i
< addr_size
; i
++)
2415 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2418 symbolS
*ranges_end
;
2422 memset (&exp
, 0, sizeof exp
);
2423 out_header (ranges_seg
, &exp
);
2424 ranges_end
= exp
.X_add_symbol
;
2426 out_two (DWARF2_RNGLISTS_VERSION
);
2427 out_byte (sizeof_address
);
2428 out_byte (0); /* Segment Selector size. */
2429 out_four (0); /* Offset entry count. */
2431 /* For DW_AT_ranges to point at (must be after the header). */
2432 *ranges_sym
= symbol_temp_new_now_octets ();
2434 for (s
= all_segs
; s
; s
= s
->next
)
2439 out_byte (DW_RLE_start_length
);
2441 frag
= first_frag_for_seg (s
->seg
);
2442 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2443 s
->text_start
= beg
;
2445 frag
= last_frag_for_seg (s
->seg
);
2446 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2449 exp
.X_op
= O_symbol
;
2450 exp
.X_add_symbol
= beg
;
2451 exp
.X_add_number
= 0;
2452 emit_expr (&exp
, sizeof_address
);
2454 exp
.X_op
= O_symbol
;
2455 exp
.X_add_symbol
= end
;
2456 exp
.X_add_number
= 0;
2457 emit_leb128_expr (&exp
, 0);
2460 out_byte (DW_RLE_end_of_list
);
2462 symbol_set_value_now (ranges_end
);
2465 /* Emit data for .debug_aranges. */
2468 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2470 unsigned int addr_size
= sizeof_address
;
2474 symbolS
*aranges_end
;
2478 memset (&exp
, 0, sizeof exp
);
2479 sizeof_offset
= out_header (aranges_seg
, &exp
);
2480 aranges_end
= exp
.X_add_symbol
;
2481 size
= -exp
.X_add_number
;
2484 out_two (DWARF2_ARANGES_VERSION
);
2487 /* Offset to .debug_info. */
2488 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2489 size
+= sizeof_offset
;
2491 /* Size of an address (offset portion). */
2492 out_byte (addr_size
);
2495 /* Size of a segment descriptor. */
2499 /* Align the header. */
2500 while ((size
++ % (2 * addr_size
)) > 0)
2503 for (s
= all_segs
; s
; s
= s
->next
)
2508 frag
= first_frag_for_seg (s
->seg
);
2509 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2510 s
->text_start
= beg
;
2512 frag
= last_frag_for_seg (s
->seg
);
2513 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2516 exp
.X_op
= O_symbol
;
2517 exp
.X_add_symbol
= beg
;
2518 exp
.X_add_number
= 0;
2519 emit_expr (&exp
, addr_size
);
2521 exp
.X_op
= O_subtract
;
2522 exp
.X_add_symbol
= end
;
2523 exp
.X_op_symbol
= beg
;
2524 exp
.X_add_number
= 0;
2525 emit_expr (&exp
, addr_size
);
2528 p
= frag_more (2 * addr_size
);
2529 md_number_to_chars (p
, 0, addr_size
);
2530 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2532 symbol_set_value_now (aranges_end
);
2535 /* Emit data for .debug_abbrev. Note that this must be kept in
2536 sync with out_debug_info below. */
2539 out_debug_abbrev (segT abbrev_seg
,
2540 segT info_seg ATTRIBUTE_UNUSED
,
2541 segT line_seg ATTRIBUTE_UNUSED
)
2544 subseg_set (abbrev_seg
, 0);
2547 out_uleb128 (DW_TAG_compile_unit
);
2548 out_byte (DW_CHILDREN_no
);
2549 if (DWARF2_VERSION
< 4)
2551 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2552 secoff_form
= DW_FORM_data4
;
2554 secoff_form
= DW_FORM_data8
;
2557 secoff_form
= DW_FORM_sec_offset
;
2558 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2559 if (all_segs
->next
== NULL
)
2561 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2562 if (DWARF2_VERSION
< 4)
2563 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2565 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2568 out_abbrev (DW_AT_ranges
, secoff_form
);
2569 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2570 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2571 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2572 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2575 /* Terminate the abbreviations for this compilation unit. */
2579 /* Emit a description of this compilation unit for .debug_info. */
2582 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2583 symbolS
*ranges_sym
, symbolS
*name_sym
,
2584 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2590 memset (&exp
, 0, sizeof exp
);
2591 sizeof_offset
= out_header (info_seg
, &exp
);
2592 info_end
= exp
.X_add_symbol
;
2594 /* DWARF version. */
2595 out_two (DWARF2_VERSION
);
2597 if (DWARF2_VERSION
< 5)
2599 /* .debug_abbrev offset */
2600 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2604 /* unit (header) type */
2605 out_byte (DW_UT_compile
);
2608 /* Target address size. */
2609 out_byte (sizeof_address
);
2611 if (DWARF2_VERSION
>= 5)
2613 /* .debug_abbrev offset */
2614 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2617 /* DW_TAG_compile_unit DIE abbrev */
2620 /* DW_AT_stmt_list */
2621 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2622 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2625 /* These two attributes are emitted if all of the code is contiguous. */
2626 if (all_segs
->next
== NULL
)
2629 exp
.X_op
= O_symbol
;
2630 exp
.X_add_symbol
= all_segs
->text_start
;
2631 exp
.X_add_number
= 0;
2632 emit_expr (&exp
, sizeof_address
);
2635 if (DWARF2_VERSION
< 4)
2636 exp
.X_op
= O_symbol
;
2639 exp
.X_op
= O_subtract
;
2640 exp
.X_op_symbol
= all_segs
->text_start
;
2642 exp
.X_add_symbol
= all_segs
->text_end
;
2643 exp
.X_add_number
= 0;
2644 if (DWARF2_VERSION
< 4)
2645 emit_expr (&exp
, sizeof_address
);
2647 emit_leb128_expr (&exp
, 0);
2651 /* This attribute is emitted if the code is disjoint. */
2653 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2656 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2657 setup in out_debug_str below. */
2658 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2659 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2660 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2662 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2663 dwarf2 draft has no standard code for assembler. */
2664 out_two (DW_LANG_Mips_Assembler
);
2666 symbol_set_value_now (info_end
);
2669 /* Emit the three debug strings needed in .debug_str and setup symbols
2670 to them for use in out_debug_info. */
2672 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2673 symbolS
**producer_sym
)
2676 const char *comp_dir
;
2677 const char *dirname
;
2680 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2682 subseg_set (str_seg
, 0);
2684 /* DW_AT_name. We don't have the actual file name that was present
2685 on the command line, so assume files[first_file] is the main input file.
2686 We're not supposed to get called unless at least one line number
2687 entry was emitted, so this should always be defined. */
2688 *name_sym
= symbol_temp_new_now_octets ();
2689 if (files_in_use
== 0)
2691 if (files
[first_file
].dir
)
2693 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2694 len
= strlen (dirname
);
2696 /* Already has trailing slash. */
2697 p
= frag_more (len
);
2698 memcpy (p
, dirname
, len
);
2700 p
= frag_more (len
+ 1);
2701 memcpy (p
, dirname
, len
);
2702 INSERT_DIR_SEPARATOR (p
, len
);
2705 len
= strlen (files
[first_file
].filename
) + 1;
2706 p
= frag_more (len
);
2707 memcpy (p
, files
[first_file
].filename
, len
);
2709 /* DW_AT_comp_dir */
2710 *comp_dir_sym
= symbol_temp_new_now_octets ();
2711 comp_dir
= remap_debug_filename (getpwd ());
2712 len
= strlen (comp_dir
) + 1;
2713 p
= frag_more (len
);
2714 memcpy (p
, comp_dir
, len
);
2716 /* DW_AT_producer */
2717 *producer_sym
= symbol_temp_new_now_octets ();
2718 sprintf (producer
, "GNU AS %s", VERSION
);
2719 len
= strlen (producer
) + 1;
2720 p
= frag_more (len
);
2721 memcpy (p
, producer
, len
);
2727 last_seg_ptr
= &all_segs
;
2729 /* Select the default CIE version to produce here. The global
2730 starts with a value of -1 and will be modified to a valid value
2731 either by the user providing a command line option, or some
2732 targets will select their own default in md_after_parse_args. If
2733 we get here and the global still contains -1 then it is up to us
2734 to pick a sane default. The default we choose is 1, this is the
2735 CIE version gas has produced for a long time, and there seems no
2736 reason to change it yet. */
2737 if (flag_dwarf_cie_version
== -1)
2738 flag_dwarf_cie_version
= 1;
2742 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2743 were any .file/.loc directives, or --gdwarf2 was given, and if the
2744 file has a non-empty .debug_info section and an empty .debug_line
2745 section. If we emit .debug_line, and the .debug_info section is
2746 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2747 ALL_SEGS will be non-null if there were any .file/.loc directives,
2748 or --gdwarf2 was given and there were any located instructions
2752 dwarf2_finish (void)
2757 int emit_other_sections
= 0;
2758 int empty_debug_line
= 0;
2760 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2761 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2763 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2764 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2766 /* We can't construct a new debug_line section if we already have one.
2767 Give an error if we have seen any .loc, otherwise trust the user
2768 knows what they are doing and want to generate the .debug_line
2769 (and all other debug sections) themselves. */
2770 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2771 as_fatal ("duplicate .debug_line sections");
2773 if ((!all_segs
&& emit_other_sections
)
2774 || (!emit_other_sections
&& !empty_debug_line
))
2775 /* If there is no line information and no non-empty .debug_info
2776 section, or if there is both a non-empty .debug_info and a non-empty
2777 .debug_line, then we do nothing. */
2780 /* Calculate the size of an address for the target machine. */
2781 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2783 /* Create and switch to the line number section. */
2784 if (empty_debug_line
)
2786 line_seg
= subseg_new (".debug_line", 0);
2787 bfd_set_section_flags (line_seg
,
2788 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2791 /* For each subsection, chain the debug entries together. */
2792 for (s
= all_segs
; s
; s
= s
->next
)
2794 struct line_subseg
*lss
= s
->head
;
2795 struct line_entry
**ptail
= lss
->ptail
;
2797 /* Reset the initial view of the first subsection of the
2799 if (lss
->head
&& lss
->head
->loc
.view
)
2800 set_or_check_view (lss
->head
, NULL
, NULL
);
2802 while ((lss
= lss
->next
) != NULL
)
2804 /* Link the first view of subsequent subsections to the
2806 if (lss
->head
&& lss
->head
->loc
.view
)
2807 set_or_check_view (lss
->head
,
2808 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2809 s
->head
? s
->head
->head
: NULL
);
2815 if (empty_debug_line
)
2816 out_debug_line (line_seg
);
2818 /* If this is assembler generated line info, and there is no
2819 debug_info already, we need .debug_info, .debug_abbrev and
2820 .debug_str sections as well. */
2821 if (emit_other_sections
)
2826 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2828 gas_assert (all_segs
);
2830 info_seg
= subseg_new (".debug_info", 0);
2831 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2832 aranges_seg
= subseg_new (".debug_aranges", 0);
2833 str_seg
= subseg_new (".debug_str", 0);
2835 bfd_set_section_flags (info_seg
,
2836 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2837 bfd_set_section_flags (abbrev_seg
,
2838 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2839 bfd_set_section_flags (aranges_seg
,
2840 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2841 bfd_set_section_flags (str_seg
,
2842 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2843 | SEC_MERGE
| SEC_STRINGS
);
2844 str_seg
->entsize
= 1;
2846 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2848 if (all_segs
->next
== NULL
)
2852 if (DWARF2_VERSION
< 5)
2854 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2855 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2858 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2859 out_debug_ranges (ranges_seg
, &ranges_sym
);
2863 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2864 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2867 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2871 out_debug_aranges (aranges_seg
, info_seg
);
2872 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2873 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2874 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2875 name_sym
, comp_dir_sym
, producer_sym
);
2879 /* Perform any deferred checks pertaining to debug information. */
2882 dwarf2dbg_final_check (void)
2884 /* Perform reset-view checks. Don't evaluate view_assert_failed
2885 recursively: it could be very deep. It's a chain of adds, with
2886 each chain element pointing to the next in X_add_symbol, and
2887 holding the check value in X_op_symbol. */
2888 while (view_assert_failed
)
2894 gas_assert (!symbol_resolved_p (view_assert_failed
));
2896 exp
= symbol_get_value_expression (view_assert_failed
);
2897 sym
= view_assert_failed
;
2899 /* If view_assert_failed looks like a compound check in the
2900 chain, break it up. */
2901 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2903 view_assert_failed
= exp
->X_add_symbol
;
2904 sym
= exp
->X_op_symbol
;
2907 view_assert_failed
= NULL
;
2909 failed
= resolve_symbol_value (sym
);
2910 if (!symbol_resolved_p (sym
) || failed
)
2912 as_bad (_("view number mismatch"));