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 /* Reuse NUM if it is 1 and was assigned to the input file before
794 the first .file <NUMBER> directive was seen. */
795 file
= as_where_physical (&i
);
796 file
= get_basename (file
);
797 if (num
== 1 && filename_cmp (file
, files
[num
].filename
) == 0)
798 files
[num
].filename
= NULL
;
801 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
803 dir
== NULL
? "" : dir
,
804 dir
== NULL
? "" : "/",
806 dirname
== NULL
? "" : dirname
,
807 dirname
== NULL
? "" : "/",
816 file
= get_basename (filename
);
817 dirlen
= file
- filename
;
821 dirlen
= strlen (dirname
);
825 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
828 if (! assign_file_to_slot (i
, file
, d
))
833 if (target_big_endian
)
835 /* md5's are stored in litte endian format. */
836 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
837 unsigned int byte
= NUM_MD5_BYTES
;
838 unsigned int bignum_index
= 0;
840 while (bits_remaining
)
842 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
843 valueT bignum_value
= generic_bignum
[bignum_index
];
846 while (bignum_bits_remaining
)
848 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
850 bignum_bits_remaining
-= 8;
857 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
858 unsigned int byte
= 0;
859 unsigned int bignum_index
= 0;
861 while (bits_remaining
)
863 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
864 valueT bignum_value
= generic_bignum
[bignum_index
];
868 while (bignum_bits_remaining
)
870 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
872 bignum_bits_remaining
-= 8;
879 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
884 /* Returns the current source information. If .file directives have
885 been encountered, the info for the corresponding source file is
886 returned. Otherwise, the info for the assembly source file is
890 dwarf2_where (struct dwarf2_line_info
*line
)
892 if (debug_type
== DEBUG_DWARF2
)
894 const char *filename
;
896 memset (line
, 0, sizeof (*line
));
897 filename
= as_where_physical (&line
->line
);
898 line
->filenum
= allocate_filenum (filename
);
899 /* FIXME: We should check the return value from allocate_filenum. */
901 line
->flags
= DWARF2_FLAG_IS_STMT
;
902 line
->isa
= current
.isa
;
903 line
->discriminator
= current
.discriminator
;
910 /* A hook to allow the target backend to inform the line number state
911 machine of isa changes when assembler debug info is enabled. */
914 dwarf2_set_isa (unsigned int isa
)
919 /* Called for each machine instruction, or relatively atomic group of
920 machine instructions (ie built-in macro). The instruction or group
921 is SIZE bytes in length. If dwarf2 line number generation is called
922 for, emit a line statement appropriately. */
925 dwarf2_emit_insn (int size
)
927 struct dwarf2_line_info loc
;
929 if (debug_type
!= DEBUG_DWARF2
930 ? !dwarf2_loc_directive_seen
931 : !seen_at_least_1_file ())
936 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
937 dwarf2_consume_line_info ();
940 /* Move all previously-emitted line entries for the current position by
941 DELTA bytes. This function cannot be used to move the same entries
945 dwarf2_move_insn (int delta
)
947 struct line_subseg
*lss
;
948 struct line_entry
*e
;
954 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
958 now
= frag_now_fix ();
959 while ((e
= *lss
->pmove_tail
))
961 if (S_GET_VALUE (e
->label
) == now
)
962 S_SET_VALUE (e
->label
, now
+ delta
);
963 lss
->pmove_tail
= &e
->next
;
967 /* Called after the current line information has been either used with
968 dwarf2_gen_line_info or saved with a machine instruction for later use.
969 This resets the state of the line number information to reflect that
973 dwarf2_consume_line_info (void)
975 /* Unless we generate DWARF2 debugging information for each
976 assembler line, we only emit one line symbol for one LOC. */
977 dwarf2_loc_directive_seen
= FALSE
;
979 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
980 | DWARF2_FLAG_PROLOGUE_END
981 | DWARF2_FLAG_EPILOGUE_BEGIN
);
982 current
.discriminator
= 0;
986 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
987 is enabled, emit a basic block marker. */
990 dwarf2_emit_label (symbolS
*label
)
992 struct dwarf2_line_info loc
;
994 if (!dwarf2_loc_mark_labels
)
996 if (S_GET_SEGMENT (label
) != now_seg
)
998 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1000 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1003 dwarf2_where (&loc
);
1005 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1007 dwarf2_gen_line_info_1 (label
, &loc
);
1008 dwarf2_consume_line_info ();
1011 /* Handle two forms of .file directive:
1012 - Pass .file "source.c" to s_app_file
1013 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1015 If an entry is added to the file table, return a pointer to the filename. */
1018 dwarf2_directive_filename (void)
1020 bfd_boolean with_md5
= FALSE
;
1023 const char * dirname
= NULL
;
1026 /* Continue to accept a bare string and pass it off. */
1028 if (*input_line_pointer
== '"')
1034 num
= get_absolute_expression ();
1036 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1038 as_bad (_("file number less than one"));
1039 ignore_rest_of_line ();
1043 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1044 "switch back to the already allocated file <N> as the current
1047 filename
= demand_copy_C_string (&filename_len
);
1048 if (filename
== NULL
)
1049 /* demand_copy_C_string will have already generated an error message. */
1052 /* For DWARF-5 support we also accept:
1053 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1054 if (DWARF2_LINE_VERSION
> 4)
1057 if (*input_line_pointer
== '"')
1060 filename
= demand_copy_C_string (&filename_len
);
1064 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1066 input_line_pointer
+= 3;
1070 expression_and_evaluate (& exp
);
1071 if (exp
.X_op
!= O_big
)
1072 as_bad (_("md5 value too small or not a constant"));
1078 demand_empty_rest_of_line ();
1080 /* A .file directive implies compiler generated debug information is
1081 being supplied. Turn off gas generated debug info. */
1082 debug_type
= DEBUG_NONE
;
1084 if (num
!= (unsigned int) num
1085 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1087 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1091 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1098 /* Calls dwarf2_directive_filename, but discards its result.
1099 Used in pseudo-op tables where the function result is ignored. */
1102 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1104 (void) dwarf2_directive_filename ();
1108 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1110 offsetT filenum
, line
;
1112 /* If we see two .loc directives in a row, force the first one to be
1114 if (dwarf2_loc_directive_seen
)
1115 dwarf2_emit_insn (0);
1117 filenum
= get_absolute_expression ();
1119 line
= get_absolute_expression ();
1123 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1125 as_bad (_("file number less than one"));
1130 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1132 as_bad (_("unassigned file number %ld"), (long) filenum
);
1136 current
.filenum
= filenum
;
1137 current
.line
= line
;
1138 current
.discriminator
= 0;
1143 if (files
[filenum
].dir
)
1145 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1146 size_t file_len
= strlen (files
[filenum
].filename
);
1147 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1149 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1150 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1151 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1152 cp
[dir_len
+ file_len
+ 1] = '\0';
1153 listing_source_file (cp
);
1157 listing_source_file (files
[filenum
].filename
);
1158 listing_source_line (line
);
1163 if (ISDIGIT (*input_line_pointer
))
1165 current
.column
= get_absolute_expression ();
1169 while (ISALPHA (*input_line_pointer
))
1174 c
= get_symbol_name (& p
);
1176 if (strcmp (p
, "basic_block") == 0)
1178 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1179 *input_line_pointer
= c
;
1181 else if (strcmp (p
, "prologue_end") == 0)
1183 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1184 *input_line_pointer
= c
;
1186 else if (strcmp (p
, "epilogue_begin") == 0)
1188 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1189 *input_line_pointer
= c
;
1191 else if (strcmp (p
, "is_stmt") == 0)
1193 (void) restore_line_pointer (c
);
1194 value
= get_absolute_expression ();
1196 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1197 else if (value
== 1)
1198 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1201 as_bad (_("is_stmt value not 0 or 1"));
1205 else if (strcmp (p
, "isa") == 0)
1207 (void) restore_line_pointer (c
);
1208 value
= get_absolute_expression ();
1210 current
.isa
= value
;
1213 as_bad (_("isa number less than zero"));
1217 else if (strcmp (p
, "discriminator") == 0)
1219 (void) restore_line_pointer (c
);
1220 value
= get_absolute_expression ();
1222 current
.discriminator
= value
;
1225 as_bad (_("discriminator less than zero"));
1229 else if (strcmp (p
, "view") == 0)
1233 (void) restore_line_pointer (c
);
1236 if (ISDIGIT (*input_line_pointer
)
1237 || *input_line_pointer
== '-')
1239 bfd_boolean force_reset
= *input_line_pointer
== '-';
1241 value
= get_absolute_expression ();
1244 as_bad (_("numeric view can only be asserted to zero"));
1247 if (force_reset
&& force_reset_view
)
1248 sym
= force_reset_view
;
1251 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1254 force_reset_view
= sym
;
1259 char *name
= read_symbol_name ();
1263 sym
= symbol_find_or_make (name
);
1264 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1266 if (S_IS_VOLATILE (sym
))
1267 sym
= symbol_clone (sym
, 1);
1268 else if (!S_CAN_BE_REDEFINED (sym
))
1270 as_bad (_("symbol `%s' is already defined"), name
);
1274 S_SET_SEGMENT (sym
, undefined_section
);
1275 S_SET_VALUE (sym
, 0);
1276 symbol_set_frag (sym
, &zero_address_frag
);
1282 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1283 (void) restore_line_pointer (c
);
1287 SKIP_WHITESPACE_AFTER_NAME ();
1290 demand_empty_rest_of_line ();
1291 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1292 debug_type
= DEBUG_NONE
;
1294 /* If we were given a view id, emit the row right away. */
1296 dwarf2_emit_insn (0);
1300 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1302 offsetT value
= get_absolute_expression ();
1304 if (value
!= 0 && value
!= 1)
1306 as_bad (_("expected 0 or 1"));
1307 ignore_rest_of_line ();
1311 dwarf2_loc_mark_labels
= value
!= 0;
1312 demand_empty_rest_of_line ();
1316 static struct frag
*
1317 first_frag_for_seg (segT seg
)
1319 return seg_info (seg
)->frchainP
->frch_root
;
1322 static struct frag
*
1323 last_frag_for_seg (segT seg
)
1325 frchainS
*f
= seg_info (seg
)->frchainP
;
1327 while (f
->frch_next
!= NULL
)
1330 return f
->frch_last
;
1333 /* Emit a single byte into the current segment. */
1338 FRAG_APPEND_1_CHAR (byte
);
1341 /* Emit a statement program opcode into the current segment. */
1344 out_opcode (int opc
)
1349 /* Emit a two-byte word into the current segment. */
1354 md_number_to_chars (frag_more (2), data
, 2);
1357 /* Emit a four byte word into the current segment. */
1362 md_number_to_chars (frag_more (4), data
, 4);
1365 /* Emit an unsigned "little-endian base 128" number. */
1368 out_uleb128 (addressT value
)
1370 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1373 /* Emit a signed "little-endian base 128" number. */
1376 out_leb128 (addressT value
)
1378 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1381 /* Emit a tuple for .debug_abbrev. */
1384 out_abbrev (int name
, int form
)
1390 /* Get the size of a fragment. */
1393 get_frag_fix (fragS
*frag
, segT seg
)
1398 return frag
->fr_fix
;
1400 /* If a fragment is the last in the chain, special measures must be
1401 taken to find its size before relaxation, since it may be pending
1402 on some subsegment chain. */
1403 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1404 if (fr
->frch_last
== frag
)
1405 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1410 /* Set an absolute address (may result in a relocation entry). */
1413 out_set_addr (symbolS
*sym
)
1417 memset (&exp
, 0, sizeof exp
);
1418 out_opcode (DW_LNS_extended_op
);
1419 out_uleb128 (sizeof_address
+ 1);
1421 out_opcode (DW_LNE_set_address
);
1422 exp
.X_op
= O_symbol
;
1423 exp
.X_add_symbol
= sym
;
1424 exp
.X_add_number
= 0;
1425 emit_expr (&exp
, sizeof_address
);
1428 static void scale_addr_delta (addressT
*);
1431 scale_addr_delta (addressT
*addr_delta
)
1433 static int printed_this
= 0;
1434 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1436 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1438 as_bad("unaligned opcodes detected in executable segment");
1441 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1445 /* Encode a pair of line and address skips as efficiently as possible.
1446 Note that the line skip is signed, whereas the address skip is unsigned.
1448 The following two routines *must* be kept in sync. This is
1449 enforced by making emit_inc_line_addr abort if we do not emit
1450 exactly the expected number of bytes. */
1453 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1455 unsigned int tmp
, opcode
;
1458 /* Scale the address delta by the minimum instruction length. */
1459 scale_addr_delta (&addr_delta
);
1461 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1462 We cannot use special opcodes here, since we want the end_sequence
1463 to emit the matrix entry. */
1464 if (line_delta
== INT_MAX
)
1466 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1468 else if (addr_delta
)
1469 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1473 /* Bias the line delta by the base. */
1474 tmp
= line_delta
- DWARF2_LINE_BASE
;
1476 /* If the line increment is out of range of a special opcode, we
1477 must encode it with DW_LNS_advance_line. */
1478 if (tmp
>= DWARF2_LINE_RANGE
)
1480 len
= 1 + sizeof_leb128 (line_delta
, 1);
1482 tmp
= 0 - DWARF2_LINE_BASE
;
1485 /* Bias the opcode by the special opcode base. */
1486 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1488 /* Avoid overflow when addr_delta is large. */
1489 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1491 /* Try using a special opcode. */
1492 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1496 /* Try using DW_LNS_const_add_pc followed by special op. */
1497 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1502 /* Otherwise use DW_LNS_advance_pc. */
1503 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1505 /* DW_LNS_copy or special opcode. */
1512 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1514 unsigned int tmp
, opcode
;
1516 char *end
= p
+ len
;
1518 /* Line number sequences cannot go backward in addresses. This means
1519 we've incorrectly ordered the statements in the sequence. */
1520 gas_assert ((offsetT
) addr_delta
>= 0);
1522 /* Scale the address delta by the minimum instruction length. */
1523 scale_addr_delta (&addr_delta
);
1525 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1526 We cannot use special opcodes here, since we want the end_sequence
1527 to emit the matrix entry. */
1528 if (line_delta
== INT_MAX
)
1530 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1531 *p
++ = DW_LNS_const_add_pc
;
1532 else if (addr_delta
)
1534 *p
++ = DW_LNS_advance_pc
;
1535 p
+= output_leb128 (p
, addr_delta
, 0);
1538 *p
++ = DW_LNS_extended_op
;
1540 *p
++ = DW_LNE_end_sequence
;
1544 /* Bias the line delta by the base. */
1545 tmp
= line_delta
- DWARF2_LINE_BASE
;
1547 /* If the line increment is out of range of a special opcode, we
1548 must encode it with DW_LNS_advance_line. */
1549 if (tmp
>= DWARF2_LINE_RANGE
)
1551 *p
++ = DW_LNS_advance_line
;
1552 p
+= output_leb128 (p
, line_delta
, 1);
1555 tmp
= 0 - DWARF2_LINE_BASE
;
1559 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1561 if (line_delta
== 0 && addr_delta
== 0)
1567 /* Bias the opcode by the special opcode base. */
1568 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1570 /* Avoid overflow when addr_delta is large. */
1571 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1573 /* Try using a special opcode. */
1574 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1581 /* Try using DW_LNS_const_add_pc followed by special op. */
1582 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1585 *p
++ = DW_LNS_const_add_pc
;
1591 /* Otherwise use DW_LNS_advance_pc. */
1592 *p
++ = DW_LNS_advance_pc
;
1593 p
+= output_leb128 (p
, addr_delta
, 0);
1601 gas_assert (p
== end
);
1604 /* Handy routine to combine calls to the above two routines. */
1607 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1609 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1610 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1613 /* Write out an alternative form of line and address skips using
1614 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1615 line and address information, but it is required if linker relaxation
1616 could change the code offsets. The following two routines *must* be
1618 #define ADDR_DELTA_LIMIT 50000
1621 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1625 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1626 if (line_delta
!= INT_MAX
)
1627 len
= 1 + sizeof_leb128 (line_delta
, 1);
1629 if (addr_delta
> ADDR_DELTA_LIMIT
)
1631 /* DW_LNS_extended_op */
1632 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1633 /* DW_LNE_set_address */
1634 len
+= 1 + sizeof_address
;
1637 /* DW_LNS_fixed_advance_pc */
1640 if (line_delta
== INT_MAX
)
1641 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1651 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1655 char *end
= p
+ len
;
1657 /* Line number sequences cannot go backward in addresses. This means
1658 we've incorrectly ordered the statements in the sequence. */
1659 gas_assert ((offsetT
) addr_delta
>= 0);
1661 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1662 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1664 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1665 if (line_delta
!= INT_MAX
)
1667 *p
++ = DW_LNS_advance_line
;
1668 p
+= output_leb128 (p
, line_delta
, 1);
1671 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1673 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1674 advance the address by at most 64K. Linker relaxation (without
1675 which this function would not be used) could change the operand by
1676 an unknown amount. If the address increment is getting close to
1677 the limit, just reset the address. */
1678 if (addr_delta
> ADDR_DELTA_LIMIT
)
1683 memset (&exp
, 0, sizeof exp
);
1684 gas_assert (pexp
->X_op
== O_subtract
);
1685 to_sym
= pexp
->X_add_symbol
;
1687 *p
++ = DW_LNS_extended_op
;
1688 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1689 *p
++ = DW_LNE_set_address
;
1690 exp
.X_op
= O_symbol
;
1691 exp
.X_add_symbol
= to_sym
;
1692 exp
.X_add_number
= 0;
1693 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1694 p
+= sizeof_address
;
1698 *p
++ = DW_LNS_fixed_advance_pc
;
1699 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1703 if (line_delta
== INT_MAX
)
1705 *p
++ = DW_LNS_extended_op
;
1707 *p
++ = DW_LNE_end_sequence
;
1712 gas_assert (p
== end
);
1715 /* Generate a variant frag that we can use to relax address/line
1716 increments between fragments of the target segment. */
1719 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1724 memset (&exp
, 0, sizeof exp
);
1725 exp
.X_op
= O_subtract
;
1726 exp
.X_add_symbol
= to_sym
;
1727 exp
.X_op_symbol
= from_sym
;
1728 exp
.X_add_number
= 0;
1730 /* The maximum size of the frag is the line delta with a maximum
1731 sized address delta. */
1732 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1733 max_chars
= size_fixed_inc_line_addr (line_delta
,
1734 -DWARF2_LINE_MIN_INSN_LENGTH
);
1736 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1738 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1739 make_expr_symbol (&exp
), line_delta
, NULL
);
1742 /* The function estimates the size of a rs_dwarf2dbg variant frag
1743 based on the current values of the symbols. It is called before
1744 the relaxation loop. We set fr_subtype to the expected length. */
1747 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1752 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1753 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1754 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1756 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1758 frag
->fr_subtype
= size
;
1763 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1764 current values of the symbols. fr_subtype is the current length
1765 of the frag. This returns the change in frag length. */
1768 dwarf2dbg_relax_frag (fragS
*frag
)
1770 int old_size
, new_size
;
1772 old_size
= frag
->fr_subtype
;
1773 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1775 return new_size
- old_size
;
1778 /* This function converts a rs_dwarf2dbg variant frag into a normal
1779 fill frag. This is called after all relaxation has been done.
1780 fr_subtype will be the desired length of the frag. */
1783 dwarf2dbg_convert_frag (fragS
*frag
)
1787 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1789 /* If linker relaxation is enabled then the distance between the two
1790 symbols in the frag->fr_symbol expression might change. Hence we
1791 cannot rely upon the value computed by resolve_symbol_value.
1792 Instead we leave the expression unfinalized and allow
1793 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1794 relocation) that will allow the linker to correctly compute the
1795 actual address difference. We have to use a fixed line advance for
1796 this as we cannot (easily) relocate leb128 encoded values. */
1797 int saved_finalize_syms
= finalize_syms
;
1800 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1801 finalize_syms
= saved_finalize_syms
;
1804 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1806 /* fr_var carries the max_chars that we created the fragment with.
1807 fr_subtype carries the current expected length. We must, of
1808 course, have allocated enough memory earlier. */
1809 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1811 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1812 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1813 frag
->fr_literal
+ frag
->fr_fix
,
1816 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1817 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1819 frag
->fr_fix
+= frag
->fr_subtype
;
1820 frag
->fr_type
= rs_fill
;
1822 frag
->fr_offset
= 0;
1825 /* Generate .debug_line content for the chain of line number entries
1826 beginning at E, for segment SEG. */
1829 process_entries (segT seg
, struct line_entry
*e
)
1831 unsigned filenum
= 1;
1833 unsigned column
= 0;
1835 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1836 fragS
*last_frag
= NULL
, *frag
;
1837 addressT last_frag_ofs
= 0, frag_ofs
;
1838 symbolS
*last_lab
= NULL
, *lab
;
1839 struct line_entry
*next
;
1841 if (flag_dwarf_sections
)
1844 const char * sec_name
;
1846 /* Switch to the relevant sub-section before we start to emit
1847 the line number table.
1849 FIXME: These sub-sections do not have a normal Line Number
1850 Program Header, thus strictly speaking they are not valid
1851 DWARF sections. Unfortunately the DWARF standard assumes
1852 a one-to-one relationship between compilation units and
1853 line number tables. Thus we have to have a .debug_line
1854 section, as well as our sub-sections, and we have to ensure
1855 that all of the sub-sections are merged into a proper
1856 .debug_line section before a debugger sees them. */
1858 sec_name
= bfd_section_name (seg
);
1859 if (strcmp (sec_name
, ".text") != 0)
1861 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1862 subseg_set (subseg_get (name
, FALSE
), 0);
1865 /* Don't create a .debug_line.text section -
1866 that is redundant. Instead just switch back to the
1867 normal .debug_line section. */
1868 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1875 if (filenum
!= e
->loc
.filenum
)
1877 filenum
= e
->loc
.filenum
;
1878 out_opcode (DW_LNS_set_file
);
1879 out_uleb128 (filenum
);
1882 if (column
!= e
->loc
.column
)
1884 column
= e
->loc
.column
;
1885 out_opcode (DW_LNS_set_column
);
1886 out_uleb128 (column
);
1889 if (e
->loc
.discriminator
!= 0)
1891 out_opcode (DW_LNS_extended_op
);
1892 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1893 out_opcode (DW_LNE_set_discriminator
);
1894 out_uleb128 (e
->loc
.discriminator
);
1897 if (isa
!= e
->loc
.isa
)
1900 out_opcode (DW_LNS_set_isa
);
1904 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1906 flags
= e
->loc
.flags
;
1907 out_opcode (DW_LNS_negate_stmt
);
1910 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1911 out_opcode (DW_LNS_set_basic_block
);
1913 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1914 out_opcode (DW_LNS_set_prologue_end
);
1916 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1917 out_opcode (DW_LNS_set_epilogue_begin
);
1919 /* Don't try to optimize away redundant entries; gdb wants two
1920 entries for a function where the code starts on the same line as
1921 the {, and there's no way to identify that case here. Trust gcc
1922 to optimize appropriately. */
1923 line_delta
= e
->loc
.line
- line
;
1925 frag
= symbol_get_frag (lab
);
1926 frag_ofs
= S_GET_VALUE (lab
);
1928 if (last_frag
== NULL
1929 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1930 /* If we're going to reset the view, but we know we're
1931 advancing the PC, we don't have to force with
1932 set_address. We know we do when we're at the same
1933 address of the same frag, and we know we might when
1934 we're in the beginning of a frag, and we were at the
1935 end of the previous frag. */
1936 && (frag
== last_frag
1937 ? (last_frag_ofs
== frag_ofs
)
1939 && ((offsetT
)last_frag_ofs
1940 >= get_frag_fix (last_frag
, seg
))))))
1943 out_inc_line_addr (line_delta
, 0);
1945 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1946 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1948 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1953 last_frag_ofs
= frag_ofs
;
1961 /* Emit a DW_LNE_end_sequence for the end of the section. */
1962 frag
= last_frag_for_seg (seg
);
1963 frag_ofs
= get_frag_fix (frag
, seg
);
1964 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1965 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1968 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1969 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1973 /* Switch to LINE_STR_SEG and output the given STR. Return the
1974 symbol pointing to the new string in the section. */
1977 add_line_strp (segT line_str_seg
, const char *str
)
1983 subseg_set (line_str_seg
, 0);
1985 sym
= symbol_temp_new_now_octets ();
1987 size
= strlen (str
) + 1;
1988 cp
= frag_more (size
);
1989 memcpy (cp
, str
, size
);
1995 /* Emit the directory and file tables for .debug_line. */
1998 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2004 bfd_boolean emit_md5
= FALSE
;
2005 bfd_boolean emit_timestamps
= TRUE
;
2006 bfd_boolean emit_filesize
= TRUE
;
2007 segT line_str_seg
= NULL
;
2010 /* Output the Directory Table. */
2011 if (DWARF2_LINE_VERSION
>= 5)
2013 /* We only have one column in the directory table. */
2016 /* Describe the purpose and format of the column. */
2017 out_uleb128 (DW_LNCT_path
);
2018 /* Store these strings in the .debug_line_str section so they
2020 out_uleb128 (DW_FORM_line_strp
);
2022 /* Now state how many rows there are in the table. We need at
2023 least 1 if there is one or more file names to store the
2024 "working directory". */
2025 if (dirs_in_use
== 0 && files_in_use
> 0)
2028 out_uleb128 (dirs_in_use
);
2031 /* Emit directory list. */
2032 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2034 line_str_seg
= subseg_new (".debug_line_str", 0);
2035 bfd_set_section_flags (line_str_seg
,
2036 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2037 | SEC_MERGE
| SEC_STRINGS
);
2038 line_str_seg
->entsize
= 1;
2040 /* DWARF5 uses slot zero, but that is only set explicitly
2041 using a .file 0 directive. If that isn't used, but dir
2042 one is used, then use that as main file directory.
2043 Otherwise use pwd as main file directory. */
2044 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2045 dir
= remap_debug_filename (dirs
[0]);
2046 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2047 dir
= remap_debug_filename (dirs
[1]);
2049 dir
= remap_debug_filename (getpwd ());
2051 line_strp
= add_line_strp (line_str_seg
, dir
);
2052 subseg_set (line_seg
, 0);
2053 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2055 for (i
= 1; i
< dirs_in_use
; ++i
)
2057 dir
= remap_debug_filename (dirs
[i
]);
2058 if (DWARF2_LINE_VERSION
< 5)
2060 size
= strlen (dir
) + 1;
2061 cp
= frag_more (size
);
2062 memcpy (cp
, dir
, size
);
2066 line_strp
= add_line_strp (line_str_seg
, dir
);
2067 subseg_set (line_seg
, 0);
2068 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2072 if (DWARF2_LINE_VERSION
< 5)
2076 /* Output the File Name Table. */
2077 if (DWARF2_LINE_VERSION
>= 5)
2079 unsigned int columns
= 4;
2081 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2083 emit_timestamps
= FALSE
;
2087 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2089 emit_filesize
= FALSE
;
2093 for (i
= 0; i
< files_in_use
; ++i
)
2094 if (files
[i
].md5
[0] != 0)
2096 if (i
< files_in_use
)
2102 /* The number of format entries to follow. */
2104 /* The format of the file name. */
2105 out_uleb128 (DW_LNCT_path
);
2106 /* Store these strings in the .debug_line_str section so they
2108 out_uleb128 (DW_FORM_line_strp
);
2110 /* The format of the directory index. */
2111 out_uleb128 (DW_LNCT_directory_index
);
2112 out_uleb128 (DW_FORM_udata
);
2114 if (emit_timestamps
)
2116 /* The format of the timestamp. */
2117 out_uleb128 (DW_LNCT_timestamp
);
2118 out_uleb128 (DW_FORM_udata
);
2123 /* The format of the file size. */
2124 out_uleb128 (DW_LNCT_size
);
2125 out_uleb128 (DW_FORM_udata
);
2130 /* The format of the MD5 sum. */
2131 out_uleb128 (DW_LNCT_MD5
);
2132 out_uleb128 (DW_FORM_data16
);
2135 /* The number of entries in the table. */
2136 out_uleb128 (files_in_use
);
2139 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2141 const char *fullfilename
;
2143 if (files
[i
].filename
== NULL
)
2145 /* Prevent a crash later, particularly for file 1. DWARF5
2146 uses slot zero, but that is only set explicitly using a
2147 .file 0 directive. If that isn't used, but file 1 is,
2148 then use that as main file name. */
2149 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2150 files
[0].filename
= files
[1].filename
;
2152 files
[i
].filename
= "";
2153 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2155 as_bad (_("unassigned file number %ld"), (long) i
);
2160 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2161 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2162 if (DWARF2_LINE_VERSION
< 5)
2164 size
= strlen (fullfilename
) + 1;
2165 cp
= frag_more (size
);
2166 memcpy (cp
, fullfilename
, size
);
2170 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2171 subseg_set (line_seg
, 0);
2172 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2175 /* Directory number. */
2176 out_uleb128 (files
[i
].dir
);
2178 /* Output the last modification timestamp. */
2179 if (emit_timestamps
)
2183 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2184 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2185 if (timestamp
== -1)
2187 out_uleb128 (timestamp
);
2190 /* Output the filesize. */
2194 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2195 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2198 out_uleb128 (filesize
);
2201 /* Output the md5 sum. */
2206 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2207 out_byte (files
[i
].md5
[b
]);
2211 if (DWARF2_LINE_VERSION
< 5)
2212 /* Terminate filename list. */
2216 /* Switch to SEC and output a header length field. Return the size of
2217 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2218 to the end of the section. EXPR->X_add_number will be set to the
2219 negative size of the header. */
2222 out_header (asection
*sec
, expressionS
*exp
)
2227 subseg_set (sec
, 0);
2229 if (flag_dwarf_sections
)
2231 /* If we are going to put the start and end symbols in different
2232 sections, then we need real symbols, not just fake, local ones. */
2234 start_sym
= symbol_make (".Ldebug_line_start");
2235 end_sym
= symbol_make (".Ldebug_line_end");
2236 symbol_set_value_now (start_sym
);
2240 start_sym
= symbol_temp_new_now_octets ();
2241 end_sym
= symbol_temp_make ();
2244 /* Total length of the information. */
2245 exp
->X_op
= O_subtract
;
2246 exp
->X_add_symbol
= end_sym
;
2247 exp
->X_op_symbol
= start_sym
;
2249 switch (DWARF2_FORMAT (sec
))
2251 case dwarf2_format_32bit
:
2252 exp
->X_add_number
= -4;
2256 case dwarf2_format_64bit
:
2257 exp
->X_add_number
= -12;
2262 case dwarf2_format_64bit_irix
:
2263 exp
->X_add_number
= -8;
2268 as_fatal (_("internal error: unknown dwarf2 format"));
2272 /* Emit the collected .debug_line data. */
2275 out_debug_line (segT line_seg
)
2278 symbolS
*prologue_start
, *prologue_end
;
2283 memset (&exp
, 0, sizeof exp
);
2284 sizeof_offset
= out_header (line_seg
, &exp
);
2285 line_end
= exp
.X_add_symbol
;
2288 out_two (DWARF2_LINE_VERSION
);
2290 if (DWARF2_LINE_VERSION
>= 5)
2292 out_byte (sizeof_address
);
2293 out_byte (0); /* Segment Selector size. */
2295 /* Length of the prologue following this length. */
2296 prologue_start
= symbol_temp_make ();
2297 prologue_end
= symbol_temp_make ();
2298 exp
.X_op
= O_subtract
;
2299 exp
.X_add_symbol
= prologue_end
;
2300 exp
.X_op_symbol
= prologue_start
;
2301 exp
.X_add_number
= 0;
2302 emit_expr (&exp
, sizeof_offset
);
2303 symbol_set_value_now (prologue_start
);
2305 /* Parameters of the state machine. */
2306 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2307 if (DWARF2_LINE_VERSION
>= 4)
2308 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2309 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2310 out_byte (DWARF2_LINE_BASE
);
2311 out_byte (DWARF2_LINE_RANGE
);
2312 out_byte (DWARF2_LINE_OPCODE_BASE
);
2314 /* Standard opcode lengths. */
2315 out_byte (0); /* DW_LNS_copy */
2316 out_byte (1); /* DW_LNS_advance_pc */
2317 out_byte (1); /* DW_LNS_advance_line */
2318 out_byte (1); /* DW_LNS_set_file */
2319 out_byte (1); /* DW_LNS_set_column */
2320 out_byte (0); /* DW_LNS_negate_stmt */
2321 out_byte (0); /* DW_LNS_set_basic_block */
2322 out_byte (0); /* DW_LNS_const_add_pc */
2323 out_byte (1); /* DW_LNS_fixed_advance_pc */
2324 out_byte (0); /* DW_LNS_set_prologue_end */
2325 out_byte (0); /* DW_LNS_set_epilogue_begin */
2326 out_byte (1); /* DW_LNS_set_isa */
2327 /* We have emitted 12 opcode lengths, so make that this
2328 matches up to the opcode base value we have been using. */
2329 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2331 out_dir_and_file_list (line_seg
, sizeof_offset
);
2333 symbol_set_value_now (prologue_end
);
2335 /* For each section, emit a statement program. */
2336 for (s
= all_segs
; s
; s
= s
->next
)
2337 if (SEG_NORMAL (s
->seg
))
2338 process_entries (s
->seg
, s
->head
->head
);
2340 as_warn ("dwarf line number information for %s ignored",
2341 segment_name (s
->seg
));
2343 if (flag_dwarf_sections
)
2344 /* We have to switch to the special .debug_line_end section
2345 before emitting the end-of-debug_line symbol. The linker
2346 script arranges for this section to be placed after all the
2347 (potentially garbage collected) .debug_line.<foo> sections.
2348 This section contains the line_end symbol which is used to
2349 compute the size of the linked .debug_line section, as seen
2350 in the DWARF Line Number header. */
2351 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2353 symbol_set_value_now (line_end
);
2357 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2359 unsigned int addr_size
= sizeof_address
;
2364 memset (&exp
, 0, sizeof exp
);
2365 subseg_set (ranges_seg
, 0);
2367 /* For DW_AT_ranges to point at (there is no header, so really start
2368 of section, but see out_debug_rnglists). */
2369 *ranges_sym
= symbol_temp_new_now_octets ();
2371 /* Base Address Entry. */
2372 for (i
= 0; i
< addr_size
; i
++)
2374 for (i
= 0; i
< addr_size
; i
++)
2377 /* Range List Entry. */
2378 for (s
= all_segs
; s
; s
= s
->next
)
2383 frag
= first_frag_for_seg (s
->seg
);
2384 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2385 s
->text_start
= beg
;
2387 frag
= last_frag_for_seg (s
->seg
);
2388 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2391 exp
.X_op
= O_symbol
;
2392 exp
.X_add_symbol
= beg
;
2393 exp
.X_add_number
= 0;
2394 emit_expr (&exp
, addr_size
);
2396 exp
.X_op
= O_symbol
;
2397 exp
.X_add_symbol
= end
;
2398 exp
.X_add_number
= 0;
2399 emit_expr (&exp
, addr_size
);
2402 /* End of Range Entry. */
2403 for (i
= 0; i
< addr_size
; i
++)
2405 for (i
= 0; i
< addr_size
; i
++)
2410 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2413 symbolS
*ranges_end
;
2417 memset (&exp
, 0, sizeof exp
);
2418 out_header (ranges_seg
, &exp
);
2419 ranges_end
= exp
.X_add_symbol
;
2421 out_two (DWARF2_RNGLISTS_VERSION
);
2422 out_byte (sizeof_address
);
2423 out_byte (0); /* Segment Selector size. */
2424 out_four (0); /* Offset entry count. */
2426 /* For DW_AT_ranges to point at (must be after the header). */
2427 *ranges_sym
= symbol_temp_new_now_octets ();
2429 for (s
= all_segs
; s
; s
= s
->next
)
2434 out_byte (DW_RLE_start_length
);
2436 frag
= first_frag_for_seg (s
->seg
);
2437 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2438 s
->text_start
= beg
;
2440 frag
= last_frag_for_seg (s
->seg
);
2441 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2444 exp
.X_op
= O_symbol
;
2445 exp
.X_add_symbol
= beg
;
2446 exp
.X_add_number
= 0;
2447 emit_expr (&exp
, sizeof_address
);
2449 exp
.X_op
= O_symbol
;
2450 exp
.X_add_symbol
= end
;
2451 exp
.X_add_number
= 0;
2452 emit_leb128_expr (&exp
, 0);
2455 out_byte (DW_RLE_end_of_list
);
2457 symbol_set_value_now (ranges_end
);
2460 /* Emit data for .debug_aranges. */
2463 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2465 unsigned int addr_size
= sizeof_address
;
2469 symbolS
*aranges_end
;
2473 memset (&exp
, 0, sizeof exp
);
2474 sizeof_offset
= out_header (aranges_seg
, &exp
);
2475 aranges_end
= exp
.X_add_symbol
;
2476 size
= -exp
.X_add_number
;
2479 out_two (DWARF2_ARANGES_VERSION
);
2482 /* Offset to .debug_info. */
2483 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2484 size
+= sizeof_offset
;
2486 /* Size of an address (offset portion). */
2487 out_byte (addr_size
);
2490 /* Size of a segment descriptor. */
2494 /* Align the header. */
2495 while ((size
++ % (2 * addr_size
)) > 0)
2498 for (s
= all_segs
; s
; s
= s
->next
)
2503 frag
= first_frag_for_seg (s
->seg
);
2504 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2505 s
->text_start
= beg
;
2507 frag
= last_frag_for_seg (s
->seg
);
2508 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2511 exp
.X_op
= O_symbol
;
2512 exp
.X_add_symbol
= beg
;
2513 exp
.X_add_number
= 0;
2514 emit_expr (&exp
, addr_size
);
2516 exp
.X_op
= O_subtract
;
2517 exp
.X_add_symbol
= end
;
2518 exp
.X_op_symbol
= beg
;
2519 exp
.X_add_number
= 0;
2520 emit_expr (&exp
, addr_size
);
2523 p
= frag_more (2 * addr_size
);
2524 md_number_to_chars (p
, 0, addr_size
);
2525 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2527 symbol_set_value_now (aranges_end
);
2530 /* Emit data for .debug_abbrev. Note that this must be kept in
2531 sync with out_debug_info below. */
2534 out_debug_abbrev (segT abbrev_seg
,
2535 segT info_seg ATTRIBUTE_UNUSED
,
2536 segT line_seg ATTRIBUTE_UNUSED
)
2539 subseg_set (abbrev_seg
, 0);
2542 out_uleb128 (DW_TAG_compile_unit
);
2543 out_byte (DW_CHILDREN_no
);
2544 if (DWARF2_VERSION
< 4)
2546 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2547 secoff_form
= DW_FORM_data4
;
2549 secoff_form
= DW_FORM_data8
;
2552 secoff_form
= DW_FORM_sec_offset
;
2553 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2554 if (all_segs
->next
== NULL
)
2556 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2557 if (DWARF2_VERSION
< 4)
2558 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2560 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2563 out_abbrev (DW_AT_ranges
, secoff_form
);
2564 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2565 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2566 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2567 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2570 /* Terminate the abbreviations for this compilation unit. */
2574 /* Emit a description of this compilation unit for .debug_info. */
2577 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2578 symbolS
*ranges_sym
, symbolS
*name_sym
,
2579 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2585 memset (&exp
, 0, sizeof exp
);
2586 sizeof_offset
= out_header (info_seg
, &exp
);
2587 info_end
= exp
.X_add_symbol
;
2589 /* DWARF version. */
2590 out_two (DWARF2_VERSION
);
2592 if (DWARF2_VERSION
< 5)
2594 /* .debug_abbrev offset */
2595 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2599 /* unit (header) type */
2600 out_byte (DW_UT_compile
);
2603 /* Target address size. */
2604 out_byte (sizeof_address
);
2606 if (DWARF2_VERSION
>= 5)
2608 /* .debug_abbrev offset */
2609 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2612 /* DW_TAG_compile_unit DIE abbrev */
2615 /* DW_AT_stmt_list */
2616 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2617 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2620 /* These two attributes are emitted if all of the code is contiguous. */
2621 if (all_segs
->next
== NULL
)
2624 exp
.X_op
= O_symbol
;
2625 exp
.X_add_symbol
= all_segs
->text_start
;
2626 exp
.X_add_number
= 0;
2627 emit_expr (&exp
, sizeof_address
);
2630 if (DWARF2_VERSION
< 4)
2631 exp
.X_op
= O_symbol
;
2634 exp
.X_op
= O_subtract
;
2635 exp
.X_op_symbol
= all_segs
->text_start
;
2637 exp
.X_add_symbol
= all_segs
->text_end
;
2638 exp
.X_add_number
= 0;
2639 if (DWARF2_VERSION
< 4)
2640 emit_expr (&exp
, sizeof_address
);
2642 emit_leb128_expr (&exp
, 0);
2646 /* This attribute is emitted if the code is disjoint. */
2648 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2651 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2652 setup in out_debug_str below. */
2653 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2654 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2655 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2657 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2658 dwarf2 draft has no standard code for assembler. */
2659 out_two (DW_LANG_Mips_Assembler
);
2661 symbol_set_value_now (info_end
);
2664 /* Emit the three debug strings needed in .debug_str and setup symbols
2665 to them for use in out_debug_info. */
2667 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2668 symbolS
**producer_sym
)
2671 const char *comp_dir
;
2672 const char *dirname
;
2675 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2677 subseg_set (str_seg
, 0);
2679 /* DW_AT_name. We don't have the actual file name that was present
2680 on the command line, so assume files[first_file] is the main input file.
2681 We're not supposed to get called unless at least one line number
2682 entry was emitted, so this should always be defined. */
2683 *name_sym
= symbol_temp_new_now_octets ();
2684 if (files_in_use
== 0)
2686 if (files
[first_file
].dir
)
2688 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2689 len
= strlen (dirname
);
2691 /* Already has trailing slash. */
2692 p
= frag_more (len
);
2693 memcpy (p
, dirname
, len
);
2695 p
= frag_more (len
+ 1);
2696 memcpy (p
, dirname
, len
);
2697 INSERT_DIR_SEPARATOR (p
, len
);
2700 len
= strlen (files
[first_file
].filename
) + 1;
2701 p
= frag_more (len
);
2702 memcpy (p
, files
[first_file
].filename
, len
);
2704 /* DW_AT_comp_dir */
2705 *comp_dir_sym
= symbol_temp_new_now_octets ();
2706 comp_dir
= remap_debug_filename (getpwd ());
2707 len
= strlen (comp_dir
) + 1;
2708 p
= frag_more (len
);
2709 memcpy (p
, comp_dir
, len
);
2711 /* DW_AT_producer */
2712 *producer_sym
= symbol_temp_new_now_octets ();
2713 sprintf (producer
, "GNU AS %s", VERSION
);
2714 len
= strlen (producer
) + 1;
2715 p
= frag_more (len
);
2716 memcpy (p
, producer
, len
);
2722 last_seg_ptr
= &all_segs
;
2724 /* Select the default CIE version to produce here. The global
2725 starts with a value of -1 and will be modified to a valid value
2726 either by the user providing a command line option, or some
2727 targets will select their own default in md_after_parse_args. If
2728 we get here and the global still contains -1 then it is up to us
2729 to pick a sane default. The default we choose is 1, this is the
2730 CIE version gas has produced for a long time, and there seems no
2731 reason to change it yet. */
2732 if (flag_dwarf_cie_version
== -1)
2733 flag_dwarf_cie_version
= 1;
2737 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2738 were any .file/.loc directives, or --gdwarf2 was given, and if the
2739 file has a non-empty .debug_info section and an empty .debug_line
2740 section. If we emit .debug_line, and the .debug_info section is
2741 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2742 ALL_SEGS will be non-null if there were any .file/.loc directives,
2743 or --gdwarf2 was given and there were any located instructions
2747 dwarf2_finish (void)
2752 int emit_other_sections
= 0;
2753 int empty_debug_line
= 0;
2755 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2756 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2758 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2759 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2761 /* We can't construct a new debug_line section if we already have one.
2762 Give an error if we have seen any .loc, otherwise trust the user
2763 knows what they are doing and want to generate the .debug_line
2764 (and all other debug sections) themselves. */
2765 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2766 as_fatal ("duplicate .debug_line sections");
2768 if ((!all_segs
&& emit_other_sections
)
2769 || (!emit_other_sections
&& !empty_debug_line
))
2770 /* If there is no line information and no non-empty .debug_info
2771 section, or if there is both a non-empty .debug_info and a non-empty
2772 .debug_line, then we do nothing. */
2775 /* Calculate the size of an address for the target machine. */
2776 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2778 /* Create and switch to the line number section. */
2779 if (empty_debug_line
)
2781 line_seg
= subseg_new (".debug_line", 0);
2782 bfd_set_section_flags (line_seg
,
2783 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2786 /* For each subsection, chain the debug entries together. */
2787 for (s
= all_segs
; s
; s
= s
->next
)
2789 struct line_subseg
*lss
= s
->head
;
2790 struct line_entry
**ptail
= lss
->ptail
;
2792 /* Reset the initial view of the first subsection of the
2794 if (lss
->head
&& lss
->head
->loc
.view
)
2795 set_or_check_view (lss
->head
, NULL
, NULL
);
2797 while ((lss
= lss
->next
) != NULL
)
2799 /* Link the first view of subsequent subsections to the
2801 if (lss
->head
&& lss
->head
->loc
.view
)
2802 set_or_check_view (lss
->head
,
2803 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2804 s
->head
? s
->head
->head
: NULL
);
2810 if (empty_debug_line
)
2811 out_debug_line (line_seg
);
2813 /* If this is assembler generated line info, and there is no
2814 debug_info already, we need .debug_info, .debug_abbrev and
2815 .debug_str sections as well. */
2816 if (emit_other_sections
)
2821 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2823 gas_assert (all_segs
);
2825 info_seg
= subseg_new (".debug_info", 0);
2826 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2827 aranges_seg
= subseg_new (".debug_aranges", 0);
2828 str_seg
= subseg_new (".debug_str", 0);
2830 bfd_set_section_flags (info_seg
,
2831 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2832 bfd_set_section_flags (abbrev_seg
,
2833 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2834 bfd_set_section_flags (aranges_seg
,
2835 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2836 bfd_set_section_flags (str_seg
,
2837 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2838 | SEC_MERGE
| SEC_STRINGS
);
2839 str_seg
->entsize
= 1;
2841 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2843 if (all_segs
->next
== NULL
)
2847 if (DWARF2_VERSION
< 5)
2849 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2850 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2853 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2854 out_debug_ranges (ranges_seg
, &ranges_sym
);
2858 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2859 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2862 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2866 out_debug_aranges (aranges_seg
, info_seg
);
2867 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2868 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2869 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2870 name_sym
, comp_dir_sym
, producer_sym
);
2874 /* Perform any deferred checks pertaining to debug information. */
2877 dwarf2dbg_final_check (void)
2879 /* Perform reset-view checks. Don't evaluate view_assert_failed
2880 recursively: it could be very deep. It's a chain of adds, with
2881 each chain element pointing to the next in X_add_symbol, and
2882 holding the check value in X_op_symbol. */
2883 while (view_assert_failed
)
2889 gas_assert (!symbol_resolved_p (view_assert_failed
));
2891 exp
= symbol_get_value_expression (view_assert_failed
);
2892 sym
= view_assert_failed
;
2894 /* If view_assert_failed looks like a compound check in the
2895 chain, break it up. */
2896 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2898 view_assert_failed
= exp
->X_add_symbol
;
2899 sym
= exp
->X_op_symbol
;
2902 view_assert_failed
= NULL
;
2904 failed
= resolve_symbol_value (sym
);
2905 if (!symbol_resolved_p (sym
) || failed
)
2907 as_bad (_("view number mismatch"));