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)
109 /* Since we can't generate the prolog until the body is complete, we
110 use three different subsegments for .debug_line: one holding the
111 prolog, one for the directory and filename info, and one for the
112 body ("statement program"). */
117 /* If linker relaxation might change offsets in the code, the DWARF special
118 opcodes and variable-length operands cannot be used. If this macro is
119 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
120 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
121 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
124 /* First special line opcode - leave room for the standard opcodes.
125 Note: If you want to change this, you'll have to update the
126 "standard_opcode_lengths" table that is emitted below in
128 #define DWARF2_LINE_OPCODE_BASE 13
130 #ifndef DWARF2_LINE_BASE
131 /* Minimum line offset in a special line info. opcode. This value
132 was chosen to give a reasonable range of values. */
133 # define DWARF2_LINE_BASE -5
136 /* Range of line offsets in a special line info. opcode. */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE 14
141 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
142 /* Define the architecture-dependent minimum instruction length (in
143 bytes). This value should be rather too small than too big. */
144 # define DWARF2_LINE_MIN_INSN_LENGTH 1
147 /* Flag that indicates the initial value of the is_stmt_start flag. */
148 #define DWARF2_LINE_DEFAULT_IS_STMT 1
150 #ifndef DWARF2_LINE_MAX_OPS_PER_INSN
151 #define DWARF2_LINE_MAX_OPS_PER_INSN 1
154 /* Given a special op, return the line skip amount. */
155 #define SPECIAL_LINE(op) \
156 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
158 /* Given a special op, return the address skip amount (in units of
159 DWARF2_LINE_MIN_INSN_LENGTH. */
160 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
162 /* The maximum address skip amount that can be encoded with a special op. */
163 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
165 #ifndef TC_PARSE_CONS_RETURN_NONE
166 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
171 struct line_entry
*next
;
173 struct dwarf2_line_info loc
;
176 /* Don't change the offset of next in line_entry. set_or_check_view
177 calls in dwarf2_gen_line_info_1 depend on it. */
178 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
183 struct line_subseg
*next
;
185 struct line_entry
*head
;
186 struct line_entry
**ptail
;
187 struct line_entry
**pmove_tail
;
192 struct line_seg
*next
;
194 struct line_subseg
*head
;
199 /* Collects data for all line table entries during assembly. */
200 static struct line_seg
*all_segs
;
201 static struct line_seg
**last_seg_ptr
;
203 #define NUM_MD5_BYTES 16
207 const char * filename
;
209 unsigned char md5
[NUM_MD5_BYTES
];
212 /* Table of files used by .debug_line. */
213 static struct file_entry
*files
;
214 static unsigned int files_in_use
;
215 static unsigned int files_allocated
;
217 /* Table of directories used by .debug_line. */
218 static char ** dirs
= NULL
;
219 static unsigned int dirs_in_use
= 0;
220 static unsigned int dirs_allocated
= 0;
222 /* TRUE when we've seen a .loc directive recently. Used to avoid
223 doing work when there's nothing to do. */
224 bfd_boolean dwarf2_loc_directive_seen
;
226 /* TRUE when we're supposed to set the basic block mark whenever a
228 bfd_boolean dwarf2_loc_mark_labels
;
230 /* Current location as indicated by the most recent .loc directive. */
231 static struct dwarf2_line_info current
=
234 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
238 /* This symbol is used to recognize view number forced resets in loc
240 static symbolS
*force_reset_view
;
242 /* This symbol evaluates to an expression that, if nonzero, indicates
243 some view assert check failed. */
244 static symbolS
*view_assert_failed
;
246 /* The size of an address on the target. */
247 static unsigned int sizeof_address
;
249 #ifndef TC_DWARF2_EMIT_OFFSET
250 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
252 /* Create an offset to .dwarf2_*. */
255 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
259 memset (&exp
, 0, sizeof exp
);
261 exp
.X_add_symbol
= symbol
;
262 exp
.X_add_number
= 0;
263 emit_expr (&exp
, size
);
267 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
269 static struct line_subseg
*
270 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
272 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
273 struct line_subseg
**pss
, *lss
;
280 s
= XNEW (struct line_seg
);
285 last_seg_ptr
= &s
->next
;
286 seg_info (seg
)->dwarf2_line_seg
= s
;
289 gas_assert (seg
== s
->seg
);
291 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
293 if (lss
->subseg
== subseg
)
295 if (lss
->subseg
> subseg
)
299 lss
= XNEW (struct line_subseg
);
301 lss
->subseg
= subseg
;
303 lss
->ptail
= &lss
->head
;
304 lss
->pmove_tail
= &lss
->head
;
311 /* (Un)reverse the line_entry list starting from H. */
313 static struct line_entry
*
314 reverse_line_entry_list (struct line_entry
*h
)
316 struct line_entry
*p
= NULL
, *e
, *n
;
318 for (e
= h
; e
; e
= n
)
327 /* Compute the view for E based on the previous entry P. If we
328 introduce an (undefined) view symbol for P, and H is given (P must
329 be the tail in this case), introduce view symbols for earlier list
330 entries as well, until one of them is constant. */
333 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
334 struct line_entry
*h
)
338 memset (&viewx
, 0, sizeof (viewx
));
339 viewx
.X_unsigned
= 1;
341 /* First, compute !(E->label > P->label), to tell whether or not
342 we're to reset the view number. If we can't resolve it to a
343 constant, keep it symbolic. */
344 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
346 viewx
.X_op
= O_constant
;
347 viewx
.X_add_number
= 0;
348 viewx
.X_add_symbol
= NULL
;
349 viewx
.X_op_symbol
= NULL
;
354 viewx
.X_add_number
= 0;
355 viewx
.X_add_symbol
= e
->label
;
356 viewx
.X_op_symbol
= p
->label
;
357 resolve_expression (&viewx
);
358 if (viewx
.X_op
== O_constant
)
359 viewx
.X_add_number
= !viewx
.X_add_number
;
362 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
363 viewx
.X_add_number
= 0;
364 viewx
.X_op_symbol
= NULL
;
365 viewx
.X_op
= O_logical_not
;
369 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
371 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
372 /* We can't compare the view numbers at this point, because in
373 VIEWX we've only determined whether we're to reset it so
375 if (viewx
.X_op
== O_constant
)
377 if (!value
->X_add_number
!= !viewx
.X_add_number
)
378 as_bad (_("view number mismatch"));
380 /* Record the expression to check it later. It is the result of
381 a logical not, thus 0 or 1. We just add up all such deferred
382 expressions, and resolve it at the end. */
383 else if (!value
->X_add_number
)
385 symbolS
*deferred
= make_expr_symbol (&viewx
);
386 if (view_assert_failed
)
390 memset (&chk
, 0, sizeof (chk
));
393 chk
.X_add_number
= 0;
394 chk
.X_add_symbol
= view_assert_failed
;
395 chk
.X_op_symbol
= deferred
;
396 deferred
= make_expr_symbol (&chk
);
398 view_assert_failed
= deferred
;
402 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
408 p
->loc
.view
= symbol_temp_make ();
409 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
412 memset (&incv
, 0, sizeof (incv
));
414 incv
.X_op
= O_symbol
;
415 incv
.X_add_symbol
= p
->loc
.view
;
416 incv
.X_add_number
= 1;
418 if (viewx
.X_op
== O_constant
)
420 gas_assert (viewx
.X_add_number
== 1);
425 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
426 viewx
.X_add_number
= 0;
427 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
428 viewx
.X_op
= O_multiply
;
432 if (!S_IS_DEFINED (e
->loc
.view
))
434 symbol_set_value_expression (e
->loc
.view
, &viewx
);
435 S_SET_SEGMENT (e
->loc
.view
, expr_section
);
436 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
439 /* Define and attempt to simplify any earlier views needed to
441 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
443 struct line_entry
*h2
;
444 /* Reverse the list to avoid quadratic behavior going backwards
445 in a single-linked list. */
446 struct line_entry
*r
= reverse_line_entry_list (h
);
449 /* Set or check views until we find a defined or absent view. */
452 /* Do not define the head of a (sub?)segment view while
453 handling others. It would be defined too early, without
454 regard to the last view of other subsegments.
455 set_or_check_view will be called for every head segment
459 set_or_check_view (r
, r
->next
, NULL
);
461 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
464 /* Unreverse the list, so that we can go forward again. */
465 h2
= reverse_line_entry_list (p
);
466 gas_assert (h2
== h
);
468 /* Starting from the last view we just defined, attempt to
469 simplify the view expressions, until we do so to P. */
472 /* The head view of a subsegment may remain undefined while
473 handling other elements, before it is linked to the last
474 view of the previous subsegment. */
477 gas_assert (S_IS_DEFINED (r
->loc
.view
));
478 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
480 while (r
!= p
&& (r
= r
->next
));
482 /* Now that we've defined and computed all earlier views that might
483 be needed to compute E's, attempt to simplify it. */
484 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
488 /* Record an entry for LOC occurring at LABEL. */
491 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
493 struct line_subseg
*lss
;
494 struct line_entry
*e
;
496 e
= XNEW (struct line_entry
);
501 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
503 /* Subseg heads are chained to previous subsegs in
505 if (loc
->view
&& lss
->head
)
506 set_or_check_view (e
,
507 (struct line_entry
*)lss
->ptail
,
511 lss
->ptail
= &e
->next
;
514 /* Record an entry for LOC occurring at OFS within the current fragment. */
517 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
519 static unsigned int line
= -1;
520 static unsigned int filenum
= -1;
524 /* Early out for as-yet incomplete location information. */
527 if (loc
->filenum
== 0 && DWARF2_LINE_VERSION
< 5)
530 /* Don't emit sequences of line symbols for the same line when the
531 symbols apply to assembler code. It is necessary to emit
532 duplicate line symbols when a compiler asks for them, because GDB
533 uses them to determine the end of the prologue. */
534 if (debug_type
== DEBUG_DWARF2
535 && line
== loc
->line
&& filenum
== loc
->filenum
)
539 filenum
= loc
->filenum
;
545 /* Use a non-fake name for the line number location,
546 so that it can be referred to by relocations. */
547 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
548 sym
= symbol_new (name
, now_seg
, ofs
, frag_now
);
551 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
552 dwarf2_gen_line_info_1 (sym
, loc
);
556 get_basename (const char * pathname
)
560 file
= lbasename (pathname
);
561 /* Don't make empty string from / or A: from A:/ . */
562 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
563 if (file
<= pathname
+ 3)
566 if (file
== pathname
+ 1)
573 get_directory_table_entry (const char * dirname
,
575 bfd_boolean can_use_zero
)
582 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
583 if (IS_DIR_SEPARATOR (dirname
[dirlen
- 1]))
591 for (d
= 0; d
< dirs_in_use
; ++d
)
594 && filename_ncmp (dirname
, dirs
[d
], dirlen
) == 0
595 && dirs
[d
][dirlen
] == '\0')
601 if (dirs
== NULL
|| dirs
[0] == NULL
)
607 if (d
>= dirs_allocated
)
609 unsigned int old
= dirs_allocated
;
611 dirs_allocated
= d
+ 32;
612 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
613 memset (dirs
+ old
, 0, (dirs_allocated
- old
) * sizeof (char *));
616 dirs
[d
] = xmemdup0 (dirname
, dirlen
);
617 if (dirs_in_use
<= d
)
623 /* Get a .debug_line file number for PATHNAME. If there is a
624 directory component to PATHNAME, then this will be stored
625 in the directory table, if it is not already present.
626 Returns the slot number allocated to that filename or -1
627 if there was a problem. */
630 allocate_filenum (const char * pathname
)
632 static signed int last_used
= -1, last_used_dir_len
= 0;
637 /* Short circuit the common case of adding the same pathname
641 const char * dirname
= NULL
;
644 dirname
= dirs
[files
[last_used
].dir
];
648 if (filename_cmp (pathname
, files
[last_used
].filename
) == 0)
653 if (filename_ncmp (pathname
, dirname
, last_used_dir_len
) == 0
654 && IS_DIR_SEPARATOR (pathname
[last_used_dir_len
])
655 && filename_cmp (pathname
+ last_used_dir_len
+ 1,
656 files
[last_used
].filename
) == 0)
661 file
= get_basename (pathname
);
662 dir_len
= file
- pathname
;
664 dir
= get_directory_table_entry (pathname
, dir_len
, FALSE
);
666 /* Do not use slot-0. That is specificailly reserved for use by
667 the '.file 0 "name"' directive. */
668 for (i
= 1; i
< files_in_use
; ++i
)
669 if (files
[i
].dir
== dir
671 && filename_cmp (file
, files
[i
].filename
) == 0)
674 last_used_dir_len
= dir_len
;
678 if (i
>= files_allocated
)
680 unsigned int old
= files_allocated
;
682 files_allocated
= i
+ 32;
683 /* Catch wraparound. */
684 if (files_allocated
<= old
)
686 as_bad (_("file number %lu is too big"), (unsigned long) i
);
690 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
691 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
694 files
[i
].filename
= file
;
696 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
698 if (files_in_use
< i
+ 1)
699 files_in_use
= i
+ 1;
701 last_used_dir_len
= dir_len
;
706 /* Allocate slot NUM in the .debug_line file table to FILENAME.
707 If DIRNAME is not NULL or there is a directory component to FILENAME
708 then this will be stored in the directory table, if not already present.
709 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
710 Returns TRUE if allocation succeeded, FALSE otherwise. */
713 allocate_filename_to_slot (const char * dirname
,
714 const char * filename
,
716 bfd_boolean with_md5
)
722 /* Short circuit the common case of adding the same pathname
724 if (num
< files_allocated
&& files
[num
].filename
!= NULL
)
726 const char * dir
= NULL
;
729 dir
= dirs
[files
[num
].dir
];
732 && memcmp (generic_bignum
, files
[num
].md5
, NUM_MD5_BYTES
) != 0)
737 if (dir
!= NULL
&& filename_cmp (dir
, dirname
) != 0)
740 if (filename_cmp (filename
, files
[num
].filename
) != 0)
743 /* If the filenames match, but the directory table entry was
744 empty, then fill it with the provided directory name. */
746 dirs
[files
[num
].dir
] = xmemdup0 (dirname
, strlen (dirname
));
750 else if (dir
!= NULL
)
752 dirlen
= strlen (dir
);
753 if (filename_ncmp (filename
, dir
, dirlen
) == 0
754 && IS_DIR_SEPARATOR (filename
[dirlen
])
755 && filename_cmp (filename
+ dirlen
+ 1, files
[num
].filename
) == 0)
758 else /* dir == NULL */
760 file
= get_basename (filename
);
761 if (filename_cmp (file
, files
[num
].filename
) == 0)
764 /* The filenames match, but the directory table entry is empty.
765 Fill it with the provided directory name. */
766 dirs
[files
[num
].dir
] = xmemdup0 (filename
, file
- filename
);
772 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
774 dir
== NULL
? "" : dir
,
775 dir
== NULL
? "" : "/",
777 dirname
== NULL
? "" : dirname
,
778 dirname
== NULL
? "" : "/",
786 file
= get_basename (filename
);
787 dirlen
= file
- filename
;
791 dirlen
= strlen (dirname
);
795 d
= get_directory_table_entry (dirname
, dirlen
, num
== 0);
798 if (i
>= files_allocated
)
800 unsigned int old
= files_allocated
;
802 files_allocated
= i
+ 32;
803 /* Catch wraparound. */
804 if (files_allocated
<= old
)
806 as_bad (_("file number %lu is too big"), (unsigned long) i
);
810 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
811 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
814 files
[i
].filename
= file
;
818 if (target_big_endian
)
820 /* md5's are stored in litte endian format. */
821 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
822 unsigned int byte
= NUM_MD5_BYTES
;
823 unsigned int bignum_index
= 0;
825 while (bits_remaining
)
827 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
828 valueT bignum_value
= generic_bignum
[bignum_index
];
831 while (bignum_bits_remaining
)
833 files
[i
].md5
[--byte
] = bignum_value
& 0xff;
835 bignum_bits_remaining
-= 8;
842 unsigned int bits_remaining
= NUM_MD5_BYTES
* BITS_PER_CHAR
;
843 unsigned int byte
= 0;
844 unsigned int bignum_index
= 0;
846 while (bits_remaining
)
848 unsigned int bignum_bits_remaining
= LITTLENUM_NUMBER_OF_BITS
;
849 valueT bignum_value
= generic_bignum
[bignum_index
];
853 while (bignum_bits_remaining
)
855 files
[i
].md5
[byte
++] = bignum_value
& 0xff;
857 bignum_bits_remaining
-= 8;
864 memset (files
[i
].md5
, 0, NUM_MD5_BYTES
);
866 if (files_in_use
< i
+ 1)
867 files_in_use
= i
+ 1;
872 /* Returns the current source information. If .file directives have
873 been encountered, the info for the corresponding source file is
874 returned. Otherwise, the info for the assembly source file is
878 dwarf2_where (struct dwarf2_line_info
*line
)
880 if (debug_type
== DEBUG_DWARF2
)
882 const char *filename
;
884 memset (line
, 0, sizeof (*line
));
885 filename
= as_where (&line
->line
);
886 line
->filenum
= allocate_filenum (filename
);
887 /* FIXME: We should check the return value from allocate_filenum. */
889 line
->flags
= DWARF2_FLAG_IS_STMT
;
890 line
->isa
= current
.isa
;
891 line
->discriminator
= current
.discriminator
;
898 /* A hook to allow the target backend to inform the line number state
899 machine of isa changes when assembler debug info is enabled. */
902 dwarf2_set_isa (unsigned int isa
)
907 /* Called for each machine instruction, or relatively atomic group of
908 machine instructions (ie built-in macro). The instruction or group
909 is SIZE bytes in length. If dwarf2 line number generation is called
910 for, emit a line statement appropriately. */
913 dwarf2_emit_insn (int size
)
915 struct dwarf2_line_info loc
;
917 if (debug_type
!= DEBUG_DWARF2
918 ? !dwarf2_loc_directive_seen
919 : !seen_at_least_1_file ())
924 dwarf2_gen_line_info ((frag_now_fix_octets () - size
) / OCTETS_PER_BYTE
, &loc
);
925 dwarf2_consume_line_info ();
928 /* Move all previously-emitted line entries for the current position by
929 DELTA bytes. This function cannot be used to move the same entries
933 dwarf2_move_insn (int delta
)
935 struct line_subseg
*lss
;
936 struct line_entry
*e
;
942 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
946 now
= frag_now_fix ();
947 while ((e
= *lss
->pmove_tail
))
949 if (S_GET_VALUE (e
->label
) == now
)
950 S_SET_VALUE (e
->label
, now
+ delta
);
951 lss
->pmove_tail
= &e
->next
;
955 /* Called after the current line information has been either used with
956 dwarf2_gen_line_info or saved with a machine instruction for later use.
957 This resets the state of the line number information to reflect that
961 dwarf2_consume_line_info (void)
963 /* Unless we generate DWARF2 debugging information for each
964 assembler line, we only emit one line symbol for one LOC. */
965 dwarf2_loc_directive_seen
= FALSE
;
967 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
968 | DWARF2_FLAG_PROLOGUE_END
969 | DWARF2_FLAG_EPILOGUE_BEGIN
);
970 current
.discriminator
= 0;
974 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
975 is enabled, emit a basic block marker. */
978 dwarf2_emit_label (symbolS
*label
)
980 struct dwarf2_line_info loc
;
982 if (!dwarf2_loc_mark_labels
)
984 if (S_GET_SEGMENT (label
) != now_seg
)
986 if (!(bfd_section_flags (now_seg
) & SEC_CODE
))
988 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
993 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
995 dwarf2_gen_line_info_1 (label
, &loc
);
996 dwarf2_consume_line_info ();
999 /* Handle two forms of .file directive:
1000 - Pass .file "source.c" to s_app_file
1001 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
1003 If an entry is added to the file table, return a pointer to the filename. */
1006 dwarf2_directive_filename (void)
1008 bfd_boolean with_md5
= TRUE
;
1011 const char * dirname
= NULL
;
1014 /* Continue to accept a bare string and pass it off. */
1016 if (*input_line_pointer
== '"')
1022 num
= get_absolute_expression ();
1024 if ((offsetT
) num
< 1 && DWARF2_LINE_VERSION
< 5)
1026 as_bad (_("file number less than one"));
1027 ignore_rest_of_line ();
1031 /* FIXME: Should we allow ".file <N>\n" as an expression meaning
1032 "switch back to the already allocated file <N> as the current
1035 filename
= demand_copy_C_string (&filename_len
);
1036 if (filename
== NULL
)
1037 /* demand_copy_C_string will have already generated an error message. */
1040 /* For DWARF-5 support we also accept:
1041 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
1042 if (DWARF2_LINE_VERSION
> 4)
1045 if (*input_line_pointer
== '"')
1048 filename
= demand_copy_C_string (&filename_len
);
1052 if (strncmp (input_line_pointer
, "md5", 3) == 0)
1054 input_line_pointer
+= 3;
1058 expression_and_evaluate (& exp
);
1059 if (exp
.X_op
!= O_big
)
1060 as_bad (_("md5 value too small or not a constant"));
1066 demand_empty_rest_of_line ();
1068 /* A .file directive implies compiler generated debug information is
1069 being supplied. Turn off gas generated debug info. */
1070 debug_type
= DEBUG_NONE
;
1072 if (num
!= (unsigned int) num
1073 || num
>= (size_t) -1 / sizeof (struct file_entry
) - 32)
1075 as_bad (_("file number %lu is too big"), (unsigned long) num
);
1079 if (! allocate_filename_to_slot (dirname
, filename
, (unsigned int) num
,
1086 /* Calls dwarf2_directive_filename, but discards its result.
1087 Used in pseudo-op tables where the function result is ignored. */
1090 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
1092 (void) dwarf2_directive_filename ();
1096 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
1098 offsetT filenum
, line
;
1100 /* If we see two .loc directives in a row, force the first one to be
1102 if (dwarf2_loc_directive_seen
)
1103 dwarf2_emit_insn (0);
1105 filenum
= get_absolute_expression ();
1107 line
= get_absolute_expression ();
1111 if (filenum
!= 0 || DWARF2_LINE_VERSION
< 5)
1113 as_bad (_("file number less than one"));
1118 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== NULL
)
1120 as_bad (_("unassigned file number %ld"), (long) filenum
);
1124 current
.filenum
= filenum
;
1125 current
.line
= line
;
1126 current
.discriminator
= 0;
1131 if (files
[filenum
].dir
)
1133 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
1134 size_t file_len
= strlen (files
[filenum
].filename
);
1135 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
1137 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
1138 INSERT_DIR_SEPARATOR (cp
, dir_len
);
1139 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
1140 cp
[dir_len
+ file_len
+ 1] = '\0';
1141 listing_source_file (cp
);
1145 listing_source_file (files
[filenum
].filename
);
1146 listing_source_line (line
);
1151 if (ISDIGIT (*input_line_pointer
))
1153 current
.column
= get_absolute_expression ();
1157 while (ISALPHA (*input_line_pointer
))
1162 c
= get_symbol_name (& p
);
1164 if (strcmp (p
, "basic_block") == 0)
1166 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
1167 *input_line_pointer
= c
;
1169 else if (strcmp (p
, "prologue_end") == 0)
1171 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
1172 *input_line_pointer
= c
;
1174 else if (strcmp (p
, "epilogue_begin") == 0)
1176 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
1177 *input_line_pointer
= c
;
1179 else if (strcmp (p
, "is_stmt") == 0)
1181 (void) restore_line_pointer (c
);
1182 value
= get_absolute_expression ();
1184 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
1185 else if (value
== 1)
1186 current
.flags
|= DWARF2_FLAG_IS_STMT
;
1189 as_bad (_("is_stmt value not 0 or 1"));
1193 else if (strcmp (p
, "isa") == 0)
1195 (void) restore_line_pointer (c
);
1196 value
= get_absolute_expression ();
1198 current
.isa
= value
;
1201 as_bad (_("isa number less than zero"));
1205 else if (strcmp (p
, "discriminator") == 0)
1207 (void) restore_line_pointer (c
);
1208 value
= get_absolute_expression ();
1210 current
.discriminator
= value
;
1213 as_bad (_("discriminator less than zero"));
1217 else if (strcmp (p
, "view") == 0)
1221 (void) restore_line_pointer (c
);
1224 if (ISDIGIT (*input_line_pointer
)
1225 || *input_line_pointer
== '-')
1227 bfd_boolean force_reset
= *input_line_pointer
== '-';
1229 value
= get_absolute_expression ();
1232 as_bad (_("numeric view can only be asserted to zero"));
1235 if (force_reset
&& force_reset_view
)
1236 sym
= force_reset_view
;
1239 sym
= symbol_temp_new (absolute_section
, value
,
1240 &zero_address_frag
);
1242 force_reset_view
= sym
;
1247 char *name
= read_symbol_name ();
1251 sym
= symbol_find_or_make (name
);
1252 if (S_IS_DEFINED (sym
) || symbol_equated_p (sym
))
1254 if (S_IS_VOLATILE (sym
))
1255 sym
= symbol_clone (sym
, 1);
1256 else if (!S_CAN_BE_REDEFINED (sym
))
1258 as_bad (_("symbol `%s' is already defined"), name
);
1262 S_SET_SEGMENT (sym
, undefined_section
);
1263 S_SET_VALUE (sym
, 0);
1264 symbol_set_frag (sym
, &zero_address_frag
);
1270 as_bad (_("unknown .loc sub-directive `%s'"), p
);
1271 (void) restore_line_pointer (c
);
1275 SKIP_WHITESPACE_AFTER_NAME ();
1278 demand_empty_rest_of_line ();
1279 dwarf2_loc_directive_seen
= TRUE
;
1280 debug_type
= DEBUG_NONE
;
1282 /* If we were given a view id, emit the row right away. */
1284 dwarf2_emit_insn (0);
1288 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
1290 offsetT value
= get_absolute_expression ();
1292 if (value
!= 0 && value
!= 1)
1294 as_bad (_("expected 0 or 1"));
1295 ignore_rest_of_line ();
1299 dwarf2_loc_mark_labels
= value
!= 0;
1300 demand_empty_rest_of_line ();
1304 static struct frag
*
1305 first_frag_for_seg (segT seg
)
1307 return seg_info (seg
)->frchainP
->frch_root
;
1310 static struct frag
*
1311 last_frag_for_seg (segT seg
)
1313 frchainS
*f
= seg_info (seg
)->frchainP
;
1315 while (f
->frch_next
!= NULL
)
1318 return f
->frch_last
;
1321 /* Emit a single byte into the current segment. */
1326 FRAG_APPEND_1_CHAR (byte
);
1329 /* Emit a statement program opcode into the current segment. */
1332 out_opcode (int opc
)
1337 /* Emit a two-byte word into the current segment. */
1342 md_number_to_chars (frag_more (2), data
, 2);
1345 /* Emit a four byte word into the current segment. */
1350 md_number_to_chars (frag_more (4), data
, 4);
1353 /* Emit an unsigned "little-endian base 128" number. */
1356 out_uleb128 (addressT value
)
1358 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1361 /* Emit a signed "little-endian base 128" number. */
1364 out_leb128 (addressT value
)
1366 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1369 /* Emit a tuple for .debug_abbrev. */
1372 out_abbrev (int name
, int form
)
1378 /* Get the size of a fragment. */
1381 get_frag_fix (fragS
*frag
, segT seg
)
1386 return frag
->fr_fix
;
1388 /* If a fragment is the last in the chain, special measures must be
1389 taken to find its size before relaxation, since it may be pending
1390 on some subsegment chain. */
1391 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1392 if (fr
->frch_last
== frag
)
1393 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1398 /* Set an absolute address (may result in a relocation entry). */
1401 out_set_addr (symbolS
*sym
)
1405 memset (&exp
, 0, sizeof exp
);
1406 out_opcode (DW_LNS_extended_op
);
1407 out_uleb128 (sizeof_address
+ 1);
1409 out_opcode (DW_LNE_set_address
);
1410 exp
.X_op
= O_symbol
;
1411 exp
.X_add_symbol
= sym
;
1412 exp
.X_add_number
= 0;
1413 emit_expr (&exp
, sizeof_address
);
1416 static void scale_addr_delta (addressT
*);
1419 scale_addr_delta (addressT
*addr_delta
)
1421 static int printed_this
= 0;
1422 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1424 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1426 as_bad("unaligned opcodes detected in executable segment");
1429 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1433 /* Encode a pair of line and address skips as efficiently as possible.
1434 Note that the line skip is signed, whereas the address skip is unsigned.
1436 The following two routines *must* be kept in sync. This is
1437 enforced by making emit_inc_line_addr abort if we do not emit
1438 exactly the expected number of bytes. */
1441 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1443 unsigned int tmp
, opcode
;
1446 /* Scale the address delta by the minimum instruction length. */
1447 scale_addr_delta (&addr_delta
);
1449 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1450 We cannot use special opcodes here, since we want the end_sequence
1451 to emit the matrix entry. */
1452 if (line_delta
== INT_MAX
)
1454 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1456 else if (addr_delta
)
1457 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1461 /* Bias the line delta by the base. */
1462 tmp
= line_delta
- DWARF2_LINE_BASE
;
1464 /* If the line increment is out of range of a special opcode, we
1465 must encode it with DW_LNS_advance_line. */
1466 if (tmp
>= DWARF2_LINE_RANGE
)
1468 len
= 1 + sizeof_leb128 (line_delta
, 1);
1470 tmp
= 0 - DWARF2_LINE_BASE
;
1473 /* Bias the opcode by the special opcode base. */
1474 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1476 /* Avoid overflow when addr_delta is large. */
1477 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1479 /* Try using a special opcode. */
1480 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1484 /* Try using DW_LNS_const_add_pc followed by special op. */
1485 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1490 /* Otherwise use DW_LNS_advance_pc. */
1491 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1493 /* DW_LNS_copy or special opcode. */
1500 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1502 unsigned int tmp
, opcode
;
1504 char *end
= p
+ len
;
1506 /* Line number sequences cannot go backward in addresses. This means
1507 we've incorrectly ordered the statements in the sequence. */
1508 gas_assert ((offsetT
) addr_delta
>= 0);
1510 /* Scale the address delta by the minimum instruction length. */
1511 scale_addr_delta (&addr_delta
);
1513 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1514 We cannot use special opcodes here, since we want the end_sequence
1515 to emit the matrix entry. */
1516 if (line_delta
== INT_MAX
)
1518 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1519 *p
++ = DW_LNS_const_add_pc
;
1520 else if (addr_delta
)
1522 *p
++ = DW_LNS_advance_pc
;
1523 p
+= output_leb128 (p
, addr_delta
, 0);
1526 *p
++ = DW_LNS_extended_op
;
1528 *p
++ = DW_LNE_end_sequence
;
1532 /* Bias the line delta by the base. */
1533 tmp
= line_delta
- DWARF2_LINE_BASE
;
1535 /* If the line increment is out of range of a special opcode, we
1536 must encode it with DW_LNS_advance_line. */
1537 if (tmp
>= DWARF2_LINE_RANGE
)
1539 *p
++ = DW_LNS_advance_line
;
1540 p
+= output_leb128 (p
, line_delta
, 1);
1543 tmp
= 0 - DWARF2_LINE_BASE
;
1547 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1549 if (line_delta
== 0 && addr_delta
== 0)
1555 /* Bias the opcode by the special opcode base. */
1556 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1558 /* Avoid overflow when addr_delta is large. */
1559 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1561 /* Try using a special opcode. */
1562 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1569 /* Try using DW_LNS_const_add_pc followed by special op. */
1570 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1573 *p
++ = DW_LNS_const_add_pc
;
1579 /* Otherwise use DW_LNS_advance_pc. */
1580 *p
++ = DW_LNS_advance_pc
;
1581 p
+= output_leb128 (p
, addr_delta
, 0);
1589 gas_assert (p
== end
);
1592 /* Handy routine to combine calls to the above two routines. */
1595 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1597 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1598 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1601 /* Write out an alternative form of line and address skips using
1602 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1603 line and address information, but it is required if linker relaxation
1604 could change the code offsets. The following two routines *must* be
1606 #define ADDR_DELTA_LIMIT 50000
1609 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1613 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1614 if (line_delta
!= INT_MAX
)
1615 len
= 1 + sizeof_leb128 (line_delta
, 1);
1617 if (addr_delta
> ADDR_DELTA_LIMIT
)
1619 /* DW_LNS_extended_op */
1620 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1621 /* DW_LNE_set_address */
1622 len
+= 1 + sizeof_address
;
1625 /* DW_LNS_fixed_advance_pc */
1628 if (line_delta
== INT_MAX
)
1629 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1639 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1643 char *end
= p
+ len
;
1645 /* Line number sequences cannot go backward in addresses. This means
1646 we've incorrectly ordered the statements in the sequence. */
1647 gas_assert ((offsetT
) addr_delta
>= 0);
1649 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1650 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1652 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1653 if (line_delta
!= INT_MAX
)
1655 *p
++ = DW_LNS_advance_line
;
1656 p
+= output_leb128 (p
, line_delta
, 1);
1659 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1661 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1662 advance the address by at most 64K. Linker relaxation (without
1663 which this function would not be used) could change the operand by
1664 an unknown amount. If the address increment is getting close to
1665 the limit, just reset the address. */
1666 if (addr_delta
> ADDR_DELTA_LIMIT
)
1671 memset (&exp
, 0, sizeof exp
);
1672 gas_assert (pexp
->X_op
== O_subtract
);
1673 to_sym
= pexp
->X_add_symbol
;
1675 *p
++ = DW_LNS_extended_op
;
1676 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1677 *p
++ = DW_LNE_set_address
;
1678 exp
.X_op
= O_symbol
;
1679 exp
.X_add_symbol
= to_sym
;
1680 exp
.X_add_number
= 0;
1681 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1682 p
+= sizeof_address
;
1686 *p
++ = DW_LNS_fixed_advance_pc
;
1687 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1691 if (line_delta
== INT_MAX
)
1693 *p
++ = DW_LNS_extended_op
;
1695 *p
++ = DW_LNE_end_sequence
;
1700 gas_assert (p
== end
);
1703 /* Generate a variant frag that we can use to relax address/line
1704 increments between fragments of the target segment. */
1707 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1712 memset (&exp
, 0, sizeof exp
);
1713 exp
.X_op
= O_subtract
;
1714 exp
.X_add_symbol
= to_sym
;
1715 exp
.X_op_symbol
= from_sym
;
1716 exp
.X_add_number
= 0;
1718 /* The maximum size of the frag is the line delta with a maximum
1719 sized address delta. */
1720 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1721 max_chars
= size_fixed_inc_line_addr (line_delta
,
1722 -DWARF2_LINE_MIN_INSN_LENGTH
);
1724 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1726 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1727 make_expr_symbol (&exp
), line_delta
, NULL
);
1730 /* The function estimates the size of a rs_dwarf2dbg variant frag
1731 based on the current values of the symbols. It is called before
1732 the relaxation loop. We set fr_subtype to the expected length. */
1735 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1740 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1741 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1742 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1744 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1746 frag
->fr_subtype
= size
;
1751 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1752 current values of the symbols. fr_subtype is the current length
1753 of the frag. This returns the change in frag length. */
1756 dwarf2dbg_relax_frag (fragS
*frag
)
1758 int old_size
, new_size
;
1760 old_size
= frag
->fr_subtype
;
1761 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1763 return new_size
- old_size
;
1766 /* This function converts a rs_dwarf2dbg variant frag into a normal
1767 fill frag. This is called after all relaxation has been done.
1768 fr_subtype will be the desired length of the frag. */
1771 dwarf2dbg_convert_frag (fragS
*frag
)
1775 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1777 /* If linker relaxation is enabled then the distance between the two
1778 symbols in the frag->fr_symbol expression might change. Hence we
1779 cannot rely upon the value computed by resolve_symbol_value.
1780 Instead we leave the expression unfinalized and allow
1781 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1782 relocation) that will allow the linker to correctly compute the
1783 actual address difference. We have to use a fixed line advance for
1784 this as we cannot (easily) relocate leb128 encoded values. */
1785 int saved_finalize_syms
= finalize_syms
;
1788 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1789 finalize_syms
= saved_finalize_syms
;
1792 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1794 /* fr_var carries the max_chars that we created the fragment with.
1795 fr_subtype carries the current expected length. We must, of
1796 course, have allocated enough memory earlier. */
1797 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1799 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1800 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1801 frag
->fr_literal
+ frag
->fr_fix
,
1804 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1805 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1807 frag
->fr_fix
+= frag
->fr_subtype
;
1808 frag
->fr_type
= rs_fill
;
1810 frag
->fr_offset
= 0;
1813 /* Generate .debug_line content for the chain of line number entries
1814 beginning at E, for segment SEG. */
1817 process_entries (segT seg
, struct line_entry
*e
)
1819 unsigned filenum
= 1;
1821 unsigned column
= 0;
1823 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1824 fragS
*last_frag
= NULL
, *frag
;
1825 addressT last_frag_ofs
= 0, frag_ofs
;
1826 symbolS
*last_lab
= NULL
, *lab
;
1827 struct line_entry
*next
;
1829 if (flag_dwarf_sections
)
1832 const char * sec_name
;
1834 /* Switch to the relevant sub-section before we start to emit
1835 the line number table.
1837 FIXME: These sub-sections do not have a normal Line Number
1838 Program Header, thus strictly speaking they are not valid
1839 DWARF sections. Unfortunately the DWARF standard assumes
1840 a one-to-one relationship between compilation units and
1841 line number tables. Thus we have to have a .debug_line
1842 section, as well as our sub-sections, and we have to ensure
1843 that all of the sub-sections are merged into a proper
1844 .debug_line section before a debugger sees them. */
1846 sec_name
= bfd_section_name (seg
);
1847 if (strcmp (sec_name
, ".text") != 0)
1849 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1850 subseg_set (subseg_get (name
, FALSE
), 0);
1853 /* Don't create a .debug_line.text section -
1854 that is redundant. Instead just switch back to the
1855 normal .debug_line section. */
1856 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1863 if (filenum
!= e
->loc
.filenum
)
1865 filenum
= e
->loc
.filenum
;
1866 out_opcode (DW_LNS_set_file
);
1867 out_uleb128 (filenum
);
1870 if (column
!= e
->loc
.column
)
1872 column
= e
->loc
.column
;
1873 out_opcode (DW_LNS_set_column
);
1874 out_uleb128 (column
);
1877 if (e
->loc
.discriminator
!= 0)
1879 out_opcode (DW_LNS_extended_op
);
1880 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1881 out_opcode (DW_LNE_set_discriminator
);
1882 out_uleb128 (e
->loc
.discriminator
);
1885 if (isa
!= e
->loc
.isa
)
1888 out_opcode (DW_LNS_set_isa
);
1892 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1894 flags
= e
->loc
.flags
;
1895 out_opcode (DW_LNS_negate_stmt
);
1898 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1899 out_opcode (DW_LNS_set_basic_block
);
1901 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1902 out_opcode (DW_LNS_set_prologue_end
);
1904 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1905 out_opcode (DW_LNS_set_epilogue_begin
);
1907 /* Don't try to optimize away redundant entries; gdb wants two
1908 entries for a function where the code starts on the same line as
1909 the {, and there's no way to identify that case here. Trust gcc
1910 to optimize appropriately. */
1911 line_delta
= e
->loc
.line
- line
;
1913 frag
= symbol_get_frag (lab
);
1914 frag_ofs
= S_GET_VALUE (lab
);
1916 if (last_frag
== NULL
1917 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1918 /* If we're going to reset the view, but we know we're
1919 advancing the PC, we don't have to force with
1920 set_address. We know we do when we're at the same
1921 address of the same frag, and we know we might when
1922 we're in the beginning of a frag, and we were at the
1923 end of the previous frag. */
1924 && (frag
== last_frag
1925 ? (last_frag_ofs
== frag_ofs
)
1927 && ((offsetT
)last_frag_ofs
1928 >= get_frag_fix (last_frag
, seg
))))))
1931 out_inc_line_addr (line_delta
, 0);
1933 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1934 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1936 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1941 last_frag_ofs
= frag_ofs
;
1949 /* Emit a DW_LNE_end_sequence for the end of the section. */
1950 frag
= last_frag_for_seg (seg
);
1951 frag_ofs
= get_frag_fix (frag
, seg
);
1952 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1953 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1956 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1957 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1961 /* Emit the directory and file tables for .debug_line. */
1964 out_dir_and_file_list (void)
1970 bfd_boolean emit_md5
= FALSE
;
1971 bfd_boolean emit_timestamps
= TRUE
;
1972 bfd_boolean emit_filesize
= TRUE
;
1974 /* Output the Directory Table. */
1976 if (DWARF2_LINE_VERSION
>= 5)
1979 out_uleb128 (DW_LNCT_path
);
1980 /* FIXME: it would be better to store these strings in
1981 the .debug_line_str section and reference them here. */
1982 out_uleb128 (DW_FORM_string
);
1983 out_uleb128 (dirs_in_use
);
1986 /* Emit directory list. */
1987 if (DWARF2_LINE_VERSION
>= 5)
1989 if (dirs
[0] == NULL
)
1990 dir
= remap_debug_filename (".");
1992 dir
= remap_debug_filename (dirs
[0]);
1994 size
= strlen (dir
) + 1;
1995 cp
= frag_more (size
);
1996 memcpy (cp
, dir
, size
);
1998 for (i
= 1; i
< dirs_in_use
; ++i
)
2000 dir
= remap_debug_filename (dirs
[i
]);
2001 size
= strlen (dir
) + 1;
2002 cp
= frag_more (size
);
2003 memcpy (cp
, dir
, size
);
2006 if (DWARF2_LINE_VERSION
< 5)
2010 /* Output the File Name Table. */
2012 if (DWARF2_LINE_VERSION
>= 5)
2014 unsigned int columns
= 4;
2016 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
2018 emit_timestamps
= FALSE
;
2022 if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
2024 emit_filesize
= FALSE
;
2028 for (i
= 0; i
< files_in_use
; ++i
)
2029 if (files
[i
].md5
[0] != 0)
2031 if (i
< files_in_use
)
2037 /* The number of format entries to follow. */
2040 /* The format of the file name. */
2041 out_uleb128 (DW_LNCT_path
);
2042 /* FIXME: it would be better to store these strings in
2043 the .debug_line_str section and reference them here. */
2044 out_uleb128 (DW_FORM_string
);
2046 /* The format of the directory index. */
2047 out_uleb128 (DW_LNCT_directory_index
);
2048 out_uleb128 (DW_FORM_udata
);
2050 if (emit_timestamps
)
2052 /* The format of the timestamp. */
2053 out_uleb128 (DW_LNCT_timestamp
);
2054 out_uleb128 (DW_FORM_udata
);
2059 /* The format of the file size. */
2060 out_uleb128 (DW_LNCT_size
);
2061 out_uleb128 (DW_FORM_udata
);
2066 /* The format of the MD5 sum. */
2067 out_uleb128 (DW_LNCT_MD5
);
2068 out_uleb128 (DW_FORM_data16
);
2071 /* The number of entries in the table. */
2072 out_uleb128 (files_in_use
);
2075 for (i
= DWARF2_LINE_VERSION
> 4 ? 0 : 1; i
< files_in_use
; ++i
)
2077 const char *fullfilename
;
2079 if (files
[i
].filename
== NULL
)
2081 /* Prevent a crash later, particularly for file 1. */
2082 files
[i
].filename
= "";
2083 if (DWARF2_LINE_VERSION
< 5 || i
!= 0)
2085 as_bad (_("unassigned file number %ld"), (long) i
);
2090 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
2091 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2092 size
= strlen (fullfilename
) + 1;
2093 cp
= frag_more (size
);
2094 memcpy (cp
, fullfilename
, size
);
2096 /* Directory number. */
2097 out_uleb128 (files
[i
].dir
);
2099 /* Output the last modification timestamp. */
2100 if (emit_timestamps
)
2104 timestamp
= DWARF2_FILE_TIME_NAME (files
[i
].filename
,
2105 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2106 if (timestamp
== -1)
2108 out_uleb128 (timestamp
);
2111 /* Output the filesize. */
2115 filesize
= DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
2116 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
2119 out_uleb128 (filesize
);
2122 /* Output the md5 sum. */
2127 for (b
= 0; b
< NUM_MD5_BYTES
; b
++)
2128 out_byte (files
[i
].md5
[b
]);
2132 if (DWARF2_LINE_VERSION
< 5)
2133 /* Terminate filename list. */
2137 /* Switch to SEC and output a header length field. Return the size of
2138 offsets used in SEC. The caller must set EXPR->X_add_symbol value
2139 to the end of the section. EXPR->X_add_number will be set to the
2140 negative size of the header. */
2143 out_header (asection
*sec
, expressionS
*exp
)
2148 subseg_set (sec
, 0);
2150 if (flag_dwarf_sections
)
2152 /* If we are going to put the start and end symbols in different
2153 sections, then we need real symbols, not just fake, local ones. */
2155 start_sym
= symbol_make (".Ldebug_line_start");
2156 end_sym
= symbol_make (".Ldebug_line_end");
2157 symbol_set_value_now (start_sym
);
2161 start_sym
= symbol_temp_new_now_octets ();
2162 end_sym
= symbol_temp_make ();
2165 /* Total length of the information. */
2166 exp
->X_op
= O_subtract
;
2167 exp
->X_add_symbol
= end_sym
;
2168 exp
->X_op_symbol
= start_sym
;
2170 switch (DWARF2_FORMAT (sec
))
2172 case dwarf2_format_32bit
:
2173 exp
->X_add_number
= -4;
2177 case dwarf2_format_64bit
:
2178 exp
->X_add_number
= -12;
2183 case dwarf2_format_64bit_irix
:
2184 exp
->X_add_number
= -8;
2189 as_fatal (_("internal error: unknown dwarf2 format"));
2193 /* Emit the collected .debug_line data. */
2196 out_debug_line (segT line_seg
)
2199 symbolS
*prologue_start
, *prologue_end
;
2204 memset (&exp
, 0, sizeof exp
);
2205 sizeof_offset
= out_header (line_seg
, &exp
);
2206 line_end
= exp
.X_add_symbol
;
2209 out_two (DWARF2_LINE_VERSION
);
2211 if (DWARF2_LINE_VERSION
>= 5)
2213 out_byte (sizeof_address
);
2214 out_byte (0); /* Segment Selector size. */
2216 /* Length of the prologue following this length. */
2217 prologue_start
= symbol_temp_make ();
2218 prologue_end
= symbol_temp_make ();
2219 exp
.X_op
= O_subtract
;
2220 exp
.X_add_symbol
= prologue_end
;
2221 exp
.X_op_symbol
= prologue_start
;
2222 exp
.X_add_number
= 0;
2223 emit_expr (&exp
, sizeof_offset
);
2224 symbol_set_value_now (prologue_start
);
2226 /* Parameters of the state machine. */
2227 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
2228 if (DWARF2_LINE_VERSION
>= 4)
2229 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN
);
2230 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
2231 out_byte (DWARF2_LINE_BASE
);
2232 out_byte (DWARF2_LINE_RANGE
);
2233 out_byte (DWARF2_LINE_OPCODE_BASE
);
2235 /* Standard opcode lengths. */
2236 out_byte (0); /* DW_LNS_copy */
2237 out_byte (1); /* DW_LNS_advance_pc */
2238 out_byte (1); /* DW_LNS_advance_line */
2239 out_byte (1); /* DW_LNS_set_file */
2240 out_byte (1); /* DW_LNS_set_column */
2241 out_byte (0); /* DW_LNS_negate_stmt */
2242 out_byte (0); /* DW_LNS_set_basic_block */
2243 out_byte (0); /* DW_LNS_const_add_pc */
2244 out_byte (1); /* DW_LNS_fixed_advance_pc */
2245 out_byte (0); /* DW_LNS_set_prologue_end */
2246 out_byte (0); /* DW_LNS_set_epilogue_begin */
2247 out_byte (1); /* DW_LNS_set_isa */
2248 /* We have emitted 12 opcode lengths, so make that this
2249 matches up to the opcode base value we have been using. */
2250 gas_assert (DWARF2_LINE_OPCODE_BASE
== 13);
2252 out_dir_and_file_list ();
2254 symbol_set_value_now (prologue_end
);
2256 /* For each section, emit a statement program. */
2257 for (s
= all_segs
; s
; s
= s
->next
)
2258 if (SEG_NORMAL (s
->seg
))
2259 process_entries (s
->seg
, s
->head
->head
);
2261 as_warn ("dwarf line number information for %s ignored",
2262 segment_name (s
->seg
));
2264 if (flag_dwarf_sections
)
2265 /* We have to switch to the special .debug_line_end section
2266 before emitting the end-of-debug_line symbol. The linker
2267 script arranges for this section to be placed after all the
2268 (potentially garbage collected) .debug_line.<foo> sections.
2269 This section contains the line_end symbol which is used to
2270 compute the size of the linked .debug_line section, as seen
2271 in the DWARF Line Number header. */
2272 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
2274 symbol_set_value_now (line_end
);
2278 out_debug_ranges (segT ranges_seg
)
2280 unsigned int addr_size
= sizeof_address
;
2285 memset (&exp
, 0, sizeof exp
);
2286 subseg_set (ranges_seg
, 0);
2288 /* Base Address Entry. */
2289 for (i
= 0; i
< addr_size
; i
++)
2291 for (i
= 0; i
< addr_size
; i
++)
2294 /* Range List Entry. */
2295 for (s
= all_segs
; s
; s
= s
->next
)
2300 frag
= first_frag_for_seg (s
->seg
);
2301 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2302 s
->text_start
= beg
;
2304 frag
= last_frag_for_seg (s
->seg
);
2305 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2308 exp
.X_op
= O_symbol
;
2309 exp
.X_add_symbol
= beg
;
2310 exp
.X_add_number
= 0;
2311 emit_expr (&exp
, addr_size
);
2313 exp
.X_op
= O_symbol
;
2314 exp
.X_add_symbol
= end
;
2315 exp
.X_add_number
= 0;
2316 emit_expr (&exp
, addr_size
);
2319 /* End of Range Entry. */
2320 for (i
= 0; i
< addr_size
; i
++)
2322 for (i
= 0; i
< addr_size
; i
++)
2326 /* Emit data for .debug_aranges. */
2329 out_debug_aranges (segT aranges_seg
, segT info_seg
)
2331 unsigned int addr_size
= sizeof_address
;
2335 symbolS
*aranges_end
;
2339 memset (&exp
, 0, sizeof exp
);
2340 sizeof_offset
= out_header (aranges_seg
, &exp
);
2341 aranges_end
= exp
.X_add_symbol
;
2342 size
= -exp
.X_add_number
;
2345 out_two (DWARF2_ARANGES_VERSION
);
2348 /* Offset to .debug_info. */
2349 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
2350 size
+= sizeof_offset
;
2352 /* Size of an address (offset portion). */
2353 out_byte (addr_size
);
2356 /* Size of a segment descriptor. */
2360 /* Align the header. */
2361 while ((size
++ % (2 * addr_size
)) > 0)
2364 for (s
= all_segs
; s
; s
= s
->next
)
2369 frag
= first_frag_for_seg (s
->seg
);
2370 beg
= symbol_temp_new (s
->seg
, 0, frag
);
2371 s
->text_start
= beg
;
2373 frag
= last_frag_for_seg (s
->seg
);
2374 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
2377 exp
.X_op
= O_symbol
;
2378 exp
.X_add_symbol
= beg
;
2379 exp
.X_add_number
= 0;
2380 emit_expr (&exp
, addr_size
);
2382 exp
.X_op
= O_subtract
;
2383 exp
.X_add_symbol
= end
;
2384 exp
.X_op_symbol
= beg
;
2385 exp
.X_add_number
= 0;
2386 emit_expr (&exp
, addr_size
);
2389 p
= frag_more (2 * addr_size
);
2390 md_number_to_chars (p
, 0, addr_size
);
2391 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
2393 symbol_set_value_now (aranges_end
);
2396 /* Emit data for .debug_abbrev. Note that this must be kept in
2397 sync with out_debug_info below. */
2400 out_debug_abbrev (segT abbrev_seg
,
2401 segT info_seg ATTRIBUTE_UNUSED
,
2402 segT line_seg ATTRIBUTE_UNUSED
)
2404 subseg_set (abbrev_seg
, 0);
2407 out_uleb128 (DW_TAG_compile_unit
);
2408 out_byte (DW_CHILDREN_no
);
2409 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
2410 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
2412 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
2413 if (all_segs
->next
== NULL
)
2415 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
2416 if (DWARF2_VERSION
< 4)
2417 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
2419 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
2420 ? DW_FORM_data4
: DW_FORM_data8
));
2424 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
2425 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
2427 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
2429 out_abbrev (DW_AT_name
, DW_FORM_strp
);
2430 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
2431 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
2432 out_abbrev (DW_AT_language
, DW_FORM_data2
);
2435 /* Terminate the abbreviations for this compilation unit. */
2439 /* Emit a description of this compilation unit for .debug_info. */
2442 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
2443 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2449 memset (&exp
, 0, sizeof exp
);
2450 sizeof_offset
= out_header (info_seg
, &exp
);
2451 info_end
= exp
.X_add_symbol
;
2453 /* DWARF version. */
2454 out_two (DWARF2_VERSION
);
2456 /* .debug_abbrev offset */
2457 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2459 /* Target address size. */
2460 out_byte (sizeof_address
);
2462 /* DW_TAG_compile_unit DIE abbrev */
2465 /* DW_AT_stmt_list */
2466 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2467 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2470 /* These two attributes are emitted if all of the code is contiguous. */
2471 if (all_segs
->next
== NULL
)
2474 exp
.X_op
= O_symbol
;
2475 exp
.X_add_symbol
= all_segs
->text_start
;
2476 exp
.X_add_number
= 0;
2477 emit_expr (&exp
, sizeof_address
);
2480 if (DWARF2_VERSION
< 4)
2481 exp
.X_op
= O_symbol
;
2484 exp
.X_op
= O_subtract
;
2485 exp
.X_op_symbol
= all_segs
->text_start
;
2487 exp
.X_add_symbol
= all_segs
->text_end
;
2488 exp
.X_add_number
= 0;
2489 emit_expr (&exp
, sizeof_address
);
2493 /* This attribute is emitted if the code is disjoint. */
2495 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2498 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2499 setup in out_debug_str below. */
2500 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2501 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2502 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2504 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2505 dwarf2 draft has no standard code for assembler. */
2506 out_two (DW_LANG_Mips_Assembler
);
2508 symbol_set_value_now (info_end
);
2511 /* Emit the three debug strings needed in .debug_str and setup symbols
2512 to them for use in out_debug_info. */
2514 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2515 symbolS
**producer_sym
)
2518 const char *comp_dir
;
2519 const char *dirname
;
2522 int first_file
= DWARF2_LINE_VERSION
> 4 ? 0 : 1;
2524 subseg_set (str_seg
, 0);
2526 /* DW_AT_name. We don't have the actual file name that was present
2527 on the command line, so assume files[first_file] is the main input file.
2528 We're not supposed to get called unless at least one line number
2529 entry was emitted, so this should always be defined. */
2530 *name_sym
= symbol_temp_new_now_octets ();
2531 if (files_in_use
== 0)
2533 if (files
[first_file
].dir
)
2535 dirname
= remap_debug_filename (dirs
[files
[first_file
].dir
]);
2536 len
= strlen (dirname
);
2538 /* Already has trailing slash. */
2539 p
= frag_more (len
);
2540 memcpy (p
, dirname
, len
);
2542 p
= frag_more (len
+ 1);
2543 memcpy (p
, dirname
, len
);
2544 INSERT_DIR_SEPARATOR (p
, len
);
2547 len
= strlen (files
[first_file
].filename
) + 1;
2548 p
= frag_more (len
);
2549 memcpy (p
, files
[first_file
].filename
, len
);
2551 /* DW_AT_comp_dir */
2552 *comp_dir_sym
= symbol_temp_new_now_octets ();
2553 comp_dir
= remap_debug_filename (getpwd ());
2554 len
= strlen (comp_dir
) + 1;
2555 p
= frag_more (len
);
2556 memcpy (p
, comp_dir
, len
);
2558 /* DW_AT_producer */
2559 *producer_sym
= symbol_temp_new_now_octets ();
2560 sprintf (producer
, "GNU AS %s", VERSION
);
2561 len
= strlen (producer
) + 1;
2562 p
= frag_more (len
);
2563 memcpy (p
, producer
, len
);
2569 last_seg_ptr
= &all_segs
;
2571 /* Select the default CIE version to produce here. The global
2572 starts with a value of -1 and will be modified to a valid value
2573 either by the user providing a command line option, or some
2574 targets will select their own default in md_after_parse_args. If
2575 we get here and the global still contains -1 then it is up to us
2576 to pick a sane default. The default we choose is 1, this is the
2577 CIE version gas has produced for a long time, and there seems no
2578 reason to change it yet. */
2579 if (flag_dwarf_cie_version
== -1)
2580 flag_dwarf_cie_version
= 1;
2584 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2585 were any .file/.loc directives, or --gdwarf2 was given, or if the
2586 file has a non-empty .debug_info section and an empty .debug_line
2587 section. If we emit .debug_line, and the .debug_info section is
2588 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2589 ALL_SEGS will be non-null if there were any .file/.loc directives,
2590 or --gdwarf2 was given and there were any located instructions
2594 dwarf2_finish (void)
2599 int emit_other_sections
= 0;
2600 int empty_debug_line
= 0;
2602 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2603 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2605 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2606 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2608 /* We can't construct a new debug_line section if we already have one.
2610 if (all_segs
&& !empty_debug_line
)
2611 as_fatal ("duplicate .debug_line sections");
2613 if ((!all_segs
&& emit_other_sections
)
2614 || (!emit_other_sections
&& !empty_debug_line
))
2615 /* If there is no line information and no non-empty .debug_info
2616 section, or if there is both a non-empty .debug_info and a non-empty
2617 .debug_line, then we do nothing. */
2620 /* Calculate the size of an address for the target machine. */
2621 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2623 /* Create and switch to the line number section. */
2624 line_seg
= subseg_new (".debug_line", 0);
2625 bfd_set_section_flags (line_seg
, SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2627 /* For each subsection, chain the debug entries together. */
2628 for (s
= all_segs
; s
; s
= s
->next
)
2630 struct line_subseg
*lss
= s
->head
;
2631 struct line_entry
**ptail
= lss
->ptail
;
2633 /* Reset the initial view of the first subsection of the
2635 if (lss
->head
&& lss
->head
->loc
.view
)
2636 set_or_check_view (lss
->head
, NULL
, NULL
);
2638 while ((lss
= lss
->next
) != NULL
)
2640 /* Link the first view of subsequent subsections to the
2642 if (lss
->head
&& lss
->head
->loc
.view
)
2643 set_or_check_view (lss
->head
,
2644 !s
->head
? NULL
: (struct line_entry
*)ptail
,
2645 s
->head
? s
->head
->head
: NULL
);
2651 out_debug_line (line_seg
);
2653 /* If this is assembler generated line info, and there is no
2654 debug_info already, we need .debug_info, .debug_abbrev and
2655 .debug_str sections as well. */
2656 if (emit_other_sections
)
2662 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2664 gas_assert (all_segs
);
2666 info_seg
= subseg_new (".debug_info", 0);
2667 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2668 aranges_seg
= subseg_new (".debug_aranges", 0);
2669 str_seg
= subseg_new (".debug_str", 0);
2671 bfd_set_section_flags (info_seg
,
2672 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2673 bfd_set_section_flags (abbrev_seg
,
2674 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2675 bfd_set_section_flags (aranges_seg
,
2676 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2677 bfd_set_section_flags (str_seg
,
2678 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
2679 | SEC_MERGE
| SEC_STRINGS
);
2680 str_seg
->entsize
= 1;
2682 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2684 if (all_segs
->next
== NULL
)
2688 ranges_seg
= subseg_new (".debug_ranges", 0);
2689 bfd_set_section_flags (ranges_seg
,
2690 SEC_READONLY
| SEC_DEBUGGING
| SEC_OCTETS
);
2691 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2692 out_debug_ranges (ranges_seg
);
2695 out_debug_aranges (aranges_seg
, info_seg
);
2696 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2697 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2698 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2699 name_sym
, comp_dir_sym
, producer_sym
);
2703 /* Perform any deferred checks pertaining to debug information. */
2706 dwarf2dbg_final_check (void)
2708 /* Perform reset-view checks. Don't evaluate view_assert_failed
2709 recursively: it could be very deep. It's a chain of adds, with
2710 each chain element pointing to the next in X_add_symbol, and
2711 holding the check value in X_op_symbol. */
2712 while (view_assert_failed
)
2718 gas_assert (!symbol_resolved_p (view_assert_failed
));
2720 exp
= symbol_get_value_expression (view_assert_failed
);
2721 sym
= view_assert_failed
;
2723 /* If view_assert_failed looks like a compound check in the
2724 chain, break it up. */
2725 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2727 view_assert_failed
= exp
->X_add_symbol
;
2728 sym
= exp
->X_op_symbol
;
2731 view_assert_failed
= NULL
;
2733 failed
= resolve_symbol_value (sym
);
2734 if (!symbol_resolved_p (sym
) || failed
)
2736 as_bad (_("view number mismatch"));