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"
38 #ifdef HAVE_SYS_PARAM_H
39 #include <sys/param.h>
42 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
46 #include "dwarf2dbg.h"
47 #include <filenames.h>
49 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
50 /* We need to decide which character to use as a directory separator.
51 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
52 necessarily mean that the backslash character is the one to use.
53 Some environments, eg Cygwin, can support both naming conventions.
54 So we use the heuristic that we only need to use the backslash if
55 the path is an absolute path starting with a DOS style drive
56 selector. eg C: or D: */
57 # define INSERT_DIR_SEPARATOR(string, offset) \
62 && string[1] == ':') \
63 string [offset] = '\\'; \
65 string [offset] = '/'; \
69 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
73 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
76 #ifndef DWARF2_ADDR_SIZE
77 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
80 #ifndef DWARF2_FILE_NAME
81 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
84 #ifndef DWARF2_FILE_TIME_NAME
85 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
88 #ifndef DWARF2_FILE_SIZE_NAME
89 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
92 #ifndef DWARF2_VERSION
93 #define DWARF2_VERSION dwarf_level
96 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
97 #ifndef DWARF2_ARANGES_VERSION
98 #define DWARF2_ARANGES_VERSION 2
101 /* This implementation outputs version 3 .debug_line information. */
102 #ifndef DWARF2_LINE_VERSION
103 #define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
110 /* Since we can't generate the prolog until the body is complete, we
111 use three different subsegments for .debug_line: one holding the
112 prolog, one for the directory and filename info, and one for the
113 body ("statement program"). */
118 /* If linker relaxation might change offsets in the code, the DWARF special
119 opcodes and variable-length operands cannot be used. If this macro is
120 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
121 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
122 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
125 /* First special line opcode - leave room for the standard opcodes.
126 Note: If you want to change this, you'll have to update the
127 "standard_opcode_lengths" table that is emitted below in
129 #define DWARF2_LINE_OPCODE_BASE 13
131 #ifndef DWARF2_LINE_BASE
132 /* Minimum line offset in a special line info. opcode. This value
133 was chosen to give a reasonable range of values. */
134 # define DWARF2_LINE_BASE -5
137 /* Range of line offsets in a special line info. opcode. */
138 #ifndef DWARF2_LINE_RANGE
139 # define DWARF2_LINE_RANGE 14
142 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
143 /* Define the architecture-dependent minimum instruction length (in
144 bytes). This value should be rather too small than too big. */
145 # define DWARF2_LINE_MIN_INSN_LENGTH 1
148 /* Flag that indicates the initial value of the is_stmt_start flag. */
149 #define DWARF2_LINE_DEFAULT_IS_STMT 1
151 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
152 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
155 /* Given a special op, return the line skip amount. */
156 #define SPECIAL_LINE(op) \
157 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
159 /* Given a special op, return the address skip amount (in units of
160 DWARF2_LINE_MIN_INSN_LENGTH. */
161 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
163 /* The maximum address skip amount that can be encoded with a special op. */
164 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
166 #ifndef TC_PARSE_CONS_RETURN_NONE
167 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
172 struct line_entry
*next
;
174 struct dwarf2_line_info loc
;
177 /* Don't change the offset of next in line_entry. set_or_check_view
178 calls in dwarf2_gen_line_info_1 depend on it. */
179 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
184 struct line_subseg
*next
;
186 struct line_entry
*head
;
187 struct line_entry
**ptail
;
188 struct line_entry
**pmove_tail
;
193 struct line_seg
*next
;
195 struct line_subseg
*head
;
200 /* Collects data for all line table entries during assembly. */
201 static struct line_seg
*all_segs
;
202 static struct line_seg
**last_seg_ptr
;
204 #define NUM_MD5_BYTES 16
208 const char * filename
;
210 unsigned char md5
[NUM_MD5_BYTES
];
213 /* Table of files used by .debug_line. */
214 static struct file_entry
*files
;
215 static unsigned int files_in_use
;
216 static unsigned int files_allocated
;
218 /* Table of directories used by .debug_line. */
219 static char ** dirs
= NULL
;
220 static unsigned int dirs_in_use
= 0;
221 static unsigned int dirs_allocated
= 0;
223 /* TRUE when we've seen a .loc directive recently. Used to avoid
224 doing work when there's nothing to do. */
225 bfd_boolean dwarf2_loc_directive_seen
;
227 /* TRUE when we're supposed to set the basic block mark whenever a
229 bfd_boolean dwarf2_loc_mark_labels
;
231 /* Current location as indicated by the most recent .loc directive. */
232 static struct dwarf2_line_info current
=
235 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
239 /* This symbol is used to recognize view number forced resets in loc
241 static symbolS
*force_reset_view
;
243 /* This symbol evaluates to an expression that, if nonzero, indicates
244 some view assert check failed. */
245 static symbolS
*view_assert_failed
;
247 /* The size of an address on the target. */
248 static unsigned int sizeof_address
;
250 #ifndef TC_DWARF2_EMIT_OFFSET
251 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
253 /* Create an offset to .dwarf2_*. */
256 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
260 memset (&exp
, 0, sizeof exp
);
262 exp
.X_add_symbol
= symbol
;
263 exp
.X_add_number
= 0;
264 emit_expr (&exp
, size
);
268 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
270 static struct line_subseg
*
271 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
273 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
274 struct line_subseg
**pss
, *lss
;
281 s
= XNEW (struct line_seg
);
286 last_seg_ptr
= &s
->next
;
287 seg_info (seg
)->dwarf2_line_seg
= s
;
290 gas_assert (seg
== s
->seg
);
292 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
294 if (lss
->subseg
== subseg
)
296 if (lss
->subseg
> subseg
)
300 lss
= XNEW (struct line_subseg
);
302 lss
->subseg
= subseg
;
304 lss
->ptail
= &lss
->head
;
305 lss
->pmove_tail
= &lss
->head
;
312 /* (Un)reverse the line_entry list starting from H. */
314 static struct line_entry
*
315 reverse_line_entry_list (struct line_entry
*h
)
317 struct line_entry
*p
= NULL
, *e
, *n
;
319 for (e
= h
; e
; e
= n
)
328 /* Compute the view for E based on the previous entry P. If we
329 introduce an (undefined) view symbol for P, and H is given (P must
330 be the tail in this case), introduce view symbols for earlier list
331 entries as well, until one of them is constant. */
334 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
335 struct line_entry
*h
)
339 memset (&viewx
, 0, sizeof (viewx
));
340 viewx
.X_unsigned
= 1;
342 /* First, compute !(E->label > P->label), to tell whether or not
343 we're to reset the view number. If we can't resolve it to a
344 constant, keep it symbolic. */
345 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
347 viewx
.X_op
= O_constant
;
348 viewx
.X_add_number
= 0;
349 viewx
.X_add_symbol
= NULL
;
350 viewx
.X_op_symbol
= NULL
;
355 viewx
.X_add_number
= 0;
356 viewx
.X_add_symbol
= e
->label
;
357 viewx
.X_op_symbol
= p
->label
;
358 resolve_expression (&viewx
);
359 if (viewx
.X_op
== O_constant
)
360 viewx
.X_add_number
= !viewx
.X_add_number
;
363 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
364 viewx
.X_add_number
= 0;
365 viewx
.X_op_symbol
= NULL
;
366 viewx
.X_op
= O_logical_not
;
370 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
372 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
373 /* We can't compare the view numbers at this point, because in
374 VIEWX we've only determined whether we're to reset it so
376 if (viewx
.X_op
== O_constant
)
378 if (!value
->X_add_number
!= !viewx
.X_add_number
)
379 as_bad (_("view number mismatch"));
381 /* Record the expression to check it later. It is the result of
382 a logical not, thus 0 or 1. We just add up all such deferred
383 expressions, and resolve it at the end. */
384 else if (!value
->X_add_number
)
386 symbolS
*deferred
= make_expr_symbol (&viewx
);
387 if (view_assert_failed
)
391 memset (&chk
, 0, sizeof (chk
));
394 chk
.X_add_number
= 0;
395 chk
.X_add_symbol
= view_assert_failed
;
396 chk
.X_op_symbol
= deferred
;
397 deferred
= make_expr_symbol (&chk
);
399 view_assert_failed
= deferred
;
403 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
409 p
->loc
.view
= symbol_temp_make ();
410 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
413 memset (&incv
, 0, sizeof (incv
));
415 incv
.X_op
= O_symbol
;
416 incv
.X_add_symbol
= p
->loc
.view
;
417 incv
.X_add_number
= 1;
419 if (viewx
.X_op
== O_constant
)
421 gas_assert (viewx
.X_add_number
== 1);
426 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
427 viewx
.X_add_number
= 0;
428 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
429 viewx
.X_op
= O_multiply
;
433 if (!S_IS_DEFINED (e
->loc
.view
))
435 symbol_set_value_expression (e
->loc
.view
, &viewx
);
436 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
437 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
440 /* Define and attempt to simplify any earlier views needed to
442 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
444 struct line_entry
*h2
;
445 /* Reverse the list to avoid quadratic behavior going backwards
446 in a single-linked list. */
447 struct line_entry
*r
= reverse_line_entry_list (h
);
450 /* Set or check views until we find a defined or absent view. */
453 /* Do not define the head of a (sub?)segment view while
454 handling others. It would be defined too early, without
455 regard to the last view of other subsegments.
456 set_or_check_view will be called for every head segment
460 set_or_check_view (r
, r
->next
, NULL
);
462 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
465 /* Unreverse the list, so that we can go forward again. */
466 h2
= reverse_line_entry_list (p
);
467 gas_assert (h2
== h
);
469 /* Starting from the last view we just defined, attempt to
470 simplify the view expressions, until we do so to P. */
473 /* The head view of a subsegment may remain undefined while
474 handling other elements, before it is linked to the last
475 view of the previous subsegment. */
478 gas_assert (S_IS_DEFINED (r
->loc
.view
));
479 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
481 while (r
!= p
&& (r
= r
->next
));
483 /* Now that we've defined and computed all earlier views that might
484 be needed to compute E's, attempt to simplify it. */
485 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
489 /* Record an entry for LOC occurring at LABEL. */
492 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
494 struct line_subseg
*lss
;
495 struct line_entry
*e
;
497 e
= XNEW (struct line_entry
);
502 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
504 /* Subseg heads are chained to previous subsegs in
506 if (loc
->view
&& lss
->head
)
507 set_or_check_view (e
,
508 (struct line_entry
*)lss
->ptail
,
512 lss
->ptail
= &e
->next
;
515 /* Record an entry for LOC occurring at OFS within the current fragment. */
518 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
520 static unsigned int line
= -1;
521 static unsigned int filenum
= -1;
525 /* Early out for as-yet incomplete location information. */
528 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
531 /* Don't emit sequences of line symbols for the same line when the
532 symbols apply to assembler code. It is necessary to emit
533 duplicate line symbols when a compiler asks for them, because GDB
534 uses them to determine the end of the prologue. */
535 if (debug_type
== DEBUG_DWARF2
536 && line
== loc
->line
&& filenum
== loc
->filenum
)
540 filenum
= loc
->filenum
;
546 /* Use a non-fake name for the line number location,
547 so that it can be referred to by relocations. */
548 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
549 sym
= symbol_new (name
, now_seg
, ofs
, frag_now
);
552 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
553 dwarf2_gen_line_info_1 (sym
, loc
);
557 get_basename (const char * pathname
)
561 file
= lbasename (pathname
);
562 /* Don't make empty string from / or A: from A:/ . */
563 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
564 if (file
<= pathname
+ 3)
567 if (file
== pathname
+ 1)
574 get_directory_table_entry (const char * dirname
,
576 bfd_boolean can_use_zero
)
583 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
584 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
592 for (d
= 0; d
< dirs_in_use
; ++d
)
595 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
596 && dirs
[d
][dirlen
] == '\0')
602 if (dirs
== NULL
|| dirs
[0] == NULL
)
608 if (d
>= dirs_allocated
)
610 unsigned int old
= dirs_allocated
;
612 dirs_allocated
= d
+ 32;
613 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
614 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
617 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
618 if (dirs_in_use
<= d
)
624 /* Get a .debug_line file number for PATHNAME. If there is a
625 directory component to PATHNAME, then this will be stored
626 in the directory table, if it is not already present.
627 Returns the slot number allocated to that filename or -1
628 if there was a problem. */
631 allocate_filenum (const char * pathname
)
633 static signed int last_used
= -1, last_used_dir_len
= 0;
638 /* Short circuit the common case of adding the same pathname
642 const char * dirname
= NULL
;
645 dirname
= dirs
[files
[last_used
].dir
];
649 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
654 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
655 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
656 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
657 files
[last_used
].filename
) == 0)
662 file
= get_basename (pathname
);
663 dir_len
= file
- pathname
;
665 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
667 /* Do not use slot-0. That is specificailly reserved for use by
668 the '.file 0 "name"' directive. */
669 for (i
= 1; i
< files_in_use
; ++i
)
670 if (files
[i
].dir
== dir
672 && filename_cmp (file
, files
[i
].filename
) == 0)
675 last_used_dir_len
= dir_len
;
679 if (i
>= files_allocated
)
681 unsigned int old
= files_allocated
;
683 files_allocated
= i
+ 32;
684 /* Catch wraparound. */
685 if (files_allocated
<= old
)
687 as_bad (_("file number %lu is too big"), (unsigned long) i
);
691 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
692 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
695 files
[i
].filename
= file
;
697 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
699 if (files_in_use
< i
+ 1)
700 files_in_use
= i
+ 1;
702 last_used_dir_len
= dir_len
;
707 /* Allocate slot NUM in the .debug_line file table to FILENAME.
708 If DIRNAME is not NULL or there is a directory component to FILENAME
709 then this will be stored in the directory table, if not already present.
710 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
711 Returns TRUE if allocation succeeded, FALSE otherwise. */
714 allocate_filename_to_slot (const char * dirname
,
715 const char * filename
,
717 bfd_boolean with_md5
)
723 /* Short circuit the common case of adding the same pathname
725 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
727 const char * dir
= NULL
;
730 dir
= dirs
[files
[num
].dir
];
733 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
738 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
741 if (filename_cmp (filename
, files
[num
].filename
) != 0)
744 /* If the filenames match, but the directory table entry was
745 empty, then fill it with the provided directory name. */
747 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
751 else if (dir
!= NULL
)
753 dirlen
= strlen (dir
);
754 if (filename_ncmp (filename
, dir
, dirlen
) == 0
755 && IS_DIR_SEPARATOR (filename
[dirlen
])
756 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
759 else /* dir == NULL */
761 file
= get_basename (filename
);
762 if (filename_cmp (file
, files
[num
].filename
) == 0)
765 /* The filenames match, but the directory table entry is empty.
766 Fill it with the provided directory name. */
767 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
773 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
775 dir
== NULL
? "" : dir
,
776 dir
== NULL
? "" : "/",
778 dirname
== NULL
? "" : dirname
,
779 dirname
== NULL
? "" : "/",
787 file
= get_basename (filename
);
788 dirlen
= file
- filename
;
792 dirlen
= strlen (dirname
);
796 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
799 if (i
>= files_allocated
)
801 unsigned int old
= files_allocated
;
803 files_allocated
= i
+ 32;
804 /* Catch wraparound. */
805 if (files_allocated
<= old
)
807 as_bad (_("file number %lu is too big"), (unsigned long) i
);
811 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
812 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
815 files
[i
].filename
= file
;
819 if (target_big_endian
)
821 /* md5's are stored in litte endian format. */
822 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
823 unsigned int byte
= NUM_MD5_BYTES
;
824 unsigned int bignum_index
= 0;
826 while (bits_remaining
)
828 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
829 valueT bignum_value
= generic_bignum
[bignum_index
];
832 while (bignum_bits_remaining
)
834 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
836 bignum_bits_remaining
-= 8;
843 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
844 unsigned int byte
= 0;
845 unsigned int bignum_index
= 0;
847 while (bits_remaining
)
849 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
850 valueT bignum_value
= generic_bignum
[bignum_index
];
854 while (bignum_bits_remaining
)
856 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
858 bignum_bits_remaining
-= 8;
865 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
867 if (files_in_use
< i
+ 1)
868 files_in_use
= i
+ 1;
873 /* Returns the current source information. If .file directives have
874 been encountered, the info for the corresponding source file is
875 returned. Otherwise, the info for the assembly source file is
879 dwarf2_where (struct dwarf2_line_info
*line
)
881 if (debug_type
== DEBUG_DWARF2
)
883 const char *filename
;
885 memset (line
, 0, sizeof (*line
));
886 filename
= as_where (&line
->line
);
887 line
->filenum
= allocate_filenum (filename
);
888 /* FIXME: We should check the return value from allocate_filenum. */
890 line
->flags
= DWARF2_FLAG_IS_STMT
;
891 line
->isa
= current
.isa
;
892 line
->discriminator
= current
.discriminator
;
899 /* A hook to allow the target backend to inform the line number state
900 machine of isa changes when assembler debug info is enabled. */
903 dwarf2_set_isa (unsigned int isa
)
908 /* Called for each machine instruction, or relatively atomic group of
909 machine instructions (ie built-in macro). The instruction or group
910 is SIZE bytes in length. If dwarf2 line number generation is called
911 for, emit a line statement appropriately. */
914 dwarf2_emit_insn (int size
)
916 struct dwarf2_line_info loc
;
918 if (debug_type
!= DEBUG_DWARF2
919 ? !dwarf2_loc_directive_seen
920 : !seen_at_least_1_file ())
925 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
926 dwarf2_consume_line_info ();
929 /* Move all previously-emitted line entries for the current position by
930 DELTA bytes. This function cannot be used to move the same entries
934 dwarf2_move_insn (int delta
)
936 struct line_subseg
*lss
;
937 struct line_entry
*e
;
943 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
947 now
= frag_now_fix ();
948 while ((e
= *lss
->pmove_tail
))
950 if (S_GET_VALUE (e
->label
) == now
)
951 S_SET_VALUE (e
->label
, now
+ delta
);
952 lss
->pmove_tail
= &e
->next
;
956 /* Called after the current line information has been either used with
957 dwarf2_gen_line_info or saved with a machine instruction for later use.
958 This resets the state of the line number information to reflect that
962 dwarf2_consume_line_info (void)
964 /* Unless we generate DWARF2 debugging information for each
965 assembler line, we only emit one line symbol for one LOC. */
966 dwarf2_loc_directive_seen
= FALSE
;
968 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
969 | DWARF2_FLAG_PROLOGUE_END
970 | DWARF2_FLAG_EPILOGUE_BEGIN
);
971 current
.discriminator
= 0;
975 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
976 is enabled, emit a basic block marker. */
979 dwarf2_emit_label (symbolS
*label
)
981 struct dwarf2_line_info loc
;
983 if (!dwarf2_loc_mark_labels
)
985 if (S_GET_SEGMENT (label
) != now_seg
)
987 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
989 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
994 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
996 dwarf2_gen_line_info_1 (label
, &loc
);
997 dwarf2_consume_line_info ();
1000 /* Handle two forms of .file directive:
1001 - Pass .file "source.c" to s_app_file
1002 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1004 If an entry is added to the file table, return a pointer to the filename. */
1007 dwarf2_directive_filename (void)
1009 bfd_boolean with_md5
= TRUE
;
1012 const char * dirname
= NULL
;
1015 /* Continue to accept a bare string and pass it off. */
1017 if (*input_line_pointer
== '"')
1023 num
= get_absolute_expression ();
1025 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1027 as_bad (_("file number less than one"));
1028 ignore_rest_of_line ();
1032 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1033 "switch back to the already allocated file <N> as the current
1036 filename
= demand_copy_C_string (&filename_len
);
1037 if (filename
== NULL
)
1038 /* demand_copy_C_string will have already generated an error message. */
1041 /* For DWARF-5 support we also accept:
1042 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1043 if (DWARF2_LINE_VERSION
> 4)
1046 if (*input_line_pointer
== '"')
1049 filename
= demand_copy_C_string (&filename_len
);
1053 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1055 input_line_pointer
+= 3;
1059 expression_and_evaluate (& exp
);
1060 if (exp
.X_op
!= O_big
)
1061 as_bad (_("md5 value too small or not a constant"));
1067 demand_empty_rest_of_line ();
1069 /* A .file directive implies compiler generated debug information is
1070 being supplied. Turn off gas generated debug info. */
1071 debug_type
= DEBUG_NONE
;
1073 if (num
!= (unsigned int) num
1074 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1076 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1080 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1087 /* Calls dwarf2_directive_filename, but discards its result.
1088 Used in pseudo-op tables where the function result is ignored. */
1091 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1093 (void) dwarf2_directive_filename ();
1097 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1099 offsetT filenum
, line
;
1101 /* If we see two .loc directives in a row, force the first one to be
1103 if (dwarf2_loc_directive_seen
)
1104 dwarf2_emit_insn (0);
1106 filenum
= get_absolute_expression ();
1108 line
= get_absolute_expression ();
1112 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1114 as_bad (_("file number less than one"));
1119 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1121 as_bad (_("unassigned file number %ld"), (long) filenum
);
1125 current
.filenum
= filenum
;
1126 current
.line
= line
;
1127 current
.discriminator
= 0;
1132 if (files
[filenum
].dir
)
1134 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1135 size_t file_len
= strlen (files
[filenum
].filename
);
1136 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1138 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1139 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1140 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1141 cp
[dir_len
+ file_len
+ 1] = '\0';
1142 listing_source_file (cp
);
1146 listing_source_file (files
[filenum
].filename
);
1147 listing_source_line (line
);
1152 if (ISDIGIT (*input_line_pointer
))
1154 current
.column
= get_absolute_expression ();
1158 while (ISALPHA (*input_line_pointer
))
1163 c
= get_symbol_name (& p
);
1165 if (strcmp (p
, "basic_block") == 0)
1167 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1168 *input_line_pointer
= c
;
1170 else if (strcmp (p
, "prologue_end") == 0)
1172 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1173 *input_line_pointer
= c
;
1175 else if (strcmp (p
, "epilogue_begin") == 0)
1177 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1178 *input_line_pointer
= c
;
1180 else if (strcmp (p
, "is_stmt") == 0)
1182 (void) restore_line_pointer (c
);
1183 value
= get_absolute_expression ();
1185 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1186 else if (value
== 1)
1187 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1190 as_bad (_("is_stmt value not 0 or 1"));
1194 else if (strcmp (p
, "isa") == 0)
1196 (void) restore_line_pointer (c
);
1197 value
= get_absolute_expression ();
1199 current
.isa
= value
;
1202 as_bad (_("isa number less than zero"));
1206 else if (strcmp (p
, "discriminator") == 0)
1208 (void) restore_line_pointer (c
);
1209 value
= get_absolute_expression ();
1211 current
.discriminator
= value
;
1214 as_bad (_("discriminator less than zero"));
1218 else if (strcmp (p
, "view") == 0)
1222 (void) restore_line_pointer (c
);
1225 if (ISDIGIT (*input_line_pointer
)
1226 || *input_line_pointer
== '-')
1228 bfd_boolean force_reset
= *input_line_pointer
== '-';
1230 value
= get_absolute_expression ();
1233 as_bad (_("numeric view can only be asserted to zero"));
1236 if (force_reset
&& force_reset_view
)
1237 sym
= force_reset_view
;
1240 sym
= symbol_temp_new (absolute_section
, value
,
1241 &zero_address_frag
);
1243 force_reset_view
= sym
;
1248 char *name
= read_symbol_name ();
1252 sym
= symbol_find_or_make (name
);
1253 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1255 if (S_IS_VOLATILE (sym
))
1256 sym
= symbol_clone (sym
, 1);
1257 else if (!S_CAN_BE_REDEFINED (sym
))
1259 as_bad (_("symbol `%s' is already defined"), name
);
1263 S_SET_SEGMENT (sym
, undefined_section
);
1264 S_SET_VALUE (sym
, 0);
1265 symbol_set_frag (sym
, &zero_address_frag
);
1271 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1272 (void) restore_line_pointer (c
);
1276 SKIP_WHITESPACE_AFTER_NAME ();
1279 demand_empty_rest_of_line ();
1280 dwarf2_loc_directive_seen
= TRUE
;
1281 debug_type
= DEBUG_NONE
;
1283 /* If we were given a view id, emit the row right away. */
1285 dwarf2_emit_insn (0);
1289 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1291 offsetT value
= get_absolute_expression ();
1293 if (value
!= 0 && value
!= 1)
1295 as_bad (_("expected 0 or 1"));
1296 ignore_rest_of_line ();
1300 dwarf2_loc_mark_labels
= value
!= 0;
1301 demand_empty_rest_of_line ();
1305 static struct frag
*
1306 first_frag_for_seg (segT seg
)
1308 return seg_info (seg
)->frchainP
->frch_root
;
1311 static struct frag
*
1312 last_frag_for_seg (segT seg
)
1314 frchainS
*f
= seg_info (seg
)->frchainP
;
1316 while (f
->frch_next
!= NULL
)
1319 return f
->frch_last
;
1322 /* Emit a single byte into the current segment. */
1327 FRAG_APPEND_1_CHAR (byte
);
1330 /* Emit a statement program opcode into the current segment. */
1333 out_opcode (int opc
)
1338 /* Emit a two-byte word into the current segment. */
1343 md_number_to_chars (frag_more (2), data
, 2);
1346 /* Emit a four byte word into the current segment. */
1351 md_number_to_chars (frag_more (4), data
, 4);
1354 /* Emit an unsigned "little-endian base 128" number. */
1357 out_uleb128 (addressT value
)
1359 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1362 /* Emit a signed "little-endian base 128" number. */
1365 out_leb128 (addressT value
)
1367 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1370 /* Emit a tuple for .debug_abbrev. */
1373 out_abbrev (int name
, int form
)
1379 /* Get the size of a fragment. */
1382 get_frag_fix (fragS
*frag
, segT seg
)
1387 return frag
->fr_fix
;
1389 /* If a fragment is the last in the chain, special measures must be
1390 taken to find its size before relaxation, since it may be pending
1391 on some subsegment chain. */
1392 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1393 if (fr
->frch_last
== frag
)
1394 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1399 /* Set an absolute address (may result in a relocation entry). */
1402 out_set_addr (symbolS
*sym
)
1406 memset (&exp
, 0, sizeof exp
);
1407 out_opcode (DW_LNS_extended_op
);
1408 out_uleb128 (sizeof_address
+ 1);
1410 out_opcode (DW_LNE_set_address
);
1411 exp
.X_op
= O_symbol
;
1412 exp
.X_add_symbol
= sym
;
1413 exp
.X_add_number
= 0;
1414 emit_expr (&exp
, sizeof_address
);
1417 static void scale_addr_delta (addressT
*);
1420 scale_addr_delta (addressT
*addr_delta
)
1422 static int printed_this
= 0;
1423 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1425 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1427 as_bad("unaligned opcodes detected in executable segment");
1430 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1434 /* Encode a pair of line and address skips as efficiently as possible.
1435 Note that the line skip is signed, whereas the address skip is unsigned.
1437 The following two routines *must* be kept in sync. This is
1438 enforced by making emit_inc_line_addr abort if we do not emit
1439 exactly the expected number of bytes. */
1442 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1444 unsigned int tmp
, opcode
;
1447 /* Scale the address delta by the minimum instruction length. */
1448 scale_addr_delta (&addr_delta
);
1450 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1451 We cannot use special opcodes here, since we want the end_sequence
1452 to emit the matrix entry. */
1453 if (line_delta
== INT_MAX
)
1455 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1457 else if (addr_delta
)
1458 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1462 /* Bias the line delta by the base. */
1463 tmp
= line_delta
- DWARF2_LINE_BASE
;
1465 /* If the line increment is out of range of a special opcode, we
1466 must encode it with DW_LNS_advance_line. */
1467 if (tmp
>= DWARF2_LINE_RANGE
)
1469 len
= 1 + sizeof_leb128 (line_delta
, 1);
1471 tmp
= 0 - DWARF2_LINE_BASE
;
1474 /* Bias the opcode by the special opcode base. */
1475 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1477 /* Avoid overflow when addr_delta is large. */
1478 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1480 /* Try using a special opcode. */
1481 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1485 /* Try using DW_LNS_const_add_pc followed by special op. */
1486 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1491 /* Otherwise use DW_LNS_advance_pc. */
1492 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1494 /* DW_LNS_copy or special opcode. */
1501 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1503 unsigned int tmp
, opcode
;
1505 char *end
= p
+ len
;
1507 /* Line number sequences cannot go backward in addresses. This means
1508 we've incorrectly ordered the statements in the sequence. */
1509 gas_assert ((offsetT
) addr_delta
>= 0);
1511 /* Scale the address delta by the minimum instruction length. */
1512 scale_addr_delta (&addr_delta
);
1514 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1515 We cannot use special opcodes here, since we want the end_sequence
1516 to emit the matrix entry. */
1517 if (line_delta
== INT_MAX
)
1519 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1520 *p
++ = DW_LNS_const_add_pc
;
1521 else if (addr_delta
)
1523 *p
++ = DW_LNS_advance_pc
;
1524 p
+= output_leb128 (p
, addr_delta
, 0);
1527 *p
++ = DW_LNS_extended_op
;
1529 *p
++ = DW_LNE_end_sequence
;
1533 /* Bias the line delta by the base. */
1534 tmp
= line_delta
- DWARF2_LINE_BASE
;
1536 /* If the line increment is out of range of a special opcode, we
1537 must encode it with DW_LNS_advance_line. */
1538 if (tmp
>= DWARF2_LINE_RANGE
)
1540 *p
++ = DW_LNS_advance_line
;
1541 p
+= output_leb128 (p
, line_delta
, 1);
1544 tmp
= 0 - DWARF2_LINE_BASE
;
1548 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1550 if (line_delta
== 0 && addr_delta
== 0)
1556 /* Bias the opcode by the special opcode base. */
1557 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1559 /* Avoid overflow when addr_delta is large. */
1560 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1562 /* Try using a special opcode. */
1563 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1570 /* Try using DW_LNS_const_add_pc followed by special op. */
1571 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1574 *p
++ = DW_LNS_const_add_pc
;
1580 /* Otherwise use DW_LNS_advance_pc. */
1581 *p
++ = DW_LNS_advance_pc
;
1582 p
+= output_leb128 (p
, addr_delta
, 0);
1590 gas_assert (p
== end
);
1593 /* Handy routine to combine calls to the above two routines. */
1596 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1598 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1599 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1602 /* Write out an alternative form of line and address skips using
1603 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1604 line and address information, but it is required if linker relaxation
1605 could change the code offsets. The following two routines *must* be
1607 #define ADDR_DELTA_LIMIT 50000
1610 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1614 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1615 if (line_delta
!= INT_MAX
)
1616 len
= 1 + sizeof_leb128 (line_delta
, 1);
1618 if (addr_delta
> ADDR_DELTA_LIMIT
)
1620 /* DW_LNS_extended_op */
1621 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1622 /* DW_LNE_set_address */
1623 len
+= 1 + sizeof_address
;
1626 /* DW_LNS_fixed_advance_pc */
1629 if (line_delta
== INT_MAX
)
1630 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1640 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1644 char *end
= p
+ len
;
1646 /* Line number sequences cannot go backward in addresses. This means
1647 we've incorrectly ordered the statements in the sequence. */
1648 gas_assert ((offsetT
) addr_delta
>= 0);
1650 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1651 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1653 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1654 if (line_delta
!= INT_MAX
)
1656 *p
++ = DW_LNS_advance_line
;
1657 p
+= output_leb128 (p
, line_delta
, 1);
1660 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1662 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1663 advance the address by at most 64K. Linker relaxation (without
1664 which this function would not be used) could change the operand by
1665 an unknown amount. If the address increment is getting close to
1666 the limit, just reset the address. */
1667 if (addr_delta
> ADDR_DELTA_LIMIT
)
1672 memset (&exp
, 0, sizeof exp
);
1673 gas_assert (pexp
->X_op
== O_subtract
);
1674 to_sym
= pexp
->X_add_symbol
;
1676 *p
++ = DW_LNS_extended_op
;
1677 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1678 *p
++ = DW_LNE_set_address
;
1679 exp
.X_op
= O_symbol
;
1680 exp
.X_add_symbol
= to_sym
;
1681 exp
.X_add_number
= 0;
1682 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1683 p
+= sizeof_address
;
1687 *p
++ = DW_LNS_fixed_advance_pc
;
1688 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1692 if (line_delta
== INT_MAX
)
1694 *p
++ = DW_LNS_extended_op
;
1696 *p
++ = DW_LNE_end_sequence
;
1701 gas_assert (p
== end
);
1704 /* Generate a variant frag that we can use to relax address/line
1705 increments between fragments of the target segment. */
1708 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1713 memset (&exp
, 0, sizeof exp
);
1714 exp
.X_op
= O_subtract
;
1715 exp
.X_add_symbol
= to_sym
;
1716 exp
.X_op_symbol
= from_sym
;
1717 exp
.X_add_number
= 0;
1719 /* The maximum size of the frag is the line delta with a maximum
1720 sized address delta. */
1721 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1722 max_chars
= size_fixed_inc_line_addr (line_delta
,
1723 -DWARF2_LINE_MIN_INSN_LENGTH
);
1725 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1727 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1728 make_expr_symbol (&exp
), line_delta
, NULL
);
1731 /* The function estimates the size of a rs_dwarf2dbg variant frag
1732 based on the current values of the symbols. It is called before
1733 the relaxation loop. We set fr_subtype to the expected length. */
1736 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1741 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1742 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1743 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1745 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1747 frag
->fr_subtype
= size
;
1752 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1753 current values of the symbols. fr_subtype is the current length
1754 of the frag. This returns the change in frag length. */
1757 dwarf2dbg_relax_frag (fragS
*frag
)
1759 int old_size
, new_size
;
1761 old_size
= frag
->fr_subtype
;
1762 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1764 return new_size
- old_size
;
1767 /* This function converts a rs_dwarf2dbg variant frag into a normal
1768 fill frag. This is called after all relaxation has been done.
1769 fr_subtype will be the desired length of the frag. */
1772 dwarf2dbg_convert_frag (fragS
*frag
)
1776 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1778 /* If linker relaxation is enabled then the distance between the two
1779 symbols in the frag->fr_symbol expression might change. Hence we
1780 cannot rely upon the value computed by resolve_symbol_value.
1781 Instead we leave the expression unfinalized and allow
1782 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1783 relocation) that will allow the linker to correctly compute the
1784 actual address difference. We have to use a fixed line advance for
1785 this as we cannot (easily) relocate leb128 encoded values. */
1786 int saved_finalize_syms
= finalize_syms
;
1789 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1790 finalize_syms
= saved_finalize_syms
;
1793 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1795 /* fr_var carries the max_chars that we created the fragment with.
1796 fr_subtype carries the current expected length. We must, of
1797 course, have allocated enough memory earlier. */
1798 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1800 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1801 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1802 frag
->fr_literal
+ frag
->fr_fix
,
1805 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1806 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1808 frag
->fr_fix
+= frag
->fr_subtype
;
1809 frag
->fr_type
= rs_fill
;
1811 frag
->fr_offset
= 0;
1814 /* Generate .debug_line content for the chain of line number entries
1815 beginning at E, for segment SEG. */
1818 process_entries (segT seg
, struct line_entry
*e
)
1820 unsigned filenum
= 1;
1822 unsigned column
= 0;
1824 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1825 fragS
*last_frag
= NULL
, *frag
;
1826 addressT last_frag_ofs
= 0, frag_ofs
;
1827 symbolS
*last_lab
= NULL
, *lab
;
1828 struct line_entry
*next
;
1830 if (flag_dwarf_sections
)
1833 const char * sec_name
;
1835 /* Switch to the relevant sub-section before we start to emit
1836 the line number table.
1838 FIXME: These sub-sections do not have a normal Line Number
1839 Program Header, thus strictly speaking they are not valid
1840 DWARF sections. Unfortunately the DWARF standard assumes
1841 a one-to-one relationship between compilation units and
1842 line number tables. Thus we have to have a .debug_line
1843 section, as well as our sub-sections, and we have to ensure
1844 that all of the sub-sections are merged into a proper
1845 .debug_line section before a debugger sees them. */
1847 sec_name
= bfd_section_name (seg
);
1848 if (strcmp (sec_name
, ".text") != 0)
1850 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1851 subseg_set (subseg_get (name
, FALSE
), 0);
1854 /* Don't create a .debug_line.text section -
1855 that is redundant. Instead just switch back to the
1856 normal .debug_line section. */
1857 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1864 if (filenum
!= e
->loc
.filenum
)
1866 filenum
= e
->loc
.filenum
;
1867 out_opcode (DW_LNS_set_file
);
1868 out_uleb128 (filenum
);
1871 if (column
!= e
->loc
.column
)
1873 column
= e
->loc
.column
;
1874 out_opcode (DW_LNS_set_column
);
1875 out_uleb128 (column
);
1878 if (e
->loc
.discriminator
!= 0)
1880 out_opcode (DW_LNS_extended_op
);
1881 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1882 out_opcode (DW_LNE_set_discriminator
);
1883 out_uleb128 (e
->loc
.discriminator
);
1886 if (isa
!= e
->loc
.isa
)
1889 out_opcode (DW_LNS_set_isa
);
1893 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1895 flags
= e
->loc
.flags
;
1896 out_opcode (DW_LNS_negate_stmt
);
1899 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1900 out_opcode (DW_LNS_set_basic_block
);
1902 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1903 out_opcode (DW_LNS_set_prologue_end
);
1905 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1906 out_opcode (DW_LNS_set_epilogue_begin
);
1908 /* Don't try to optimize away redundant entries; gdb wants two
1909 entries for a function where the code starts on the same line as
1910 the {, and there's no way to identify that case here. Trust gcc
1911 to optimize appropriately. */
1912 line_delta
= e
->loc
.line
- line
;
1914 frag
= symbol_get_frag (lab
);
1915 frag_ofs
= S_GET_VALUE (lab
);
1917 if (last_frag
== NULL
1918 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1919 /* If we're going to reset the view, but we know we're
1920 advancing the PC, we don't have to force with
1921 set_address. We know we do when we're at the same
1922 address of the same frag, and we know we might when
1923 we're in the beginning of a frag, and we were at the
1924 end of the previous frag. */
1925 && (frag
== last_frag
1926 ? (last_frag_ofs
== frag_ofs
)
1928 && ((offsetT
)last_frag_ofs
1929 >= get_frag_fix (last_frag
, seg
))))))
1932 out_inc_line_addr (line_delta
, 0);
1934 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1935 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1937 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1942 last_frag_ofs
= frag_ofs
;
1950 /* Emit a DW_LNE_end_sequence for the end of the section. */
1951 frag
= last_frag_for_seg (seg
);
1952 frag_ofs
= get_frag_fix (frag
, seg
);
1953 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1954 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1957 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1958 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1962 /* Emit the directory and file tables for .debug_line. */
1965 out_dir_and_file_list (void)
1971 bfd_boolean emit_md5
= FALSE
;
1972 bfd_boolean emit_timestamps
= TRUE
;
1973 bfd_boolean emit_filesize
= TRUE
;
1975 /* Output the Directory Table. */
1977 if (DWARF2_LINE_VERSION
>= 5)
1980 out_uleb128 (DW_LNCT_path
);
1981 /* FIXME: it would be better to store these strings in
1982 the .debug_line_str section and reference them here. */
1983 out_uleb128 (DW_FORM_string
);
1984 out_uleb128 (dirs_in_use
);
1987 /* Emit directory list. */
1988 if (DWARF2_LINE_VERSION
>= 5)
1990 if (dirs
[0] == NULL
)
1991 dir
= remap_debug_filename (".");
1993 dir
= remap_debug_filename (dirs
[0]);
1995 size
= strlen (dir
) + 1;
1996 cp
= frag_more (size
);
1997 memcpy (cp
, dir
, size
);
1999 for (i
= 1; i
< dirs_in_use
; ++i
)
2001 dir
= remap_debug_filename (dirs
[i
]);
2002 size
= strlen (dir
) + 1;
2003 cp
= frag_more (size
);
2004 memcpy (cp
, dir
, size
);
2007 if (DWARF2_LINE_VERSION
< 5)
2011 /* Output the File Name Table. */
2013 if (DWARF2_LINE_VERSION
>= 5)
2015 unsigned int columns
= 4;
2017 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2019 emit_timestamps
= FALSE
;
2023 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2025 emit_filesize
= FALSE
;
2029 for (i
= 0; i
< files_in_use
; ++i
)
2030 if (files
[i
].md5
[0] != 0)
2032 if (i
< files_in_use
)
2038 /* The number of format entries to follow. */
2041 /* The format of the file name. */
2042 out_uleb128 (DW_LNCT_path
);
2043 /* FIXME: it would be better to store these strings in
2044 the .debug_line_str section and reference them here. */
2045 out_uleb128 (DW_FORM_string
);
2047 /* The format of the directory index. */
2048 out_uleb128 (DW_LNCT_directory_index
);
2049 out_uleb128 (DW_FORM_udata
);
2051 if (emit_timestamps
)
2053 /* The format of the timestamp. */
2054 out_uleb128 (DW_LNCT_timestamp
);
2055 out_uleb128 (DW_FORM_udata
);
2060 /* The format of the file size. */
2061 out_uleb128 (DW_LNCT_size
);
2062 out_uleb128 (DW_FORM_udata
);
2067 /* The format of the MD5 sum. */
2068 out_uleb128 (DW_LNCT_MD5
);
2069 out_uleb128 (DW_FORM_data16
);
2072 /* The number of entries in the table. */
2073 out_uleb128 (files_in_use
);
2076 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2078 const char *fullfilename
;
2080 if (files
[i
].filename
== NULL
)
2082 /* Prevent a crash later, particularly for file 1. */
2083 files
[i
].filename
= "";
2084 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2086 as_bad (_("unassigned file number %ld"), (long) i
);
2091 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2092 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2093 size
= strlen (fullfilename
) + 1;
2094 cp
= frag_more (size
);
2095 memcpy (cp
, fullfilename
, size
);
2097 /* Directory number. */
2098 out_uleb128 (files
[i
].dir
);
2100 /* Output the last modification timestamp. */
2101 if (emit_timestamps
)
2105 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2106 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2107 if (timestamp
== -1)
2109 out_uleb128 (timestamp
);
2112 /* Output the filesize. */
2116 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2117 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2120 out_uleb128 (filesize
);
2123 /* Output the md5 sum. */
2128 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2129 out_byte (files
[i
].md5
[b
]);
2133 if (DWARF2_LINE_VERSION
< 5)
2134 /* Terminate filename list. */
2138 /* Switch to SEC and output a header length field. Return the size of
2139 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2140 to the end of the section. EXPR->X_add_number will be set to the
2141 negative size of the header. */
2144 out_header (asection
*sec
, expressionS
*exp
)
2149 subseg_set (sec
, 0);
2151 if (flag_dwarf_sections
)
2153 /* If we are going to put the start and end symbols in different
2154 sections, then we need real symbols, not just fake, local ones. */
2156 start_sym
= symbol_make (".Ldebug_line_start");
2157 end_sym
= symbol_make (".Ldebug_line_end");
2158 symbol_set_value_now (start_sym
);
2162 start_sym
= symbol_temp_new_now_octets ();
2163 end_sym
= symbol_temp_make ();
2166 /* Total length of the information. */
2167 exp
->X_op
= O_subtract
;
2168 exp
->X_add_symbol
= end_sym
;
2169 exp
->X_op_symbol
= start_sym
;
2171 switch (DWARF2_FORMAT (sec
))
2173 case dwarf2_format_32bit
:
2174 exp
->X_add_number
= -4;
2178 case dwarf2_format_64bit
:
2179 exp
->X_add_number
= -12;
2184 case dwarf2_format_64bit_irix
:
2185 exp
->X_add_number
= -8;
2190 as_fatal (_("internal error: unknown dwarf2 format"));
2194 /* Emit the collected .debug_line data. */
2197 out_debug_line (segT line_seg
)
2200 symbolS
*prologue_start
, *prologue_end
;
2205 memset (&exp
, 0, sizeof exp
);
2206 sizeof_offset
= out_header (line_seg
, &exp
);
2207 line_end
= exp
.X_add_symbol
;
2210 out_two (DWARF2_LINE_VERSION
);
2212 if (DWARF2_LINE_VERSION
>= 5)
2214 out_byte (sizeof_address
);
2215 out_byte (0); /* Segment Selector size. */
2217 /* Length of the prologue following this length. */
2218 prologue_start
= symbol_temp_make ();
2219 prologue_end
= symbol_temp_make ();
2220 exp
.X_op
= O_subtract
;
2221 exp
.X_add_symbol
= prologue_end
;
2222 exp
.X_op_symbol
= prologue_start
;
2223 exp
.X_add_number
= 0;
2224 emit_expr (&exp
, sizeof_offset
);
2225 symbol_set_value_now (prologue_start
);
2227 /* Parameters of the state machine. */
2228 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2229 if (DWARF2_LINE_VERSION
>= 4)
2230 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2231 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2232 out_byte (DWARF2_LINE_BASE
);
2233 out_byte (DWARF2_LINE_RANGE
);
2234 out_byte (DWARF2_LINE_OPCODE_BASE
);
2236 /* Standard opcode lengths. */
2237 out_byte (0); /* DW_LNS_copy */
2238 out_byte (1); /* DW_LNS_advance_pc */
2239 out_byte (1); /* DW_LNS_advance_line */
2240 out_byte (1); /* DW_LNS_set_file */
2241 out_byte (1); /* DW_LNS_set_column */
2242 out_byte (0); /* DW_LNS_negate_stmt */
2243 out_byte (0); /* DW_LNS_set_basic_block */
2244 out_byte (0); /* DW_LNS_const_add_pc */
2245 out_byte (1); /* DW_LNS_fixed_advance_pc */
2246 out_byte (0); /* DW_LNS_set_prologue_end */
2247 out_byte (0); /* DW_LNS_set_epilogue_begin */
2248 out_byte (1); /* DW_LNS_set_isa */
2249 /* We have emitted 12 opcode lengths, so make that this
2250 matches up to the opcode base value we have been using. */
2251 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2253 out_dir_and_file_list ();
2255 symbol_set_value_now (prologue_end
);
2257 /* For each section, emit a statement program. */
2258 for (s
= all_segs
; s
; s
= s
->next
)
2259 if (SEG_NORMAL (s
->seg
))
2260 process_entries (s
->seg
, s
->head
->head
);
2262 as_warn ("dwarf line number information for %s ignored",
2263 segment_name (s
->seg
));
2265 if (flag_dwarf_sections
)
2266 /* We have to switch to the special .debug_line_end section
2267 before emitting the end-of-debug_line symbol. The linker
2268 script arranges for this section to be placed after all the
2269 (potentially garbage collected) .debug_line.<foo> sections.
2270 This section contains the line_end symbol which is used to
2271 compute the size of the linked .debug_line section, as seen
2272 in the DWARF Line Number header. */
2273 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2275 symbol_set_value_now (line_end
);
2279 out_debug_ranges (segT ranges_seg
)
2281 unsigned int addr_size
= sizeof_address
;
2286 memset (&exp
, 0, sizeof exp
);
2287 subseg_set (ranges_seg
, 0);
2289 /* Base Address Entry. */
2290 for (i
= 0; i
< addr_size
; i
++)
2292 for (i
= 0; i
< addr_size
; i
++)
2295 /* Range List Entry. */
2296 for (s
= all_segs
; s
; s
= s
->next
)
2301 frag
= first_frag_for_seg (s
->seg
);
2302 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2303 s
->text_start
= beg
;
2305 frag
= last_frag_for_seg (s
->seg
);
2306 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2309 exp
.X_op
= O_symbol
;
2310 exp
.X_add_symbol
= beg
;
2311 exp
.X_add_number
= 0;
2312 emit_expr (&exp
, addr_size
);
2314 exp
.X_op
= O_symbol
;
2315 exp
.X_add_symbol
= end
;
2316 exp
.X_add_number
= 0;
2317 emit_expr (&exp
, addr_size
);
2320 /* End of Range Entry. */
2321 for (i
= 0; i
< addr_size
; i
++)
2323 for (i
= 0; i
< addr_size
; i
++)
2327 /* Emit data for .debug_aranges. */
2330 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2332 unsigned int addr_size
= sizeof_address
;
2336 symbolS
*aranges_end
;
2340 memset (&exp
, 0, sizeof exp
);
2341 sizeof_offset
= out_header (aranges_seg
, &exp
);
2342 aranges_end
= exp
.X_add_symbol
;
2343 size
= -exp
.X_add_number
;
2346 out_two (DWARF2_ARANGES_VERSION
);
2349 /* Offset to .debug_info. */
2350 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2351 size
+= sizeof_offset
;
2353 /* Size of an address (offset portion). */
2354 out_byte (addr_size
);
2357 /* Size of a segment descriptor. */
2361 /* Align the header. */
2362 while ((size
++ % (2 * addr_size
)) > 0)
2365 for (s
= all_segs
; s
; s
= s
->next
)
2370 frag
= first_frag_for_seg (s
->seg
);
2371 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2372 s
->text_start
= beg
;
2374 frag
= last_frag_for_seg (s
->seg
);
2375 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2378 exp
.X_op
= O_symbol
;
2379 exp
.X_add_symbol
= beg
;
2380 exp
.X_add_number
= 0;
2381 emit_expr (&exp
, addr_size
);
2383 exp
.X_op
= O_subtract
;
2384 exp
.X_add_symbol
= end
;
2385 exp
.X_op_symbol
= beg
;
2386 exp
.X_add_number
= 0;
2387 emit_expr (&exp
, addr_size
);
2390 p
= frag_more (2 * addr_size
);
2391 md_number_to_chars (p
, 0, addr_size
);
2392 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2394 symbol_set_value_now (aranges_end
);
2397 /* Emit data for .debug_abbrev. Note that this must be kept in
2398 sync with out_debug_info below. */
2401 out_debug_abbrev (segT abbrev_seg
,
2402 segT info_seg ATTRIBUTE_UNUSED
,
2403 segT line_seg ATTRIBUTE_UNUSED
)
2405 subseg_set (abbrev_seg
, 0);
2408 out_uleb128 (DW_TAG_compile_unit
);
2409 out_byte (DW_CHILDREN_no
);
2410 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2411 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
2413 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
2414 if (all_segs
->next
== NULL
)
2416 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2417 if (DWARF2_VERSION
< 4)
2418 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2420 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
2421 ? DW_FORM_data4
: DW_FORM_data8
));
2425 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
2426 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
2428 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
2430 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2431 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2432 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2433 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2436 /* Terminate the abbreviations for this compilation unit. */
2440 /* Emit a description of this compilation unit for .debug_info. */
2443 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
2444 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2450 memset (&exp
, 0, sizeof exp
);
2451 sizeof_offset
= out_header (info_seg
, &exp
);
2452 info_end
= exp
.X_add_symbol
;
2454 /* DWARF version. */
2455 out_two (DWARF2_VERSION
);
2457 /* .debug_abbrev offset */
2458 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2460 /* Target address size. */
2461 out_byte (sizeof_address
);
2463 /* DW_TAG_compile_unit DIE abbrev */
2466 /* DW_AT_stmt_list */
2467 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2468 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2471 /* These two attributes are emitted if all of the code is contiguous. */
2472 if (all_segs
->next
== NULL
)
2475 exp
.X_op
= O_symbol
;
2476 exp
.X_add_symbol
= all_segs
->text_start
;
2477 exp
.X_add_number
= 0;
2478 emit_expr (&exp
, sizeof_address
);
2481 if (DWARF2_VERSION
< 4)
2482 exp
.X_op
= O_symbol
;
2485 exp
.X_op
= O_subtract
;
2486 exp
.X_op_symbol
= all_segs
->text_start
;
2488 exp
.X_add_symbol
= all_segs
->text_end
;
2489 exp
.X_add_number
= 0;
2490 emit_expr (&exp
, sizeof_address
);
2494 /* This attribute is emitted if the code is disjoint. */
2496 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2499 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2500 setup in out_debug_str below. */
2501 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2502 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2503 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2505 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2506 dwarf2 draft has no standard code for assembler. */
2507 out_two (DW_LANG_Mips_Assembler
);
2509 symbol_set_value_now (info_end
);
2512 /* Emit the three debug strings needed in .debug_str and setup symbols
2513 to them for use in out_debug_info. */
2515 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2516 symbolS
**producer_sym
)
2519 const char *comp_dir
;
2520 const char *dirname
;
2523 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2525 subseg_set (str_seg
, 0);
2527 /* DW_AT_name. We don't have the actual file name that was present
2528 on the command line, so assume files[first_file] is the main input file.
2529 We're not supposed to get called unless at least one line number
2530 entry was emitted, so this should always be defined. */
2531 *name_sym
= symbol_temp_new_now_octets ();
2532 if (files_in_use
== 0)
2534 if (files
[first_file
].dir
)
2536 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2537 len
= strlen (dirname
);
2539 /* Already has trailing slash. */
2540 p
= frag_more (len
);
2541 memcpy (p
, dirname
, len
);
2543 p
= frag_more (len
+ 1);
2544 memcpy (p
, dirname
, len
);
2545 INSERT_DIR_SEPARATOR (p
, len
);
2548 len
= strlen (files
[first_file
].filename
) + 1;
2549 p
= frag_more (len
);
2550 memcpy (p
, files
[first_file
].filename
, len
);
2552 /* DW_AT_comp_dir */
2553 *comp_dir_sym
= symbol_temp_new_now_octets ();
2554 comp_dir
= remap_debug_filename (getpwd ());
2555 len
= strlen (comp_dir
) + 1;
2556 p
= frag_more (len
);
2557 memcpy (p
, comp_dir
, len
);
2559 /* DW_AT_producer */
2560 *producer_sym
= symbol_temp_new_now_octets ();
2561 sprintf (producer
, "GNU AS %s", VERSION
);
2562 len
= strlen (producer
) + 1;
2563 p
= frag_more (len
);
2564 memcpy (p
, producer
, len
);
2570 last_seg_ptr
= &all_segs
;
2572 /* Select the default CIE version to produce here. The global
2573 starts with a value of -1 and will be modified to a valid value
2574 either by the user providing a command line option, or some
2575 targets will select their own default in md_after_parse_args. If
2576 we get here and the global still contains -1 then it is up to us
2577 to pick a sane default. The default we choose is 1, this is the
2578 CIE version gas has produced for a long time, and there seems no
2579 reason to change it yet. */
2580 if (flag_dwarf_cie_version
== -1)
2581 flag_dwarf_cie_version
= 1;
2585 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2586 were any .file/.loc directives, or --gdwarf2 was given, or if the
2587 file has a non-empty .debug_info section and an empty .debug_line
2588 section. If we emit .debug_line, and the .debug_info section is
2589 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2590 ALL_SEGS will be non-null if there were any .file/.loc directives,
2591 or --gdwarf2 was given and there were any located instructions
2595 dwarf2_finish (void)
2600 int emit_other_sections
= 0;
2601 int empty_debug_line
= 0;
2603 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2604 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2606 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2607 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2609 /* We can't construct a new debug_line section if we already have one.
2611 if (all_segs
&& !empty_debug_line
)
2612 as_fatal ("duplicate .debug_line sections");
2614 if ((!all_segs
&& emit_other_sections
)
2615 || (!emit_other_sections
&& !empty_debug_line
))
2616 /* If there is no line information and no non-empty .debug_info
2617 section, or if there is both a non-empty .debug_info and a non-empty
2618 .debug_line, then we do nothing. */
2621 /* Calculate the size of an address for the target machine. */
2622 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2624 /* Create and switch to the line number section. */
2625 line_seg
= subseg_new (".debug_line", 0);
2626 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2628 /* For each subsection, chain the debug entries together. */
2629 for (s
= all_segs
; s
; s
= s
->next
)
2631 struct line_subseg
*lss
= s
->head
;
2632 struct line_entry
**ptail
= lss
->ptail
;
2634 /* Reset the initial view of the first subsection of the
2636 if (lss
->head
&& lss
->head
->loc
.view
)
2637 set_or_check_view (lss
->head
, NULL
, NULL
);
2639 while ((lss
= lss
->next
) != NULL
)
2641 /* Link the first view of subsequent subsections to the
2643 if (lss
->head
&& lss
->head
->loc
.view
)
2644 set_or_check_view (lss
->head
,
2645 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2646 s
->head
? s
->head
->head
: NULL
);
2652 out_debug_line (line_seg
);
2654 /* If this is assembler generated line info, and there is no
2655 debug_info already, we need .debug_info, .debug_abbrev and
2656 .debug_str sections as well. */
2657 if (emit_other_sections
)
2663 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2665 gas_assert (all_segs
);
2667 info_seg
= subseg_new (".debug_info", 0);
2668 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2669 aranges_seg
= subseg_new (".debug_aranges", 0);
2670 str_seg
= subseg_new (".debug_str", 0);
2672 bfd_set_section_flags (info_seg
,
2673 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2674 bfd_set_section_flags (abbrev_seg
,
2675 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2676 bfd_set_section_flags (aranges_seg
,
2677 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2678 bfd_set_section_flags (str_seg
,
2679 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2680 | SEC_MERGE
| SEC_STRINGS
);
2681 str_seg
->entsize
= 1;
2683 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2685 if (all_segs
->next
== NULL
)
2689 ranges_seg
= subseg_new (".debug_ranges", 0);
2690 bfd_set_section_flags (ranges_seg
,
2691 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2692 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2693 out_debug_ranges (ranges_seg
);
2696 out_debug_aranges (aranges_seg
, info_seg
);
2697 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2698 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2699 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2700 name_sym
, comp_dir_sym
, producer_sym
);
2704 /* Perform any deferred checks pertaining to debug information. */
2707 dwarf2dbg_final_check (void)
2709 /* Perform reset-view checks. Don't evaluate view_assert_failed
2710 recursively: it could be very deep. It's a chain of adds, with
2711 each chain element pointing to the next in X_add_symbol, and
2712 holding the check value in X_op_symbol. */
2713 while (view_assert_failed
)
2719 gas_assert (!symbol_resolved_p (view_assert_failed
));
2721 exp
= symbol_get_value_expression (view_assert_failed
);
2722 sym
= view_assert_failed
;
2724 /* If view_assert_failed looks like a compound check in the
2725 chain, break it up. */
2726 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2728 view_assert_failed
= exp
->X_add_symbol
;
2729 sym
= exp
->X_op_symbol
;
2732 view_assert_failed
= NULL
;
2734 failed
= resolve_symbol_value (sym
);
2735 if (!symbol_resolved_p (sym
) || failed
)
2737 as_bad (_("view number mismatch"));