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 if (debug_type
!= DEBUG_DWARF2
)
518 as_warn ("dwarf line number information for %s ignored",
519 segment_name (now_seg
));
523 e
= XNEW (struct line_entry
);
528 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
530 /* Subseg heads are chained to previous subsegs in
532 if (loc
->view
&& lss
->head
)
533 set_or_check_view (e
,
534 (struct line_entry
*)lss
->ptail
,
538 lss
->ptail
= &e
->next
;
541 /* Record an entry for LOC occurring at OFS within the current fragment. */
544 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
546 static unsigned int line
= -1;
547 static unsigned int filenum
= -1;
551 /* Early out for as-yet incomplete location information. */
554 if (loc
->filenum
== 0)
558 if (DWARF2_LINE_VERSION
< 5)
562 /* Don't emit sequences of line symbols for the same line when the
563 symbols apply to assembler code. It is necessary to emit
564 duplicate line symbols when a compiler asks for them, because GDB
565 uses them to determine the end of the prologue. */
566 if (debug_type
== DEBUG_DWARF2
567 && line
== loc
->line
&& filenum
== loc
->filenum
)
571 filenum
= loc
->filenum
;
577 /* Use a non-fake name for the line number location,
578 so that it can be referred to by relocations. */
579 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
580 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
583 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
584 dwarf2_gen_line_info_1 (sym
, loc
);
588 get_basename (const char * pathname
)
592 file
= lbasename (pathname
);
593 /* Don't make empty string from / or A: from A:/ . */
594 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
595 if (file
<= pathname
+ 3)
598 if (file
== pathname
+ 1)
605 get_directory_table_entry (const char * dirname
,
607 bfd_boolean can_use_zero
)
614 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
615 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
623 for (d
= 0; d
< dirs_in_use
; ++d
)
626 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
627 && dirs
[d
][dirlen
] == '\0')
633 if (dirs
== NULL
|| dirs
[0] == NULL
)
639 if (d
>= dirs_allocated
)
641 unsigned int old
= dirs_allocated
;
643 dirs_allocated
= d
+ 32;
644 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
645 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
648 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
649 if (dirs_in_use
<= d
)
656 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
)
658 if (i
>= files_allocated
)
660 unsigned int old
= files_allocated
;
662 files_allocated
= i
+ 32;
663 /* Catch wraparound. */
664 if (files_allocated
<= old
)
666 as_bad (_("file number %lu is too big"), (unsigned long) i
);
670 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
671 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
674 files
[i
].filename
= file
;
676 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
678 if (files_in_use
< i
+ 1)
679 files_in_use
= i
+ 1;
684 /* Get a .debug_line file number for PATHNAME. If there is a
685 directory component to PATHNAME, then this will be stored
686 in the directory table, if it is not already present.
687 Returns the slot number allocated to that filename or -1
688 if there was a problem. */
691 allocate_filenum (const char * pathname
)
693 static signed int last_used
= -1, last_used_dir_len
= 0;
698 /* Short circuit the common case of adding the same pathname
702 const char * dirname
= NULL
;
705 dirname
= dirs
[files
[last_used
].dir
];
709 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
714 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
715 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
716 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
717 files
[last_used
].filename
) == 0)
722 file
= get_basename (pathname
);
723 dir_len
= file
- pathname
;
725 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
727 /* Do not use slot-0. That is specifically reserved for use by
728 the '.file 0 "name"' directive. */
729 for (i
= 1; i
< files_in_use
; ++i
)
730 if (files
[i
].dir
== dir
732 && filename_cmp (file
, files
[i
].filename
) == 0)
735 last_used_dir_len
= dir_len
;
739 if (!assign_file_to_slot (i
, file
, dir
))
742 num_of_auto_assigned
++;
745 last_used_dir_len
= dir_len
;
750 /* Allocate slot NUM in the .debug_line file table to FILENAME.
751 If DIRNAME is not NULL or there is a directory component to FILENAME
752 then this will be stored in the directory table, if not already present.
753 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
754 Returns TRUE if allocation succeeded, FALSE otherwise. */
757 allocate_filename_to_slot (const char * dirname
,
758 const char * filename
,
760 bfd_boolean with_md5
)
766 /* Short circuit the common case of adding the same pathname
768 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
770 const char * dir
= NULL
;
773 dir
= dirs
[files
[num
].dir
];
776 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
781 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
784 if (filename_cmp (filename
, files
[num
].filename
) != 0)
787 /* If the filenames match, but the directory table entry was
788 empty, then fill it with the provided directory name. */
793 dirs_allocated
= files
[num
].dir
+ 32;
794 dirs
= XCNEWVEC (char *, dirs_allocated
);
797 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
802 else if (dir
!= NULL
)
804 dirlen
= strlen (dir
);
805 if (filename_ncmp (filename
, dir
, dirlen
) == 0
806 && IS_DIR_SEPARATOR (filename
[dirlen
])
807 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
810 else /* dir == NULL */
812 file
= get_basename (filename
);
813 if (filename_cmp (file
, files
[num
].filename
) == 0)
816 /* The filenames match, but the directory table entry is empty.
817 Fill it with the provided directory name. */
818 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
824 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
826 dir
== NULL
? "" : dir
,
827 dir
== NULL
? "" : "/",
829 dirname
== NULL
? "" : dirname
,
830 dirname
== NULL
? "" : "/",
838 file
= get_basename (filename
);
839 dirlen
= file
- filename
;
843 dirlen
= strlen (dirname
);
847 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
850 if (! assign_file_to_slot (i
, file
, d
))
855 if (target_big_endian
)
857 /* md5's are stored in litte endian format. */
858 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
859 unsigned int byte
= NUM_MD5_BYTES
;
860 unsigned int bignum_index
= 0;
862 while (bits_remaining
)
864 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
865 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 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
880 unsigned int byte
= 0;
881 unsigned int bignum_index
= 0;
883 while (bits_remaining
)
885 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
886 valueT bignum_value
= generic_bignum
[bignum_index
];
890 while (bignum_bits_remaining
)
892 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
894 bignum_bits_remaining
-= 8;
901 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
906 /* Returns the current source information. If .file directives have
907 been encountered, the info for the corresponding source file is
908 returned. Otherwise, the info for the assembly source file is
912 dwarf2_where (struct dwarf2_line_info
*line
)
914 if (debug_type
== DEBUG_DWARF2
)
916 const char *filename
;
918 memset (line
, 0, sizeof (*line
));
919 filename
= as_where (&line
->line
);
920 line
->filenum
= allocate_filenum (filename
);
921 /* FIXME: We should check the return value from allocate_filenum. */
923 line
->flags
= DWARF2_FLAG_IS_STMT
;
924 line
->isa
= current
.isa
;
925 line
->discriminator
= current
.discriminator
;
932 /* A hook to allow the target backend to inform the line number state
933 machine of isa changes when assembler debug info is enabled. */
936 dwarf2_set_isa (unsigned int isa
)
941 /* Called for each machine instruction, or relatively atomic group of
942 machine instructions (ie built-in macro). The instruction or group
943 is SIZE bytes in length. If dwarf2 line number generation is called
944 for, emit a line statement appropriately. */
947 dwarf2_emit_insn (int size
)
949 struct dwarf2_line_info loc
;
951 if (debug_type
!= DEBUG_DWARF2
952 ? !dwarf2_loc_directive_seen
953 : !seen_at_least_1_file ())
958 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
959 dwarf2_consume_line_info ();
962 /* Move all previously-emitted line entries for the current position by
963 DELTA bytes. This function cannot be used to move the same entries
967 dwarf2_move_insn (int delta
)
969 struct line_subseg
*lss
;
970 struct line_entry
*e
;
976 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
980 now
= frag_now_fix ();
981 while ((e
= *lss
->pmove_tail
))
983 if (S_GET_VALUE (e
->label
) == now
)
984 S_SET_VALUE (e
->label
, now
+ delta
);
985 lss
->pmove_tail
= &e
->next
;
989 /* Called after the current line information has been either used with
990 dwarf2_gen_line_info or saved with a machine instruction for later use.
991 This resets the state of the line number information to reflect that
995 dwarf2_consume_line_info (void)
997 /* Unless we generate DWARF2 debugging information for each
998 assembler line, we only emit one line symbol for one LOC. */
999 dwarf2_loc_directive_seen
= FALSE
;
1001 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
1002 | DWARF2_FLAG_PROLOGUE_END
1003 | DWARF2_FLAG_EPILOGUE_BEGIN
);
1004 current
.discriminator
= 0;
1005 current
.view
= NULL
;
1008 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
1009 is enabled, emit a basic block marker. */
1012 dwarf2_emit_label (symbolS
*label
)
1014 struct dwarf2_line_info loc
;
1016 if (!dwarf2_loc_mark_labels
)
1018 if (S_GET_SEGMENT (label
) != now_seg
)
1020 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1022 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1025 dwarf2_where (&loc
);
1027 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1029 dwarf2_gen_line_info_1 (label
, &loc
);
1030 dwarf2_consume_line_info ();
1033 /* Handle two forms of .file directive:
1034 - Pass .file "source.c" to s_app_file
1035 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1037 If an entry is added to the file table, return a pointer to the filename. */
1040 dwarf2_directive_filename (void)
1042 bfd_boolean with_md5
= FALSE
;
1045 const char * dirname
= NULL
;
1049 /* Continue to accept a bare string and pass it off. */
1051 if (*input_line_pointer
== '"')
1057 num
= get_absolute_expression ();
1059 if ((offsetT
) num
< 1)
1061 if (num
== 0 && dwarf_level
< 5)
1063 if ((offsetT
) num
< 0 || DWARF2_LINE_VERSION
< 5)
1065 as_bad (_("file number less than one"));
1066 ignore_rest_of_line ();
1071 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1072 "switch back to the already allocated file <N> as the current
1075 filename
= demand_copy_C_string (&filename_len
);
1076 if (filename
== NULL
)
1077 /* demand_copy_C_string will have already generated an error message. */
1080 /* For DWARF-5 support we also accept:
1081 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1082 if (DWARF2_LINE_VERSION
> 4)
1085 if (*input_line_pointer
== '"')
1088 filename
= demand_copy_C_string (&filename_len
);
1092 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1094 input_line_pointer
+= 3;
1098 expression_and_evaluate (& exp
);
1099 if (exp
.X_op
!= O_big
)
1100 as_bad (_("md5 value too small or not a constant"));
1106 demand_empty_rest_of_line ();
1108 /* A .file directive implies compiler generated debug information is
1109 being supplied. Turn off gas generated debug info. */
1110 debug_type
= DEBUG_NONE
;
1112 if (num
!= (unsigned int) num
1113 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1115 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1119 if (num_of_auto_assigned
)
1121 /* Clear slots auto-assigned before the first .file <NUMBER>
1122 directive was seen. */
1123 if (files_in_use
!= (num_of_auto_assigned
+ 1))
1125 for (i
= 1; i
< files_in_use
; i
++)
1126 files
[i
].filename
= NULL
;
1128 num_of_auto_assigned
= 0;
1131 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1138 /* Calls dwarf2_directive_filename, but discards its result.
1139 Used in pseudo-op tables where the function result is ignored. */
1142 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1144 (void) dwarf2_directive_filename ();
1148 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1150 offsetT filenum
, line
;
1152 /* If we see two .loc directives in a row, force the first one to be
1154 if (dwarf2_loc_directive_seen
)
1155 dwarf2_emit_insn (0);
1157 filenum
= get_absolute_expression ();
1159 line
= get_absolute_expression ();
1163 if (filenum
== 0 && dwarf_level
< 5)
1165 if (filenum
< 0 || DWARF2_LINE_VERSION
< 5)
1167 as_bad (_("file number less than one"));
1172 if ((valueT
) filenum
>= files_in_use
|| files
[filenum
].filename
== NULL
)
1174 as_bad (_("unassigned file number %ld"), (long) filenum
);
1178 current
.filenum
= filenum
;
1179 current
.line
= line
;
1180 current
.discriminator
= 0;
1185 if (files
[filenum
].dir
)
1187 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1188 size_t file_len
= strlen (files
[filenum
].filename
);
1189 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1191 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1192 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1193 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1194 cp
[dir_len
+ file_len
+ 1] = '\0';
1195 listing_source_file (cp
);
1199 listing_source_file (files
[filenum
].filename
);
1200 listing_source_line (line
);
1205 if (ISDIGIT (*input_line_pointer
))
1207 current
.column
= get_absolute_expression ();
1211 while (ISALPHA (*input_line_pointer
))
1216 c
= get_symbol_name (& p
);
1218 if (strcmp (p
, "basic_block") == 0)
1220 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1221 *input_line_pointer
= c
;
1223 else if (strcmp (p
, "prologue_end") == 0)
1225 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1226 *input_line_pointer
= c
;
1228 else if (strcmp (p
, "epilogue_begin") == 0)
1230 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1231 *input_line_pointer
= c
;
1233 else if (strcmp (p
, "is_stmt") == 0)
1235 (void) restore_line_pointer (c
);
1236 value
= get_absolute_expression ();
1238 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1239 else if (value
== 1)
1240 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1243 as_bad (_("is_stmt value not 0 or 1"));
1247 else if (strcmp (p
, "isa") == 0)
1249 (void) restore_line_pointer (c
);
1250 value
= get_absolute_expression ();
1252 current
.isa
= value
;
1255 as_bad (_("isa number less than zero"));
1259 else if (strcmp (p
, "discriminator") == 0)
1261 (void) restore_line_pointer (c
);
1262 value
= get_absolute_expression ();
1264 current
.discriminator
= value
;
1267 as_bad (_("discriminator less than zero"));
1271 else if (strcmp (p
, "view") == 0)
1275 (void) restore_line_pointer (c
);
1278 if (ISDIGIT (*input_line_pointer
)
1279 || *input_line_pointer
== '-')
1281 bfd_boolean force_reset
= *input_line_pointer
== '-';
1283 value
= get_absolute_expression ();
1286 as_bad (_("numeric view can only be asserted to zero"));
1289 if (force_reset
&& force_reset_view
)
1290 sym
= force_reset_view
;
1293 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1296 force_reset_view
= sym
;
1301 char *name
= read_symbol_name ();
1305 sym
= symbol_find_or_make (name
);
1306 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1308 if (S_IS_VOLATILE (sym
))
1309 sym
= symbol_clone (sym
, 1);
1310 else if (!S_CAN_BE_REDEFINED (sym
))
1312 as_bad (_("symbol `%s' is already defined"), name
);
1316 S_SET_SEGMENT (sym
, undefined_section
);
1317 S_SET_VALUE (sym
, 0);
1318 symbol_set_frag (sym
, &zero_address_frag
);
1324 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1325 (void) restore_line_pointer (c
);
1329 SKIP_WHITESPACE_AFTER_NAME ();
1332 demand_empty_rest_of_line ();
1333 dwarf2_any_loc_directive_seen
= dwarf2_loc_directive_seen
= TRUE
;
1334 debug_type
= DEBUG_NONE
;
1336 /* If we were given a view id, emit the row right away. */
1338 dwarf2_emit_insn (0);
1342 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1344 offsetT value
= get_absolute_expression ();
1346 if (value
!= 0 && value
!= 1)
1348 as_bad (_("expected 0 or 1"));
1349 ignore_rest_of_line ();
1353 dwarf2_loc_mark_labels
= value
!= 0;
1354 demand_empty_rest_of_line ();
1358 static struct frag
*
1359 first_frag_for_seg (segT seg
)
1361 return seg_info (seg
)->frchainP
->frch_root
;
1364 static struct frag
*
1365 last_frag_for_seg (segT seg
)
1367 frchainS
*f
= seg_info (seg
)->frchainP
;
1369 while (f
->frch_next
!= NULL
)
1372 return f
->frch_last
;
1375 /* Emit a single byte into the current segment. */
1380 FRAG_APPEND_1_CHAR (byte
);
1383 /* Emit a statement program opcode into the current segment. */
1386 out_opcode (int opc
)
1391 /* Emit a two-byte word into the current segment. */
1396 md_number_to_chars (frag_more (2), data
, 2);
1399 /* Emit a four byte word into the current segment. */
1404 md_number_to_chars (frag_more (4), data
, 4);
1407 /* Emit an unsigned "little-endian base 128" number. */
1410 out_uleb128 (addressT value
)
1412 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1415 /* Emit a signed "little-endian base 128" number. */
1418 out_leb128 (addressT value
)
1420 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1423 /* Emit a tuple for .debug_abbrev. */
1426 out_abbrev (int name
, int form
)
1432 /* Get the size of a fragment. */
1435 get_frag_fix (fragS
*frag
, segT seg
)
1440 return frag
->fr_fix
;
1442 /* If a fragment is the last in the chain, special measures must be
1443 taken to find its size before relaxation, since it may be pending
1444 on some subsegment chain. */
1445 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1446 if (fr
->frch_last
== frag
)
1447 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1452 /* Set an absolute address (may result in a relocation entry). */
1455 out_set_addr (symbolS
*sym
)
1459 memset (&exp
, 0, sizeof exp
);
1460 out_opcode (DW_LNS_extended_op
);
1461 out_uleb128 (sizeof_address
+ 1);
1463 out_opcode (DW_LNE_set_address
);
1464 exp
.X_op
= O_symbol
;
1465 exp
.X_add_symbol
= sym
;
1466 exp
.X_add_number
= 0;
1467 emit_expr (&exp
, sizeof_address
);
1470 static void scale_addr_delta (addressT
*);
1473 scale_addr_delta (addressT
*addr_delta
)
1475 static int printed_this
= 0;
1476 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1478 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1480 as_bad("unaligned opcodes detected in executable segment");
1483 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1487 /* Encode a pair of line and address skips as efficiently as possible.
1488 Note that the line skip is signed, whereas the address skip is unsigned.
1490 The following two routines *must* be kept in sync. This is
1491 enforced by making emit_inc_line_addr abort if we do not emit
1492 exactly the expected number of bytes. */
1495 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1497 unsigned int tmp
, opcode
;
1500 /* Scale the address delta by the minimum instruction length. */
1501 scale_addr_delta (&addr_delta
);
1503 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1504 We cannot use special opcodes here, since we want the end_sequence
1505 to emit the matrix entry. */
1506 if (line_delta
== INT_MAX
)
1508 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1510 else if (addr_delta
)
1511 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1515 /* Bias the line delta by the base. */
1516 tmp
= line_delta
- DWARF2_LINE_BASE
;
1518 /* If the line increment is out of range of a special opcode, we
1519 must encode it with DW_LNS_advance_line. */
1520 if (tmp
>= DWARF2_LINE_RANGE
)
1522 len
= 1 + sizeof_leb128 (line_delta
, 1);
1524 tmp
= 0 - DWARF2_LINE_BASE
;
1527 /* Bias the opcode by the special opcode base. */
1528 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1530 /* Avoid overflow when addr_delta is large. */
1531 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1533 /* Try using a special opcode. */
1534 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1538 /* Try using DW_LNS_const_add_pc followed by special op. */
1539 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1544 /* Otherwise use DW_LNS_advance_pc. */
1545 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1547 /* DW_LNS_copy or special opcode. */
1554 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1556 unsigned int tmp
, opcode
;
1558 char *end
= p
+ len
;
1560 /* Line number sequences cannot go backward in addresses. This means
1561 we've incorrectly ordered the statements in the sequence. */
1562 gas_assert ((offsetT
) addr_delta
>= 0);
1564 /* Scale the address delta by the minimum instruction length. */
1565 scale_addr_delta (&addr_delta
);
1567 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1568 We cannot use special opcodes here, since we want the end_sequence
1569 to emit the matrix entry. */
1570 if (line_delta
== INT_MAX
)
1572 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1573 *p
++ = DW_LNS_const_add_pc
;
1574 else if (addr_delta
)
1576 *p
++ = DW_LNS_advance_pc
;
1577 p
+= output_leb128 (p
, addr_delta
, 0);
1580 *p
++ = DW_LNS_extended_op
;
1582 *p
++ = DW_LNE_end_sequence
;
1586 /* Bias the line delta by the base. */
1587 tmp
= line_delta
- DWARF2_LINE_BASE
;
1589 /* If the line increment is out of range of a special opcode, we
1590 must encode it with DW_LNS_advance_line. */
1591 if (tmp
>= DWARF2_LINE_RANGE
)
1593 *p
++ = DW_LNS_advance_line
;
1594 p
+= output_leb128 (p
, line_delta
, 1);
1597 tmp
= 0 - DWARF2_LINE_BASE
;
1601 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1603 if (line_delta
== 0 && addr_delta
== 0)
1609 /* Bias the opcode by the special opcode base. */
1610 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1612 /* Avoid overflow when addr_delta is large. */
1613 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1615 /* Try using a special opcode. */
1616 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1623 /* Try using DW_LNS_const_add_pc followed by special op. */
1624 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1627 *p
++ = DW_LNS_const_add_pc
;
1633 /* Otherwise use DW_LNS_advance_pc. */
1634 *p
++ = DW_LNS_advance_pc
;
1635 p
+= output_leb128 (p
, addr_delta
, 0);
1643 gas_assert (p
== end
);
1646 /* Handy routine to combine calls to the above two routines. */
1649 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1651 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1652 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1655 /* Write out an alternative form of line and address skips using
1656 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1657 line and address information, but it is required if linker relaxation
1658 could change the code offsets. The following two routines *must* be
1660 #define ADDR_DELTA_LIMIT 50000
1663 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1667 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1668 if (line_delta
!= INT_MAX
)
1669 len
= 1 + sizeof_leb128 (line_delta
, 1);
1671 if (addr_delta
> ADDR_DELTA_LIMIT
)
1673 /* DW_LNS_extended_op */
1674 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1675 /* DW_LNE_set_address */
1676 len
+= 1 + sizeof_address
;
1679 /* DW_LNS_fixed_advance_pc */
1682 if (line_delta
== INT_MAX
)
1683 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1693 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1697 char *end
= p
+ len
;
1699 /* Line number sequences cannot go backward in addresses. This means
1700 we've incorrectly ordered the statements in the sequence. */
1701 gas_assert ((offsetT
) addr_delta
>= 0);
1703 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1704 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1706 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1707 if (line_delta
!= INT_MAX
)
1709 *p
++ = DW_LNS_advance_line
;
1710 p
+= output_leb128 (p
, line_delta
, 1);
1713 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1715 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1716 advance the address by at most 64K. Linker relaxation (without
1717 which this function would not be used) could change the operand by
1718 an unknown amount. If the address increment is getting close to
1719 the limit, just reset the address. */
1720 if (addr_delta
> ADDR_DELTA_LIMIT
)
1725 memset (&exp
, 0, sizeof exp
);
1726 gas_assert (pexp
->X_op
== O_subtract
);
1727 to_sym
= pexp
->X_add_symbol
;
1729 *p
++ = DW_LNS_extended_op
;
1730 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1731 *p
++ = DW_LNE_set_address
;
1732 exp
.X_op
= O_symbol
;
1733 exp
.X_add_symbol
= to_sym
;
1734 exp
.X_add_number
= 0;
1735 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1736 p
+= sizeof_address
;
1740 *p
++ = DW_LNS_fixed_advance_pc
;
1741 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1745 if (line_delta
== INT_MAX
)
1747 *p
++ = DW_LNS_extended_op
;
1749 *p
++ = DW_LNE_end_sequence
;
1754 gas_assert (p
== end
);
1757 /* Generate a variant frag that we can use to relax address/line
1758 increments between fragments of the target segment. */
1761 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1766 memset (&exp
, 0, sizeof exp
);
1767 exp
.X_op
= O_subtract
;
1768 exp
.X_add_symbol
= to_sym
;
1769 exp
.X_op_symbol
= from_sym
;
1770 exp
.X_add_number
= 0;
1772 /* The maximum size of the frag is the line delta with a maximum
1773 sized address delta. */
1774 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1775 max_chars
= size_fixed_inc_line_addr (line_delta
,
1776 -DWARF2_LINE_MIN_INSN_LENGTH
);
1778 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1780 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1781 make_expr_symbol (&exp
), line_delta
, NULL
);
1784 /* The function estimates the size of a rs_dwarf2dbg variant frag
1785 based on the current values of the symbols. It is called before
1786 the relaxation loop. We set fr_subtype to the expected length. */
1789 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1794 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1795 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1796 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1798 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1800 frag
->fr_subtype
= size
;
1805 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1806 current values of the symbols. fr_subtype is the current length
1807 of the frag. This returns the change in frag length. */
1810 dwarf2dbg_relax_frag (fragS
*frag
)
1812 int old_size
, new_size
;
1814 old_size
= frag
->fr_subtype
;
1815 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1817 return new_size
- old_size
;
1820 /* This function converts a rs_dwarf2dbg variant frag into a normal
1821 fill frag. This is called after all relaxation has been done.
1822 fr_subtype will be the desired length of the frag. */
1825 dwarf2dbg_convert_frag (fragS
*frag
)
1829 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1831 /* If linker relaxation is enabled then the distance between the two
1832 symbols in the frag->fr_symbol expression might change. Hence we
1833 cannot rely upon the value computed by resolve_symbol_value.
1834 Instead we leave the expression unfinalized and allow
1835 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1836 relocation) that will allow the linker to correctly compute the
1837 actual address difference. We have to use a fixed line advance for
1838 this as we cannot (easily) relocate leb128 encoded values. */
1839 int saved_finalize_syms
= finalize_syms
;
1842 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1843 finalize_syms
= saved_finalize_syms
;
1846 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1848 /* fr_var carries the max_chars that we created the fragment with.
1849 fr_subtype carries the current expected length. We must, of
1850 course, have allocated enough memory earlier. */
1851 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1853 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1854 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1855 frag
->fr_literal
+ frag
->fr_fix
,
1858 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1859 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1861 frag
->fr_fix
+= frag
->fr_subtype
;
1862 frag
->fr_type
= rs_fill
;
1864 frag
->fr_offset
= 0;
1867 /* Generate .debug_line content for the chain of line number entries
1868 beginning at E, for segment SEG. */
1871 process_entries (segT seg
, struct line_entry
*e
)
1873 unsigned filenum
= 1;
1875 unsigned column
= 0;
1877 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1878 fragS
*last_frag
= NULL
, *frag
;
1879 addressT last_frag_ofs
= 0, frag_ofs
;
1880 symbolS
*last_lab
= NULL
, *lab
;
1881 struct line_entry
*next
;
1883 if (flag_dwarf_sections
)
1886 const char * sec_name
;
1888 /* Switch to the relevant sub-section before we start to emit
1889 the line number table.
1891 FIXME: These sub-sections do not have a normal Line Number
1892 Program Header, thus strictly speaking they are not valid
1893 DWARF sections. Unfortunately the DWARF standard assumes
1894 a one-to-one relationship between compilation units and
1895 line number tables. Thus we have to have a .debug_line
1896 section, as well as our sub-sections, and we have to ensure
1897 that all of the sub-sections are merged into a proper
1898 .debug_line section before a debugger sees them. */
1900 sec_name
= bfd_section_name (seg
);
1901 if (strcmp (sec_name
, ".text") != 0)
1903 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1904 subseg_set (subseg_get (name
, FALSE
), 0);
1907 /* Don't create a .debug_line.text section -
1908 that is redundant. Instead just switch back to the
1909 normal .debug_line section. */
1910 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1917 if (filenum
!= e
->loc
.filenum
)
1919 filenum
= e
->loc
.filenum
;
1920 out_opcode (DW_LNS_set_file
);
1921 out_uleb128 (filenum
);
1924 if (column
!= e
->loc
.column
)
1926 column
= e
->loc
.column
;
1927 out_opcode (DW_LNS_set_column
);
1928 out_uleb128 (column
);
1931 if (e
->loc
.discriminator
!= 0)
1933 out_opcode (DW_LNS_extended_op
);
1934 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1935 out_opcode (DW_LNE_set_discriminator
);
1936 out_uleb128 (e
->loc
.discriminator
);
1939 if (isa
!= e
->loc
.isa
)
1942 out_opcode (DW_LNS_set_isa
);
1946 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1948 flags
= e
->loc
.flags
;
1949 out_opcode (DW_LNS_negate_stmt
);
1952 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1953 out_opcode (DW_LNS_set_basic_block
);
1955 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1956 out_opcode (DW_LNS_set_prologue_end
);
1958 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1959 out_opcode (DW_LNS_set_epilogue_begin
);
1961 /* Don't try to optimize away redundant entries; gdb wants two
1962 entries for a function where the code starts on the same line as
1963 the {, and there's no way to identify that case here. Trust gcc
1964 to optimize appropriately. */
1965 line_delta
= e
->loc
.line
- line
;
1967 frag
= symbol_get_frag (lab
);
1968 frag_ofs
= S_GET_VALUE (lab
);
1970 if (last_frag
== NULL
1971 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1972 /* If we're going to reset the view, but we know we're
1973 advancing the PC, we don't have to force with
1974 set_address. We know we do when we're at the same
1975 address of the same frag, and we know we might when
1976 we're in the beginning of a frag, and we were at the
1977 end of the previous frag. */
1978 && (frag
== last_frag
1979 ? (last_frag_ofs
== frag_ofs
)
1981 && ((offsetT
)last_frag_ofs
1982 >= get_frag_fix (last_frag
, seg
))))))
1985 out_inc_line_addr (line_delta
, 0);
1987 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1988 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1990 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1995 last_frag_ofs
= frag_ofs
;
2003 /* Emit a DW_LNE_end_sequence for the end of the section. */
2004 frag
= last_frag_for_seg (seg
);
2005 frag_ofs
= get_frag_fix (frag
, seg
);
2006 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
2007 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
2010 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
2011 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
2015 /* Switch to LINE_STR_SEG and output the given STR. Return the
2016 symbol pointing to the new string in the section. */
2019 add_line_strp (segT line_str_seg
, const char *str
)
2025 subseg_set (line_str_seg
, 0);
2027 sym
= symbol_temp_new_now_octets ();
2029 size
= strlen (str
) + 1;
2030 cp
= frag_more (size
);
2031 memcpy (cp
, str
, size
);
2037 /* Emit the directory and file tables for .debug_line. */
2040 out_dir_and_file_list (segT line_seg
, int sizeof_offset
)
2046 bfd_boolean emit_md5
= FALSE
;
2047 bfd_boolean emit_timestamps
= TRUE
;
2048 bfd_boolean emit_filesize
= TRUE
;
2049 segT line_str_seg
= NULL
;
2052 /* Output the Directory Table. */
2053 if (DWARF2_LINE_VERSION
>= 5)
2055 /* We only have one column in the directory table. */
2058 /* Describe the purpose and format of the column. */
2059 out_uleb128 (DW_LNCT_path
);
2060 /* Store these strings in the .debug_line_str section so they
2062 out_uleb128 (DW_FORM_line_strp
);
2064 /* Now state how many rows there are in the table. We need at
2065 least 1 if there is one or more file names to store the
2066 "working directory". */
2067 if (dirs_in_use
== 0 && files_in_use
> 0)
2070 out_uleb128 (dirs_in_use
);
2073 /* Emit directory list. */
2074 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2076 line_str_seg
= subseg_new (".debug_line_str", 0);
2077 bfd_set_section_flags (line_str_seg
,
2078 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2079 | SEC_MERGE
| SEC_STRINGS
);
2080 line_str_seg
->entsize
= 1;
2082 /* DWARF5 uses slot zero, but that is only set explicitly
2083 using a .file 0 directive. If that isn't used, but dir
2084 one is used, then use that as main file directory.
2085 Otherwise use pwd as main file directory. */
2086 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2087 dir
= remap_debug_filename (dirs
[0]);
2088 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2089 dir
= remap_debug_filename (dirs
[1]);
2091 dir
= remap_debug_filename (getpwd ());
2093 line_strp
= add_line_strp (line_str_seg
, dir
);
2094 subseg_set (line_seg
, 0);
2095 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2097 for (i
= 1; i
< dirs_in_use
; ++i
)
2099 dir
= remap_debug_filename (dirs
[i
]);
2100 if (DWARF2_LINE_VERSION
< 5)
2102 size
= strlen (dir
) + 1;
2103 cp
= frag_more (size
);
2104 memcpy (cp
, dir
, size
);
2108 line_strp
= add_line_strp (line_str_seg
, dir
);
2109 subseg_set (line_seg
, 0);
2110 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2114 if (DWARF2_LINE_VERSION
< 5)
2118 /* Output the File Name Table. */
2119 if (DWARF2_LINE_VERSION
>= 5)
2121 unsigned int columns
= 4;
2123 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2125 emit_timestamps
= FALSE
;
2129 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2131 emit_filesize
= FALSE
;
2135 for (i
= 0; i
< files_in_use
; ++i
)
2136 if (files
[i
].md5
[0] != 0)
2138 if (i
< files_in_use
)
2144 /* The number of format entries to follow. */
2146 /* The format of the file name. */
2147 out_uleb128 (DW_LNCT_path
);
2148 /* Store these strings in the .debug_line_str section so they
2150 out_uleb128 (DW_FORM_line_strp
);
2152 /* The format of the directory index. */
2153 out_uleb128 (DW_LNCT_directory_index
);
2154 out_uleb128 (DW_FORM_udata
);
2156 if (emit_timestamps
)
2158 /* The format of the timestamp. */
2159 out_uleb128 (DW_LNCT_timestamp
);
2160 out_uleb128 (DW_FORM_udata
);
2165 /* The format of the file size. */
2166 out_uleb128 (DW_LNCT_size
);
2167 out_uleb128 (DW_FORM_udata
);
2172 /* The format of the MD5 sum. */
2173 out_uleb128 (DW_LNCT_MD5
);
2174 out_uleb128 (DW_FORM_data16
);
2177 /* The number of entries in the table. */
2178 out_uleb128 (files_in_use
);
2181 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2183 const char *fullfilename
;
2185 if (files
[i
].filename
== NULL
)
2187 /* Prevent a crash later, particularly for file 1. DWARF5
2188 uses slot zero, but that is only set explicitly using a
2189 .file 0 directive. If that isn't used, but file 1 is,
2190 then use that as main file name. */
2191 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2192 files
[0].filename
= files
[1].filename
;
2194 files
[i
].filename
= "";
2195 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2197 as_bad (_("unassigned file number %ld"), (long) i
);
2202 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2203 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2204 if (DWARF2_LINE_VERSION
< 5)
2206 size
= strlen (fullfilename
) + 1;
2207 cp
= frag_more (size
);
2208 memcpy (cp
, fullfilename
, size
);
2212 line_strp
= add_line_strp (line_str_seg
, fullfilename
);
2213 subseg_set (line_seg
, 0);
2214 TC_DWARF2_EMIT_OFFSET (line_strp
, sizeof_offset
);
2217 /* Directory number. */
2218 out_uleb128 (files
[i
].dir
);
2220 /* Output the last modification timestamp. */
2221 if (emit_timestamps
)
2225 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2226 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2227 if (timestamp
== -1)
2229 out_uleb128 (timestamp
);
2232 /* Output the filesize. */
2236 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2237 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2240 out_uleb128 (filesize
);
2243 /* Output the md5 sum. */
2248 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2249 out_byte (files
[i
].md5
[b
]);
2253 if (DWARF2_LINE_VERSION
< 5)
2254 /* Terminate filename list. */
2258 /* Switch to SEC and output a header length field. Return the size of
2259 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2260 to the end of the section. EXPR->X_add_number will be set to the
2261 negative size of the header. */
2264 out_header (asection
*sec
, expressionS
*exp
)
2269 subseg_set (sec
, 0);
2271 if (flag_dwarf_sections
)
2273 /* If we are going to put the start and end symbols in different
2274 sections, then we need real symbols, not just fake, local ones. */
2276 start_sym
= symbol_make (".Ldebug_line_start");
2277 end_sym
= symbol_make (".Ldebug_line_end");
2278 symbol_set_value_now (start_sym
);
2282 start_sym
= symbol_temp_new_now_octets ();
2283 end_sym
= symbol_temp_make ();
2286 /* Total length of the information. */
2287 exp
->X_op
= O_subtract
;
2288 exp
->X_add_symbol
= end_sym
;
2289 exp
->X_op_symbol
= start_sym
;
2291 switch (DWARF2_FORMAT (sec
))
2293 case dwarf2_format_32bit
:
2294 exp
->X_add_number
= -4;
2298 case dwarf2_format_64bit
:
2299 exp
->X_add_number
= -12;
2304 case dwarf2_format_64bit_irix
:
2305 exp
->X_add_number
= -8;
2310 as_fatal (_("internal error: unknown dwarf2 format"));
2314 /* Emit the collected .debug_line data. */
2317 out_debug_line (segT line_seg
)
2320 symbolS
*prologue_start
, *prologue_end
;
2325 memset (&exp
, 0, sizeof exp
);
2326 sizeof_offset
= out_header (line_seg
, &exp
);
2327 line_end
= exp
.X_add_symbol
;
2330 out_two (DWARF2_LINE_VERSION
);
2332 if (DWARF2_LINE_VERSION
>= 5)
2334 out_byte (sizeof_address
);
2335 out_byte (0); /* Segment Selector size. */
2337 /* Length of the prologue following this length. */
2338 prologue_start
= symbol_temp_make ();
2339 prologue_end
= symbol_temp_make ();
2340 exp
.X_op
= O_subtract
;
2341 exp
.X_add_symbol
= prologue_end
;
2342 exp
.X_op_symbol
= prologue_start
;
2343 exp
.X_add_number
= 0;
2344 emit_expr (&exp
, sizeof_offset
);
2345 symbol_set_value_now (prologue_start
);
2347 /* Parameters of the state machine. */
2348 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2349 if (DWARF2_LINE_VERSION
>= 4)
2350 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2351 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2352 out_byte (DWARF2_LINE_BASE
);
2353 out_byte (DWARF2_LINE_RANGE
);
2354 out_byte (DWARF2_LINE_OPCODE_BASE
);
2356 /* Standard opcode lengths. */
2357 out_byte (0); /* DW_LNS_copy */
2358 out_byte (1); /* DW_LNS_advance_pc */
2359 out_byte (1); /* DW_LNS_advance_line */
2360 out_byte (1); /* DW_LNS_set_file */
2361 out_byte (1); /* DW_LNS_set_column */
2362 out_byte (0); /* DW_LNS_negate_stmt */
2363 out_byte (0); /* DW_LNS_set_basic_block */
2364 out_byte (0); /* DW_LNS_const_add_pc */
2365 out_byte (1); /* DW_LNS_fixed_advance_pc */
2366 out_byte (0); /* DW_LNS_set_prologue_end */
2367 out_byte (0); /* DW_LNS_set_epilogue_begin */
2368 out_byte (1); /* DW_LNS_set_isa */
2369 /* We have emitted 12 opcode lengths, so make that this
2370 matches up to the opcode base value we have been using. */
2371 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2373 out_dir_and_file_list (line_seg
, sizeof_offset
);
2375 symbol_set_value_now (prologue_end
);
2377 /* For each section, emit a statement program. */
2378 for (s
= all_segs
; s
; s
= s
->next
)
2379 /* Paranoia - this check should have already have
2380 been handled in dwarf2_gen_line_info_1(). */
2381 if (SEG_NORMAL (s
->seg
))
2382 process_entries (s
->seg
, s
->head
->head
);
2384 if (flag_dwarf_sections
)
2385 /* We have to switch to the special .debug_line_end section
2386 before emitting the end-of-debug_line symbol. The linker
2387 script arranges for this section to be placed after all the
2388 (potentially garbage collected) .debug_line.<foo> sections.
2389 This section contains the line_end symbol which is used to
2390 compute the size of the linked .debug_line section, as seen
2391 in the DWARF Line Number header. */
2392 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2394 symbol_set_value_now (line_end
);
2398 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2400 unsigned int addr_size
= sizeof_address
;
2405 memset (&exp
, 0, sizeof exp
);
2406 subseg_set (ranges_seg
, 0);
2408 /* For DW_AT_ranges to point at (there is no header, so really start
2409 of section, but see out_debug_rnglists). */
2410 *ranges_sym
= symbol_temp_new_now_octets ();
2412 /* Base Address Entry. */
2413 for (i
= 0; i
< addr_size
; i
++)
2415 for (i
= 0; i
< addr_size
; i
++)
2418 /* Range List Entry. */
2419 for (s
= all_segs
; s
; s
= s
->next
)
2424 frag
= first_frag_for_seg (s
->seg
);
2425 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2426 s
->text_start
= beg
;
2428 frag
= last_frag_for_seg (s
->seg
);
2429 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2432 exp
.X_op
= O_symbol
;
2433 exp
.X_add_symbol
= beg
;
2434 exp
.X_add_number
= 0;
2435 emit_expr (&exp
, addr_size
);
2437 exp
.X_op
= O_symbol
;
2438 exp
.X_add_symbol
= end
;
2439 exp
.X_add_number
= 0;
2440 emit_expr (&exp
, addr_size
);
2443 /* End of Range Entry. */
2444 for (i
= 0; i
< addr_size
; i
++)
2446 for (i
= 0; i
< addr_size
; i
++)
2451 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2454 symbolS
*ranges_end
;
2458 memset (&exp
, 0, sizeof exp
);
2459 out_header (ranges_seg
, &exp
);
2460 ranges_end
= exp
.X_add_symbol
;
2462 out_two (DWARF2_RNGLISTS_VERSION
);
2463 out_byte (sizeof_address
);
2464 out_byte (0); /* Segment Selector size. */
2465 out_four (0); /* Offset entry count. */
2467 /* For DW_AT_ranges to point at (must be after the header). */
2468 *ranges_sym
= symbol_temp_new_now_octets ();
2470 for (s
= all_segs
; s
; s
= s
->next
)
2475 out_byte (DW_RLE_start_length
);
2477 frag
= first_frag_for_seg (s
->seg
);
2478 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2479 s
->text_start
= beg
;
2481 frag
= last_frag_for_seg (s
->seg
);
2482 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2485 exp
.X_op
= O_symbol
;
2486 exp
.X_add_symbol
= beg
;
2487 exp
.X_add_number
= 0;
2488 emit_expr (&exp
, sizeof_address
);
2490 exp
.X_op
= O_symbol
;
2491 exp
.X_add_symbol
= end
;
2492 exp
.X_add_number
= 0;
2493 emit_leb128_expr (&exp
, 0);
2496 out_byte (DW_RLE_end_of_list
);
2498 symbol_set_value_now (ranges_end
);
2501 /* Emit data for .debug_aranges. */
2504 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2506 unsigned int addr_size
= sizeof_address
;
2510 symbolS
*aranges_end
;
2514 memset (&exp
, 0, sizeof exp
);
2515 sizeof_offset
= out_header (aranges_seg
, &exp
);
2516 aranges_end
= exp
.X_add_symbol
;
2517 size
= -exp
.X_add_number
;
2520 out_two (DWARF2_ARANGES_VERSION
);
2523 /* Offset to .debug_info. */
2524 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2525 size
+= sizeof_offset
;
2527 /* Size of an address (offset portion). */
2528 out_byte (addr_size
);
2531 /* Size of a segment descriptor. */
2535 /* Align the header. */
2536 while ((size
++ % (2 * addr_size
)) > 0)
2539 for (s
= all_segs
; s
; s
= s
->next
)
2544 frag
= first_frag_for_seg (s
->seg
);
2545 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2546 s
->text_start
= beg
;
2548 frag
= last_frag_for_seg (s
->seg
);
2549 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2552 exp
.X_op
= O_symbol
;
2553 exp
.X_add_symbol
= beg
;
2554 exp
.X_add_number
= 0;
2555 emit_expr (&exp
, addr_size
);
2557 exp
.X_op
= O_subtract
;
2558 exp
.X_add_symbol
= end
;
2559 exp
.X_op_symbol
= beg
;
2560 exp
.X_add_number
= 0;
2561 emit_expr (&exp
, addr_size
);
2564 p
= frag_more (2 * addr_size
);
2565 md_number_to_chars (p
, 0, addr_size
);
2566 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2568 symbol_set_value_now (aranges_end
);
2571 /* Emit data for .debug_abbrev. Note that this must be kept in
2572 sync with out_debug_info below. */
2575 out_debug_abbrev (segT abbrev_seg
,
2576 segT info_seg ATTRIBUTE_UNUSED
,
2577 segT line_seg ATTRIBUTE_UNUSED
)
2580 subseg_set (abbrev_seg
, 0);
2583 out_uleb128 (DW_TAG_compile_unit
);
2584 out_byte (DW_CHILDREN_no
);
2585 if (DWARF2_VERSION
< 4)
2587 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2588 secoff_form
= DW_FORM_data4
;
2590 secoff_form
= DW_FORM_data8
;
2593 secoff_form
= DW_FORM_sec_offset
;
2594 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2595 if (all_segs
->next
== NULL
)
2597 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2598 if (DWARF2_VERSION
< 4)
2599 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2601 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2604 out_abbrev (DW_AT_ranges
, secoff_form
);
2605 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2606 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2607 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2608 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2611 /* Terminate the abbreviations for this compilation unit. */
2615 /* Emit a description of this compilation unit for .debug_info. */
2618 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2619 symbolS
*ranges_sym
, symbolS
*name_sym
,
2620 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2626 memset (&exp
, 0, sizeof exp
);
2627 sizeof_offset
= out_header (info_seg
, &exp
);
2628 info_end
= exp
.X_add_symbol
;
2630 /* DWARF version. */
2631 out_two (DWARF2_VERSION
);
2633 if (DWARF2_VERSION
< 5)
2635 /* .debug_abbrev offset */
2636 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2640 /* unit (header) type */
2641 out_byte (DW_UT_compile
);
2644 /* Target address size. */
2645 out_byte (sizeof_address
);
2647 if (DWARF2_VERSION
>= 5)
2649 /* .debug_abbrev offset */
2650 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2653 /* DW_TAG_compile_unit DIE abbrev */
2656 /* DW_AT_stmt_list */
2657 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2658 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2661 /* These two attributes are emitted if all of the code is contiguous. */
2662 if (all_segs
->next
== NULL
)
2665 exp
.X_op
= O_symbol
;
2666 exp
.X_add_symbol
= all_segs
->text_start
;
2667 exp
.X_add_number
= 0;
2668 emit_expr (&exp
, sizeof_address
);
2671 if (DWARF2_VERSION
< 4)
2672 exp
.X_op
= O_symbol
;
2675 exp
.X_op
= O_subtract
;
2676 exp
.X_op_symbol
= all_segs
->text_start
;
2678 exp
.X_add_symbol
= all_segs
->text_end
;
2679 exp
.X_add_number
= 0;
2680 if (DWARF2_VERSION
< 4)
2681 emit_expr (&exp
, sizeof_address
);
2683 emit_leb128_expr (&exp
, 0);
2687 /* This attribute is emitted if the code is disjoint. */
2689 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2692 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2693 setup in out_debug_str below. */
2694 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2695 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2696 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2698 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2699 dwarf2 draft has no standard code for assembler. */
2700 out_two (DW_LANG_Mips_Assembler
);
2702 symbol_set_value_now (info_end
);
2705 /* Emit the three debug strings needed in .debug_str and setup symbols
2706 to them for use in out_debug_info. */
2708 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2709 symbolS
**producer_sym
)
2712 const char *comp_dir
;
2713 const char *dirname
;
2716 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2718 subseg_set (str_seg
, 0);
2720 /* DW_AT_name. We don't have the actual file name that was present
2721 on the command line, so assume files[first_file] is the main input file.
2722 We're not supposed to get called unless at least one line number
2723 entry was emitted, so this should always be defined. */
2724 *name_sym
= symbol_temp_new_now_octets ();
2725 if (files_in_use
== 0)
2727 if (files
[first_file
].dir
)
2729 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2730 len
= strlen (dirname
);
2732 /* Already has trailing slash. */
2733 p
= frag_more (len
);
2734 memcpy (p
, dirname
, len
);
2736 p
= frag_more (len
+ 1);
2737 memcpy (p
, dirname
, len
);
2738 INSERT_DIR_SEPARATOR (p
, len
);
2741 len
= strlen (files
[first_file
].filename
) + 1;
2742 p
= frag_more (len
);
2743 memcpy (p
, files
[first_file
].filename
, len
);
2745 /* DW_AT_comp_dir */
2746 *comp_dir_sym
= symbol_temp_new_now_octets ();
2747 comp_dir
= remap_debug_filename (getpwd ());
2748 len
= strlen (comp_dir
) + 1;
2749 p
= frag_more (len
);
2750 memcpy (p
, comp_dir
, len
);
2752 /* DW_AT_producer */
2753 *producer_sym
= symbol_temp_new_now_octets ();
2754 sprintf (producer
, "GNU AS %s", VERSION
);
2755 len
= strlen (producer
) + 1;
2756 p
= frag_more (len
);
2757 memcpy (p
, producer
, len
);
2763 last_seg_ptr
= &all_segs
;
2765 /* Select the default CIE version to produce here. The global
2766 starts with a value of -1 and will be modified to a valid value
2767 either by the user providing a command line option, or some
2768 targets will select their own default in md_after_parse_args. If
2769 we get here and the global still contains -1 then it is up to us
2770 to pick a sane default. The default we choose is 1, this is the
2771 CIE version gas has produced for a long time, and there seems no
2772 reason to change it yet. */
2773 if (flag_dwarf_cie_version
== -1)
2774 flag_dwarf_cie_version
= 1;
2777 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2778 were any .file/.loc directives, or --gdwarf2 was given, and if the
2779 file has a non-empty .debug_info section and an empty .debug_line
2780 section. If we emit .debug_line, and the .debug_info section is
2781 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2782 ALL_SEGS will be non-null if there were any .file/.loc directives,
2783 or --gdwarf2 was given and there were any located instructions
2787 dwarf2_finish (void)
2792 int emit_other_sections
= 0;
2793 int empty_debug_line
= 0;
2795 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2796 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2798 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2799 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2801 /* We can't construct a new debug_line section if we already have one.
2802 Give an error if we have seen any .loc, otherwise trust the user
2803 knows what they are doing and want to generate the .debug_line
2804 (and all other debug sections) themselves. */
2805 if (all_segs
&& !empty_debug_line
&& dwarf2_any_loc_directive_seen
)
2806 as_fatal ("duplicate .debug_line sections");
2808 if ((!all_segs
&& emit_other_sections
)
2809 || (!emit_other_sections
&& !empty_debug_line
))
2810 /* If there is no line information and no non-empty .debug_info
2811 section, or if there is both a non-empty .debug_info and a non-empty
2812 .debug_line, then we do nothing. */
2815 /* Calculate the size of an address for the target machine. */
2816 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2818 /* Create and switch to the line number section. */
2819 if (empty_debug_line
)
2821 line_seg
= subseg_new (".debug_line", 0);
2822 bfd_set_section_flags (line_seg
,
2823 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2826 /* For each subsection, chain the debug entries together. */
2827 for (s
= all_segs
; s
; s
= s
->next
)
2829 struct line_subseg
*lss
= s
->head
;
2830 struct line_entry
**ptail
= lss
->ptail
;
2832 /* Reset the initial view of the first subsection of the
2834 if (lss
->head
&& lss
->head
->loc
.view
)
2835 set_or_check_view (lss
->head
, NULL
, NULL
);
2837 while ((lss
= lss
->next
) != NULL
)
2839 /* Link the first view of subsequent subsections to the
2841 if (lss
->head
&& lss
->head
->loc
.view
)
2842 set_or_check_view (lss
->head
,
2843 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2844 s
->head
? s
->head
->head
: NULL
);
2850 if (empty_debug_line
)
2851 out_debug_line (line_seg
);
2853 /* If this is assembler generated line info, and there is no
2854 debug_info already, we need .debug_info, .debug_abbrev and
2855 .debug_str sections as well. */
2856 if (emit_other_sections
)
2861 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2863 gas_assert (all_segs
);
2865 info_seg
= subseg_new (".debug_info", 0);
2866 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2867 aranges_seg
= subseg_new (".debug_aranges", 0);
2868 str_seg
= subseg_new (".debug_str", 0);
2870 bfd_set_section_flags (info_seg
,
2871 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2872 bfd_set_section_flags (abbrev_seg
,
2873 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2874 bfd_set_section_flags (aranges_seg
,
2875 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2876 bfd_set_section_flags (str_seg
,
2877 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2878 | SEC_MERGE
| SEC_STRINGS
);
2879 str_seg
->entsize
= 1;
2881 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2883 if (all_segs
->next
== NULL
)
2887 if (DWARF2_VERSION
< 5)
2889 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2890 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2893 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2894 out_debug_ranges (ranges_seg
, &ranges_sym
);
2898 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2899 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2902 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2906 out_debug_aranges (aranges_seg
, info_seg
);
2907 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2908 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2909 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2910 name_sym
, comp_dir_sym
, producer_sym
);
2914 /* Perform any deferred checks pertaining to debug information. */
2917 dwarf2dbg_final_check (void)
2919 /* Perform reset-view checks. Don't evaluate view_assert_failed
2920 recursively: it could be very deep. It's a chain of adds, with
2921 each chain element pointing to the next in X_add_symbol, and
2922 holding the check value in X_op_symbol. */
2923 while (view_assert_failed
)
2929 gas_assert (!symbol_resolved_p (view_assert_failed
));
2931 exp
= symbol_get_value_expression (view_assert_failed
);
2932 sym
= view_assert_failed
;
2934 /* If view_assert_failed looks like a compound check in the
2935 chain, break it up. */
2936 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2938 view_assert_failed
= exp
->X_add_symbol
;
2939 sym
= exp
->X_op_symbol
;
2942 view_assert_failed
= NULL
;
2944 failed
= resolve_symbol_value (sym
);
2945 if (!symbol_resolved_p (sym
) || failed
)
2947 as_bad (_("view number mismatch"));