1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2020 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION dwarf_level
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation outputs version 3 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
105 /* The .debug_rnglists has only been in DWARF version 5. */
106 #ifndef DWARF2_RNGLISTS_VERSION
107 #define DWARF2_RNGLISTS_VERSION 5
114 /* Since we can't generate the prolog until the body is complete, we
115 use three different subsegments for .debug_line: one holding the
116 prolog, one for the directory and filename info, and one for the
117 body ("statement program"). */
122 /* If linker relaxation might change offsets in the code, the DWARF special
123 opcodes and variable-length operands cannot be used. If this macro is
124 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
125 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
126 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
129 /* First special line opcode - leave room for the standard opcodes.
130 Note: If you want to change this, you'll have to update the
131 "standard_opcode_lengths" table that is emitted below in
133 #define DWARF2_LINE_OPCODE_BASE 13
135 #ifndef DWARF2_LINE_BASE
136 /* Minimum line offset in a special line info. opcode. This value
137 was chosen to give a reasonable range of values. */
138 # define DWARF2_LINE_BASE -5
141 /* Range of line offsets in a special line info. opcode. */
142 #ifndef DWARF2_LINE_RANGE
143 # define DWARF2_LINE_RANGE 14
146 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
147 /* Define the architecture-dependent minimum instruction length (in
148 bytes). This value should be rather too small than too big. */
149 # define DWARF2_LINE_MIN_INSN_LENGTH 1
152 /* Flag that indicates the initial value of the is_stmt_start flag. */
153 #define DWARF2_LINE_DEFAULT_IS_STMT 1
155 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
156 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
159 /* Given a special op, return the line skip amount. */
160 #define SPECIAL_LINE(op) \
161 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
163 /* Given a special op, return the address skip amount (in units of
164 DWARF2_LINE_MIN_INSN_LENGTH. */
165 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
167 /* The maximum address skip amount that can be encoded with a special op. */
168 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
170 #ifndef TC_PARSE_CONS_RETURN_NONE
171 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
176 struct line_entry
*next
;
178 struct dwarf2_line_info loc
;
181 /* Don't change the offset of next in line_entry. set_or_check_view
182 calls in dwarf2_gen_line_info_1 depend on it. */
183 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
188 struct line_subseg
*next
;
190 struct line_entry
*head
;
191 struct line_entry
**ptail
;
192 struct line_entry
**pmove_tail
;
197 struct line_seg
*next
;
199 struct line_subseg
*head
;
204 /* Collects data for all line table entries during assembly. */
205 static struct line_seg
*all_segs
;
206 static struct line_seg
**last_seg_ptr
;
208 #define NUM_MD5_BYTES 16
212 const char * filename
;
214 bfd_boolean auto_assigned
;
215 unsigned char md5
[NUM_MD5_BYTES
];
218 /* Table of files used by .debug_line. */
219 static struct file_entry
*files
;
220 static unsigned int files_in_use
;
221 static unsigned int files_allocated
;
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. */
230 bfd_boolean dwarf2_loc_directive_seen
;
232 /* TRUE when we're supposed to set the basic block mark whenever a
234 bfd_boolean dwarf2_loc_mark_labels
;
236 /* Current location as indicated by the most recent .loc directive. */
237 static struct dwarf2_line_info current
=
240 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
244 /* This symbol is used to recognize view number forced resets in loc
246 static symbolS
*force_reset_view
;
248 /* This symbol evaluates to an expression that, if nonzero, indicates
249 some view assert check failed. */
250 static symbolS
*view_assert_failed
;
252 /* The size of an address on the target. */
253 static unsigned int sizeof_address
;
255 #ifndef TC_DWARF2_EMIT_OFFSET
256 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
258 /* Create an offset to .dwarf2_*. */
261 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
265 memset (&exp
, 0, sizeof exp
);
267 exp
.X_add_symbol
= symbol
;
268 exp
.X_add_number
= 0;
269 emit_expr (&exp
, size
);
273 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
275 static struct line_subseg
*
276 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
278 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
279 struct line_subseg
**pss
, *lss
;
286 s
= XNEW (struct line_seg
);
291 last_seg_ptr
= &s
->next
;
292 seg_info (seg
)->dwarf2_line_seg
= s
;
295 gas_assert (seg
== s
->seg
);
297 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
299 if (lss
->subseg
== subseg
)
301 if (lss
->subseg
> subseg
)
305 lss
= XNEW (struct line_subseg
);
307 lss
->subseg
= subseg
;
309 lss
->ptail
= &lss
->head
;
310 lss
->pmove_tail
= &lss
->head
;
317 /* (Un)reverse the line_entry list starting from H. */
319 static struct line_entry
*
320 reverse_line_entry_list (struct line_entry
*h
)
322 struct line_entry
*p
= NULL
, *e
, *n
;
324 for (e
= h
; e
; e
= n
)
333 /* Compute the view for E based on the previous entry P. If we
334 introduce an (undefined) view symbol for P, and H is given (P must
335 be the tail in this case), introduce view symbols for earlier list
336 entries as well, until one of them is constant. */
339 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
340 struct line_entry
*h
)
344 memset (&viewx
, 0, sizeof (viewx
));
345 viewx
.X_unsigned
= 1;
347 /* First, compute !(E->label > P->label), to tell whether or not
348 we're to reset the view number. If we can't resolve it to a
349 constant, keep it symbolic. */
350 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
352 viewx
.X_op
= O_constant
;
353 viewx
.X_add_number
= 0;
354 viewx
.X_add_symbol
= NULL
;
355 viewx
.X_op_symbol
= NULL
;
360 viewx
.X_add_number
= 0;
361 viewx
.X_add_symbol
= e
->label
;
362 viewx
.X_op_symbol
= p
->label
;
363 resolve_expression (&viewx
);
364 if (viewx
.X_op
== O_constant
)
365 viewx
.X_add_number
= !viewx
.X_add_number
;
368 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
369 viewx
.X_add_number
= 0;
370 viewx
.X_op_symbol
= NULL
;
371 viewx
.X_op
= O_logical_not
;
375 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
377 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
378 /* We can't compare the view numbers at this point, because in
379 VIEWX we've only determined whether we're to reset it so
381 if (viewx
.X_op
== O_constant
)
383 if (!value
->X_add_number
!= !viewx
.X_add_number
)
384 as_bad (_("view number mismatch"));
386 /* Record the expression to check it later. It is the result of
387 a logical not, thus 0 or 1. We just add up all such deferred
388 expressions, and resolve it at the end. */
389 else if (!value
->X_add_number
)
391 symbolS
*deferred
= make_expr_symbol (&viewx
);
392 if (view_assert_failed
)
396 memset (&chk
, 0, sizeof (chk
));
399 chk
.X_add_number
= 0;
400 chk
.X_add_symbol
= view_assert_failed
;
401 chk
.X_op_symbol
= deferred
;
402 deferred
= make_expr_symbol (&chk
);
404 view_assert_failed
= deferred
;
408 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
414 p
->loc
.view
= symbol_temp_make ();
415 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
418 memset (&incv
, 0, sizeof (incv
));
420 incv
.X_op
= O_symbol
;
421 incv
.X_add_symbol
= p
->loc
.view
;
422 incv
.X_add_number
= 1;
424 if (viewx
.X_op
== O_constant
)
426 gas_assert (viewx
.X_add_number
== 1);
431 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
432 viewx
.X_add_number
= 0;
433 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
434 viewx
.X_op
= O_multiply
;
438 if (!S_IS_DEFINED (e
->loc
.view
))
440 symbol_set_value_expression (e
->loc
.view
, &viewx
);
441 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
442 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
445 /* Define and attempt to simplify any earlier views needed to
447 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
449 struct line_entry
*h2
;
450 /* Reverse the list to avoid quadratic behavior going backwards
451 in a single-linked list. */
452 struct line_entry
*r
= reverse_line_entry_list (h
);
455 /* Set or check views until we find a defined or absent view. */
458 /* Do not define the head of a (sub?)segment view while
459 handling others. It would be defined too early, without
460 regard to the last view of other subsegments.
461 set_or_check_view will be called for every head segment
465 set_or_check_view (r
, r
->next
, NULL
);
467 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
470 /* Unreverse the list, so that we can go forward again. */
471 h2
= reverse_line_entry_list (p
);
472 gas_assert (h2
== h
);
474 /* Starting from the last view we just defined, attempt to
475 simplify the view expressions, until we do so to P. */
478 /* The head view of a subsegment may remain undefined while
479 handling other elements, before it is linked to the last
480 view of the previous subsegment. */
483 gas_assert (S_IS_DEFINED (r
->loc
.view
));
484 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
486 while (r
!= p
&& (r
= r
->next
));
488 /* Now that we've defined and computed all earlier views that might
489 be needed to compute E's, attempt to simplify it. */
490 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
494 /* Record an entry for LOC occurring at LABEL. */
497 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
499 struct line_subseg
*lss
;
500 struct line_entry
*e
;
502 e
= XNEW (struct line_entry
);
507 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
509 /* Subseg heads are chained to previous subsegs in
511 if (loc
->view
&& lss
->head
)
512 set_or_check_view (e
,
513 (struct line_entry
*)lss
->ptail
,
517 lss
->ptail
= &e
->next
;
520 /* Record an entry for LOC occurring at OFS within the current fragment. */
523 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
525 static unsigned int line
= -1;
526 static unsigned int filenum
= -1;
530 /* Early out for as-yet incomplete location information. */
533 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
536 /* Don't emit sequences of line symbols for the same line when the
537 symbols apply to assembler code. It is necessary to emit
538 duplicate line symbols when a compiler asks for them, because GDB
539 uses them to determine the end of the prologue. */
540 if (debug_type
== DEBUG_DWARF2
541 && line
== loc
->line
&& filenum
== loc
->filenum
)
545 filenum
= loc
->filenum
;
551 /* Use a non-fake name for the line number location,
552 so that it can be referred to by relocations. */
553 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
554 sym
= symbol_new (name
, now_seg
, frag_now
, ofs
);
557 sym
= symbol_temp_new (now_seg
, frag_now
, ofs
);
558 dwarf2_gen_line_info_1 (sym
, loc
);
562 get_basename (const char * pathname
)
566 file
= lbasename (pathname
);
567 /* Don't make empty string from / or A: from A:/ . */
568 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
569 if (file
<= pathname
+ 3)
572 if (file
== pathname
+ 1)
579 get_directory_table_entry (const char * dirname
,
581 bfd_boolean can_use_zero
)
588 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
589 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
597 for (d
= 0; d
< dirs_in_use
; ++d
)
600 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
601 && dirs
[d
][dirlen
] == '\0')
607 if (dirs
== NULL
|| dirs
[0] == NULL
)
613 if (d
>= dirs_allocated
)
615 unsigned int old
= dirs_allocated
;
617 dirs_allocated
= d
+ 32;
618 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
619 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
622 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
623 if (dirs_in_use
<= d
)
630 assign_file_to_slot (unsigned long i
, const char *file
, unsigned int dir
, bfd_boolean auto_assign
)
632 if (i
>= files_allocated
)
634 unsigned int old
= files_allocated
;
636 files_allocated
= i
+ 32;
637 /* Catch wraparound. */
638 if (files_allocated
<= old
)
640 as_bad (_("file number %lu is too big"), (unsigned long) i
);
644 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
645 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
648 files
[i
].filename
= file
;
650 files
[i
].auto_assigned
= auto_assign
;
651 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
653 if (files_in_use
< i
+ 1)
654 files_in_use
= i
+ 1;
659 /* Get a .debug_line file number for PATHNAME. If there is a
660 directory component to PATHNAME, then this will be stored
661 in the directory table, if it is not already present.
662 Returns the slot number allocated to that filename or -1
663 if there was a problem. */
666 allocate_filenum (const char * pathname
)
668 static signed int last_used
= -1, last_used_dir_len
= 0;
673 /* Short circuit the common case of adding the same pathname
677 const char * dirname
= NULL
;
680 dirname
= dirs
[files
[last_used
].dir
];
684 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
689 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
690 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
691 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
692 files
[last_used
].filename
) == 0)
697 file
= get_basename (pathname
);
698 dir_len
= file
- pathname
;
700 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
702 /* Do not use slot-0. That is specifically reserved for use by
703 the '.file 0 "name"' directive. */
704 for (i
= 1; i
< files_in_use
; ++i
)
705 if (files
[i
].dir
== dir
707 && filename_cmp (file
, files
[i
].filename
) == 0)
710 last_used_dir_len
= dir_len
;
714 if (!assign_file_to_slot (i
, file
, dir
, TRUE
))
718 last_used_dir_len
= dir_len
;
723 /* Allocate slot NUM in the .debug_line file table to FILENAME.
724 If DIRNAME is not NULL or there is a directory component to FILENAME
725 then this will be stored in the directory table, if not already present.
726 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
727 Returns TRUE if allocation succeeded, FALSE otherwise. */
730 allocate_filename_to_slot (const char * dirname
,
731 const char * filename
,
733 bfd_boolean with_md5
)
739 /* Short circuit the common case of adding the same pathname
741 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
743 const char * dir
= NULL
;
746 dir
= dirs
[files
[num
].dir
];
749 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
754 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
757 if (filename_cmp (filename
, files
[num
].filename
) != 0)
760 /* If the filenames match, but the directory table entry was
761 empty, then fill it with the provided directory name. */
763 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
767 else if (dir
!= NULL
)
769 dirlen
= strlen (dir
);
770 if (filename_ncmp (filename
, dir
, dirlen
) == 0
771 && IS_DIR_SEPARATOR (filename
[dirlen
])
772 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
775 else /* dir == NULL */
777 file
= get_basename (filename
);
778 if (filename_cmp (file
, files
[num
].filename
) == 0)
781 /* The filenames match, but the directory table entry is empty.
782 Fill it with the provided directory name. */
783 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
789 /* If NUM was previously allocated automatically then
790 choose another slot for it, so that we can reuse NUM. */
791 if (files
[num
].auto_assigned
)
793 /* Find an unused slot. */
794 for (i
= 1; i
< files_in_use
; ++i
)
795 if (files
[i
].filename
== NULL
)
797 if (! assign_file_to_slot (i
, files
[num
].filename
, files
[num
].dir
, TRUE
))
799 files
[num
].filename
= NULL
;
803 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
805 dir
== NULL
? "" : dir
,
806 dir
== NULL
? "" : "/",
808 dirname
== NULL
? "" : dirname
,
809 dirname
== NULL
? "" : "/",
818 file
= get_basename (filename
);
819 dirlen
= file
- filename
;
823 dirlen
= strlen (dirname
);
827 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
830 if (! assign_file_to_slot (i
, file
, d
, FALSE
))
835 if (target_big_endian
)
837 /* md5's are stored in litte endian format. */
838 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
839 unsigned int byte
= NUM_MD5_BYTES
;
840 unsigned int bignum_index
= 0;
842 while (bits_remaining
)
844 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
845 valueT bignum_value
= generic_bignum
[bignum_index
];
848 while (bignum_bits_remaining
)
850 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
852 bignum_bits_remaining
-= 8;
859 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
860 unsigned int byte
= 0;
861 unsigned int bignum_index
= 0;
863 while (bits_remaining
)
865 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
866 valueT bignum_value
= generic_bignum
[bignum_index
];
870 while (bignum_bits_remaining
)
872 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
874 bignum_bits_remaining
-= 8;
881 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
886 /* Returns the current source information. If .file directives have
887 been encountered, the info for the corresponding source file is
888 returned. Otherwise, the info for the assembly source file is
892 dwarf2_where (struct dwarf2_line_info
*line
)
894 if (debug_type
== DEBUG_DWARF2
)
896 const char *filename
;
898 memset (line
, 0, sizeof (*line
));
899 filename
= as_where (&line
->line
);
900 line
->filenum
= allocate_filenum (filename
);
901 /* FIXME: We should check the return value from allocate_filenum. */
903 line
->flags
= DWARF2_FLAG_IS_STMT
;
904 line
->isa
= current
.isa
;
905 line
->discriminator
= current
.discriminator
;
912 /* A hook to allow the target backend to inform the line number state
913 machine of isa changes when assembler debug info is enabled. */
916 dwarf2_set_isa (unsigned int isa
)
921 /* Called for each machine instruction, or relatively atomic group of
922 machine instructions (ie built-in macro). The instruction or group
923 is SIZE bytes in length. If dwarf2 line number generation is called
924 for, emit a line statement appropriately. */
927 dwarf2_emit_insn (int size
)
929 struct dwarf2_line_info loc
;
931 if (debug_type
!= DEBUG_DWARF2
932 ? !dwarf2_loc_directive_seen
933 : !seen_at_least_1_file ())
938 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
939 dwarf2_consume_line_info ();
942 /* Move all previously-emitted line entries for the current position by
943 DELTA bytes. This function cannot be used to move the same entries
947 dwarf2_move_insn (int delta
)
949 struct line_subseg
*lss
;
950 struct line_entry
*e
;
956 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
960 now
= frag_now_fix ();
961 while ((e
= *lss
->pmove_tail
))
963 if (S_GET_VALUE (e
->label
) == now
)
964 S_SET_VALUE (e
->label
, now
+ delta
);
965 lss
->pmove_tail
= &e
->next
;
969 /* Called after the current line information has been either used with
970 dwarf2_gen_line_info or saved with a machine instruction for later use.
971 This resets the state of the line number information to reflect that
975 dwarf2_consume_line_info (void)
977 /* Unless we generate DWARF2 debugging information for each
978 assembler line, we only emit one line symbol for one LOC. */
979 dwarf2_loc_directive_seen
= FALSE
;
981 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
982 | DWARF2_FLAG_PROLOGUE_END
983 | DWARF2_FLAG_EPILOGUE_BEGIN
);
984 current
.discriminator
= 0;
988 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
989 is enabled, emit a basic block marker. */
992 dwarf2_emit_label (symbolS
*label
)
994 struct dwarf2_line_info loc
;
996 if (!dwarf2_loc_mark_labels
)
998 if (S_GET_SEGMENT (label
) != now_seg
)
1000 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
1002 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
1005 dwarf2_where (&loc
);
1007 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1009 dwarf2_gen_line_info_1 (label
, &loc
);
1010 dwarf2_consume_line_info ();
1013 /* Handle two forms of .file directive:
1014 - Pass .file "source.c" to s_app_file
1015 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1017 If an entry is added to the file table, return a pointer to the filename. */
1020 dwarf2_directive_filename (void)
1022 bfd_boolean with_md5
= FALSE
;
1025 const char * dirname
= NULL
;
1028 /* Continue to accept a bare string and pass it off. */
1030 if (*input_line_pointer
== '"')
1036 num
= get_absolute_expression ();
1038 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1040 as_bad (_("file number less than one"));
1041 ignore_rest_of_line ();
1045 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1046 "switch back to the already allocated file <N> as the current
1049 filename
= demand_copy_C_string (&filename_len
);
1050 if (filename
== NULL
)
1051 /* demand_copy_C_string will have already generated an error message. */
1054 /* For DWARF-5 support we also accept:
1055 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1056 if (DWARF2_LINE_VERSION
> 4)
1059 if (*input_line_pointer
== '"')
1062 filename
= demand_copy_C_string (&filename_len
);
1066 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1068 input_line_pointer
+= 3;
1072 expression_and_evaluate (& exp
);
1073 if (exp
.X_op
!= O_big
)
1074 as_bad (_("md5 value too small or not a constant"));
1080 demand_empty_rest_of_line ();
1082 /* A .file directive implies compiler generated debug information is
1083 being supplied. Turn off gas generated debug info. */
1084 debug_type
= DEBUG_NONE
;
1086 if (num
!= (unsigned int) num
1087 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1089 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1093 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1100 /* Calls dwarf2_directive_filename, but discards its result.
1101 Used in pseudo-op tables where the function result is ignored. */
1104 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1106 (void) dwarf2_directive_filename ();
1110 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1112 offsetT filenum
, line
;
1114 /* If we see two .loc directives in a row, force the first one to be
1116 if (dwarf2_loc_directive_seen
)
1117 dwarf2_emit_insn (0);
1119 filenum
= get_absolute_expression ();
1121 line
= get_absolute_expression ();
1125 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1127 as_bad (_("file number less than one"));
1132 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1134 as_bad (_("unassigned file number %ld"), (long) filenum
);
1138 current
.filenum
= filenum
;
1139 current
.line
= line
;
1140 current
.discriminator
= 0;
1145 if (files
[filenum
].dir
)
1147 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1148 size_t file_len
= strlen (files
[filenum
].filename
);
1149 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1151 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1152 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1153 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1154 cp
[dir_len
+ file_len
+ 1] = '\0';
1155 listing_source_file (cp
);
1159 listing_source_file (files
[filenum
].filename
);
1160 listing_source_line (line
);
1165 if (ISDIGIT (*input_line_pointer
))
1167 current
.column
= get_absolute_expression ();
1171 while (ISALPHA (*input_line_pointer
))
1176 c
= get_symbol_name (& p
);
1178 if (strcmp (p
, "basic_block") == 0)
1180 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1181 *input_line_pointer
= c
;
1183 else if (strcmp (p
, "prologue_end") == 0)
1185 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1186 *input_line_pointer
= c
;
1188 else if (strcmp (p
, "epilogue_begin") == 0)
1190 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1191 *input_line_pointer
= c
;
1193 else if (strcmp (p
, "is_stmt") == 0)
1195 (void) restore_line_pointer (c
);
1196 value
= get_absolute_expression ();
1198 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1199 else if (value
== 1)
1200 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1203 as_bad (_("is_stmt value not 0 or 1"));
1207 else if (strcmp (p
, "isa") == 0)
1209 (void) restore_line_pointer (c
);
1210 value
= get_absolute_expression ();
1212 current
.isa
= value
;
1215 as_bad (_("isa number less than zero"));
1219 else if (strcmp (p
, "discriminator") == 0)
1221 (void) restore_line_pointer (c
);
1222 value
= get_absolute_expression ();
1224 current
.discriminator
= value
;
1227 as_bad (_("discriminator less than zero"));
1231 else if (strcmp (p
, "view") == 0)
1235 (void) restore_line_pointer (c
);
1238 if (ISDIGIT (*input_line_pointer
)
1239 || *input_line_pointer
== '-')
1241 bfd_boolean force_reset
= *input_line_pointer
== '-';
1243 value
= get_absolute_expression ();
1246 as_bad (_("numeric view can only be asserted to zero"));
1249 if (force_reset
&& force_reset_view
)
1250 sym
= force_reset_view
;
1253 sym
= symbol_temp_new (absolute_section
, &zero_address_frag
,
1256 force_reset_view
= sym
;
1261 char *name
= read_symbol_name ();
1265 sym
= symbol_find_or_make (name
);
1266 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1268 if (S_IS_VOLATILE (sym
))
1269 sym
= symbol_clone (sym
, 1);
1270 else if (!S_CAN_BE_REDEFINED (sym
))
1272 as_bad (_("symbol `%s' is already defined"), name
);
1276 S_SET_SEGMENT (sym
, undefined_section
);
1277 S_SET_VALUE (sym
, 0);
1278 symbol_set_frag (sym
, &zero_address_frag
);
1284 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1285 (void) restore_line_pointer (c
);
1289 SKIP_WHITESPACE_AFTER_NAME ();
1292 demand_empty_rest_of_line ();
1293 dwarf2_loc_directive_seen
= TRUE
;
1294 debug_type
= DEBUG_NONE
;
1296 /* If we were given a view id, emit the row right away. */
1298 dwarf2_emit_insn (0);
1302 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1304 offsetT value
= get_absolute_expression ();
1306 if (value
!= 0 && value
!= 1)
1308 as_bad (_("expected 0 or 1"));
1309 ignore_rest_of_line ();
1313 dwarf2_loc_mark_labels
= value
!= 0;
1314 demand_empty_rest_of_line ();
1318 static struct frag
*
1319 first_frag_for_seg (segT seg
)
1321 return seg_info (seg
)->frchainP
->frch_root
;
1324 static struct frag
*
1325 last_frag_for_seg (segT seg
)
1327 frchainS
*f
= seg_info (seg
)->frchainP
;
1329 while (f
->frch_next
!= NULL
)
1332 return f
->frch_last
;
1335 /* Emit a single byte into the current segment. */
1340 FRAG_APPEND_1_CHAR (byte
);
1343 /* Emit a statement program opcode into the current segment. */
1346 out_opcode (int opc
)
1351 /* Emit a two-byte word into the current segment. */
1356 md_number_to_chars (frag_more (2), data
, 2);
1359 /* Emit a four byte word into the current segment. */
1364 md_number_to_chars (frag_more (4), data
, 4);
1367 /* Emit an unsigned "little-endian base 128" number. */
1370 out_uleb128 (addressT value
)
1372 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1375 /* Emit a signed "little-endian base 128" number. */
1378 out_leb128 (addressT value
)
1380 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1383 /* Emit a tuple for .debug_abbrev. */
1386 out_abbrev (int name
, int form
)
1392 /* Get the size of a fragment. */
1395 get_frag_fix (fragS
*frag
, segT seg
)
1400 return frag
->fr_fix
;
1402 /* If a fragment is the last in the chain, special measures must be
1403 taken to find its size before relaxation, since it may be pending
1404 on some subsegment chain. */
1405 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1406 if (fr
->frch_last
== frag
)
1407 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1412 /* Set an absolute address (may result in a relocation entry). */
1415 out_set_addr (symbolS
*sym
)
1419 memset (&exp
, 0, sizeof exp
);
1420 out_opcode (DW_LNS_extended_op
);
1421 out_uleb128 (sizeof_address
+ 1);
1423 out_opcode (DW_LNE_set_address
);
1424 exp
.X_op
= O_symbol
;
1425 exp
.X_add_symbol
= sym
;
1426 exp
.X_add_number
= 0;
1427 emit_expr (&exp
, sizeof_address
);
1430 static void scale_addr_delta (addressT
*);
1433 scale_addr_delta (addressT
*addr_delta
)
1435 static int printed_this
= 0;
1436 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1438 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1440 as_bad("unaligned opcodes detected in executable segment");
1443 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1447 /* Encode a pair of line and address skips as efficiently as possible.
1448 Note that the line skip is signed, whereas the address skip is unsigned.
1450 The following two routines *must* be kept in sync. This is
1451 enforced by making emit_inc_line_addr abort if we do not emit
1452 exactly the expected number of bytes. */
1455 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1457 unsigned int tmp
, opcode
;
1460 /* Scale the address delta by the minimum instruction length. */
1461 scale_addr_delta (&addr_delta
);
1463 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1464 We cannot use special opcodes here, since we want the end_sequence
1465 to emit the matrix entry. */
1466 if (line_delta
== INT_MAX
)
1468 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1470 else if (addr_delta
)
1471 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1475 /* Bias the line delta by the base. */
1476 tmp
= line_delta
- DWARF2_LINE_BASE
;
1478 /* If the line increment is out of range of a special opcode, we
1479 must encode it with DW_LNS_advance_line. */
1480 if (tmp
>= DWARF2_LINE_RANGE
)
1482 len
= 1 + sizeof_leb128 (line_delta
, 1);
1484 tmp
= 0 - DWARF2_LINE_BASE
;
1487 /* Bias the opcode by the special opcode base. */
1488 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1490 /* Avoid overflow when addr_delta is large. */
1491 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1493 /* Try using a special opcode. */
1494 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1498 /* Try using DW_LNS_const_add_pc followed by special op. */
1499 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1504 /* Otherwise use DW_LNS_advance_pc. */
1505 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1507 /* DW_LNS_copy or special opcode. */
1514 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1516 unsigned int tmp
, opcode
;
1518 char *end
= p
+ len
;
1520 /* Line number sequences cannot go backward in addresses. This means
1521 we've incorrectly ordered the statements in the sequence. */
1522 gas_assert ((offsetT
) addr_delta
>= 0);
1524 /* Scale the address delta by the minimum instruction length. */
1525 scale_addr_delta (&addr_delta
);
1527 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1528 We cannot use special opcodes here, since we want the end_sequence
1529 to emit the matrix entry. */
1530 if (line_delta
== INT_MAX
)
1532 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1533 *p
++ = DW_LNS_const_add_pc
;
1534 else if (addr_delta
)
1536 *p
++ = DW_LNS_advance_pc
;
1537 p
+= output_leb128 (p
, addr_delta
, 0);
1540 *p
++ = DW_LNS_extended_op
;
1542 *p
++ = DW_LNE_end_sequence
;
1546 /* Bias the line delta by the base. */
1547 tmp
= line_delta
- DWARF2_LINE_BASE
;
1549 /* If the line increment is out of range of a special opcode, we
1550 must encode it with DW_LNS_advance_line. */
1551 if (tmp
>= DWARF2_LINE_RANGE
)
1553 *p
++ = DW_LNS_advance_line
;
1554 p
+= output_leb128 (p
, line_delta
, 1);
1557 tmp
= 0 - DWARF2_LINE_BASE
;
1561 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1563 if (line_delta
== 0 && addr_delta
== 0)
1569 /* Bias the opcode by the special opcode base. */
1570 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1572 /* Avoid overflow when addr_delta is large. */
1573 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1575 /* Try using a special opcode. */
1576 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1583 /* Try using DW_LNS_const_add_pc followed by special op. */
1584 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1587 *p
++ = DW_LNS_const_add_pc
;
1593 /* Otherwise use DW_LNS_advance_pc. */
1594 *p
++ = DW_LNS_advance_pc
;
1595 p
+= output_leb128 (p
, addr_delta
, 0);
1603 gas_assert (p
== end
);
1606 /* Handy routine to combine calls to the above two routines. */
1609 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1611 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1612 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1615 /* Write out an alternative form of line and address skips using
1616 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1617 line and address information, but it is required if linker relaxation
1618 could change the code offsets. The following two routines *must* be
1620 #define ADDR_DELTA_LIMIT 50000
1623 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1627 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1628 if (line_delta
!= INT_MAX
)
1629 len
= 1 + sizeof_leb128 (line_delta
, 1);
1631 if (addr_delta
> ADDR_DELTA_LIMIT
)
1633 /* DW_LNS_extended_op */
1634 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1635 /* DW_LNE_set_address */
1636 len
+= 1 + sizeof_address
;
1639 /* DW_LNS_fixed_advance_pc */
1642 if (line_delta
== INT_MAX
)
1643 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1653 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1657 char *end
= p
+ len
;
1659 /* Line number sequences cannot go backward in addresses. This means
1660 we've incorrectly ordered the statements in the sequence. */
1661 gas_assert ((offsetT
) addr_delta
>= 0);
1663 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1664 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1666 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1667 if (line_delta
!= INT_MAX
)
1669 *p
++ = DW_LNS_advance_line
;
1670 p
+= output_leb128 (p
, line_delta
, 1);
1673 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1675 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1676 advance the address by at most 64K. Linker relaxation (without
1677 which this function would not be used) could change the operand by
1678 an unknown amount. If the address increment is getting close to
1679 the limit, just reset the address. */
1680 if (addr_delta
> ADDR_DELTA_LIMIT
)
1685 memset (&exp
, 0, sizeof exp
);
1686 gas_assert (pexp
->X_op
== O_subtract
);
1687 to_sym
= pexp
->X_add_symbol
;
1689 *p
++ = DW_LNS_extended_op
;
1690 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1691 *p
++ = DW_LNE_set_address
;
1692 exp
.X_op
= O_symbol
;
1693 exp
.X_add_symbol
= to_sym
;
1694 exp
.X_add_number
= 0;
1695 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1696 p
+= sizeof_address
;
1700 *p
++ = DW_LNS_fixed_advance_pc
;
1701 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1705 if (line_delta
== INT_MAX
)
1707 *p
++ = DW_LNS_extended_op
;
1709 *p
++ = DW_LNE_end_sequence
;
1714 gas_assert (p
== end
);
1717 /* Generate a variant frag that we can use to relax address/line
1718 increments between fragments of the target segment. */
1721 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1726 memset (&exp
, 0, sizeof exp
);
1727 exp
.X_op
= O_subtract
;
1728 exp
.X_add_symbol
= to_sym
;
1729 exp
.X_op_symbol
= from_sym
;
1730 exp
.X_add_number
= 0;
1732 /* The maximum size of the frag is the line delta with a maximum
1733 sized address delta. */
1734 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1735 max_chars
= size_fixed_inc_line_addr (line_delta
,
1736 -DWARF2_LINE_MIN_INSN_LENGTH
);
1738 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1740 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1741 make_expr_symbol (&exp
), line_delta
, NULL
);
1744 /* The function estimates the size of a rs_dwarf2dbg variant frag
1745 based on the current values of the symbols. It is called before
1746 the relaxation loop. We set fr_subtype to the expected length. */
1749 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1754 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1755 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1756 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1758 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1760 frag
->fr_subtype
= size
;
1765 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1766 current values of the symbols. fr_subtype is the current length
1767 of the frag. This returns the change in frag length. */
1770 dwarf2dbg_relax_frag (fragS
*frag
)
1772 int old_size
, new_size
;
1774 old_size
= frag
->fr_subtype
;
1775 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1777 return new_size
- old_size
;
1780 /* This function converts a rs_dwarf2dbg variant frag into a normal
1781 fill frag. This is called after all relaxation has been done.
1782 fr_subtype will be the desired length of the frag. */
1785 dwarf2dbg_convert_frag (fragS
*frag
)
1789 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1791 /* If linker relaxation is enabled then the distance between the two
1792 symbols in the frag->fr_symbol expression might change. Hence we
1793 cannot rely upon the value computed by resolve_symbol_value.
1794 Instead we leave the expression unfinalized and allow
1795 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1796 relocation) that will allow the linker to correctly compute the
1797 actual address difference. We have to use a fixed line advance for
1798 this as we cannot (easily) relocate leb128 encoded values. */
1799 int saved_finalize_syms
= finalize_syms
;
1802 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1803 finalize_syms
= saved_finalize_syms
;
1806 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1808 /* fr_var carries the max_chars that we created the fragment with.
1809 fr_subtype carries the current expected length. We must, of
1810 course, have allocated enough memory earlier. */
1811 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1813 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1814 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1815 frag
->fr_literal
+ frag
->fr_fix
,
1818 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1819 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1821 frag
->fr_fix
+= frag
->fr_subtype
;
1822 frag
->fr_type
= rs_fill
;
1824 frag
->fr_offset
= 0;
1827 /* Generate .debug_line content for the chain of line number entries
1828 beginning at E, for segment SEG. */
1831 process_entries (segT seg
, struct line_entry
*e
)
1833 unsigned filenum
= 1;
1835 unsigned column
= 0;
1837 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1838 fragS
*last_frag
= NULL
, *frag
;
1839 addressT last_frag_ofs
= 0, frag_ofs
;
1840 symbolS
*last_lab
= NULL
, *lab
;
1841 struct line_entry
*next
;
1843 if (flag_dwarf_sections
)
1846 const char * sec_name
;
1848 /* Switch to the relevant sub-section before we start to emit
1849 the line number table.
1851 FIXME: These sub-sections do not have a normal Line Number
1852 Program Header, thus strictly speaking they are not valid
1853 DWARF sections. Unfortunately the DWARF standard assumes
1854 a one-to-one relationship between compilation units and
1855 line number tables. Thus we have to have a .debug_line
1856 section, as well as our sub-sections, and we have to ensure
1857 that all of the sub-sections are merged into a proper
1858 .debug_line section before a debugger sees them. */
1860 sec_name
= bfd_section_name (seg
);
1861 if (strcmp (sec_name
, ".text") != 0)
1863 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1864 subseg_set (subseg_get (name
, FALSE
), 0);
1867 /* Don't create a .debug_line.text section -
1868 that is redundant. Instead just switch back to the
1869 normal .debug_line section. */
1870 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1877 if (filenum
!= e
->loc
.filenum
)
1879 filenum
= e
->loc
.filenum
;
1880 out_opcode (DW_LNS_set_file
);
1881 out_uleb128 (filenum
);
1884 if (column
!= e
->loc
.column
)
1886 column
= e
->loc
.column
;
1887 out_opcode (DW_LNS_set_column
);
1888 out_uleb128 (column
);
1891 if (e
->loc
.discriminator
!= 0)
1893 out_opcode (DW_LNS_extended_op
);
1894 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1895 out_opcode (DW_LNE_set_discriminator
);
1896 out_uleb128 (e
->loc
.discriminator
);
1899 if (isa
!= e
->loc
.isa
)
1902 out_opcode (DW_LNS_set_isa
);
1906 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1908 flags
= e
->loc
.flags
;
1909 out_opcode (DW_LNS_negate_stmt
);
1912 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1913 out_opcode (DW_LNS_set_basic_block
);
1915 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1916 out_opcode (DW_LNS_set_prologue_end
);
1918 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1919 out_opcode (DW_LNS_set_epilogue_begin
);
1921 /* Don't try to optimize away redundant entries; gdb wants two
1922 entries for a function where the code starts on the same line as
1923 the {, and there's no way to identify that case here. Trust gcc
1924 to optimize appropriately. */
1925 line_delta
= e
->loc
.line
- line
;
1927 frag
= symbol_get_frag (lab
);
1928 frag_ofs
= S_GET_VALUE (lab
);
1930 if (last_frag
== NULL
1931 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1932 /* If we're going to reset the view, but we know we're
1933 advancing the PC, we don't have to force with
1934 set_address. We know we do when we're at the same
1935 address of the same frag, and we know we might when
1936 we're in the beginning of a frag, and we were at the
1937 end of the previous frag. */
1938 && (frag
== last_frag
1939 ? (last_frag_ofs
== frag_ofs
)
1941 && ((offsetT
)last_frag_ofs
1942 >= get_frag_fix (last_frag
, seg
))))))
1945 out_inc_line_addr (line_delta
, 0);
1947 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1948 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1950 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1955 last_frag_ofs
= frag_ofs
;
1963 /* Emit a DW_LNE_end_sequence for the end of the section. */
1964 frag
= last_frag_for_seg (seg
);
1965 frag_ofs
= get_frag_fix (frag
, seg
);
1966 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1967 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1970 lab
= symbol_temp_new (seg
, frag
, frag_ofs
);
1971 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1975 /* Emit the directory and file tables for .debug_line. */
1978 out_dir_and_file_list (void)
1984 bfd_boolean emit_md5
= FALSE
;
1985 bfd_boolean emit_timestamps
= TRUE
;
1986 bfd_boolean emit_filesize
= TRUE
;
1988 /* Output the Directory Table. */
1989 if (DWARF2_LINE_VERSION
>= 5)
1991 /* We only have one column in the directory table. */
1994 /* Describe the purpose and format of the column. */
1995 out_uleb128 (DW_LNCT_path
);
1996 /* FIXME: it would be better to store these strings in
1997 the .debug_line_str section and reference them here. */
1998 out_uleb128 (DW_FORM_string
);
2000 /* Now state how many rows there are in the table. We need at
2001 least 1 if there is one or more file names to store the
2002 "working directory". */
2003 if (dirs_in_use
== 0 && files_in_use
> 0)
2006 out_uleb128 (dirs_in_use
);
2009 /* Emit directory list. */
2010 if (DWARF2_LINE_VERSION
>= 5 && (dirs_in_use
> 0 || files_in_use
> 0))
2012 /* DWARF5 uses slot zero, but that is only set explicitly
2013 using a .file 0 directive. If that isn't used, but dir
2014 one is used, then use that as main file directory.
2015 Otherwise use pwd as main file directory. */
2016 if (dirs_in_use
> 0 && dirs
!= NULL
&& dirs
[0] != NULL
)
2017 dir
= remap_debug_filename (dirs
[0]);
2018 else if (dirs_in_use
> 1 && dirs
!= NULL
&& dirs
[1] != NULL
)
2019 dir
= remap_debug_filename (dirs
[1]);
2021 dir
= remap_debug_filename (getpwd ());
2023 size
= strlen (dir
) + 1;
2024 cp
= frag_more (size
);
2025 memcpy (cp
, dir
, size
);
2027 for (i
= 1; i
< dirs_in_use
; ++i
)
2029 dir
= remap_debug_filename (dirs
[i
]);
2030 size
= strlen (dir
) + 1;
2031 cp
= frag_more (size
);
2032 memcpy (cp
, dir
, size
);
2035 if (DWARF2_LINE_VERSION
< 5)
2039 /* Output the File Name Table. */
2040 if (DWARF2_LINE_VERSION
>= 5)
2042 unsigned int columns
= 4;
2044 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2046 emit_timestamps
= FALSE
;
2050 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2052 emit_filesize
= FALSE
;
2056 for (i
= 0; i
< files_in_use
; ++i
)
2057 if (files
[i
].md5
[0] != 0)
2059 if (i
< files_in_use
)
2065 /* The number of format entries to follow. */
2067 /* The format of the file name. */
2068 out_uleb128 (DW_LNCT_path
);
2069 /* FIXME: it would be better to store these strings in
2070 the .debug_line_str section and reference them here. */
2071 out_uleb128 (DW_FORM_string
);
2073 /* The format of the directory index. */
2074 out_uleb128 (DW_LNCT_directory_index
);
2075 out_uleb128 (DW_FORM_udata
);
2077 if (emit_timestamps
)
2079 /* The format of the timestamp. */
2080 out_uleb128 (DW_LNCT_timestamp
);
2081 out_uleb128 (DW_FORM_udata
);
2086 /* The format of the file size. */
2087 out_uleb128 (DW_LNCT_size
);
2088 out_uleb128 (DW_FORM_udata
);
2093 /* The format of the MD5 sum. */
2094 out_uleb128 (DW_LNCT_MD5
);
2095 out_uleb128 (DW_FORM_data16
);
2098 /* The number of entries in the table. */
2099 out_uleb128 (files_in_use
);
2102 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2104 const char *fullfilename
;
2106 if (files
[i
].filename
== NULL
)
2108 /* Prevent a crash later, particularly for file 1. DWARF5
2109 uses slot zero, but that is only set explicitly using a
2110 .file 0 directive. If that isn't used, but file 1 is,
2111 then use that as main file name. */
2112 if (DWARF2_LINE_VERSION
>= 5 && i
== 0 && files_in_use
>= 1)
2113 files
[0].filename
= files
[1].filename
;
2115 files
[i
].filename
= "";
2116 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2118 as_bad (_("unassigned file number %ld"), (long) i
);
2123 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2124 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2125 size
= strlen (fullfilename
) + 1;
2126 cp
= frag_more (size
);
2127 memcpy (cp
, fullfilename
, size
);
2129 /* Directory number. */
2130 out_uleb128 (files
[i
].dir
);
2132 /* Output the last modification timestamp. */
2133 if (emit_timestamps
)
2137 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2138 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2139 if (timestamp
== -1)
2141 out_uleb128 (timestamp
);
2144 /* Output the filesize. */
2148 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2149 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2152 out_uleb128 (filesize
);
2155 /* Output the md5 sum. */
2160 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2161 out_byte (files
[i
].md5
[b
]);
2165 if (DWARF2_LINE_VERSION
< 5)
2166 /* Terminate filename list. */
2170 /* Switch to SEC and output a header length field. Return the size of
2171 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2172 to the end of the section. EXPR->X_add_number will be set to the
2173 negative size of the header. */
2176 out_header (asection
*sec
, expressionS
*exp
)
2181 subseg_set (sec
, 0);
2183 if (flag_dwarf_sections
)
2185 /* If we are going to put the start and end symbols in different
2186 sections, then we need real symbols, not just fake, local ones. */
2188 start_sym
= symbol_make (".Ldebug_line_start");
2189 end_sym
= symbol_make (".Ldebug_line_end");
2190 symbol_set_value_now (start_sym
);
2194 start_sym
= symbol_temp_new_now_octets ();
2195 end_sym
= symbol_temp_make ();
2198 /* Total length of the information. */
2199 exp
->X_op
= O_subtract
;
2200 exp
->X_add_symbol
= end_sym
;
2201 exp
->X_op_symbol
= start_sym
;
2203 switch (DWARF2_FORMAT (sec
))
2205 case dwarf2_format_32bit
:
2206 exp
->X_add_number
= -4;
2210 case dwarf2_format_64bit
:
2211 exp
->X_add_number
= -12;
2216 case dwarf2_format_64bit_irix
:
2217 exp
->X_add_number
= -8;
2222 as_fatal (_("internal error: unknown dwarf2 format"));
2226 /* Emit the collected .debug_line data. */
2229 out_debug_line (segT line_seg
)
2232 symbolS
*prologue_start
, *prologue_end
;
2237 memset (&exp
, 0, sizeof exp
);
2238 sizeof_offset
= out_header (line_seg
, &exp
);
2239 line_end
= exp
.X_add_symbol
;
2242 out_two (DWARF2_LINE_VERSION
);
2244 if (DWARF2_LINE_VERSION
>= 5)
2246 out_byte (sizeof_address
);
2247 out_byte (0); /* Segment Selector size. */
2249 /* Length of the prologue following this length. */
2250 prologue_start
= symbol_temp_make ();
2251 prologue_end
= symbol_temp_make ();
2252 exp
.X_op
= O_subtract
;
2253 exp
.X_add_symbol
= prologue_end
;
2254 exp
.X_op_symbol
= prologue_start
;
2255 exp
.X_add_number
= 0;
2256 emit_expr (&exp
, sizeof_offset
);
2257 symbol_set_value_now (prologue_start
);
2259 /* Parameters of the state machine. */
2260 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2261 if (DWARF2_LINE_VERSION
>= 4)
2262 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2263 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2264 out_byte (DWARF2_LINE_BASE
);
2265 out_byte (DWARF2_LINE_RANGE
);
2266 out_byte (DWARF2_LINE_OPCODE_BASE
);
2268 /* Standard opcode lengths. */
2269 out_byte (0); /* DW_LNS_copy */
2270 out_byte (1); /* DW_LNS_advance_pc */
2271 out_byte (1); /* DW_LNS_advance_line */
2272 out_byte (1); /* DW_LNS_set_file */
2273 out_byte (1); /* DW_LNS_set_column */
2274 out_byte (0); /* DW_LNS_negate_stmt */
2275 out_byte (0); /* DW_LNS_set_basic_block */
2276 out_byte (0); /* DW_LNS_const_add_pc */
2277 out_byte (1); /* DW_LNS_fixed_advance_pc */
2278 out_byte (0); /* DW_LNS_set_prologue_end */
2279 out_byte (0); /* DW_LNS_set_epilogue_begin */
2280 out_byte (1); /* DW_LNS_set_isa */
2281 /* We have emitted 12 opcode lengths, so make that this
2282 matches up to the opcode base value we have been using. */
2283 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2285 out_dir_and_file_list ();
2287 symbol_set_value_now (prologue_end
);
2289 /* For each section, emit a statement program. */
2290 for (s
= all_segs
; s
; s
= s
->next
)
2291 if (SEG_NORMAL (s
->seg
))
2292 process_entries (s
->seg
, s
->head
->head
);
2294 as_warn ("dwarf line number information for %s ignored",
2295 segment_name (s
->seg
));
2297 if (flag_dwarf_sections
)
2298 /* We have to switch to the special .debug_line_end section
2299 before emitting the end-of-debug_line symbol. The linker
2300 script arranges for this section to be placed after all the
2301 (potentially garbage collected) .debug_line.<foo> sections.
2302 This section contains the line_end symbol which is used to
2303 compute the size of the linked .debug_line section, as seen
2304 in the DWARF Line Number header. */
2305 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2307 symbol_set_value_now (line_end
);
2311 out_debug_ranges (segT ranges_seg
, symbolS
**ranges_sym
)
2313 unsigned int addr_size
= sizeof_address
;
2318 memset (&exp
, 0, sizeof exp
);
2319 subseg_set (ranges_seg
, 0);
2321 /* For DW_AT_ranges to point at (there is no header, so really start
2322 of section, but see out_debug_rnglists). */
2323 *ranges_sym
= symbol_temp_new_now_octets ();
2325 /* Base Address Entry. */
2326 for (i
= 0; i
< addr_size
; i
++)
2328 for (i
= 0; i
< addr_size
; i
++)
2331 /* Range List Entry. */
2332 for (s
= all_segs
; s
; s
= s
->next
)
2337 frag
= first_frag_for_seg (s
->seg
);
2338 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2339 s
->text_start
= beg
;
2341 frag
= last_frag_for_seg (s
->seg
);
2342 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2345 exp
.X_op
= O_symbol
;
2346 exp
.X_add_symbol
= beg
;
2347 exp
.X_add_number
= 0;
2348 emit_expr (&exp
, addr_size
);
2350 exp
.X_op
= O_symbol
;
2351 exp
.X_add_symbol
= end
;
2352 exp
.X_add_number
= 0;
2353 emit_expr (&exp
, addr_size
);
2356 /* End of Range Entry. */
2357 for (i
= 0; i
< addr_size
; i
++)
2359 for (i
= 0; i
< addr_size
; i
++)
2364 out_debug_rnglists (segT ranges_seg
, symbolS
**ranges_sym
)
2367 symbolS
*ranges_end
;
2371 memset (&exp
, 0, sizeof exp
);
2372 out_header (ranges_seg
, &exp
);
2373 ranges_end
= exp
.X_add_symbol
;
2375 out_two (DWARF2_RNGLISTS_VERSION
);
2376 out_byte (sizeof_address
);
2377 out_byte (0); /* Segment Selector size. */
2378 out_four (0); /* Offset entry count. */
2380 /* For DW_AT_ranges to point at (must be after the header). */
2381 *ranges_sym
= symbol_temp_new_now_octets ();
2383 for (s
= all_segs
; s
; s
= s
->next
)
2388 out_byte (DW_RLE_start_length
);
2390 frag
= first_frag_for_seg (s
->seg
);
2391 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2392 s
->text_start
= beg
;
2394 frag
= last_frag_for_seg (s
->seg
);
2395 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2398 exp
.X_op
= O_symbol
;
2399 exp
.X_add_symbol
= beg
;
2400 exp
.X_add_number
= 0;
2401 emit_expr (&exp
, sizeof_address
);
2403 exp
.X_op
= O_symbol
;
2404 exp
.X_add_symbol
= end
;
2405 exp
.X_add_number
= 0;
2406 emit_leb128_expr (&exp
, 0);
2409 out_byte (DW_RLE_end_of_list
);
2411 symbol_set_value_now (ranges_end
);
2414 /* Emit data for .debug_aranges. */
2417 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2419 unsigned int addr_size
= sizeof_address
;
2423 symbolS
*aranges_end
;
2427 memset (&exp
, 0, sizeof exp
);
2428 sizeof_offset
= out_header (aranges_seg
, &exp
);
2429 aranges_end
= exp
.X_add_symbol
;
2430 size
= -exp
.X_add_number
;
2433 out_two (DWARF2_ARANGES_VERSION
);
2436 /* Offset to .debug_info. */
2437 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2438 size
+= sizeof_offset
;
2440 /* Size of an address (offset portion). */
2441 out_byte (addr_size
);
2444 /* Size of a segment descriptor. */
2448 /* Align the header. */
2449 while ((size
++ % (2 * addr_size
)) > 0)
2452 for (s
= all_segs
; s
; s
= s
->next
)
2457 frag
= first_frag_for_seg (s
->seg
);
2458 beg
= symbol_temp_new (s
->seg
, frag
, 0);
2459 s
->text_start
= beg
;
2461 frag
= last_frag_for_seg (s
->seg
);
2462 end
= symbol_temp_new (s
->seg
, frag
, get_frag_fix (frag
, s
->seg
));
2465 exp
.X_op
= O_symbol
;
2466 exp
.X_add_symbol
= beg
;
2467 exp
.X_add_number
= 0;
2468 emit_expr (&exp
, addr_size
);
2470 exp
.X_op
= O_subtract
;
2471 exp
.X_add_symbol
= end
;
2472 exp
.X_op_symbol
= beg
;
2473 exp
.X_add_number
= 0;
2474 emit_expr (&exp
, addr_size
);
2477 p
= frag_more (2 * addr_size
);
2478 md_number_to_chars (p
, 0, addr_size
);
2479 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2481 symbol_set_value_now (aranges_end
);
2484 /* Emit data for .debug_abbrev. Note that this must be kept in
2485 sync with out_debug_info below. */
2488 out_debug_abbrev (segT abbrev_seg
,
2489 segT info_seg ATTRIBUTE_UNUSED
,
2490 segT line_seg ATTRIBUTE_UNUSED
)
2493 subseg_set (abbrev_seg
, 0);
2496 out_uleb128 (DW_TAG_compile_unit
);
2497 out_byte (DW_CHILDREN_no
);
2498 if (DWARF2_VERSION
< 4)
2500 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2501 secoff_form
= DW_FORM_data4
;
2503 secoff_form
= DW_FORM_data8
;
2506 secoff_form
= DW_FORM_sec_offset
;
2507 out_abbrev (DW_AT_stmt_list
, secoff_form
);
2508 if (all_segs
->next
== NULL
)
2510 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2511 if (DWARF2_VERSION
< 4)
2512 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2514 out_abbrev (DW_AT_high_pc
, DW_FORM_udata
);
2517 out_abbrev (DW_AT_ranges
, secoff_form
);
2518 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2519 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2520 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2521 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2524 /* Terminate the abbreviations for this compilation unit. */
2528 /* Emit a description of this compilation unit for .debug_info. */
2531 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
,
2532 symbolS
*ranges_sym
, symbolS
*name_sym
,
2533 symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2539 memset (&exp
, 0, sizeof exp
);
2540 sizeof_offset
= out_header (info_seg
, &exp
);
2541 info_end
= exp
.X_add_symbol
;
2543 /* DWARF version. */
2544 out_two (DWARF2_VERSION
);
2546 if (DWARF2_VERSION
< 5)
2548 /* .debug_abbrev offset */
2549 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2553 /* unit (header) type */
2554 out_byte (DW_UT_compile
);
2557 /* Target address size. */
2558 out_byte (sizeof_address
);
2560 if (DWARF2_VERSION
>= 5)
2562 /* .debug_abbrev offset */
2563 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2566 /* DW_TAG_compile_unit DIE abbrev */
2569 /* DW_AT_stmt_list */
2570 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2571 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2574 /* These two attributes are emitted if all of the code is contiguous. */
2575 if (all_segs
->next
== NULL
)
2578 exp
.X_op
= O_symbol
;
2579 exp
.X_add_symbol
= all_segs
->text_start
;
2580 exp
.X_add_number
= 0;
2581 emit_expr (&exp
, sizeof_address
);
2584 if (DWARF2_VERSION
< 4)
2585 exp
.X_op
= O_symbol
;
2588 exp
.X_op
= O_subtract
;
2589 exp
.X_op_symbol
= all_segs
->text_start
;
2591 exp
.X_add_symbol
= all_segs
->text_end
;
2592 exp
.X_add_number
= 0;
2593 if (DWARF2_VERSION
< 4)
2594 emit_expr (&exp
, sizeof_address
);
2596 emit_leb128_expr (&exp
, 0);
2600 /* This attribute is emitted if the code is disjoint. */
2602 TC_DWARF2_EMIT_OFFSET (ranges_sym
, sizeof_offset
);
2605 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2606 setup in out_debug_str below. */
2607 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2608 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2609 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2611 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2612 dwarf2 draft has no standard code for assembler. */
2613 out_two (DW_LANG_Mips_Assembler
);
2615 symbol_set_value_now (info_end
);
2618 /* Emit the three debug strings needed in .debug_str and setup symbols
2619 to them for use in out_debug_info. */
2621 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2622 symbolS
**producer_sym
)
2625 const char *comp_dir
;
2626 const char *dirname
;
2629 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2631 subseg_set (str_seg
, 0);
2633 /* DW_AT_name. We don't have the actual file name that was present
2634 on the command line, so assume files[first_file] is the main input file.
2635 We're not supposed to get called unless at least one line number
2636 entry was emitted, so this should always be defined. */
2637 *name_sym
= symbol_temp_new_now_octets ();
2638 if (files_in_use
== 0)
2640 if (files
[first_file
].dir
)
2642 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2643 len
= strlen (dirname
);
2645 /* Already has trailing slash. */
2646 p
= frag_more (len
);
2647 memcpy (p
, dirname
, len
);
2649 p
= frag_more (len
+ 1);
2650 memcpy (p
, dirname
, len
);
2651 INSERT_DIR_SEPARATOR (p
, len
);
2654 len
= strlen (files
[first_file
].filename
) + 1;
2655 p
= frag_more (len
);
2656 memcpy (p
, files
[first_file
].filename
, len
);
2658 /* DW_AT_comp_dir */
2659 *comp_dir_sym
= symbol_temp_new_now_octets ();
2660 comp_dir
= remap_debug_filename (getpwd ());
2661 len
= strlen (comp_dir
) + 1;
2662 p
= frag_more (len
);
2663 memcpy (p
, comp_dir
, len
);
2665 /* DW_AT_producer */
2666 *producer_sym
= symbol_temp_new_now_octets ();
2667 sprintf (producer
, "GNU AS %s", VERSION
);
2668 len
= strlen (producer
) + 1;
2669 p
= frag_more (len
);
2670 memcpy (p
, producer
, len
);
2676 last_seg_ptr
= &all_segs
;
2678 /* Select the default CIE version to produce here. The global
2679 starts with a value of -1 and will be modified to a valid value
2680 either by the user providing a command line option, or some
2681 targets will select their own default in md_after_parse_args. If
2682 we get here and the global still contains -1 then it is up to us
2683 to pick a sane default. The default we choose is 1, this is the
2684 CIE version gas has produced for a long time, and there seems no
2685 reason to change it yet. */
2686 if (flag_dwarf_cie_version
== -1)
2687 flag_dwarf_cie_version
= 1;
2691 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2692 were any .file/.loc directives, or --gdwarf2 was given, or if the
2693 file has a non-empty .debug_info section and an empty .debug_line
2694 section. If we emit .debug_line, and the .debug_info section is
2695 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2696 ALL_SEGS will be non-null if there were any .file/.loc directives,
2697 or --gdwarf2 was given and there were any located instructions
2701 dwarf2_finish (void)
2706 int emit_other_sections
= 0;
2707 int empty_debug_line
= 0;
2709 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2710 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2712 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2713 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2715 /* We can't construct a new debug_line section if we already have one.
2717 if (all_segs
&& !empty_debug_line
)
2718 as_fatal ("duplicate .debug_line sections");
2720 if ((!all_segs
&& emit_other_sections
)
2721 || (!emit_other_sections
&& !empty_debug_line
))
2722 /* If there is no line information and no non-empty .debug_info
2723 section, or if there is both a non-empty .debug_info and a non-empty
2724 .debug_line, then we do nothing. */
2727 /* Calculate the size of an address for the target machine. */
2728 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2730 /* Create and switch to the line number section. */
2731 line_seg
= subseg_new (".debug_line", 0);
2732 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2734 /* For each subsection, chain the debug entries together. */
2735 for (s
= all_segs
; s
; s
= s
->next
)
2737 struct line_subseg
*lss
= s
->head
;
2738 struct line_entry
**ptail
= lss
->ptail
;
2740 /* Reset the initial view of the first subsection of the
2742 if (lss
->head
&& lss
->head
->loc
.view
)
2743 set_or_check_view (lss
->head
, NULL
, NULL
);
2745 while ((lss
= lss
->next
) != NULL
)
2747 /* Link the first view of subsequent subsections to the
2749 if (lss
->head
&& lss
->head
->loc
.view
)
2750 set_or_check_view (lss
->head
,
2751 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2752 s
->head
? s
->head
->head
: NULL
);
2758 out_debug_line (line_seg
);
2760 /* If this is assembler generated line info, and there is no
2761 debug_info already, we need .debug_info, .debug_abbrev and
2762 .debug_str sections as well. */
2763 if (emit_other_sections
)
2768 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
, *ranges_sym
;
2770 gas_assert (all_segs
);
2772 info_seg
= subseg_new (".debug_info", 0);
2773 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2774 aranges_seg
= subseg_new (".debug_aranges", 0);
2775 str_seg
= subseg_new (".debug_str", 0);
2777 bfd_set_section_flags (info_seg
,
2778 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2779 bfd_set_section_flags (abbrev_seg
,
2780 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2781 bfd_set_section_flags (aranges_seg
,
2782 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2783 bfd_set_section_flags (str_seg
,
2784 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2785 | SEC_MERGE
| SEC_STRINGS
);
2786 str_seg
->entsize
= 1;
2788 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2790 if (all_segs
->next
== NULL
)
2794 if (DWARF2_VERSION
< 5)
2796 segT ranges_seg
= subseg_new (".debug_ranges", 0);
2797 bfd_set_section_flags (ranges_seg
, (SEC_READONLY
2800 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2801 out_debug_ranges (ranges_seg
, &ranges_sym
);
2805 segT rnglists_seg
= subseg_new (".debug_rnglists", 0);
2806 bfd_set_section_flags (rnglists_seg
, (SEC_READONLY
2809 out_debug_rnglists (rnglists_seg
, &ranges_sym
);
2813 out_debug_aranges (aranges_seg
, info_seg
);
2814 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2815 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2816 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_sym
,
2817 name_sym
, comp_dir_sym
, producer_sym
);
2821 /* Perform any deferred checks pertaining to debug information. */
2824 dwarf2dbg_final_check (void)
2826 /* Perform reset-view checks. Don't evaluate view_assert_failed
2827 recursively: it could be very deep. It's a chain of adds, with
2828 each chain element pointing to the next in X_add_symbol, and
2829 holding the check value in X_op_symbol. */
2830 while (view_assert_failed
)
2836 gas_assert (!symbol_resolved_p (view_assert_failed
));
2838 exp
= symbol_get_value_expression (view_assert_failed
);
2839 sym
= view_assert_failed
;
2841 /* If view_assert_failed looks like a compound check in the
2842 chain, break it up. */
2843 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2845 view_assert_failed
= exp
->X_add_symbol
;
2846 sym
= exp
->X_op_symbol
;
2849 view_assert_failed
= NULL
;
2851 failed
= resolve_symbol_value (sym
);
2852 if (!symbol_resolved_p (sym
) || failed
)
2854 as_bad (_("view number mismatch"));