1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2017 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) 0
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION 2
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 output version 2 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION 2
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 /* Given a special op, return the line skip amount. */
151 #define SPECIAL_LINE(op) \
152 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
154 /* Given a special op, return the address skip amount (in units of
155 DWARF2_LINE_MIN_INSN_LENGTH. */
156 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
158 /* The maximum address skip amount that can be encoded with a special op. */
159 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
161 #ifndef TC_PARSE_CONS_RETURN_NONE
162 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
167 struct line_entry
*next
;
169 struct dwarf2_line_info loc
;
172 /* Don't change the offset of next in line_entry. set_or_check_view
173 calls in dwarf2_gen_line_info_1 depend on it. */
174 static char unused
[offsetof(struct line_entry
, next
) ? -1 : 1]
179 struct line_subseg
*next
;
181 struct line_entry
*head
;
182 struct line_entry
**ptail
;
183 struct line_entry
**pmove_tail
;
188 struct line_seg
*next
;
190 struct line_subseg
*head
;
195 /* Collects data for all line table entries during assembly. */
196 static struct line_seg
*all_segs
;
197 static struct line_seg
**last_seg_ptr
;
201 const char *filename
;
205 /* Table of files used by .debug_line. */
206 static struct file_entry
*files
;
207 static unsigned int files_in_use
;
208 static unsigned int files_allocated
;
210 /* Table of directories used by .debug_line. */
212 static unsigned int dirs_in_use
;
213 static unsigned int dirs_allocated
;
215 /* TRUE when we've seen a .loc directive recently. Used to avoid
216 doing work when there's nothing to do. */
217 bfd_boolean dwarf2_loc_directive_seen
;
219 /* TRUE when we're supposed to set the basic block mark whenever a
221 bfd_boolean dwarf2_loc_mark_labels
;
223 /* Current location as indicated by the most recent .loc directive. */
224 static struct dwarf2_line_info current
=
227 DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0,
231 /* This symbol is used to recognize view number forced resets in loc
233 static symbolS
*force_reset_view
;
235 /* This symbol evaluates to an expression that, if nonzero, indicates
236 some view assert check failed. */
237 static symbolS
*view_assert_failed
;
239 /* The size of an address on the target. */
240 static unsigned int sizeof_address
;
242 static unsigned int get_filenum (const char *, unsigned int);
244 #ifndef TC_DWARF2_EMIT_OFFSET
245 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
247 /* Create an offset to .dwarf2_*. */
250 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
255 exp
.X_add_symbol
= symbol
;
256 exp
.X_add_number
= 0;
257 emit_expr (&exp
, size
);
261 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
263 static struct line_subseg
*
264 get_line_subseg (segT seg
, subsegT subseg
, bfd_boolean create_p
)
266 struct line_seg
*s
= seg_info (seg
)->dwarf2_line_seg
;
267 struct line_subseg
**pss
, *lss
;
274 s
= XNEW (struct line_seg
);
279 last_seg_ptr
= &s
->next
;
280 seg_info (seg
)->dwarf2_line_seg
= s
;
282 gas_assert (seg
== s
->seg
);
284 for (pss
= &s
->head
; (lss
= *pss
) != NULL
; pss
= &lss
->next
)
286 if (lss
->subseg
== subseg
)
288 if (lss
->subseg
> subseg
)
292 lss
= XNEW (struct line_subseg
);
294 lss
->subseg
= subseg
;
296 lss
->ptail
= &lss
->head
;
297 lss
->pmove_tail
= &lss
->head
;
304 /* (Un)reverse the line_entry list starting from H. */
306 static struct line_entry
*
307 reverse_line_entry_list (struct line_entry
*h
)
309 struct line_entry
*p
= NULL
, *e
, *n
;
311 for (e
= h
; e
; e
= n
)
320 /* Compute the view for E based on the previous entry P. If we
321 introduce an (undefined) view symbol for P, and H is given (P must
322 be the tail in this case), introduce view symbols for earlier list
323 entries as well, until one of them is constant. */
326 set_or_check_view (struct line_entry
*e
, struct line_entry
*p
,
327 struct line_entry
*h
)
331 memset (&viewx
, 0, sizeof (viewx
));
332 viewx
.X_unsigned
= 1;
334 /* First, compute !(E->label > P->label), to tell whether or not
335 we're to reset the view number. If we can't resolve it to a
336 constant, keep it symbolic. */
337 if (!p
|| (e
->loc
.view
== force_reset_view
&& force_reset_view
))
339 viewx
.X_op
= O_constant
;
340 viewx
.X_add_number
= 0;
341 viewx
.X_add_symbol
= NULL
;
342 viewx
.X_op_symbol
= NULL
;
347 viewx
.X_add_number
= 0;
348 viewx
.X_add_symbol
= e
->label
;
349 viewx
.X_op_symbol
= p
->label
;
350 resolve_expression (&viewx
);
351 if (viewx
.X_op
== O_constant
)
352 viewx
.X_add_number
= !viewx
.X_add_number
;
355 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
356 viewx
.X_add_number
= 0;
357 viewx
.X_op_symbol
= NULL
;
358 viewx
.X_op
= O_logical_not
;
362 if (S_IS_DEFINED (e
->loc
.view
) && symbol_constant_p (e
->loc
.view
))
364 expressionS
*value
= symbol_get_value_expression (e
->loc
.view
);
365 /* We can't compare the view numbers at this point, because in
366 VIEWX we've only determined whether we're to reset it so
368 if (viewx
.X_op
== O_constant
)
370 if (!value
->X_add_number
!= !viewx
.X_add_number
)
371 as_bad (_("view number mismatch"));
373 /* Record the expression to check it later. It is the result of
374 a logical not, thus 0 or 1. We just add up all such deferred
375 expressions, and resolve it at the end. */
376 else if (!value
->X_add_number
)
378 symbolS
*deferred
= make_expr_symbol (&viewx
);
379 if (view_assert_failed
)
382 memset (&chk
, 0, sizeof (chk
));
385 chk
.X_add_number
= 0;
386 chk
.X_add_symbol
= view_assert_failed
;
387 chk
.X_op_symbol
= deferred
;
388 deferred
= make_expr_symbol (&chk
);
390 view_assert_failed
= deferred
;
394 if (viewx
.X_op
!= O_constant
|| viewx
.X_add_number
)
400 p
->loc
.view
= symbol_temp_make ();
401 gas_assert (!S_IS_DEFINED (p
->loc
.view
));
404 memset (&incv
, 0, sizeof (incv
));
406 incv
.X_op
= O_symbol
;
407 incv
.X_add_symbol
= p
->loc
.view
;
408 incv
.X_add_number
= 1;
410 if (viewx
.X_op
== O_constant
)
412 gas_assert (viewx
.X_add_number
== 1);
417 viewx
.X_add_symbol
= make_expr_symbol (&viewx
);
418 viewx
.X_add_number
= 0;
419 viewx
.X_op_symbol
= make_expr_symbol (&incv
);
420 viewx
.X_op
= O_multiply
;
424 if (!S_IS_DEFINED (e
->loc
.view
))
426 symbol_set_value_expression (e
->loc
.view
, &viewx
);
427 S_SET_SEGMENT (e
->loc
.view
, absolute_section
);
428 symbol_set_frag (e
->loc
.view
, &zero_address_frag
);
431 /* Define and attempt to simplify any earlier views needed to
433 if (h
&& p
&& p
->loc
.view
&& !S_IS_DEFINED (p
->loc
.view
))
435 struct line_entry
*h2
;
436 /* Reverse the list to avoid quadratic behavior going backwards
437 in a single-linked list. */
438 struct line_entry
*r
= reverse_line_entry_list (h
);
441 /* Set or check views until we find a defined or absent view. */
443 set_or_check_view (r
, r
->next
, NULL
);
444 while (r
->next
&& r
->next
->loc
.view
&& !S_IS_DEFINED (r
->next
->loc
.view
)
447 /* Unreverse the list, so that we can go forward again. */
448 h2
= reverse_line_entry_list (p
);
449 gas_assert (h2
== h
);
451 /* Starting from the last view we just defined, attempt to
452 simplify the view expressions, until we do so to P. */
455 gas_assert (S_IS_DEFINED (r
->loc
.view
));
456 resolve_expression (symbol_get_value_expression (r
->loc
.view
));
458 while (r
!= p
&& (r
= r
->next
));
460 /* Now that we've defined and computed all earlier views that might
461 be needed to compute E's, attempt to simplify it. */
462 resolve_expression (symbol_get_value_expression (e
->loc
.view
));
466 /* Record an entry for LOC occurring at LABEL. */
469 dwarf2_gen_line_info_1 (symbolS
*label
, struct dwarf2_line_info
*loc
)
471 struct line_subseg
*lss
;
472 struct line_entry
*e
;
474 e
= XNEW (struct line_entry
);
479 lss
= get_line_subseg (now_seg
, now_subseg
, TRUE
);
482 set_or_check_view (e
,
483 !lss
->head
? NULL
: (struct line_entry
*)lss
->ptail
,
487 lss
->ptail
= &e
->next
;
490 /* Record an entry for LOC occurring at OFS within the current fragment. */
493 dwarf2_gen_line_info (addressT ofs
, struct dwarf2_line_info
*loc
)
495 static unsigned int line
= -1;
496 static unsigned int filenum
= -1;
500 /* Early out for as-yet incomplete location information. */
501 if (loc
->filenum
== 0 || loc
->line
== 0)
504 /* Don't emit sequences of line symbols for the same line when the
505 symbols apply to assembler code. It is necessary to emit
506 duplicate line symbols when a compiler asks for them, because GDB
507 uses them to determine the end of the prologue. */
508 if (debug_type
== DEBUG_DWARF2
509 && line
== loc
->line
&& filenum
== loc
->filenum
)
513 filenum
= loc
->filenum
;
519 /* Use a non-fake name for the line number location,
520 so that it can be referred to by relocations. */
521 sprintf (name
, ".Loc.%u.%u", line
, filenum
);
522 sym
= symbol_new (name
, now_seg
, ofs
, frag_now
);
525 sym
= symbol_temp_new (now_seg
, ofs
, frag_now
);
526 dwarf2_gen_line_info_1 (sym
, loc
);
529 /* Returns the current source information. If .file directives have
530 been encountered, the info for the corresponding source file is
531 returned. Otherwise, the info for the assembly source file is
535 dwarf2_where (struct dwarf2_line_info
*line
)
537 if (debug_type
== DEBUG_DWARF2
)
539 const char *filename
;
541 memset (line
, 0, sizeof (*line
));
542 filename
= as_where (&line
->line
);
543 line
->filenum
= get_filenum (filename
, 0);
545 line
->flags
= DWARF2_FLAG_IS_STMT
;
546 line
->isa
= current
.isa
;
547 line
->discriminator
= current
.discriminator
;
554 /* A hook to allow the target backend to inform the line number state
555 machine of isa changes when assembler debug info is enabled. */
558 dwarf2_set_isa (unsigned int isa
)
563 /* Called for each machine instruction, or relatively atomic group of
564 machine instructions (ie built-in macro). The instruction or group
565 is SIZE bytes in length. If dwarf2 line number generation is called
566 for, emit a line statement appropriately. */
569 dwarf2_emit_insn (int size
)
571 struct dwarf2_line_info loc
;
573 if (debug_type
!= DEBUG_DWARF2
574 ? !dwarf2_loc_directive_seen
575 : !seen_at_least_1_file ())
580 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
581 dwarf2_consume_line_info ();
584 /* Move all previously-emitted line entries for the current position by
585 DELTA bytes. This function cannot be used to move the same entries
589 dwarf2_move_insn (int delta
)
591 struct line_subseg
*lss
;
592 struct line_entry
*e
;
598 lss
= get_line_subseg (now_seg
, now_subseg
, FALSE
);
602 now
= frag_now_fix ();
603 while ((e
= *lss
->pmove_tail
))
605 if (S_GET_VALUE (e
->label
) == now
)
606 S_SET_VALUE (e
->label
, now
+ delta
);
607 lss
->pmove_tail
= &e
->next
;
611 /* Called after the current line information has been either used with
612 dwarf2_gen_line_info or saved with a machine instruction for later use.
613 This resets the state of the line number information to reflect that
617 dwarf2_consume_line_info (void)
619 /* Unless we generate DWARF2 debugging information for each
620 assembler line, we only emit one line symbol for one LOC. */
621 dwarf2_loc_directive_seen
= FALSE
;
623 current
.flags
&= ~(DWARF2_FLAG_BASIC_BLOCK
624 | DWARF2_FLAG_PROLOGUE_END
625 | DWARF2_FLAG_EPILOGUE_BEGIN
);
626 current
.discriminator
= 0;
629 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
630 is enabled, emit a basic block marker. */
633 dwarf2_emit_label (symbolS
*label
)
635 struct dwarf2_line_info loc
;
637 if (!dwarf2_loc_mark_labels
)
639 if (S_GET_SEGMENT (label
) != now_seg
)
641 if (!(bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
))
643 if (files_in_use
== 0 && debug_type
!= DEBUG_DWARF2
)
648 loc
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
650 dwarf2_gen_line_info_1 (label
, &loc
);
651 dwarf2_consume_line_info ();
654 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
655 allocate it on that file table slot, otherwise return the first
659 get_filenum (const char *filename
, unsigned int num
)
661 static unsigned int last_used
, last_used_dir_len
;
666 if (num
== 0 && last_used
)
668 if (! files
[last_used
].dir
669 && filename_cmp (filename
, files
[last_used
].filename
) == 0)
671 if (files
[last_used
].dir
672 && filename_ncmp (filename
, dirs
[files
[last_used
].dir
],
673 last_used_dir_len
) == 0
674 && IS_DIR_SEPARATOR (filename
[last_used_dir_len
])
675 && filename_cmp (filename
+ last_used_dir_len
+ 1,
676 files
[last_used
].filename
) == 0)
680 file
= lbasename (filename
);
681 /* Don't make empty string from / or A: from A:/ . */
682 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
683 if (file
<= filename
+ 3)
686 if (file
== filename
+ 1)
689 dir_len
= file
- filename
;
694 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
697 for (dir
= 1; dir
< dirs_in_use
; ++dir
)
698 if (filename_ncmp (filename
, dirs
[dir
], dir_len
) == 0
699 && dirs
[dir
][dir_len
] == '\0')
702 if (dir
>= dirs_in_use
)
704 if (dir
>= dirs_allocated
)
706 dirs_allocated
= dir
+ 32;
707 dirs
= XRESIZEVEC (char *, dirs
, dirs_allocated
);
710 dirs
[dir
] = xmemdup0 (filename
, dir_len
);
711 dirs_in_use
= dir
+ 1;
717 for (i
= 1; i
< files_in_use
; ++i
)
718 if (files
[i
].dir
== dir
720 && filename_cmp (file
, files
[i
].filename
) == 0)
723 last_used_dir_len
= dir_len
;
730 if (i
>= files_allocated
)
732 unsigned int old
= files_allocated
;
734 files_allocated
= i
+ 32;
735 files
= XRESIZEVEC (struct file_entry
, files
, files_allocated
);
737 memset (files
+ old
, 0, (i
+ 32 - old
) * sizeof (struct file_entry
));
740 files
[i
].filename
= num
? file
: xstrdup (file
);
742 if (files_in_use
< i
+ 1)
743 files_in_use
= i
+ 1;
745 last_used_dir_len
= dir_len
;
750 /* Handle two forms of .file directive:
751 - Pass .file "source.c" to s_app_file
752 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
754 If an entry is added to the file table, return a pointer to the filename. */
757 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED
)
763 /* Continue to accept a bare string and pass it off. */
765 if (*input_line_pointer
== '"')
771 num
= get_absolute_expression ();
772 filename
= demand_copy_C_string (&filename_len
);
773 if (filename
== NULL
)
775 demand_empty_rest_of_line ();
779 as_bad (_("file number less than one"));
783 /* A .file directive implies compiler generated debug information is
784 being supplied. Turn off gas generated debug info. */
785 debug_type
= DEBUG_NONE
;
787 if (num
< (int) files_in_use
&& files
[num
].filename
!= 0)
789 as_bad (_("file number %ld already allocated"), (long) num
);
793 get_filenum (filename
, num
);
799 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED
)
801 offsetT filenum
, line
;
803 /* If we see two .loc directives in a row, force the first one to be
805 if (dwarf2_loc_directive_seen
)
806 dwarf2_emit_insn (0);
808 filenum
= get_absolute_expression ();
810 line
= get_absolute_expression ();
814 as_bad (_("file number less than one"));
817 if (filenum
>= (int) files_in_use
|| files
[filenum
].filename
== 0)
819 as_bad (_("unassigned file number %ld"), (long) filenum
);
823 current
.filenum
= filenum
;
825 current
.discriminator
= 0;
830 if (files
[filenum
].dir
)
832 size_t dir_len
= strlen (dirs
[files
[filenum
].dir
]);
833 size_t file_len
= strlen (files
[filenum
].filename
);
834 char *cp
= XNEWVEC (char, dir_len
+ 1 + file_len
+ 1);
836 memcpy (cp
, dirs
[files
[filenum
].dir
], dir_len
);
837 INSERT_DIR_SEPARATOR (cp
, dir_len
);
838 memcpy (cp
+ dir_len
+ 1, files
[filenum
].filename
, file_len
);
839 cp
[dir_len
+ file_len
+ 1] = '\0';
840 listing_source_file (cp
);
844 listing_source_file (files
[filenum
].filename
);
845 listing_source_line (line
);
850 if (ISDIGIT (*input_line_pointer
))
852 current
.column
= get_absolute_expression ();
856 while (ISALPHA (*input_line_pointer
))
861 c
= get_symbol_name (& p
);
863 if (strcmp (p
, "basic_block") == 0)
865 current
.flags
|= DWARF2_FLAG_BASIC_BLOCK
;
866 *input_line_pointer
= c
;
868 else if (strcmp (p
, "prologue_end") == 0)
870 current
.flags
|= DWARF2_FLAG_PROLOGUE_END
;
871 *input_line_pointer
= c
;
873 else if (strcmp (p
, "epilogue_begin") == 0)
875 current
.flags
|= DWARF2_FLAG_EPILOGUE_BEGIN
;
876 *input_line_pointer
= c
;
878 else if (strcmp (p
, "is_stmt") == 0)
880 (void) restore_line_pointer (c
);
881 value
= get_absolute_expression ();
883 current
.flags
&= ~DWARF2_FLAG_IS_STMT
;
885 current
.flags
|= DWARF2_FLAG_IS_STMT
;
888 as_bad (_("is_stmt value not 0 or 1"));
892 else if (strcmp (p
, "isa") == 0)
894 (void) restore_line_pointer (c
);
895 value
= get_absolute_expression ();
900 as_bad (_("isa number less than zero"));
904 else if (strcmp (p
, "discriminator") == 0)
906 (void) restore_line_pointer (c
);
907 value
= get_absolute_expression ();
909 current
.discriminator
= value
;
912 as_bad (_("discriminator less than zero"));
916 else if (strcmp (p
, "view") == 0)
920 (void) restore_line_pointer (c
);
923 if (ISDIGIT (*input_line_pointer
)
924 || *input_line_pointer
== '-')
926 bfd_boolean force_reset
= *input_line_pointer
== '-';
928 value
= get_absolute_expression ();
931 as_bad (_("numeric view can only be asserted to zero"));
934 if (force_reset
&& force_reset_view
)
935 sym
= force_reset_view
;
938 sym
= symbol_temp_new (absolute_section
, value
,
941 force_reset_view
= sym
;
946 char *name
= read_symbol_name ();
950 sym
= symbol_find_or_make (name
);
951 if (S_IS_DEFINED (sym
))
953 if (!S_CAN_BE_REDEFINED (sym
))
954 as_bad (_("symbol `%s' is already defined"), name
);
956 sym
= symbol_clone (sym
, 1);
957 S_SET_SEGMENT (sym
, undefined_section
);
958 S_SET_VALUE (sym
, 0);
959 symbol_set_frag (sym
, &zero_address_frag
);
966 as_bad (_("unknown .loc sub-directive `%s'"), p
);
967 (void) restore_line_pointer (c
);
971 SKIP_WHITESPACE_AFTER_NAME ();
974 demand_empty_rest_of_line ();
975 dwarf2_loc_directive_seen
= TRUE
;
976 debug_type
= DEBUG_NONE
;
978 /* If we were given a view id, emit the row right away. */
980 dwarf2_emit_insn (0);
984 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED
)
986 offsetT value
= get_absolute_expression ();
988 if (value
!= 0 && value
!= 1)
990 as_bad (_("expected 0 or 1"));
991 ignore_rest_of_line ();
995 dwarf2_loc_mark_labels
= value
!= 0;
996 demand_empty_rest_of_line ();
1000 static struct frag
*
1001 first_frag_for_seg (segT seg
)
1003 return seg_info (seg
)->frchainP
->frch_root
;
1006 static struct frag
*
1007 last_frag_for_seg (segT seg
)
1009 frchainS
*f
= seg_info (seg
)->frchainP
;
1011 while (f
->frch_next
!= NULL
)
1014 return f
->frch_last
;
1017 /* Emit a single byte into the current segment. */
1022 FRAG_APPEND_1_CHAR (byte
);
1025 /* Emit a statement program opcode into the current segment. */
1028 out_opcode (int opc
)
1033 /* Emit a two-byte word into the current segment. */
1038 md_number_to_chars (frag_more (2), data
, 2);
1041 /* Emit a four byte word into the current segment. */
1046 md_number_to_chars (frag_more (4), data
, 4);
1049 /* Emit an unsigned "little-endian base 128" number. */
1052 out_uleb128 (addressT value
)
1054 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1057 /* Emit a signed "little-endian base 128" number. */
1060 out_leb128 (addressT value
)
1062 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1065 /* Emit a tuple for .debug_abbrev. */
1068 out_abbrev (int name
, int form
)
1074 /* Get the size of a fragment. */
1077 get_frag_fix (fragS
*frag
, segT seg
)
1082 return frag
->fr_fix
;
1084 /* If a fragment is the last in the chain, special measures must be
1085 taken to find its size before relaxation, since it may be pending
1086 on some subsegment chain. */
1087 for (fr
= seg_info (seg
)->frchainP
; fr
; fr
= fr
->frch_next
)
1088 if (fr
->frch_last
== frag
)
1089 return (char *) obstack_next_free (&fr
->frch_obstack
) - frag
->fr_literal
;
1094 /* Set an absolute address (may result in a relocation entry). */
1097 out_set_addr (symbolS
*sym
)
1101 out_opcode (DW_LNS_extended_op
);
1102 out_uleb128 (sizeof_address
+ 1);
1104 out_opcode (DW_LNE_set_address
);
1105 exp
.X_op
= O_symbol
;
1106 exp
.X_add_symbol
= sym
;
1107 exp
.X_add_number
= 0;
1108 emit_expr (&exp
, sizeof_address
);
1111 static void scale_addr_delta (addressT
*);
1114 scale_addr_delta (addressT
*addr_delta
)
1116 static int printed_this
= 0;
1117 if (DWARF2_LINE_MIN_INSN_LENGTH
> 1)
1119 if (*addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
!= 0 && !printed_this
)
1121 as_bad("unaligned opcodes detected in executable segment");
1124 *addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
1128 /* Encode a pair of line and address skips as efficiently as possible.
1129 Note that the line skip is signed, whereas the address skip is unsigned.
1131 The following two routines *must* be kept in sync. This is
1132 enforced by making emit_inc_line_addr abort if we do not emit
1133 exactly the expected number of bytes. */
1136 size_inc_line_addr (int line_delta
, addressT addr_delta
)
1138 unsigned int tmp
, opcode
;
1141 /* Scale the address delta by the minimum instruction length. */
1142 scale_addr_delta (&addr_delta
);
1144 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1145 We cannot use special opcodes here, since we want the end_sequence
1146 to emit the matrix entry. */
1147 if (line_delta
== INT_MAX
)
1149 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1152 len
= 1 + sizeof_leb128 (addr_delta
, 0);
1156 /* Bias the line delta by the base. */
1157 tmp
= line_delta
- DWARF2_LINE_BASE
;
1159 /* If the line increment is out of range of a special opcode, we
1160 must encode it with DW_LNS_advance_line. */
1161 if (tmp
>= DWARF2_LINE_RANGE
)
1163 len
= 1 + sizeof_leb128 (line_delta
, 1);
1165 tmp
= 0 - DWARF2_LINE_BASE
;
1168 /* Bias the opcode by the special opcode base. */
1169 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1171 /* Avoid overflow when addr_delta is large. */
1172 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1174 /* Try using a special opcode. */
1175 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1179 /* Try using DW_LNS_const_add_pc followed by special op. */
1180 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1185 /* Otherwise use DW_LNS_advance_pc. */
1186 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
1188 /* DW_LNS_copy or special opcode. */
1195 emit_inc_line_addr (int line_delta
, addressT addr_delta
, char *p
, int len
)
1197 unsigned int tmp
, opcode
;
1199 char *end
= p
+ len
;
1201 /* Line number sequences cannot go backward in addresses. This means
1202 we've incorrectly ordered the statements in the sequence. */
1203 gas_assert ((offsetT
) addr_delta
>= 0);
1205 /* Scale the address delta by the minimum instruction length. */
1206 scale_addr_delta (&addr_delta
);
1208 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1209 We cannot use special opcodes here, since we want the end_sequence
1210 to emit the matrix entry. */
1211 if (line_delta
== INT_MAX
)
1213 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
1214 *p
++ = DW_LNS_const_add_pc
;
1217 *p
++ = DW_LNS_advance_pc
;
1218 p
+= output_leb128 (p
, addr_delta
, 0);
1221 *p
++ = DW_LNS_extended_op
;
1223 *p
++ = DW_LNE_end_sequence
;
1227 /* Bias the line delta by the base. */
1228 tmp
= line_delta
- DWARF2_LINE_BASE
;
1230 /* If the line increment is out of range of a special opcode, we
1231 must encode it with DW_LNS_advance_line. */
1232 if (tmp
>= DWARF2_LINE_RANGE
)
1234 *p
++ = DW_LNS_advance_line
;
1235 p
+= output_leb128 (p
, line_delta
, 1);
1238 tmp
= 0 - DWARF2_LINE_BASE
;
1242 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1244 if (line_delta
== 0 && addr_delta
== 0)
1250 /* Bias the opcode by the special opcode base. */
1251 tmp
+= DWARF2_LINE_OPCODE_BASE
;
1253 /* Avoid overflow when addr_delta is large. */
1254 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
1256 /* Try using a special opcode. */
1257 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
1264 /* Try using DW_LNS_const_add_pc followed by special op. */
1265 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
1268 *p
++ = DW_LNS_const_add_pc
;
1274 /* Otherwise use DW_LNS_advance_pc. */
1275 *p
++ = DW_LNS_advance_pc
;
1276 p
+= output_leb128 (p
, addr_delta
, 0);
1284 gas_assert (p
== end
);
1287 /* Handy routine to combine calls to the above two routines. */
1290 out_inc_line_addr (int line_delta
, addressT addr_delta
)
1292 int len
= size_inc_line_addr (line_delta
, addr_delta
);
1293 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
1296 /* Write out an alternative form of line and address skips using
1297 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1298 line and address information, but it is required if linker relaxation
1299 could change the code offsets. The following two routines *must* be
1301 #define ADDR_DELTA_LIMIT 50000
1304 size_fixed_inc_line_addr (int line_delta
, addressT addr_delta
)
1308 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1309 if (line_delta
!= INT_MAX
)
1310 len
= 1 + sizeof_leb128 (line_delta
, 1);
1312 if (addr_delta
> ADDR_DELTA_LIMIT
)
1314 /* DW_LNS_extended_op */
1315 len
+= 1 + sizeof_leb128 (sizeof_address
+ 1, 0);
1316 /* DW_LNE_set_address */
1317 len
+= 1 + sizeof_address
;
1320 /* DW_LNS_fixed_advance_pc */
1323 if (line_delta
== INT_MAX
)
1324 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1334 emit_fixed_inc_line_addr (int line_delta
, addressT addr_delta
, fragS
*frag
,
1338 char *end
= p
+ len
;
1340 /* Line number sequences cannot go backward in addresses. This means
1341 we've incorrectly ordered the statements in the sequence. */
1342 gas_assert ((offsetT
) addr_delta
>= 0);
1344 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1345 gas_assert (len
== size_fixed_inc_line_addr (line_delta
, addr_delta
));
1347 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1348 if (line_delta
!= INT_MAX
)
1350 *p
++ = DW_LNS_advance_line
;
1351 p
+= output_leb128 (p
, line_delta
, 1);
1354 pexp
= symbol_get_value_expression (frag
->fr_symbol
);
1356 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1357 advance the address by at most 64K. Linker relaxation (without
1358 which this function would not be used) could change the operand by
1359 an unknown amount. If the address increment is getting close to
1360 the limit, just reset the address. */
1361 if (addr_delta
> ADDR_DELTA_LIMIT
)
1366 gas_assert (pexp
->X_op
== O_subtract
);
1367 to_sym
= pexp
->X_add_symbol
;
1369 *p
++ = DW_LNS_extended_op
;
1370 p
+= output_leb128 (p
, sizeof_address
+ 1, 0);
1371 *p
++ = DW_LNE_set_address
;
1372 exp
.X_op
= O_symbol
;
1373 exp
.X_add_symbol
= to_sym
;
1374 exp
.X_add_number
= 0;
1375 emit_expr_fix (&exp
, sizeof_address
, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1376 p
+= sizeof_address
;
1380 *p
++ = DW_LNS_fixed_advance_pc
;
1381 emit_expr_fix (pexp
, 2, frag
, p
, TC_PARSE_CONS_RETURN_NONE
);
1385 if (line_delta
== INT_MAX
)
1387 *p
++ = DW_LNS_extended_op
;
1389 *p
++ = DW_LNE_end_sequence
;
1394 gas_assert (p
== end
);
1397 /* Generate a variant frag that we can use to relax address/line
1398 increments between fragments of the target segment. */
1401 relax_inc_line_addr (int line_delta
, symbolS
*to_sym
, symbolS
*from_sym
)
1406 exp
.X_op
= O_subtract
;
1407 exp
.X_add_symbol
= to_sym
;
1408 exp
.X_op_symbol
= from_sym
;
1409 exp
.X_add_number
= 0;
1411 /* The maximum size of the frag is the line delta with a maximum
1412 sized address delta. */
1413 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1414 max_chars
= size_fixed_inc_line_addr (line_delta
,
1415 -DWARF2_LINE_MIN_INSN_LENGTH
);
1417 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
1419 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
1420 make_expr_symbol (&exp
), line_delta
, NULL
);
1423 /* The function estimates the size of a rs_dwarf2dbg variant frag
1424 based on the current values of the symbols. It is called before
1425 the relaxation loop. We set fr_subtype to the expected length. */
1428 dwarf2dbg_estimate_size_before_relax (fragS
*frag
)
1433 addr_delta
= resolve_symbol_value (frag
->fr_symbol
);
1434 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1435 size
= size_fixed_inc_line_addr (frag
->fr_offset
, addr_delta
);
1437 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
1439 frag
->fr_subtype
= size
;
1444 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1445 current values of the symbols. fr_subtype is the current length
1446 of the frag. This returns the change in frag length. */
1449 dwarf2dbg_relax_frag (fragS
*frag
)
1451 int old_size
, new_size
;
1453 old_size
= frag
->fr_subtype
;
1454 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
1456 return new_size
- old_size
;
1459 /* This function converts a rs_dwarf2dbg variant frag into a normal
1460 fill frag. This is called after all relaxation has been done.
1461 fr_subtype will be the desired length of the frag. */
1464 dwarf2dbg_convert_frag (fragS
*frag
)
1468 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1470 /* If linker relaxation is enabled then the distance between the two
1471 symbols in the frag->fr_symbol expression might change. Hence we
1472 cannot rely upon the value computed by resolve_symbol_value.
1473 Instead we leave the expression unfinalized and allow
1474 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1475 relocation) that will allow the linker to correctly compute the
1476 actual address difference. We have to use a fixed line advance for
1477 this as we cannot (easily) relocate leb128 encoded values. */
1478 int saved_finalize_syms
= finalize_syms
;
1481 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1482 finalize_syms
= saved_finalize_syms
;
1485 addr_diff
= resolve_symbol_value (frag
->fr_symbol
);
1487 /* fr_var carries the max_chars that we created the fragment with.
1488 fr_subtype carries the current expected length. We must, of
1489 course, have allocated enough memory earlier. */
1490 gas_assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
1492 if (DWARF2_USE_FIXED_ADVANCE_PC
)
1493 emit_fixed_inc_line_addr (frag
->fr_offset
, addr_diff
, frag
,
1494 frag
->fr_literal
+ frag
->fr_fix
,
1497 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
1498 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
1500 frag
->fr_fix
+= frag
->fr_subtype
;
1501 frag
->fr_type
= rs_fill
;
1503 frag
->fr_offset
= 0;
1506 /* Generate .debug_line content for the chain of line number entries
1507 beginning at E, for segment SEG. */
1510 process_entries (segT seg
, struct line_entry
*e
)
1512 unsigned filenum
= 1;
1514 unsigned column
= 0;
1516 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_IS_STMT
: 0;
1517 fragS
*last_frag
= NULL
, *frag
;
1518 addressT last_frag_ofs
= 0, frag_ofs
;
1519 symbolS
*last_lab
= NULL
, *lab
;
1520 struct line_entry
*next
;
1522 if (flag_dwarf_sections
)
1525 const char * sec_name
;
1527 /* Switch to the relevant sub-section before we start to emit
1528 the line number table.
1530 FIXME: These sub-sections do not have a normal Line Number
1531 Program Header, thus strictly speaking they are not valid
1532 DWARF sections. Unfortunately the DWARF standard assumes
1533 a one-to-one relationship between compilation units and
1534 line number tables. Thus we have to have a .debug_line
1535 section, as well as our sub-sections, and we have to ensure
1536 that all of the sub-sections are merged into a proper
1537 .debug_line section before a debugger sees them. */
1539 sec_name
= bfd_get_section_name (stdoutput
, seg
);
1540 if (strcmp (sec_name
, ".text") != 0)
1542 name
= concat (".debug_line", sec_name
, (char *) NULL
);
1543 subseg_set (subseg_get (name
, FALSE
), 0);
1546 /* Don't create a .debug_line.text section -
1547 that is redundant. Instead just switch back to the
1548 normal .debug_line section. */
1549 subseg_set (subseg_get (".debug_line", FALSE
), 0);
1556 if (filenum
!= e
->loc
.filenum
)
1558 filenum
= e
->loc
.filenum
;
1559 out_opcode (DW_LNS_set_file
);
1560 out_uleb128 (filenum
);
1563 if (column
!= e
->loc
.column
)
1565 column
= e
->loc
.column
;
1566 out_opcode (DW_LNS_set_column
);
1567 out_uleb128 (column
);
1570 if (e
->loc
.discriminator
!= 0)
1572 out_opcode (DW_LNS_extended_op
);
1573 out_leb128 (1 + sizeof_leb128 (e
->loc
.discriminator
, 0));
1574 out_opcode (DW_LNE_set_discriminator
);
1575 out_uleb128 (e
->loc
.discriminator
);
1578 if (isa
!= e
->loc
.isa
)
1581 out_opcode (DW_LNS_set_isa
);
1585 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_IS_STMT
)
1587 flags
= e
->loc
.flags
;
1588 out_opcode (DW_LNS_negate_stmt
);
1591 if (e
->loc
.flags
& DWARF2_FLAG_BASIC_BLOCK
)
1592 out_opcode (DW_LNS_set_basic_block
);
1594 if (e
->loc
.flags
& DWARF2_FLAG_PROLOGUE_END
)
1595 out_opcode (DW_LNS_set_prologue_end
);
1597 if (e
->loc
.flags
& DWARF2_FLAG_EPILOGUE_BEGIN
)
1598 out_opcode (DW_LNS_set_epilogue_begin
);
1600 /* Don't try to optimize away redundant entries; gdb wants two
1601 entries for a function where the code starts on the same line as
1602 the {, and there's no way to identify that case here. Trust gcc
1603 to optimize appropriately. */
1604 line_delta
= e
->loc
.line
- line
;
1606 frag
= symbol_get_frag (lab
);
1607 frag_ofs
= S_GET_VALUE (lab
);
1609 if (last_frag
== NULL
1610 || (e
->loc
.view
== force_reset_view
&& force_reset_view
1611 /* If we're going to reset the view, but we know we're
1612 advancing the PC, we don't have to force with
1613 set_address. We know we do when we're at the same
1614 address of the same frag, and we know we might when
1615 we're in the beginning of a frag, and we were at the
1616 end of the previous frag. */
1617 && (frag
== last_frag
1618 ? (last_frag_ofs
== frag_ofs
)
1620 && ((offsetT
)last_frag_ofs
1621 >= get_frag_fix (last_frag
, seg
))))))
1624 out_inc_line_addr (line_delta
, 0);
1626 else if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1627 out_inc_line_addr (line_delta
, frag_ofs
- last_frag_ofs
);
1629 relax_inc_line_addr (line_delta
, lab
, last_lab
);
1634 last_frag_ofs
= frag_ofs
;
1642 /* Emit a DW_LNE_end_sequence for the end of the section. */
1643 frag
= last_frag_for_seg (seg
);
1644 frag_ofs
= get_frag_fix (frag
, seg
);
1645 if (frag
== last_frag
&& ! DWARF2_USE_FIXED_ADVANCE_PC
)
1646 out_inc_line_addr (INT_MAX
, frag_ofs
- last_frag_ofs
);
1649 lab
= symbol_temp_new (seg
, frag_ofs
, frag
);
1650 relax_inc_line_addr (INT_MAX
, lab
, last_lab
);
1654 /* Emit the directory and file tables for .debug_line. */
1657 out_file_list (void)
1664 /* Emit directory list. */
1665 for (i
= 1; i
< dirs_in_use
; ++i
)
1667 dir
= remap_debug_filename (dirs
[i
]);
1668 size
= strlen (dir
) + 1;
1669 cp
= frag_more (size
);
1670 memcpy (cp
, dir
, size
);
1675 for (i
= 1; i
< files_in_use
; ++i
)
1677 const char *fullfilename
;
1679 if (files
[i
].filename
== NULL
)
1681 as_bad (_("unassigned file number %ld"), (long) i
);
1682 /* Prevent a crash later, particularly for file 1. */
1683 files
[i
].filename
= "";
1687 fullfilename
= DWARF2_FILE_NAME (files
[i
].filename
,
1688 files
[i
].dir
? dirs
[files
[i
].dir
] : "");
1689 size
= strlen (fullfilename
) + 1;
1690 cp
= frag_more (size
);
1691 memcpy (cp
, fullfilename
, size
);
1693 out_uleb128 (files
[i
].dir
); /* directory number */
1694 /* Output the last modification timestamp. */
1695 out_uleb128 (DWARF2_FILE_TIME_NAME (files
[i
].filename
,
1696 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1697 /* Output the filesize. */
1698 out_uleb128 (DWARF2_FILE_SIZE_NAME (files
[i
].filename
,
1699 files
[i
].dir
? dirs
[files
[i
].dir
] : ""));
1702 /* Terminate filename list. */
1706 /* Switch to SEC and output a header length field. Return the size of
1707 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1708 to the end of the section. EXPR->X_add_number will be set to the
1709 negative size of the header. */
1712 out_header (asection
*sec
, expressionS
*exp
)
1717 subseg_set (sec
, 0);
1719 if (flag_dwarf_sections
)
1721 /* If we are going to put the start and end symbols in different
1722 sections, then we need real symbols, not just fake, local ones. */
1724 start_sym
= symbol_make (".Ldebug_line_start");
1725 end_sym
= symbol_make (".Ldebug_line_end");
1726 symbol_set_value_now (start_sym
);
1730 start_sym
= symbol_temp_new_now ();
1731 end_sym
= symbol_temp_make ();
1734 /* Total length of the information. */
1735 exp
->X_op
= O_subtract
;
1736 exp
->X_add_symbol
= end_sym
;
1737 exp
->X_op_symbol
= start_sym
;
1739 switch (DWARF2_FORMAT (sec
))
1741 case dwarf2_format_32bit
:
1742 exp
->X_add_number
= -4;
1746 case dwarf2_format_64bit
:
1747 exp
->X_add_number
= -12;
1752 case dwarf2_format_64bit_irix
:
1753 exp
->X_add_number
= -8;
1758 as_fatal (_("internal error: unknown dwarf2 format"));
1762 /* Emit the collected .debug_line data. */
1765 out_debug_line (segT line_seg
)
1768 symbolS
*prologue_start
, *prologue_end
;
1773 sizeof_offset
= out_header (line_seg
, &exp
);
1774 line_end
= exp
.X_add_symbol
;
1777 out_two (DWARF2_LINE_VERSION
);
1779 /* Length of the prologue following this length. */
1780 prologue_start
= symbol_temp_make ();
1781 prologue_end
= symbol_temp_make ();
1782 exp
.X_op
= O_subtract
;
1783 exp
.X_add_symbol
= prologue_end
;
1784 exp
.X_op_symbol
= prologue_start
;
1785 exp
.X_add_number
= 0;
1786 emit_expr (&exp
, sizeof_offset
);
1787 symbol_set_value_now (prologue_start
);
1789 /* Parameters of the state machine. */
1790 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
1791 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
1792 out_byte (DWARF2_LINE_BASE
);
1793 out_byte (DWARF2_LINE_RANGE
);
1794 out_byte (DWARF2_LINE_OPCODE_BASE
);
1796 /* Standard opcode lengths. */
1797 out_byte (0); /* DW_LNS_copy */
1798 out_byte (1); /* DW_LNS_advance_pc */
1799 out_byte (1); /* DW_LNS_advance_line */
1800 out_byte (1); /* DW_LNS_set_file */
1801 out_byte (1); /* DW_LNS_set_column */
1802 out_byte (0); /* DW_LNS_negate_stmt */
1803 out_byte (0); /* DW_LNS_set_basic_block */
1804 out_byte (0); /* DW_LNS_const_add_pc */
1805 out_byte (1); /* DW_LNS_fixed_advance_pc */
1806 out_byte (0); /* DW_LNS_set_prologue_end */
1807 out_byte (0); /* DW_LNS_set_epilogue_begin */
1808 out_byte (1); /* DW_LNS_set_isa */
1812 symbol_set_value_now (prologue_end
);
1814 /* For each section, emit a statement program. */
1815 for (s
= all_segs
; s
; s
= s
->next
)
1816 if (SEG_NORMAL (s
->seg
))
1817 process_entries (s
->seg
, s
->head
->head
);
1819 as_warn ("dwarf line number information for %s ignored",
1820 segment_name (s
->seg
));
1822 if (flag_dwarf_sections
)
1823 /* We have to switch to the special .debug_line_end section
1824 before emitting the end-of-debug_line symbol. The linker
1825 script arranges for this section to be placed after all the
1826 (potentially garbage collected) .debug_line.<foo> sections.
1827 This section contains the line_end symbol which is used to
1828 compute the size of the linked .debug_line section, as seen
1829 in the DWARF Line Number header. */
1830 subseg_set (subseg_get (".debug_line_end", FALSE
), 0);
1832 symbol_set_value_now (line_end
);
1836 out_debug_ranges (segT ranges_seg
)
1838 unsigned int addr_size
= sizeof_address
;
1843 subseg_set (ranges_seg
, 0);
1845 /* Base Address Entry. */
1846 for (i
= 0; i
< addr_size
; i
++)
1848 for (i
= 0; i
< addr_size
; i
++)
1851 /* Range List Entry. */
1852 for (s
= all_segs
; s
; s
= s
->next
)
1857 frag
= first_frag_for_seg (s
->seg
);
1858 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1859 s
->text_start
= beg
;
1861 frag
= last_frag_for_seg (s
->seg
);
1862 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1865 exp
.X_op
= O_symbol
;
1866 exp
.X_add_symbol
= beg
;
1867 exp
.X_add_number
= 0;
1868 emit_expr (&exp
, addr_size
);
1870 exp
.X_op
= O_symbol
;
1871 exp
.X_add_symbol
= end
;
1872 exp
.X_add_number
= 0;
1873 emit_expr (&exp
, addr_size
);
1876 /* End of Range Entry. */
1877 for (i
= 0; i
< addr_size
; i
++)
1879 for (i
= 0; i
< addr_size
; i
++)
1883 /* Emit data for .debug_aranges. */
1886 out_debug_aranges (segT aranges_seg
, segT info_seg
)
1888 unsigned int addr_size
= sizeof_address
;
1892 symbolS
*aranges_end
;
1896 sizeof_offset
= out_header (aranges_seg
, &exp
);
1897 aranges_end
= exp
.X_add_symbol
;
1898 size
= -exp
.X_add_number
;
1901 out_two (DWARF2_ARANGES_VERSION
);
1904 /* Offset to .debug_info. */
1905 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg
), sizeof_offset
);
1906 size
+= sizeof_offset
;
1908 /* Size of an address (offset portion). */
1909 out_byte (addr_size
);
1912 /* Size of a segment descriptor. */
1916 /* Align the header. */
1917 while ((size
++ % (2 * addr_size
)) > 0)
1920 for (s
= all_segs
; s
; s
= s
->next
)
1925 frag
= first_frag_for_seg (s
->seg
);
1926 beg
= symbol_temp_new (s
->seg
, 0, frag
);
1927 s
->text_start
= beg
;
1929 frag
= last_frag_for_seg (s
->seg
);
1930 end
= symbol_temp_new (s
->seg
, get_frag_fix (frag
, s
->seg
), frag
);
1933 exp
.X_op
= O_symbol
;
1934 exp
.X_add_symbol
= beg
;
1935 exp
.X_add_number
= 0;
1936 emit_expr (&exp
, addr_size
);
1938 exp
.X_op
= O_subtract
;
1939 exp
.X_add_symbol
= end
;
1940 exp
.X_op_symbol
= beg
;
1941 exp
.X_add_number
= 0;
1942 emit_expr (&exp
, addr_size
);
1945 p
= frag_more (2 * addr_size
);
1946 md_number_to_chars (p
, 0, addr_size
);
1947 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1949 symbol_set_value_now (aranges_end
);
1952 /* Emit data for .debug_abbrev. Note that this must be kept in
1953 sync with out_debug_info below. */
1956 out_debug_abbrev (segT abbrev_seg
,
1957 segT info_seg ATTRIBUTE_UNUSED
,
1958 segT line_seg ATTRIBUTE_UNUSED
)
1960 subseg_set (abbrev_seg
, 0);
1963 out_uleb128 (DW_TAG_compile_unit
);
1964 out_byte (DW_CHILDREN_no
);
1965 if (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
)
1966 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1968 out_abbrev (DW_AT_stmt_list
, DW_FORM_data8
);
1969 if (all_segs
->next
== NULL
)
1971 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1972 if (DWARF2_VERSION
< 4)
1973 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1975 out_abbrev (DW_AT_high_pc
, (sizeof_address
== 4
1976 ? DW_FORM_data4
: DW_FORM_data8
));
1980 if (DWARF2_FORMAT (info_seg
) == dwarf2_format_32bit
)
1981 out_abbrev (DW_AT_ranges
, DW_FORM_data4
);
1983 out_abbrev (DW_AT_ranges
, DW_FORM_data8
);
1985 out_abbrev (DW_AT_name
, DW_FORM_strp
);
1986 out_abbrev (DW_AT_comp_dir
, DW_FORM_strp
);
1987 out_abbrev (DW_AT_producer
, DW_FORM_strp
);
1988 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1991 /* Terminate the abbreviations for this compilation unit. */
1995 /* Emit a description of this compilation unit for .debug_info. */
1998 out_debug_info (segT info_seg
, segT abbrev_seg
, segT line_seg
, segT ranges_seg
,
1999 symbolS
*name_sym
, symbolS
*comp_dir_sym
, symbolS
*producer_sym
)
2005 sizeof_offset
= out_header (info_seg
, &exp
);
2006 info_end
= exp
.X_add_symbol
;
2008 /* DWARF version. */
2009 out_two (DWARF2_VERSION
);
2011 /* .debug_abbrev offset */
2012 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg
), sizeof_offset
);
2014 /* Target address size. */
2015 out_byte (sizeof_address
);
2017 /* DW_TAG_compile_unit DIE abbrev */
2020 /* DW_AT_stmt_list */
2021 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg
),
2022 (DWARF2_FORMAT (line_seg
) == dwarf2_format_32bit
2025 /* These two attributes are emitted if all of the code is contiguous. */
2026 if (all_segs
->next
== NULL
)
2029 exp
.X_op
= O_symbol
;
2030 exp
.X_add_symbol
= all_segs
->text_start
;
2031 exp
.X_add_number
= 0;
2032 emit_expr (&exp
, sizeof_address
);
2035 if (DWARF2_VERSION
< 4)
2036 exp
.X_op
= O_symbol
;
2039 exp
.X_op
= O_subtract
;
2040 exp
.X_op_symbol
= all_segs
->text_start
;
2042 exp
.X_add_symbol
= all_segs
->text_end
;
2043 exp
.X_add_number
= 0;
2044 emit_expr (&exp
, sizeof_address
);
2048 /* This attribute is emitted if the code is disjoint. */
2050 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg
), sizeof_offset
);
2053 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2054 setup in out_debug_str below. */
2055 TC_DWARF2_EMIT_OFFSET (name_sym
, sizeof_offset
);
2056 TC_DWARF2_EMIT_OFFSET (comp_dir_sym
, sizeof_offset
);
2057 TC_DWARF2_EMIT_OFFSET (producer_sym
, sizeof_offset
);
2059 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2060 dwarf2 draft has no standard code for assembler. */
2061 out_two (DW_LANG_Mips_Assembler
);
2063 symbol_set_value_now (info_end
);
2066 /* Emit the three debug strings needed in .debug_str and setup symbols
2067 to them for use in out_debug_info. */
2069 out_debug_str (segT str_seg
, symbolS
**name_sym
, symbolS
**comp_dir_sym
,
2070 symbolS
**producer_sym
)
2073 const char *comp_dir
;
2074 const char *dirname
;
2078 subseg_set (str_seg
, 0);
2080 /* DW_AT_name. We don't have the actual file name that was present
2081 on the command line, so assume files[1] is the main input file.
2082 We're not supposed to get called unless at least one line number
2083 entry was emitted, so this should always be defined. */
2084 *name_sym
= symbol_temp_new_now ();
2085 if (files_in_use
== 0)
2089 dirname
= remap_debug_filename (dirs
[files
[1].dir
]);
2090 len
= strlen (dirname
);
2092 /* Already has trailing slash. */
2093 p
= frag_more (len
);
2094 memcpy (p
, dirname
, len
);
2096 p
= frag_more (len
+ 1);
2097 memcpy (p
, dirname
, len
);
2098 INSERT_DIR_SEPARATOR (p
, len
);
2101 len
= strlen (files
[1].filename
) + 1;
2102 p
= frag_more (len
);
2103 memcpy (p
, files
[1].filename
, len
);
2105 /* DW_AT_comp_dir */
2106 *comp_dir_sym
= symbol_temp_new_now ();
2107 comp_dir
= remap_debug_filename (getpwd ());
2108 len
= strlen (comp_dir
) + 1;
2109 p
= frag_more (len
);
2110 memcpy (p
, comp_dir
, len
);
2112 /* DW_AT_producer */
2113 *producer_sym
= symbol_temp_new_now ();
2114 sprintf (producer
, "GNU AS %s", VERSION
);
2115 len
= strlen (producer
) + 1;
2116 p
= frag_more (len
);
2117 memcpy (p
, producer
, len
);
2123 last_seg_ptr
= &all_segs
;
2127 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2128 were any .file/.loc directives, or --gdwarf2 was given, or if the
2129 file has a non-empty .debug_info section and an empty .debug_line
2130 section. If we emit .debug_line, and the .debug_info section is
2131 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2132 ALL_SEGS will be non-null if there were any .file/.loc directives,
2133 or --gdwarf2 was given and there were any located instructions
2137 dwarf2_finish (void)
2142 int emit_other_sections
= 0;
2143 int empty_debug_line
= 0;
2145 info_seg
= bfd_get_section_by_name (stdoutput
, ".debug_info");
2146 emit_other_sections
= info_seg
== NULL
|| !seg_not_empty_p (info_seg
);
2148 line_seg
= bfd_get_section_by_name (stdoutput
, ".debug_line");
2149 empty_debug_line
= line_seg
== NULL
|| !seg_not_empty_p (line_seg
);
2151 /* We can't construct a new debug_line section if we already have one.
2153 if (all_segs
&& !empty_debug_line
)
2154 as_fatal ("duplicate .debug_line sections");
2156 if ((!all_segs
&& emit_other_sections
)
2157 || (!emit_other_sections
&& !empty_debug_line
))
2158 /* If there is no line information and no non-empty .debug_info
2159 section, or if there is both a non-empty .debug_info and a non-empty
2160 .debug_line, then we do nothing. */
2163 /* Calculate the size of an address for the target machine. */
2164 sizeof_address
= DWARF2_ADDR_SIZE (stdoutput
);
2166 /* Create and switch to the line number section. */
2167 line_seg
= subseg_new (".debug_line", 0);
2168 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
| SEC_DEBUGGING
);
2170 /* For each subsection, chain the debug entries together. */
2171 for (s
= all_segs
; s
; s
= s
->next
)
2173 struct line_subseg
*lss
= s
->head
;
2174 struct line_entry
**ptail
= lss
->ptail
;
2176 while ((lss
= lss
->next
) != NULL
)
2183 out_debug_line (line_seg
);
2185 /* If this is assembler generated line info, and there is no
2186 debug_info already, we need .debug_info, .debug_abbrev and
2187 .debug_str sections as well. */
2188 if (emit_other_sections
)
2194 symbolS
*name_sym
, *comp_dir_sym
, *producer_sym
;
2196 gas_assert (all_segs
);
2198 info_seg
= subseg_new (".debug_info", 0);
2199 abbrev_seg
= subseg_new (".debug_abbrev", 0);
2200 aranges_seg
= subseg_new (".debug_aranges", 0);
2201 str_seg
= subseg_new (".debug_str", 0);
2203 bfd_set_section_flags (stdoutput
, info_seg
,
2204 SEC_READONLY
| SEC_DEBUGGING
);
2205 bfd_set_section_flags (stdoutput
, abbrev_seg
,
2206 SEC_READONLY
| SEC_DEBUGGING
);
2207 bfd_set_section_flags (stdoutput
, aranges_seg
,
2208 SEC_READONLY
| SEC_DEBUGGING
);
2209 bfd_set_section_flags (stdoutput
, str_seg
,
2210 (SEC_READONLY
| SEC_DEBUGGING
2211 | SEC_MERGE
| SEC_STRINGS
));
2212 str_seg
->entsize
= 1;
2214 record_alignment (aranges_seg
, ffs (2 * sizeof_address
) - 1);
2216 if (all_segs
->next
== NULL
)
2220 ranges_seg
= subseg_new (".debug_ranges", 0);
2221 bfd_set_section_flags (stdoutput
, ranges_seg
,
2222 SEC_READONLY
| SEC_DEBUGGING
);
2223 record_alignment (ranges_seg
, ffs (2 * sizeof_address
) - 1);
2224 out_debug_ranges (ranges_seg
);
2227 out_debug_aranges (aranges_seg
, info_seg
);
2228 out_debug_abbrev (abbrev_seg
, info_seg
, line_seg
);
2229 out_debug_str (str_seg
, &name_sym
, &comp_dir_sym
, &producer_sym
);
2230 out_debug_info (info_seg
, abbrev_seg
, line_seg
, ranges_seg
,
2231 name_sym
, comp_dir_sym
, producer_sym
);
2235 /* Perform any deferred checks pertaining to debug information. */
2238 dwarf2dbg_final_check (void)
2240 /* Perform reset-view checks. Don't evaluate view_assert_failed
2241 recursively: it could be very deep. It's a chain of adds, with
2242 each chain element pointing to the next in X_add_symbol, and
2243 holding the check value in X_op_symbol. */
2244 while (view_assert_failed
)
2250 gas_assert (!symbol_resolved_p (view_assert_failed
));
2252 exp
= symbol_get_value_expression (view_assert_failed
);
2253 sym
= view_assert_failed
;
2255 /* If view_assert_failed looks like a compound check in the
2256 chain, break it up. */
2257 if (exp
->X_op
== O_add
&& exp
->X_add_number
== 0 && exp
->X_unsigned
)
2259 view_assert_failed
= exp
->X_add_symbol
;
2260 sym
= exp
->X_op_symbol
;
2263 view_assert_failed
= NULL
;
2265 failed
= resolve_symbol_value (sym
);
2266 if (!symbol_resolved_p (sym
) || failed
)
2268 as_bad (_("view number mismatch"));