1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2021 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
;
221 static unsigned int num_of_auto_assigned
;
223 /* Table of directories used by .debug_line. */
224 static char ** dirs
= NULL
;
225 static unsigned int dirs_in_use
= 0;
226 static unsigned int dirs_allocated
= 0;
228 /* TRUE when we've seen a .loc directive recently. Used to avoid
229 doing work when there's nothing to do. Will be reset by
230 dwarf2_consume_line_info. */
231 bfd_boolean dwarf2_loc_directive_seen
;
233 /* TRUE when we've seen any .loc directive at any time during parsing.
234 Indicates the user wants us to generate a .debug_line section.
235 Used in dwarf2_finish as sanity check. */
236 static bfd_boolean dwarf2_any_loc_directive_seen
;
238 /* TRUE when we're supposed to set the basic block mark whenever a
240 bfd_boolean dwarf2_loc_mark_labels
;
242 /* Current location as indicated by the most recent .loc directive. */
243 static struct dwarf2_line_info current
=
246 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
250 /* This symbol is used to recognize view number forced resets in loc
252 static symbolS
*force_reset_view
;
254 /* This symbol evaluates to an expression that, if nonzero, indicates
255 some view assert check failed. */
256 static symbolS
*view_assert_failed
;
258 /* The size of an address on the target. */
259 static unsigned int sizeof_address
;
261 #ifndef TC_DWARF2_EMIT_OFFSET
262 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
264 /* Create an offset to .dwarf2_*. */
267 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
271 memset (&exp
, 0, sizeof exp
);
273 exp
.X_add_symbol
= symbol
;
274 exp
.X_add_number
= 0;
275 emit_expr (&exp
, size
);
279 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
281 static struct line_subseg
*
282 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
284 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
285 struct line_subseg
**pss
, *lss
;
292 s
= XNEW (struct line_seg
);
297 last_seg_ptr
= &s
->next
;
298 seg_info (seg
)->dwarf2_line_seg
= s
;
301 gas_assert (seg
== s
->seg
);
303 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
305 if (lss
->subseg
== subseg
)
307 if (lss
->subseg
> subseg
)
311 lss
= XNEW (struct line_subseg
);
313 lss
->subseg
= subseg
;
315 lss
->ptail
= &lss
->head
;
316 lss
->pmove_tail
= &lss
->head
;
323 /* (Un)reverse the line_entry list starting from H. */
325 static struct line_entry
*
326 reverse_line_entry_list (struct line_entry
*h
)
328 struct line_entry
*p
= NULL
, *e
, *n
;
330 for (e
= h
; e
; e
= n
)
339 /* Compute the view for E based on the previous entry P. If we
340 introduce an (undefined) view symbol for P, and H is given (P must
341 be the tail in this case), introduce view symbols for earlier list
342 entries as well, until one of them is constant. */
345 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
346 struct line_entry
*h
)
350 memset (&viewx
, 0, sizeof (viewx
));
351 viewx
.X_unsigned
= 1;
353 /* First, compute !(E->label > P->label), to tell whether or not
354 we're to reset the view number. If we can't resolve it to a
355 constant, keep it symbolic. */
356 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
358 viewx
.X_op
= O_constant
;
359 viewx
.X_add_number
= 0;
360 viewx
.X_add_symbol
= NULL
;
361 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_add_number
= 0;
367 viewx
.X_add_symbol
= e
->label
;
368 viewx
.X_op_symbol
= p
->label
;
369 resolve_expression (&viewx
);
370 if (viewx
.X_op
== O_constant
)
371 viewx
.X_add_number
= !viewx
.X_add_number
;
374 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
375 viewx
.X_add_number
= 0;
376 viewx
.X_op_symbol
= NULL
;
377 viewx
.X_op
= O_logical_not
;
381 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
383 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
384 /* We can't compare the view numbers at this point, because in
385 VIEWX we've only determined whether we're to reset it so
387 if (viewx
.X_op
== O_constant
)
389 if (!value
->X_add_number
!= !viewx
.X_add_number
)
390 as_bad (_("view number mismatch"));
392 /* Record the expression to check it later. It is the result of
393 a logical not, thus 0 or 1. We just add up all such deferred
394 expressions, and resolve it at the end. */
395 else if (!value
->X_add_number
)
397 symbolS
*deferred
= make_expr_symbol (&viewx
);
398 if (view_assert_failed
)
402 memset (&chk
, 0, sizeof (chk
));
405 chk
.X_add_number
= 0;
406 chk
.X_add_symbol
= view_assert_failed
;
407 chk
.X_op_symbol
= deferred
;
408 deferred
= make_expr_symbol (&chk
);
410 view_assert_failed
= deferred
;
414 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
420 p
->loc
.view
= symbol_temp_make ();
421 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
424 memset (&incv
, 0, sizeof (incv
));
426 incv
.X_op
= O_symbol
;
427 incv
.X_add_symbol
= p
->loc
.view
;
428 incv
.X_add_number
= 1;
430 if (viewx
.X_op
== O_constant
)
432 gas_assert (viewx
.X_add_number
== 1);
437 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
438 viewx
.X_add_number
= 0;
439 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
440 viewx
.X_op
= O_multiply
;
444 if (!S_IS_DEFINED (e
->loc
.view
))
446 symbol_set_value_expression (e
->loc
.view
, &viewx
);
447 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
448 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
451 /* Define and attempt to simplify any earlier views needed to
453 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
455 struct line_entry
*h2
;
456 /* Reverse the list to avoid quadratic behavior going backwards
457 in a single-linked list. */
458 struct line_entry
*r
= reverse_line_entry_list (h
);
461 /* Set or check views until we find a defined or absent view. */
464 /* Do not define the head of a (sub?)segment view while
465 handling others. It would be defined too early, without
466 regard to the last view of other subsegments.
467 set_or_check_view will be called for every head segment
471 set_or_check_view (r
, r
->next
, NULL
);
473 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
476 /* Unreverse the list, so that we can go forward again. */
477 h2
= reverse_line_entry_list (p
);
478 gas_assert (h2
== h
);
480 /* Starting from the last view we just defined, attempt to
481 simplify the view expressions, until we do so to P. */
484 /* The head view of a subsegment may remain undefined while
485 handling other elements, before it is linked to the last
486 view of the previous subsegment. */
489 gas_assert (S_IS_DEFINED (r
->loc
.view
));
490 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
492 while (r
!= p
&& (r
= r
->next
));
494 /* Now that we've defined and computed all earlier views that might
495 be needed to compute E's, attempt to simplify it. */
496 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
500 /* Record an entry for LOC occurring at LABEL. */
503 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
505 struct line_subseg
*lss
;
506 struct line_entry
*e
;
507 flagword need_flags
= SEC_LOAD
| SEC_CODE
;
509 /* PR 26850: Do not record LOCs in non-executable or non-loaded
510 sections. SEC_ALLOC isn't tested for non-ELF because obj-coff.c
511 obj_coff_section is careless in setting SEC_ALLOC. */
513 need_flags
|= SEC_ALLOC
;
514 if ((now_seg
->flags
& need_flags
) != need_flags
)
516 /* FIXME: Add code to suppress multiple warnings ? */
517 as_warn ("dwarf line number information for %s ignored",
518 segment_name (now_seg
));
522 e
= XNEW (struct line_entry
);
527 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
529 /* Subseg heads are chained to previous subsegs in
531 if (loc
->view
&& lss
->head
)
532 set_or_check_view (e
,
533 (struct line_entry
*)lss
->ptail
,
537 lss
->ptail
= &e
->next
;
540 /* Record an entry for LOC occurring at OFS within the current fragment. */
543 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
545 static unsigned int line
= -1;
546 static unsigned int filenum
= -1;
550 /* Early out for as-yet incomplete location information. */
553 if (loc
->filenum
== 0)
557 if (DWARF2_LINE_VERSION
< 5)
561 /* Don't emit sequences of line symbols for the same line when the
562 symbols apply to assembler code. It is necessary to emit
563 duplicate line symbols when a compiler asks for them, because GDB
564 uses them to determine the end of the prologue. */
565 if (debug_type
== DEBUG_DWARF2
566 && line
== loc
->line
&& filenum
== loc
->filenum
)
570 filenum
= loc
->filenum
;
576 /* Use a non-fake name for the line number location,
577 so that it can be referred to by relocations. */
578 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
579 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
582 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
583 dwarf2_gen_line_info_1 (sym
, loc
);
587 get_basename (const char * pathname
)
591 file
= lbasename (pathname
);
592 /* Don't make empty string from / or A: from A:/ . */
593 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
594 if (file
<= pathname
+ 3)
597 if (file
== pathname
+ 1)
604 get_directory_table_entry (const char * dirname
,
606 bfd_boolean can_use_zero
)
613 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
614 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
622 for (d
= 0; d
< dirs_in_use
; ++d
)
625 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
626 && dirs
[d
][dirlen
] == '\0')
632 if (dirs
== NULL
|| dirs
[0] == NULL
)
638 if (d
>= dirs_allocated
)
640 unsigned int old
= dirs_allocated
;
642 dirs_allocated
= d
+ 32;
643 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
644 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
647 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
648 if (dirs_in_use
<= d
)
655 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
657 if (i
>= files_allocated
)
659 unsigned int old
= files_allocated
;
661 files_allocated
= i
+ 32;
662 /* Catch wraparound. */
663 if (files_allocated
<= old
)
665 as_bad (_("file number %lu is too big"), (unsigned long) i
);
669 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
670 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
673 files
[i
].filename
= file
;
675 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
677 if (files_in_use
< i
+ 1)
678 files_in_use
= i
+ 1;
683 /* Get a .debug_line file number for PATHNAME. If there is a
684 directory component to PATHNAME, then this will be stored
685 in the directory table, if it is not already present.
686 Returns the slot number allocated to that filename or -1
687 if there was a problem. */
690 allocate_filenum (const char * pathname
)
692 static signed int last_used
= -1, last_used_dir_len
= 0;
697 /* Short circuit the common case of adding the same pathname
701 const char * dirname
= NULL
;
704 dirname
= dirs
[files
[last_used
].dir
];
708 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
713 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
714 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
715 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
716 files
[last_used
].filename
) == 0)
721 file
= get_basename (pathname
);
722 dir_len
= file
- pathname
;
724 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
726 /* Do not use slot-0. That is specifically reserved for use by
727 the '.file 0 "name"' directive. */
728 for (i
= 1; i
< files_in_use
; ++i
)
729 if (files
[i
].dir
== dir
731 && filename_cmp (file
, files
[i
].filename
) == 0)
734 last_used_dir_len
= dir_len
;
738 if (!assign_file_to_slot (i
, file
, dir
))
741 num_of_auto_assigned
++;
744 last_used_dir_len
= dir_len
;
749 /* Allocate slot NUM in the .debug_line file table to FILENAME.
750 If DIRNAME is not NULL or there is a directory component to FILENAME
751 then this will be stored in the directory table, if not already present.
752 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
753 Returns TRUE if allocation succeeded, FALSE otherwise. */
756 allocate_filename_to_slot (const char * dirname
,
757 const char * filename
,
759 bfd_boolean with_md5
)
765 /* Short circuit the common case of adding the same pathname
767 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
769 const char * dir
= NULL
;
772 dir
= dirs
[files
[num
].dir
];
775 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
780 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
783 if (filename_cmp (filename
, files
[num
].filename
) != 0)
786 /* If the filenames match, but the directory table entry was
787 empty, then fill it with the provided directory name. */
789 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
793 else if (dir
!= NULL
)
795 dirlen
= strlen (dir
);
796 if (filename_ncmp (filename
, dir
, dirlen
) == 0
797 && IS_DIR_SEPARATOR (filename
[dirlen
])
798 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
801 else /* dir == NULL */
803 file
= get_basename (filename
);
804 if (filename_cmp (file
, files
[num
].filename
) == 0)
807 /* The filenames match, but the directory table entry is empty.
808 Fill it with the provided directory name. */
809 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
815 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
817 dir
== NULL
? "" : dir
,
818 dir
== NULL
? "" : "/",
820 dirname
== NULL
? "" : dirname
,
821 dirname
== NULL
? "" : "/",
829 file
= get_basename (filename
);
830 dirlen
= file
- filename
;
834 dirlen
= strlen (dirname
);
838 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
841 if (! assign_file_to_slot (i
, file
, d
))
846 if (target_big_endian
)
848 /* md5's are stored in litte endian format. */
849 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
850 unsigned int byte
= NUM_MD5_BYTES
;
851 unsigned int bignum_index
= 0;
853 while (bits_remaining
)
855 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
856 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 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
871 unsigned int byte
= 0;
872 unsigned int bignum_index
= 0;
874 while (bits_remaining
)
876 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
877 valueT bignum_value
= generic_bignum
[bignum_index
];
881 while (bignum_bits_remaining
)
883 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
885 bignum_bits_remaining
-= 8;
892 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
897 /* Returns the current source information. If .file directives have
898 been encountered, the info for the corresponding source file is
899 returned. Otherwise, the info for the assembly source file is
903 dwarf2_where (struct dwarf2_line_info
*line
)
905 if (debug_type
== DEBUG_DWARF2
)
907 const char *filename
;
909 memset (line
, 0, sizeof (*line
));
910 filename
= as_where (&line
->line
);
911 line
->filenum
= allocate_filenum (filename
);
912 /* FIXME: We should check the return value from allocate_filenum. */
914 line
->flags
= DWARF2_FLAG_IS_STMT
;
915 line
->isa
= current
.isa
;
916 line
->discriminator
= current
.discriminator
;
923 /* A hook to allow the target backend to inform the line number state
924 machine of isa changes when assembler debug info is enabled. */
927 dwarf2_set_isa (unsigned int isa
)
932 /* Called for each machine instruction, or relatively atomic group of
933 machine instructions (ie built-in macro). The instruction or group
934 is SIZE bytes in length. If dwarf2 line number generation is called
935 for, emit a line statement appropriately. */
938 dwarf2_emit_insn (int size
)
940 struct dwarf2_line_info loc
;
942 if (debug_type
!= DEBUG_DWARF2
943 ? !dwarf2_loc_directive_seen
944 : !seen_at_least_1_file ())
949 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
950 dwarf2_consume_line_info ();
953 /* Move all previously-emitted line entries for the current position by
954 DELTA bytes. This function cannot be used to move the same entries
958 dwarf2_move_insn (int delta
)
960 struct line_subseg
*lss
;
961 struct line_entry
*e
;
967 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
971 now
= frag_now_fix ();
972 while ((e
= *lss
->pmove_tail
))
974 if (S_GET_VALUE (e
->label
) == now
)
975 S_SET_VALUE (e
->label
, now
+ delta
);
976 lss
->pmove_tail
= &e
->next
;
980 /* Called after the current line information has been either used with
981 dwarf2_gen_line_info or saved with a machine instruction for later use.
982 This resets the state of the line number information to reflect that
986 dwarf2_consume_line_info (void)
988 /* Unless we generate DWARF2 debugging information for each
989 assembler line, we only emit one line symbol for one LOC. */
990 dwarf2_loc_directive_seen
= FALSE
;
992 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
993 | DWARF2_FLAG_PROLOGUE_END
994 | DWARF2_FLAG_EPILOGUE_BEGIN
);
995 current
.discriminator
= 0;
999 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1000 is enabled, emit a basic block marker. */
1003 dwarf2_emit_label (symbolS
*label
)
1005 struct dwarf2_line_info loc
;
1007 if (!dwarf2_loc_mark_labels
)
1009 if (S_GET_SEGMENT (label
) != now_seg
)
1011 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1013 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1016 dwarf2_where (&loc
);
1018 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1020 dwarf2_gen_line_info_1 (label
, &loc
);
1021 dwarf2_consume_line_info ();
1024 /* Handle two forms of .file directive:
1025 - Pass .file "source.c" to s_app_file
1026 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1028 If an entry is added to the file table, return a pointer to the filename. */
1031 dwarf2_directive_filename (void)
1033 bfd_boolean with_md5
= FALSE
;
1036 const char * dirname
= NULL
;
1040 /* Continue to accept a bare string and pass it off. */
1042 if (*input_line_pointer
== '"')
1048 num
= get_absolute_expression ();
1050 if ((offsetT
) num
< 1)
1052 if (num
== 0 && dwarf_level
< 5)
1054 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1056 as_bad (_("file number less than one"));
1057 ignore_rest_of_line ();
1062 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1063 "switch back to the already allocated file <N> as the current
1066 filename
= demand_copy_C_string (&filename_len
);
1067 if (filename
== NULL
)
1068 /* demand_copy_C_string will have already generated an error message. */
1071 /* For DWARF-5 support we also accept:
1072 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1073 if (DWARF2_LINE_VERSION
> 4)
1076 if (*input_line_pointer
== '"')
1079 filename
= demand_copy_C_string (&filename_len
);
1083 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1085 input_line_pointer
+= 3;
1089 expression_and_evaluate (& exp
);
1090 if (exp
.X_op
!= O_big
)
1091 as_bad (_("md5 value too small or not a constant"));
1097 demand_empty_rest_of_line ();
1099 /* A .file directive implies compiler generated debug information is
1100 being supplied. Turn off gas generated debug info. */
1101 debug_type
= DEBUG_NONE
;
1103 if (num
!= (unsigned int) num
1104 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1106 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1110 if (num_of_auto_assigned
)
1112 /* Clear slots auto-assigned before the first .file <NUMBER>
1113 directive was seen. */
1114 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1116 for (i
= 1; i
< files_in_use
; i
++)
1117 files
[i
].filename
= NULL
;
1119 num_of_auto_assigned
= 0;
1122 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1129 /* Calls dwarf2_directive_filename, but discards its result.
1130 Used in pseudo-op tables where the function result is ignored. */
1133 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1135 (void) dwarf2_directive_filename ();
1139 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1141 offsetT filenum
, line
;
1143 /* If we see two .loc directives in a row, force the first one to be
1145 if (dwarf2_loc_directive_seen
)
1146 dwarf2_emit_insn (0);
1148 filenum
= get_absolute_expression ();
1150 line
= get_absolute_expression ();
1154 if (filenum
== 0 && dwarf_level
< 5)
1156 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1158 as_bad (_("file number less than one"));
1163 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1165 as_bad (_("unassigned file number %ld"), (long) filenum
);
1169 current
.filenum
= filenum
;
1170 current
.line
= line
;
1171 current
.discriminator
= 0;
1176 if (files
[filenum
].dir
)
1178 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1179 size_t file_len
= strlen (files
[filenum
].filename
);
1180 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1182 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1183 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1184 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1185 cp
[dir_len
+ file_len
+ 1] = '\0';
1186 listing_source_file (cp
);
1190 listing_source_file (files
[filenum
].filename
);
1191 listing_source_line (line
);
1196 if (ISDIGIT (*input_line_pointer
))
1198 current
.column
= get_absolute_expression ();
1202 while (ISALPHA (*input_line_pointer
))
1207 c
= get_symbol_name (& p
);
1209 if (strcmp (p
, "basic_block") == 0)
1211 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1212 *input_line_pointer
= c
;
1214 else if (strcmp (p
, "prologue_end") == 0)
1216 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1217 *input_line_pointer
= c
;
1219 else if (strcmp (p
, "epilogue_begin") == 0)
1221 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1222 *input_line_pointer
= c
;
1224 else if (strcmp (p
, "is_stmt") == 0)
1226 (void) restore_line_pointer (c
);
1227 value
= get_absolute_expression ();
1229 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1230 else if (value
== 1)
1231 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1234 as_bad (_("is_stmt value not 0 or 1"));
1238 else if (strcmp (p
, "isa") == 0)
1240 (void) restore_line_pointer (c
);
1241 value
= get_absolute_expression ();
1243 current
.isa
= value
;
1246 as_bad (_("isa number less than zero"));
1250 else if (strcmp (p
, "discriminator") == 0)
1252 (void) restore_line_pointer (c
);
1253 value
= get_absolute_expression ();
1255 current
.discriminator
= value
;
1258 as_bad (_("discriminator less than zero"));
1262 else if (strcmp (p
, "view") == 0)
1266 (void) restore_line_pointer (c
);
1269 if (ISDIGIT (*input_line_pointer
)
1270 || *input_line_pointer
== '-')
1272 bfd_boolean force_reset
= *input_line_pointer
== '-';
1274 value
= get_absolute_expression ();
1277 as_bad (_("numeric view can only be asserted to zero"));
1280 if (force_reset
&& force_reset_view
)
1281 sym
= force_reset_view
;
1284 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1287 force_reset_view
= sym
;
1292 char *name
= read_symbol_name ();
1296 sym
= symbol_find_or_make (name
);
1297 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1299 if (S_IS_VOLATILE (sym
))
1300 sym
= symbol_clone (sym
, 1);
1301 else if (!S_CAN_BE_REDEFINED (sym
))
1303 as_bad (_("symbol `%s' is already defined"), name
);
1307 S_SET_SEGMENT (sym
, undefined_section
);
1308 S_SET_VALUE (sym
, 0);
1309 symbol_set_frag (sym
, &zero_address_frag
);
1315 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1316 (void) restore_line_pointer (c
);
1320 SKIP_WHITESPACE_AFTER_NAME ();
1323 demand_empty_rest_of_line ();
1324 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1325 debug_type
= DEBUG_NONE
;
1327 /* If we were given a view id, emit the row right away. */
1329 dwarf2_emit_insn (0);
1333 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1335 offsetT value
= get_absolute_expression ();
1337 if (value
!= 0 && value
!= 1)
1339 as_bad (_("expected 0 or 1"));
1340 ignore_rest_of_line ();
1344 dwarf2_loc_mark_labels
= value
!= 0;
1345 demand_empty_rest_of_line ();
1349 static struct frag
*
1350 first_frag_for_seg (segT seg
)
1352 return seg_info (seg
)->frchainP
->frch_root
;
1355 static struct frag
*
1356 last_frag_for_seg (segT seg
)
1358 frchainS
*f
= seg_info (seg
)->frchainP
;
1360 while (f
->frch_next
!= NULL
)
1363 return f
->frch_last
;
1366 /* Emit a single byte into the current segment. */
1371 FRAG_APPEND_1_CHAR (byte
);
1374 /* Emit a statement program opcode into the current segment. */
1377 out_opcode (int opc
)
1382 /* Emit a two-byte word into the current segment. */
1387 md_number_to_chars (frag_more (2), data
, 2);
1390 /* Emit a four byte word into the current segment. */
1395 md_number_to_chars (frag_more (4), data
, 4);
1398 /* Emit an unsigned "little-endian base 128" number. */
1401 out_uleb128 (addressT value
)
1403 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1406 /* Emit a signed "little-endian base 128" number. */
1409 out_leb128 (addressT value
)
1411 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1414 /* Emit a tuple for .debug_abbrev. */
1417 out_abbrev (int name
, int form
)
1423 /* Get the size of a fragment. */
1426 get_frag_fix (fragS
*frag
, segT seg
)
1431 return frag
->fr_fix
;
1433 /* If a fragment is the last in the chain, special measures must be
1434 taken to find its size before relaxation, since it may be pending
1435 on some subsegment chain. */
1436 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1437 if (fr
->frch_last
== frag
)
1438 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1443 /* Set an absolute address (may result in a relocation entry). */
1446 out_set_addr (symbolS
*sym
)
1450 memset (&exp
, 0, sizeof exp
);
1451 out_opcode (DW_LNS_extended_op
);
1452 out_uleb128 (sizeof_address
+ 1);
1454 out_opcode (DW_LNE_set_address
);
1455 exp
.X_op
= O_symbol
;
1456 exp
.X_add_symbol
= sym
;
1457 exp
.X_add_number
= 0;
1458 emit_expr (&exp
, sizeof_address
);
1461 static void scale_addr_delta (addressT
*);
1464 scale_addr_delta (addressT
*addr_delta
)
1466 static int printed_this
= 0;
1467 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1469 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1471 as_bad("unaligned opcodes detected in executable segment");
1474 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1478 /* Encode a pair of line and address skips as efficiently as possible.
1479 Note that the line skip is signed, whereas the address skip is unsigned.
1481 The following two routines *must* be kept in sync. This is
1482 enforced by making emit_inc_line_addr abort if we do not emit
1483 exactly the expected number of bytes. */
1486 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1488 unsigned int tmp
, opcode
;
1491 /* Scale the address delta by the minimum instruction length. */
1492 scale_addr_delta (&addr_delta
);
1494 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1495 We cannot use special opcodes here, since we want the end_sequence
1496 to emit the matrix entry. */
1497 if (line_delta
== INT_MAX
)
1499 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1501 else if (addr_delta
)
1502 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1506 /* Bias the line delta by the base. */
1507 tmp
= line_delta
- DWARF2_LINE_BASE
;
1509 /* If the line increment is out of range of a special opcode, we
1510 must encode it with DW_LNS_advance_line. */
1511 if (tmp
>= DWARF2_LINE_RANGE
)
1513 len
= 1 + sizeof_leb128 (line_delta
, 1);
1515 tmp
= 0 - DWARF2_LINE_BASE
;
1518 /* Bias the opcode by the special opcode base. */
1519 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1521 /* Avoid overflow when addr_delta is large. */
1522 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1524 /* Try using a special opcode. */
1525 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1529 /* Try using DW_LNS_const_add_pc followed by special op. */
1530 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1535 /* Otherwise use DW_LNS_advance_pc. */
1536 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1538 /* DW_LNS_copy or special opcode. */
1545 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1547 unsigned int tmp
, opcode
;
1549 char *end
= p
+ len
;
1551 /* Line number sequences cannot go backward in addresses. This means
1552 we've incorrectly ordered the statements in the sequence. */
1553 gas_assert ((offsetT
) addr_delta
>= 0);
1555 /* Scale the address delta by the minimum instruction length. */
1556 scale_addr_delta (&addr_delta
);
1558 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1559 We cannot use special opcodes here, since we want the end_sequence
1560 to emit the matrix entry. */
1561 if (line_delta
== INT_MAX
)
1563 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1564 *p
++ = DW_LNS_const_add_pc
;
1565 else if (addr_delta
)
1567 *p
++ = DW_LNS_advance_pc
;
1568 p
+= output_leb128 (p
, addr_delta
, 0);
1571 *p
++ = DW_LNS_extended_op
;
1573 *p
++ = DW_LNE_end_sequence
;
1577 /* Bias the line delta by the base. */
1578 tmp
= line_delta
- DWARF2_LINE_BASE
;
1580 /* If the line increment is out of range of a special opcode, we
1581 must encode it with DW_LNS_advance_line. */
1582 if (tmp
>= DWARF2_LINE_RANGE
)
1584 *p
++ = DW_LNS_advance_line
;
1585 p
+= output_leb128 (p
, line_delta
, 1);
1588 tmp
= 0 - DWARF2_LINE_BASE
;
1592 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1594 if (line_delta
== 0 && addr_delta
== 0)
1600 /* Bias the opcode by the special opcode base. */
1601 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1603 /* Avoid overflow when addr_delta is large. */
1604 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1606 /* Try using a special opcode. */
1607 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1614 /* Try using DW_LNS_const_add_pc followed by special op. */
1615 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1618 *p
++ = DW_LNS_const_add_pc
;
1624 /* Otherwise use DW_LNS_advance_pc. */
1625 *p
++ = DW_LNS_advance_pc
;
1626 p
+= output_leb128 (p
, addr_delta
, 0);
1634 gas_assert (p
== end
);
1637 /* Handy routine to combine calls to the above two routines. */
1640 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1642 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1643 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1646 /* Write out an alternative form of line and address skips using
1647 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1648 line and address information, but it is required if linker relaxation
1649 could change the code offsets. The following two routines *must* be
1651 #define ADDR_DELTA_LIMIT 50000
1654 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1658 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1659 if (line_delta
!= INT_MAX
)
1660 len
= 1 + sizeof_leb128 (line_delta
, 1);
1662 if (addr_delta
> ADDR_DELTA_LIMIT
)
1664 /* DW_LNS_extended_op */
1665 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1666 /* DW_LNE_set_address */
1667 len
+= 1 + sizeof_address
;
1670 /* DW_LNS_fixed_advance_pc */
1673 if (line_delta
== INT_MAX
)
1674 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1684 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1688 char *end
= p
+ len
;
1690 /* Line number sequences cannot go backward in addresses. This means
1691 we've incorrectly ordered the statements in the sequence. */
1692 gas_assert ((offsetT
) addr_delta
>= 0);
1694 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1695 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1697 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1698 if (line_delta
!= INT_MAX
)
1700 *p
++ = DW_LNS_advance_line
;
1701 p
+= output_leb128 (p
, line_delta
, 1);
1704 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1706 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1707 advance the address by at most 64K. Linker relaxation (without
1708 which this function would not be used) could change the operand by
1709 an unknown amount. If the address increment is getting close to
1710 the limit, just reset the address. */
1711 if (addr_delta
> ADDR_DELTA_LIMIT
)
1716 memset (&exp
, 0, sizeof exp
);
1717 gas_assert (pexp
->X_op
== O_subtract
);
1718 to_sym
= pexp
->X_add_symbol
;
1720 *p
++ = DW_LNS_extended_op
;
1721 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1722 *p
++ = DW_LNE_set_address
;
1723 exp
.X_op
= O_symbol
;
1724 exp
.X_add_symbol
= to_sym
;
1725 exp
.X_add_number
= 0;
1726 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1727 p
+= sizeof_address
;
1731 *p
++ = DW_LNS_fixed_advance_pc
;
1732 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1736 if (line_delta
== INT_MAX
)
1738 *p
++ = DW_LNS_extended_op
;
1740 *p
++ = DW_LNE_end_sequence
;
1745 gas_assert (p
== end
);
1748 /* Generate a variant frag that we can use to relax address/line
1749 increments between fragments of the target segment. */
1752 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1757 memset (&exp
, 0, sizeof exp
);
1758 exp
.X_op
= O_subtract
;
1759 exp
.X_add_symbol
= to_sym
;
1760 exp
.X_op_symbol
= from_sym
;
1761 exp
.X_add_number
= 0;
1763 /* The maximum size of the frag is the line delta with a maximum
1764 sized address delta. */
1765 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1766 max_chars
= size_fixed_inc_line_addr (line_delta
,
1767 -DWARF2_LINE_MIN_INSN_LENGTH
);
1769 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1771 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1772 make_expr_symbol (&exp
), line_delta
, NULL
);
1775 /* The function estimates the size of a rs_dwarf2dbg variant frag
1776 based on the current values of the symbols. It is called before
1777 the relaxation loop. We set fr_subtype to the expected length. */
1780 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1785 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1786 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1787 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1789 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1791 frag
->fr_subtype
= size
;
1796 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1797 current values of the symbols. fr_subtype is the current length
1798 of the frag. This returns the change in frag length. */
1801 dwarf2dbg_relax_frag (fragS
*frag
)
1803 int old_size
, new_size
;
1805 old_size
= frag
->fr_subtype
;
1806 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1808 return new_size
- old_size
;
1811 /* This function converts a rs_dwarf2dbg variant frag into a normal
1812 fill frag. This is called after all relaxation has been done.
1813 fr_subtype will be the desired length of the frag. */
1816 dwarf2dbg_convert_frag (fragS
*frag
)
1820 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1822 /* If linker relaxation is enabled then the distance between the two
1823 symbols in the frag->fr_symbol expression might change. Hence we
1824 cannot rely upon the value computed by resolve_symbol_value.
1825 Instead we leave the expression unfinalized and allow
1826 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1827 relocation) that will allow the linker to correctly compute the
1828 actual address difference. We have to use a fixed line advance for
1829 this as we cannot (easily) relocate leb128 encoded values. */
1830 int saved_finalize_syms
= finalize_syms
;
1833 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1834 finalize_syms
= saved_finalize_syms
;
1837 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1839 /* fr_var carries the max_chars that we created the fragment with.
1840 fr_subtype carries the current expected length. We must, of
1841 course, have allocated enough memory earlier. */
1842 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1844 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1845 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1846 frag
->fr_literal
+ frag
->fr_fix
,
1849 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1850 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1852 frag
->fr_fix
+= frag
->fr_subtype
;
1853 frag
->fr_type
= rs_fill
;
1855 frag
->fr_offset
= 0;
1858 /* Generate .debug_line content for the chain of line number entries
1859 beginning at E, for segment SEG. */
1862 process_entries (segT seg
, struct line_entry
*e
)
1864 unsigned filenum
= 1;
1866 unsigned column
= 0;
1868 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1869 fragS
*last_frag
= NULL
, *frag
;
1870 addressT last_frag_ofs
= 0, frag_ofs
;
1871 symbolS
*last_lab
= NULL
, *lab
;
1872 struct line_entry
*next
;
1874 if (flag_dwarf_sections
)
1877 const char * sec_name
;
1879 /* Switch to the relevant sub-section before we start to emit
1880 the line number table.
1882 FIXME: These sub-sections do not have a normal Line Number
1883 Program Header, thus strictly speaking they are not valid
1884 DWARF sections. Unfortunately the DWARF standard assumes
1885 a one-to-one relationship between compilation units and
1886 line number tables. Thus we have to have a .debug_line
1887 section, as well as our sub-sections, and we have to ensure
1888 that all of the sub-sections are merged into a proper
1889 .debug_line section before a debugger sees them. */
1891 sec_name
= bfd_section_name (seg
);
1892 if (strcmp (sec_name
, ".text") != 0)
1894 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1895 subseg_set (subseg_get (name
, FALSE
), 0);
1898 /* Don't create a .debug_line.text section -
1899 that is redundant. Instead just switch back to the
1900 normal .debug_line section. */
1901 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1908 if (filenum
!= e
->loc
.filenum
)
1910 filenum
= e
->loc
.filenum
;
1911 out_opcode (DW_LNS_set_file
);
1912 out_uleb128 (filenum
);
1915 if (column
!= e
->loc
.column
)
1917 column
= e
->loc
.column
;
1918 out_opcode (DW_LNS_set_column
);
1919 out_uleb128 (column
);
1922 if (e
->loc
.discriminator
!= 0)
1924 out_opcode (DW_LNS_extended_op
);
1925 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1926 out_opcode (DW_LNE_set_discriminator
);
1927 out_uleb128 (e
->loc
.discriminator
);
1930 if (isa
!= e
->loc
.isa
)
1933 out_opcode (DW_LNS_set_isa
);
1937 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1939 flags
= e
->loc
.flags
;
1940 out_opcode (DW_LNS_negate_stmt
);
1943 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1944 out_opcode (DW_LNS_set_basic_block
);
1946 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1947 out_opcode (DW_LNS_set_prologue_end
);
1949 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1950 out_opcode (DW_LNS_set_epilogue_begin
);
1952 /* Don't try to optimize away redundant entries; gdb wants two
1953 entries for a function where the code starts on the same line as
1954 the {, and there's no way to identify that case here. Trust gcc
1955 to optimize appropriately. */
1956 line_delta
= e
->loc
.line
- line
;
1958 frag
= symbol_get_frag (lab
);
1959 frag_ofs
= S_GET_VALUE (lab
);
1961 if (last_frag
== NULL
1962 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1963 /* If we're going to reset the view, but we know we're
1964 advancing the PC, we don't have to force with
1965 set_address. We know we do when we're at the same
1966 address of the same frag, and we know we might when
1967 we're in the beginning of a frag, and we were at the
1968 end of the previous frag. */
1969 && (frag
== last_frag
1970 ? (last_frag_ofs
== frag_ofs
)
1972 && ((offsetT
)last_frag_ofs
1973 >= get_frag_fix (last_frag
, seg
))))))
1976 out_inc_line_addr (line_delta
, 0);
1978 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1979 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1981 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1986 last_frag_ofs
= frag_ofs
;
1994 /* Emit a DW_LNE_end_sequence for the end of the section. */
1995 frag
= last_frag_for_seg (seg
);
1996 frag_ofs
= get_frag_fix (frag
, seg
);
1997 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1998 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2001 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2002 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2006 /* Switch to LINE_STR_SEG and output the given STR. Return the
2007 symbol pointing to the new string in the section. */
2010 add_line_strp (segT line_str_seg
, const char *str
)
2016 subseg_set (line_str_seg
, 0);
2018 sym
= symbol_temp_new_now_octets ();
2020 size
= strlen (str
) + 1;
2021 cp
= frag_more (size
);
2022 memcpy (cp
, str
, size
);
2028 /* Emit the directory and file tables for .debug_line. */
2031 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2037 bfd_boolean emit_md5
= FALSE
;
2038 bfd_boolean emit_timestamps
= TRUE
;
2039 bfd_boolean emit_filesize
= TRUE
;
2040 segT line_str_seg
= NULL
;
2043 /* Output the Directory Table. */
2044 if (DWARF2_LINE_VERSION
>= 5)
2046 /* We only have one column in the directory table. */
2049 /* Describe the purpose and format of the column. */
2050 out_uleb128 (DW_LNCT_path
);
2051 /* Store these strings in the .debug_line_str section so they
2053 out_uleb128 (DW_FORM_line_strp
);
2055 /* Now state how many rows there are in the table. We need at
2056 least 1 if there is one or more file names to store the
2057 "working directory". */
2058 if (dirs_in_use
== 0 && files_in_use
> 0)
2061 out_uleb128 (dirs_in_use
);
2064 /* Emit directory list. */
2065 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2067 line_str_seg
= subseg_new (".debug_line_str", 0);
2068 bfd_set_section_flags (line_str_seg
,
2069 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2070 | SEC_MERGE
| SEC_STRINGS
);
2071 line_str_seg
->entsize
= 1;
2073 /* DWARF5 uses slot zero, but that is only set explicitly
2074 using a .file 0 directive. If that isn't used, but dir
2075 one is used, then use that as main file directory.
2076 Otherwise use pwd as main file directory. */
2077 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2078 dir
= remap_debug_filename (dirs
[0]);
2079 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2080 dir
= remap_debug_filename (dirs
[1]);
2082 dir
= remap_debug_filename (getpwd ());
2084 line_strp
= add_line_strp (line_str_seg
, dir
);
2085 subseg_set (line_seg
, 0);
2086 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2088 for (i
= 1; i
< dirs_in_use
; ++i
)
2090 dir
= remap_debug_filename (dirs
[i
]);
2091 if (DWARF2_LINE_VERSION
< 5)
2093 size
= strlen (dir
) + 1;
2094 cp
= frag_more (size
);
2095 memcpy (cp
, dir
, size
);
2099 line_strp
= add_line_strp (line_str_seg
, dir
);
2100 subseg_set (line_seg
, 0);
2101 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2105 if (DWARF2_LINE_VERSION
< 5)
2109 /* Output the File Name Table. */
2110 if (DWARF2_LINE_VERSION
>= 5)
2112 unsigned int columns
= 4;
2114 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2116 emit_timestamps
= FALSE
;
2120 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2122 emit_filesize
= FALSE
;
2126 for (i
= 0; i
< files_in_use
; ++i
)
2127 if (files
[i
].md5
[0] != 0)
2129 if (i
< files_in_use
)
2135 /* The number of format entries to follow. */
2137 /* The format of the file name. */
2138 out_uleb128 (DW_LNCT_path
);
2139 /* Store these strings in the .debug_line_str section so they
2141 out_uleb128 (DW_FORM_line_strp
);
2143 /* The format of the directory index. */
2144 out_uleb128 (DW_LNCT_directory_index
);
2145 out_uleb128 (DW_FORM_udata
);
2147 if (emit_timestamps
)
2149 /* The format of the timestamp. */
2150 out_uleb128 (DW_LNCT_timestamp
);
2151 out_uleb128 (DW_FORM_udata
);
2156 /* The format of the file size. */
2157 out_uleb128 (DW_LNCT_size
);
2158 out_uleb128 (DW_FORM_udata
);
2163 /* The format of the MD5 sum. */
2164 out_uleb128 (DW_LNCT_MD5
);
2165 out_uleb128 (DW_FORM_data16
);
2168 /* The number of entries in the table. */
2169 out_uleb128 (files_in_use
);
2172 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2174 const char *fullfilename
;
2176 if (files
[i
].filename
== NULL
)
2178 /* Prevent a crash later, particularly for file 1. DWARF5
2179 uses slot zero, but that is only set explicitly using a
2180 .file 0 directive. If that isn't used, but file 1 is,
2181 then use that as main file name. */
2182 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2183 files
[0].filename
= files
[1].filename
;
2185 files
[i
].filename
= "";
2186 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2188 as_bad (_("unassigned file number %ld"), (long) i
);
2193 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2194 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2195 if (DWARF2_LINE_VERSION
< 5)
2197 size
= strlen (fullfilename
) + 1;
2198 cp
= frag_more (size
);
2199 memcpy (cp
, fullfilename
, size
);
2203 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2204 subseg_set (line_seg
, 0);
2205 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2208 /* Directory number. */
2209 out_uleb128 (files
[i
].dir
);
2211 /* Output the last modification timestamp. */
2212 if (emit_timestamps
)
2216 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2217 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2218 if (timestamp
== -1)
2220 out_uleb128 (timestamp
);
2223 /* Output the filesize. */
2227 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2228 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2231 out_uleb128 (filesize
);
2234 /* Output the md5 sum. */
2239 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2240 out_byte (files
[i
].md5
[b
]);
2244 if (DWARF2_LINE_VERSION
< 5)
2245 /* Terminate filename list. */
2249 /* Switch to SEC and output a header length field. Return the size of
2250 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2251 to the end of the section. EXPR->X_add_number will be set to the
2252 negative size of the header. */
2255 out_header (asection
*sec
, expressionS
*exp
)
2260 subseg_set (sec
, 0);
2262 if (flag_dwarf_sections
)
2264 /* If we are going to put the start and end symbols in different
2265 sections, then we need real symbols, not just fake, local ones. */
2267 start_sym
= symbol_make (".Ldebug_line_start");
2268 end_sym
= symbol_make (".Ldebug_line_end");
2269 symbol_set_value_now (start_sym
);
2273 start_sym
= symbol_temp_new_now_octets ();
2274 end_sym
= symbol_temp_make ();
2277 /* Total length of the information. */
2278 exp
->X_op
= O_subtract
;
2279 exp
->X_add_symbol
= end_sym
;
2280 exp
->X_op_symbol
= start_sym
;
2282 switch (DWARF2_FORMAT (sec
))
2284 case dwarf2_format_32bit
:
2285 exp
->X_add_number
= -4;
2289 case dwarf2_format_64bit
:
2290 exp
->X_add_number
= -12;
2295 case dwarf2_format_64bit_irix
:
2296 exp
->X_add_number
= -8;
2301 as_fatal (_("internal error: unknown dwarf2 format"));
2305 /* Emit the collected .debug_line data. */
2308 out_debug_line (segT line_seg
)
2311 symbolS
*prologue_start
, *prologue_end
;
2316 memset (&exp
, 0, sizeof exp
);
2317 sizeof_offset
= out_header (line_seg
, &exp
);
2318 line_end
= exp
.X_add_symbol
;
2321 out_two (DWARF2_LINE_VERSION
);
2323 if (DWARF2_LINE_VERSION
>= 5)
2325 out_byte (sizeof_address
);
2326 out_byte (0); /* Segment Selector size. */
2328 /* Length of the prologue following this length. */
2329 prologue_start
= symbol_temp_make ();
2330 prologue_end
= symbol_temp_make ();
2331 exp
.X_op
= O_subtract
;
2332 exp
.X_add_symbol
= prologue_end
;
2333 exp
.X_op_symbol
= prologue_start
;
2334 exp
.X_add_number
= 0;
2335 emit_expr (&exp
, sizeof_offset
);
2336 symbol_set_value_now (prologue_start
);
2338 /* Parameters of the state machine. */
2339 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2340 if (DWARF2_LINE_VERSION
>= 4)
2341 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2342 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2343 out_byte (DWARF2_LINE_BASE
);
2344 out_byte (DWARF2_LINE_RANGE
);
2345 out_byte (DWARF2_LINE_OPCODE_BASE
);
2347 /* Standard opcode lengths. */
2348 out_byte (0); /* DW_LNS_copy */
2349 out_byte (1); /* DW_LNS_advance_pc */
2350 out_byte (1); /* DW_LNS_advance_line */
2351 out_byte (1); /* DW_LNS_set_file */
2352 out_byte (1); /* DW_LNS_set_column */
2353 out_byte (0); /* DW_LNS_negate_stmt */
2354 out_byte (0); /* DW_LNS_set_basic_block */
2355 out_byte (0); /* DW_LNS_const_add_pc */
2356 out_byte (1); /* DW_LNS_fixed_advance_pc */
2357 out_byte (0); /* DW_LNS_set_prologue_end */
2358 out_byte (0); /* DW_LNS_set_epilogue_begin */
2359 out_byte (1); /* DW_LNS_set_isa */
2360 /* We have emitted 12 opcode lengths, so make that this
2361 matches up to the opcode base value we have been using. */
2362 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2364 out_dir_and_file_list (line_seg
, sizeof_offset
);
2366 symbol_set_value_now (prologue_end
);
2368 /* For each section, emit a statement program. */
2369 for (s
= all_segs
; s
; s
= s
->next
)
2370 /* Paranoia - this check should have already have
2371 been handled in dwarf2_gen_line_info_1(). */
2372 if (SEG_NORMAL (s
->seg
))
2373 process_entries (s
->seg
, s
->head
->head
);
2375 if (flag_dwarf_sections
)
2376 /* We have to switch to the special .debug_line_end section
2377 before emitting the end-of-debug_line symbol. The linker
2378 script arranges for this section to be placed after all the
2379 (potentially garbage collected) .debug_line.<foo> sections.
2380 This section contains the line_end symbol which is used to
2381 compute the size of the linked .debug_line section, as seen
2382 in the DWARF Line Number header. */
2383 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2385 symbol_set_value_now (line_end
);
2389 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2391 unsigned int addr_size
= sizeof_address
;
2396 memset (&exp
, 0, sizeof exp
);
2397 subseg_set (ranges_seg
, 0);
2399 /* For DW_AT_ranges to point at (there is no header, so really start
2400 of section, but see out_debug_rnglists). */
2401 *ranges_sym
= symbol_temp_new_now_octets ();
2403 /* Base Address Entry. */
2404 for (i
= 0; i
< addr_size
; i
++)
2406 for (i
= 0; i
< addr_size
; i
++)
2409 /* Range List Entry. */
2410 for (s
= all_segs
; s
; s
= s
->next
)
2415 frag
= first_frag_for_seg (s
->seg
);
2416 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2417 s
->text_start
= beg
;
2419 frag
= last_frag_for_seg (s
->seg
);
2420 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2423 exp
.X_op
= O_symbol
;
2424 exp
.X_add_symbol
= beg
;
2425 exp
.X_add_number
= 0;
2426 emit_expr (&exp
, addr_size
);
2428 exp
.X_op
= O_symbol
;
2429 exp
.X_add_symbol
= end
;
2430 exp
.X_add_number
= 0;
2431 emit_expr (&exp
, addr_size
);
2434 /* End of Range Entry. */
2435 for (i
= 0; i
< addr_size
; i
++)
2437 for (i
= 0; i
< addr_size
; i
++)
2442 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2445 symbolS
*ranges_end
;
2449 memset (&exp
, 0, sizeof exp
);
2450 out_header (ranges_seg
, &exp
);
2451 ranges_end
= exp
.X_add_symbol
;
2453 out_two (DWARF2_RNGLISTS_VERSION
);
2454 out_byte (sizeof_address
);
2455 out_byte (0); /* Segment Selector size. */
2456 out_four (0); /* Offset entry count. */
2458 /* For DW_AT_ranges to point at (must be after the header). */
2459 *ranges_sym
= symbol_temp_new_now_octets ();
2461 for (s
= all_segs
; s
; s
= s
->next
)
2466 out_byte (DW_RLE_start_length
);
2468 frag
= first_frag_for_seg (s
->seg
);
2469 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2470 s
->text_start
= beg
;
2472 frag
= last_frag_for_seg (s
->seg
);
2473 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2476 exp
.X_op
= O_symbol
;
2477 exp
.X_add_symbol
= beg
;
2478 exp
.X_add_number
= 0;
2479 emit_expr (&exp
, sizeof_address
);
2481 exp
.X_op
= O_symbol
;
2482 exp
.X_add_symbol
= end
;
2483 exp
.X_add_number
= 0;
2484 emit_leb128_expr (&exp
, 0);
2487 out_byte (DW_RLE_end_of_list
);
2489 symbol_set_value_now (ranges_end
);
2492 /* Emit data for .debug_aranges. */
2495 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2497 unsigned int addr_size
= sizeof_address
;
2501 symbolS
*aranges_end
;
2505 memset (&exp
, 0, sizeof exp
);
2506 sizeof_offset
= out_header (aranges_seg
, &exp
);
2507 aranges_end
= exp
.X_add_symbol
;
2508 size
= -exp
.X_add_number
;
2511 out_two (DWARF2_ARANGES_VERSION
);
2514 /* Offset to .debug_info. */
2515 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2516 size
+= sizeof_offset
;
2518 /* Size of an address (offset portion). */
2519 out_byte (addr_size
);
2522 /* Size of a segment descriptor. */
2526 /* Align the header. */
2527 while ((size
++ % (2 * addr_size
)) > 0)
2530 for (s
= all_segs
; s
; s
= s
->next
)
2535 frag
= first_frag_for_seg (s
->seg
);
2536 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2537 s
->text_start
= beg
;
2539 frag
= last_frag_for_seg (s
->seg
);
2540 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2543 exp
.X_op
= O_symbol
;
2544 exp
.X_add_symbol
= beg
;
2545 exp
.X_add_number
= 0;
2546 emit_expr (&exp
, addr_size
);
2548 exp
.X_op
= O_subtract
;
2549 exp
.X_add_symbol
= end
;
2550 exp
.X_op_symbol
= beg
;
2551 exp
.X_add_number
= 0;
2552 emit_expr (&exp
, addr_size
);
2555 p
= frag_more (2 * addr_size
);
2556 md_number_to_chars (p
, 0, addr_size
);
2557 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2559 symbol_set_value_now (aranges_end
);
2562 /* Emit data for .debug_abbrev. Note that this must be kept in
2563 sync with out_debug_info below. */
2566 out_debug_abbrev (segT abbrev_seg
,
2567 segT info_seg ATTRIBUTE_UNUSED
,
2568 segT line_seg ATTRIBUTE_UNUSED
)
2571 subseg_set (abbrev_seg
, 0);
2574 out_uleb128 (DW_TAG_compile_unit
);
2575 out_byte (DW_CHILDREN_no
);
2576 if (DWARF2_VERSION
< 4)
2578 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2579 secoff_form
= DW_FORM_data4
;
2581 secoff_form
= DW_FORM_data8
;
2584 secoff_form
= DW_FORM_sec_offset
;
2585 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2586 if (all_segs
->next
== NULL
)
2588 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2589 if (DWARF2_VERSION
< 4)
2590 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2592 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2595 out_abbrev (DW_AT_ranges
, secoff_form
);
2596 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2597 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2598 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2599 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2602 /* Terminate the abbreviations for this compilation unit. */
2606 /* Emit a description of this compilation unit for .debug_info. */
2609 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2610 symbolS
*ranges_sym
, symbolS
*name_sym
,
2611 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2617 memset (&exp
, 0, sizeof exp
);
2618 sizeof_offset
= out_header (info_seg
, &exp
);
2619 info_end
= exp
.X_add_symbol
;
2621 /* DWARF version. */
2622 out_two (DWARF2_VERSION
);
2624 if (DWARF2_VERSION
< 5)
2626 /* .debug_abbrev offset */
2627 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2631 /* unit (header) type */
2632 out_byte (DW_UT_compile
);
2635 /* Target address size. */
2636 out_byte (sizeof_address
);
2638 if (DWARF2_VERSION
>= 5)
2640 /* .debug_abbrev offset */
2641 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2644 /* DW_TAG_compile_unit DIE abbrev */
2647 /* DW_AT_stmt_list */
2648 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2649 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2652 /* These two attributes are emitted if all of the code is contiguous. */
2653 if (all_segs
->next
== NULL
)
2656 exp
.X_op
= O_symbol
;
2657 exp
.X_add_symbol
= all_segs
->text_start
;
2658 exp
.X_add_number
= 0;
2659 emit_expr (&exp
, sizeof_address
);
2662 if (DWARF2_VERSION
< 4)
2663 exp
.X_op
= O_symbol
;
2666 exp
.X_op
= O_subtract
;
2667 exp
.X_op_symbol
= all_segs
->text_start
;
2669 exp
.X_add_symbol
= all_segs
->text_end
;
2670 exp
.X_add_number
= 0;
2671 if (DWARF2_VERSION
< 4)
2672 emit_expr (&exp
, sizeof_address
);
2674 emit_leb128_expr (&exp
, 0);
2678 /* This attribute is emitted if the code is disjoint. */
2680 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2683 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2684 setup in out_debug_str below. */
2685 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2686 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2687 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2689 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2690 dwarf2 draft has no standard code for assembler. */
2691 out_two (DW_LANG_Mips_Assembler
);
2693 symbol_set_value_now (info_end
);
2696 /* Emit the three debug strings needed in .debug_str and setup symbols
2697 to them for use in out_debug_info. */
2699 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2700 symbolS
**producer_sym
)
2703 const char *comp_dir
;
2704 const char *dirname
;
2707 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2709 subseg_set (str_seg
, 0);
2711 /* DW_AT_name. We don't have the actual file name that was present
2712 on the command line, so assume files[first_file] is the main input file.
2713 We're not supposed to get called unless at least one line number
2714 entry was emitted, so this should always be defined. */
2715 *name_sym
= symbol_temp_new_now_octets ();
2716 if (files_in_use
== 0)
2718 if (files
[first_file
].dir
)
2720 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2721 len
= strlen (dirname
);
2723 /* Already has trailing slash. */
2724 p
= frag_more (len
);
2725 memcpy (p
, dirname
, len
);
2727 p
= frag_more (len
+ 1);
2728 memcpy (p
, dirname
, len
);
2729 INSERT_DIR_SEPARATOR (p
, len
);
2732 len
= strlen (files
[first_file
].filename
) + 1;
2733 p
= frag_more (len
);
2734 memcpy (p
, files
[first_file
].filename
, len
);
2736 /* DW_AT_comp_dir */
2737 *comp_dir_sym
= symbol_temp_new_now_octets ();
2738 comp_dir
= remap_debug_filename (getpwd ());
2739 len
= strlen (comp_dir
) + 1;
2740 p
= frag_more (len
);
2741 memcpy (p
, comp_dir
, len
);
2743 /* DW_AT_producer */
2744 *producer_sym
= symbol_temp_new_now_octets ();
2745 sprintf (producer
, "GNU AS %s", VERSION
);
2746 len
= strlen (producer
) + 1;
2747 p
= frag_more (len
);
2748 memcpy (p
, producer
, len
);
2754 last_seg_ptr
= &all_segs
;
2756 /* Select the default CIE version to produce here. The global
2757 starts with a value of -1 and will be modified to a valid value
2758 either by the user providing a command line option, or some
2759 targets will select their own default in md_after_parse_args. If
2760 we get here and the global still contains -1 then it is up to us
2761 to pick a sane default. The default we choose is 1, this is the
2762 CIE version gas has produced for a long time, and there seems no
2763 reason to change it yet. */
2764 if (flag_dwarf_cie_version
== -1)
2765 flag_dwarf_cie_version
= 1;
2768 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2769 were any .file/.loc directives, or --gdwarf2 was given, and if the
2770 file has a non-empty .debug_info section and an empty .debug_line
2771 section. If we emit .debug_line, and the .debug_info section is
2772 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2773 ALL_SEGS will be non-null if there were any .file/.loc directives,
2774 or --gdwarf2 was given and there were any located instructions
2778 dwarf2_finish (void)
2783 int emit_other_sections
= 0;
2784 int empty_debug_line
= 0;
2786 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2787 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2789 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2790 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2792 /* We can't construct a new debug_line section if we already have one.
2793 Give an error if we have seen any .loc, otherwise trust the user
2794 knows what they are doing and want to generate the .debug_line
2795 (and all other debug sections) themselves. */
2796 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2797 as_fatal ("duplicate .debug_line sections");
2799 if ((!all_segs
&& emit_other_sections
)
2800 || (!emit_other_sections
&& !empty_debug_line
))
2801 /* If there is no line information and no non-empty .debug_info
2802 section, or if there is both a non-empty .debug_info and a non-empty
2803 .debug_line, then we do nothing. */
2806 /* Calculate the size of an address for the target machine. */
2807 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2809 /* Create and switch to the line number section. */
2810 if (empty_debug_line
)
2812 line_seg
= subseg_new (".debug_line", 0);
2813 bfd_set_section_flags (line_seg
,
2814 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2817 /* For each subsection, chain the debug entries together. */
2818 for (s
= all_segs
; s
; s
= s
->next
)
2820 struct line_subseg
*lss
= s
->head
;
2821 struct line_entry
**ptail
= lss
->ptail
;
2823 /* Reset the initial view of the first subsection of the
2825 if (lss
->head
&& lss
->head
->loc
.view
)
2826 set_or_check_view (lss
->head
, NULL
, NULL
);
2828 while ((lss
= lss
->next
) != NULL
)
2830 /* Link the first view of subsequent subsections to the
2832 if (lss
->head
&& lss
->head
->loc
.view
)
2833 set_or_check_view (lss
->head
,
2834 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2835 s
->head
? s
->head
->head
: NULL
);
2841 if (empty_debug_line
)
2842 out_debug_line (line_seg
);
2844 /* If this is assembler generated line info, and there is no
2845 debug_info already, we need .debug_info, .debug_abbrev and
2846 .debug_str sections as well. */
2847 if (emit_other_sections
)
2852 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2854 gas_assert (all_segs
);
2856 info_seg
= subseg_new (".debug_info", 0);
2857 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2858 aranges_seg
= subseg_new (".debug_aranges", 0);
2859 str_seg
= subseg_new (".debug_str", 0);
2861 bfd_set_section_flags (info_seg
,
2862 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2863 bfd_set_section_flags (abbrev_seg
,
2864 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2865 bfd_set_section_flags (aranges_seg
,
2866 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2867 bfd_set_section_flags (str_seg
,
2868 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2869 | SEC_MERGE
| SEC_STRINGS
);
2870 str_seg
->entsize
= 1;
2872 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2874 if (all_segs
->next
== NULL
)
2878 if (DWARF2_VERSION
< 5)
2880 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2881 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2884 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2885 out_debug_ranges (ranges_seg
, &ranges_sym
);
2889 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2890 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2893 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2897 out_debug_aranges (aranges_seg
, info_seg
);
2898 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2899 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2900 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2901 name_sym
, comp_dir_sym
, producer_sym
);
2905 /* Perform any deferred checks pertaining to debug information. */
2908 dwarf2dbg_final_check (void)
2910 /* Perform reset-view checks. Don't evaluate view_assert_failed
2911 recursively: it could be very deep. It's a chain of adds, with
2912 each chain element pointing to the next in X_add_symbol, and
2913 holding the check value in X_op_symbol. */
2914 while (view_assert_failed
)
2920 gas_assert (!symbol_resolved_p (view_assert_failed
));
2922 exp
= symbol_get_value_expression (view_assert_failed
);
2923 sym
= view_assert_failed
;
2925 /* If view_assert_failed looks like a compound check in the
2926 chain, break it up. */
2927 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2929 view_assert_failed
= exp
->X_add_symbol
;
2930 sym
= exp
->X_op_symbol
;
2933 view_assert_failed
= NULL
;
2935 failed
= resolve_symbol_value (sym
);
2936 if (!symbol_resolved_p (sym
) || failed
)
2938 as_bad (_("view number mismatch"));