1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999, 2000 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 2, 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, 59 Temple Place - Suite 330, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
23 following two directives:
26 .loc FILENO LINENO [COLUMN]
28 FILENO is the filenumber. */
37 #define INT_MAX (int) (((unsigned)(-1)) >> 1)
43 #include "dwarf2dbg.h"
46 #include "elf/dwarf2.h"
48 /* Since we can't generate the prolog until the body is complete, we
49 use three different subsegments for .debug_line: one holding the
50 prolog, one for the directory and filename info, and one for the
51 body ("statement program"). */
56 /* First special line opcde - leave room for the standard opcodes.
57 Note: If you want to change this, you'll have to update the
58 "standard_opcode_lengths" table that is emitted below in
60 #define DWARF2_LINE_OPCODE_BASE 10
62 #ifndef DWARF2_LINE_BASE
63 /* Minimum line offset in a special line info. opcode. This value
64 was chosen to give a reasonable range of values. */
65 # define DWARF2_LINE_BASE -5
68 /* Range of line offsets in a special line info. opcode. */
69 #ifndef DWARF2_LINE_RANGE
70 # define DWARF2_LINE_RANGE 14
73 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
74 /* Define the architecture-dependent minimum instruction length (in
75 bytes). This value should be rather too small than too big. */
76 # define DWARF2_LINE_MIN_INSN_LENGTH 1
79 /* Flag that indicates the initial value of the is_stmt_start flag.
80 In the present implementation, we do not mark any lines as
81 the beginning of a source statement, because that information
82 is not made available by the GCC front-end. */
83 #define DWARF2_LINE_DEFAULT_IS_STMT 1
85 /* Given a special op, return the line skip amount. */
86 #define SPECIAL_LINE(op) \
87 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
89 /* Given a special op, return the address skip amount (in units of
90 DWARF2_LINE_MIN_INSN_LENGTH. */
91 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
93 /* The maximum address skip amount that can be encoded with a special op. */
94 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
99 struct line_entry
*next
;
102 struct dwarf2_line_info loc
;
107 struct line_subseg
*next
;
109 struct line_entry
*head
;
110 struct line_entry
**ptail
;
115 struct line_seg
*next
;
117 struct line_subseg
*head
;
122 /* Collects data for all line table entries during assembly. */
123 static struct line_seg
*all_segs
;
131 /* Table of files used by .debug_line. */
132 static struct file_entry
*files
;
133 static unsigned int files_in_use
;
134 static unsigned int files_allocated
;
136 /* Correlate file numbers as given by the user in .file/.loc directives
137 with the file numbers used in the output debug info. */
138 static unsigned int *user_filenum
;
139 static unsigned int user_filenum_allocated
;
141 /* True when we've seen a .loc directive recently. Used to avoid
142 doing work when there's nothing to do. */
143 static boolean loc_directive_seen
;
145 /* Current location as indicated by the most recent .loc directive. */
146 static struct dwarf2_line_info current
;
148 /* Fake label name. */
149 static char const fake_label_name
[] = ".L0\001";
151 /* The size of an address on the target. */
152 static unsigned int sizeof_address
;
154 static struct line_subseg
*get_line_subseg
PARAMS ((segT
, subsegT
));
155 static unsigned int get_filenum
PARAMS ((const char *));
156 static struct frag
*first_frag_for_seg
PARAMS ((segT
));
157 static struct frag
*last_frag_for_seg
PARAMS ((segT
));
158 static void out_byte
PARAMS ((int));
159 static void out_opcode
PARAMS ((int));
160 static void out_two
PARAMS ((int));
161 static void out_four
PARAMS ((int));
162 static void out_abbrev
PARAMS ((int, int));
163 static void out_uleb128
PARAMS ((addressT
));
164 static symbolS
*symbol_new_now
PARAMS ((void));
165 static void set_symbol_value_now
PARAMS ((symbolS
*));
166 static offsetT get_frag_fix
PARAMS ((fragS
*));
167 static void out_set_addr
PARAMS ((segT
, fragS
*, addressT
));
168 static int size_inc_line_addr
PARAMS ((int, addressT
));
169 static void emit_inc_line_addr
PARAMS ((int, addressT
, char *, int));
170 static void out_inc_line_addr
PARAMS ((int, addressT
));
171 static void relax_inc_line_addr
PARAMS ((int, segT
, fragS
*, addressT
,
173 static void process_entries
PARAMS ((segT
, struct line_entry
*));
174 static void out_file_list
PARAMS ((void));
175 static void out_debug_line
PARAMS ((segT
));
176 static void out_debug_aranges
PARAMS ((segT
, segT
));
177 static void out_debug_abbrev
PARAMS ((segT
));
178 static void out_debug_info
PARAMS ((segT
, segT
, segT
));
180 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
182 static struct line_subseg
*
183 get_line_subseg (seg
, subseg
)
187 static segT last_seg
;
188 static subsegT last_subseg
;
189 static struct line_subseg
*last_line_subseg
;
192 struct line_subseg
**pss
, *ss
;
194 if (seg
== last_seg
&& subseg
== last_subseg
)
195 return last_line_subseg
;
197 for (s
= all_segs
; s
; s
= s
->next
)
201 s
= (struct line_seg
*) xmalloc (sizeof (*s
));
208 for (pss
= &s
->head
; (ss
= *pss
) != NULL
; pss
= &ss
->next
)
210 if (ss
->subseg
== subseg
)
212 if (ss
->subseg
> subseg
)
216 ss
= (struct line_subseg
*) xmalloc (sizeof (*ss
));
220 ss
->ptail
= &ss
->head
;
225 last_subseg
= subseg
;
226 last_line_subseg
= ss
;
231 /* Record an entry for LOC ocurring at OFS within the current fragment. */
234 dwarf2_gen_line_info (ofs
, loc
)
236 struct dwarf2_line_info
*loc
;
238 struct line_subseg
*ss
;
239 struct line_entry
*e
;
241 /* Early out for as-yet incomplete location information. */
242 if (loc
->filenum
== 0 || loc
->line
== 0)
245 e
= (struct line_entry
*) xmalloc (sizeof (*e
));
251 ss
= get_line_subseg (now_seg
, now_subseg
);
253 ss
->ptail
= &e
->next
;
258 struct dwarf2_line_info
*line
;
260 if (debug_type
== DEBUG_DWARF2
)
263 as_where (&filename
, &line
->line
);
264 line
->filenum
= get_filenum (filename
);
266 line
->flags
= DWARF2_FLAG_BEGIN_STMT
;
272 /* Called for each machine instruction, or relatively atomic group of
273 machine instructions (ie built-in macro). The instruction or group
274 is SIZE bytes in length. If dwarf2 line number generation is called
275 for, emit a line statement appropriately. */
278 dwarf2_emit_insn (size
)
281 struct dwarf2_line_info loc
;
283 if (debug_type
!= DEBUG_DWARF2
&& ! loc_directive_seen
)
285 loc_directive_seen
= false;
288 dwarf2_gen_line_info (frag_now_fix () - size
, &loc
);
291 /* Get a .debug_line file number for FILENAME. */
294 get_filenum (filename
)
295 const char *filename
;
297 static unsigned int last_used
;
301 if (strcmp (filename
, files
[last_used
].filename
) == 0)
304 for (i
= 1; i
< files_in_use
; ++i
)
305 if (strcmp (filename
, files
[i
].filename
) == 0)
308 if (i
>= files_allocated
)
310 files_allocated
= i
+ 32;
311 files
= (struct file_entry
*)
312 xrealloc (files
, (i
+ 32) * sizeof(struct file_entry
));
315 files
[i
].filename
= xstrdup(filename
);
317 files_in_use
= i
+ 1;
323 /* Handle the .file directive. */
326 dwarf2_directive_file (dummy
)
327 int dummy ATTRIBUTE_UNUSED
;
330 const char *filename
;
333 /* Continue to accept a bare string and pass it off. */
335 if (*input_line_pointer
== '"')
341 num
= get_absolute_expression ();
342 filename
= demand_copy_C_string (&filename_len
);
343 demand_empty_rest_of_line ();
347 as_bad (_("File number less than zero"));
351 if (num
>= (int) user_filenum_allocated
)
353 unsigned int old
= user_filenum_allocated
;
355 user_filenum_allocated
= num
+ 16;
356 user_filenum
= (unsigned int *)
357 xrealloc (user_filenum
, (num
+ 16) * sizeof (unsigned int));
359 /* Zero the new memory. */
360 memset (user_filenum
+ old
, 0, (num
+ 16 - old
) * sizeof(unsigned int));
363 user_filenum
[num
] = get_filenum (filename
);
367 dwarf2_directive_loc (dummy
)
368 int dummy ATTRIBUTE_UNUSED
;
370 offsetT filenum
, line
, column
;
372 filenum
= get_absolute_expression ();
374 line
= get_absolute_expression ();
376 column
= get_absolute_expression ();
377 demand_empty_rest_of_line ();
381 as_bad (_("File number less than zero"));
384 if (filenum
>= (int) user_filenum_allocated
385 || user_filenum
[filenum
] == 0)
387 as_bad (_("Unassigned file number %ld"), (long) filenum
);
391 current
.filenum
= user_filenum
[filenum
];
393 current
.column
= column
;
394 current
.flags
= DWARF2_FLAG_BEGIN_STMT
;
396 loc_directive_seen
= true;
400 listing_source_line (line
);
406 first_frag_for_seg (seg
)
409 frchainS
*f
, *first
= NULL
;
411 for (f
= frchain_root
; f
; f
= f
->frch_next
)
412 if (f
->frch_seg
== seg
413 && (! first
|| first
->frch_subseg
> f
->frch_subseg
))
416 return first
? first
->frch_root
: NULL
;
420 last_frag_for_seg (seg
)
423 frchainS
*f
, *last
= NULL
;
425 for (f
= frchain_root
; f
; f
= f
->frch_next
)
426 if (f
->frch_seg
== seg
427 && (! last
|| last
->frch_subseg
< f
->frch_subseg
))
430 return last
? last
->frch_last
: NULL
;
433 /* Emit a single byte into the current segment. */
439 FRAG_APPEND_1_CHAR (byte
);
442 /* Emit a statement program opcode into the current segment. */
451 /* Emit a two-byte word into the current segment. */
457 md_number_to_chars (frag_more (2), data
, 2);
460 /* Emit a four byte word into the current segment. */
466 md_number_to_chars (frag_more (4), data
, 4);
469 /* Emit an unsigned "little-endian base 128" number. */
475 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
478 /* Emit a tuple for .debug_abbrev. */
481 out_abbrev (name
, form
)
488 /* Create a new fake symbol whose value is the current position. */
493 return symbol_new (fake_label_name
, now_seg
, frag_now_fix (), frag_now
);
496 /* Set the value of SYM to the current position in the current segment. */
499 set_symbol_value_now (sym
)
502 S_SET_SEGMENT (sym
, now_seg
);
503 S_SET_VALUE (sym
, frag_now_fix ());
504 symbol_set_frag (sym
, frag_now
);
507 /* Get the size of a fragment. */
518 /* If a fragment is the last in the chain, special measures must be
519 taken to find its size before relaxation, since it may be pending
520 on some subsegment chain. */
521 for (fr
= frchain_root
; fr
; fr
= fr
->frch_next
)
522 if (fr
->frch_last
== frag
)
524 return ((char *) obstack_next_free (&fr
->frch_obstack
)
531 /* Set an absolute address (may result in a relocation entry). */
534 out_set_addr (seg
, frag
, ofs
)
542 sym
= symbol_new (fake_label_name
, seg
, ofs
, frag
);
544 out_opcode (DW_LNS_extended_op
);
545 out_uleb128 (sizeof_address
+ 1);
547 out_opcode (DW_LNE_set_address
);
548 expr
.X_op
= O_symbol
;
549 expr
.X_add_symbol
= sym
;
550 expr
.X_add_number
= 0;
551 emit_expr (&expr
, sizeof_address
);
554 /* Encode a pair of line and address skips as efficiently as possible.
555 Note that the line skip is signed, whereas the address skip is unsigned.
557 The following two routines *must* be kept in sync. This is
558 enforced by making emit_inc_line_addr abort if we do not emit
559 exactly the expected number of bytes. */
562 size_inc_line_addr (line_delta
, addr_delta
)
566 unsigned int tmp
, opcode
;
569 /* Scale the address delta by the minimum instruction length. */
570 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
571 assert (addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
== 0);
572 addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
575 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
576 We cannot use special opcodes here, since we want the end_sequence
577 to emit the matrix entry. */
578 if (line_delta
== INT_MAX
)
580 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
583 len
= 1 + sizeof_leb128 (addr_delta
, 0);
587 /* Bias the line delta by the base. */
588 tmp
= line_delta
- DWARF2_LINE_BASE
;
590 /* If the line increment is out of range of a special opcode, we
591 must encode it with DW_LNS_advance_line. */
592 if (tmp
>= DWARF2_LINE_RANGE
)
594 len
= 1 + sizeof_leb128 (line_delta
, 1);
596 tmp
= 0 - DWARF2_LINE_BASE
;
599 /* Bias the opcode by the special opcode base. */
600 tmp
+= DWARF2_LINE_OPCODE_BASE
;
602 /* Avoid overflow when addr_delta is large. */
603 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
605 /* Try using a special opcode. */
606 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
610 /* Try using DW_LNS_const_add_pc followed by special op. */
611 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
616 /* Otherwise use DW_LNS_advance_pc. */
617 len
+= 1 + sizeof_leb128 (addr_delta
, 0);
619 /* DW_LNS_copy or special opcode. */
626 emit_inc_line_addr (line_delta
, addr_delta
, p
, len
)
632 unsigned int tmp
, opcode
;
636 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
637 /* Scale the address delta by the minimum instruction length. */
638 assert (addr_delta
% DWARF2_LINE_MIN_INSN_LENGTH
== 0);
639 addr_delta
/= DWARF2_LINE_MIN_INSN_LENGTH
;
641 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
642 We cannot use special opcodes here, since we want the end_sequence
643 to emit the matrix entry. */
644 if (line_delta
== INT_MAX
)
646 if (addr_delta
== MAX_SPECIAL_ADDR_DELTA
)
647 *p
++ = DW_LNS_const_add_pc
;
650 *p
++ = DW_LNS_advance_pc
;
651 p
+= output_leb128 (p
, addr_delta
, 0);
654 *p
++ = DW_LNS_extended_op
;
656 *p
++ = DW_LNE_end_sequence
;
660 /* Bias the line delta by the base. */
661 tmp
= line_delta
- DWARF2_LINE_BASE
;
663 /* If the line increment is out of range of a special opcode, we
664 must encode it with DW_LNS_advance_line. */
665 if (tmp
>= DWARF2_LINE_RANGE
)
667 *p
++ = DW_LNS_advance_line
;
668 p
+= output_leb128 (p
, line_delta
, 1);
670 /* Prettier, I think, to use DW_LNS_copy instead of a
671 "line +0, addr +0" special opcode. */
679 tmp
= 0 - DWARF2_LINE_BASE
;
683 /* Bias the opcode by the special opcode base. */
684 tmp
+= DWARF2_LINE_OPCODE_BASE
;
686 /* Avoid overflow when addr_delta is large. */
687 if (addr_delta
< 256 + MAX_SPECIAL_ADDR_DELTA
)
689 /* Try using a special opcode. */
690 opcode
= tmp
+ addr_delta
* DWARF2_LINE_RANGE
;
697 /* Try using DW_LNS_const_add_pc followed by special op. */
698 opcode
= tmp
+ (addr_delta
- MAX_SPECIAL_ADDR_DELTA
) * DWARF2_LINE_RANGE
;
701 *p
++ = DW_LNS_const_add_pc
;
707 /* Otherwise use DW_LNS_advance_pc. */
708 *p
++ = DW_LNS_advance_pc
;
709 p
+= output_leb128 (p
, addr_delta
, 0);
720 /* Handy routine to combine calls to the above two routines. */
723 out_inc_line_addr (line_delta
, addr_delta
)
727 int len
= size_inc_line_addr (line_delta
, addr_delta
);
728 emit_inc_line_addr (line_delta
, addr_delta
, frag_more (len
), len
);
731 /* Generate a variant frag that we can use to relax address/line
732 increments between fragments of the target segment. */
735 relax_inc_line_addr (line_delta
, seg
, to_frag
, to_ofs
, from_frag
, from_ofs
)
738 fragS
*to_frag
, *from_frag
;
739 addressT to_ofs
, from_ofs
;
741 symbolS
*to_sym
, *from_sym
;
745 to_sym
= symbol_new (fake_label_name
, seg
, to_ofs
, to_frag
);
746 from_sym
= symbol_new (fake_label_name
, seg
, from_ofs
, from_frag
);
748 expr
.X_op
= O_subtract
;
749 expr
.X_add_symbol
= to_sym
;
750 expr
.X_op_symbol
= from_sym
;
751 expr
.X_add_number
= 0;
753 /* The maximum size of the frag is the line delta with a maximum
754 sized address delta. */
755 max_chars
= size_inc_line_addr (line_delta
, -DWARF2_LINE_MIN_INSN_LENGTH
);
757 frag_var (rs_dwarf2dbg
, max_chars
, max_chars
, 1,
758 make_expr_symbol (&expr
), line_delta
, NULL
);
761 /* The function estimates the size of a rs_dwarf2dbg variant frag
762 based on the current values of the symbols. It is called before
763 the relaxation loop. We set fr_subtype to the expected length. */
766 dwarf2dbg_estimate_size_before_relax (frag
)
772 addr_delta
= resolve_symbol_value (frag
->fr_symbol
, 0);
773 size
= size_inc_line_addr (frag
->fr_offset
, addr_delta
);
775 frag
->fr_subtype
= size
;
780 /* This function relaxes a rs_dwarf2dbg variant frag based on the
781 current values of the symbols. fr_subtype is the current length
782 of the frag. This returns the change in frag length. */
785 dwarf2dbg_relax_frag (frag
)
788 int old_size
, new_size
;
790 old_size
= frag
->fr_subtype
;
791 new_size
= dwarf2dbg_estimate_size_before_relax (frag
);
793 return new_size
- old_size
;
796 /* This function converts a rs_dwarf2dbg variant frag into a normal
797 fill frag. This is called after all relaxation has been done.
798 fr_subtype will be the desired length of the frag. */
801 dwarf2dbg_convert_frag (frag
)
806 addr_diff
= resolve_symbol_value (frag
->fr_symbol
, 1);
808 /* fr_var carries the max_chars that we created the fragment with.
809 fr_subtype carries the current expected length. We must, of
810 course, have allocated enough memory earlier. */
811 assert (frag
->fr_var
>= (int) frag
->fr_subtype
);
813 emit_inc_line_addr (frag
->fr_offset
, addr_diff
,
814 frag
->fr_literal
+ frag
->fr_fix
, frag
->fr_subtype
);
816 frag
->fr_fix
+= frag
->fr_subtype
;
817 frag
->fr_type
= rs_fill
;
822 /* Generate .debug_line content for the chain of line number entries
823 beginning at E, for segment SEG. */
826 process_entries (seg
, e
)
828 struct line_entry
*e
;
830 unsigned filenum
= 1;
833 unsigned flags
= DWARF2_LINE_DEFAULT_IS_STMT
? DWARF2_FLAG_BEGIN_STMT
: 0;
836 addressT frag_ofs
= 0;
837 addressT last_frag_ofs
;
838 struct line_entry
*next
;
844 if (filenum
!= e
->loc
.filenum
)
846 filenum
= e
->loc
.filenum
;
847 out_opcode (DW_LNS_set_file
);
848 out_uleb128 (filenum
);
852 if (column
!= e
->loc
.column
)
854 column
= e
->loc
.column
;
855 out_opcode (DW_LNS_set_column
);
856 out_uleb128 (column
);
860 if ((e
->loc
.flags
^ flags
) & DWARF2_FLAG_BEGIN_STMT
)
862 flags
= e
->loc
.flags
;
863 out_opcode (DW_LNS_negate_stmt
);
867 if (e
->loc
.flags
& DWARF2_FLAG_BEGIN_BLOCK
)
869 out_opcode (DW_LNS_set_basic_block
);
873 if (line
!= e
->loc
.line
|| changed
)
875 int line_delta
= e
->loc
.line
- line
;
878 out_set_addr (seg
, e
->frag
, e
->frag_ofs
);
879 out_inc_line_addr (line_delta
, 0);
881 else if (frag
== e
->frag
)
882 out_inc_line_addr (line_delta
, e
->frag_ofs
- frag_ofs
);
884 relax_inc_line_addr (line_delta
, seg
, e
->frag
, e
->frag_ofs
,
888 frag_ofs
= e
->frag_ofs
;
891 else if (frag
== NULL
)
893 out_set_addr (seg
, e
->frag
, e
->frag_ofs
);
895 frag_ofs
= e
->frag_ofs
;
903 /* Emit a DW_LNE_end_sequence for the end of the section. */
904 last_frag
= last_frag_for_seg (seg
);
905 last_frag_ofs
= get_frag_fix (last_frag
);
906 if (frag
== last_frag
)
907 out_inc_line_addr (INT_MAX
, last_frag_ofs
- frag_ofs
);
909 relax_inc_line_addr (INT_MAX
, seg
, last_frag
, last_frag_ofs
,
913 /* Emit the directory and file tables for .debug_line. */
922 /* Terminate directory list. */
925 for (i
= 1; i
< files_in_use
; ++i
)
927 size
= strlen (files
[i
].filename
) + 1;
928 cp
= frag_more (size
);
929 memcpy (cp
, files
[i
].filename
, size
);
931 out_uleb128 (files
[i
].dir
); /* directory number */
932 out_uleb128 (0); /* last modification timestamp */
933 out_uleb128 (0); /* filesize */
936 /* Terminate filename list. */
940 /* Emit the collected .debug_line data. */
943 out_debug_line (line_seg
)
948 symbolS
*prologue_end
;
952 subseg_set (line_seg
, 0);
954 line_start
= symbol_new_now ();
955 prologue_end
= symbol_make (fake_label_name
);
956 line_end
= symbol_make (fake_label_name
);
958 /* Total length of the information for this compilation unit. */
959 expr
.X_op
= O_subtract
;
960 expr
.X_add_symbol
= line_end
;
961 expr
.X_op_symbol
= line_start
;
962 expr
.X_add_number
= -4;
963 emit_expr (&expr
, 4);
968 /* Length of the prologue following this length. */
969 expr
.X_op
= O_subtract
;
970 expr
.X_add_symbol
= prologue_end
;
971 expr
.X_op_symbol
= line_start
;
972 expr
.X_add_number
= - (4 + 2 + 4);
973 emit_expr (&expr
, 4);
975 /* Parameters of the state machine. */
976 out_byte (DWARF2_LINE_MIN_INSN_LENGTH
);
977 out_byte (DWARF2_LINE_DEFAULT_IS_STMT
);
978 out_byte (DWARF2_LINE_BASE
);
979 out_byte (DWARF2_LINE_RANGE
);
980 out_byte (DWARF2_LINE_OPCODE_BASE
);
982 /* Standard opcode lengths. */
983 out_byte (0); /* DW_LNS_copy */
984 out_byte (1); /* DW_LNS_advance_pc */
985 out_byte (1); /* DW_LNS_advance_line */
986 out_byte (1); /* DW_LNS_set_file */
987 out_byte (1); /* DW_LNS_set_column */
988 out_byte (0); /* DW_LNS_negate_stmt */
989 out_byte (0); /* DW_LNS_set_basic_block */
990 out_byte (0); /* DW_LNS_const_add_pc */
991 out_byte (1); /* DW_LNS_fixed_advance_pc */
995 set_symbol_value_now (prologue_end
);
997 /* For each section, emit a statement program. */
998 for (s
= all_segs
; s
; s
= s
->next
)
999 process_entries (s
->seg
, s
->head
->head
);
1001 set_symbol_value_now (line_end
);
1004 /* Emit data for .debug_aranges. */
1007 out_debug_aranges (aranges_seg
, info_seg
)
1011 unsigned int addr_size
= sizeof_address
;
1012 addressT size
, skip
;
1017 size
= 4 + 2 + 4 + 1 + 1;
1019 skip
= 2*addr_size
- (size
& (2*addr_size
- 1));
1020 if (skip
== 2*addr_size
)
1024 for (s
= all_segs
; s
; s
= s
->next
)
1025 size
+= 2*addr_size
;
1027 size
+= 2*addr_size
;
1029 subseg_set (aranges_seg
, 0);
1031 /* Length of the compilation unit. */
1032 out_four (size
- 4);
1037 /* Offset to .debug_info. */
1038 expr
.X_op
= O_symbol
;
1039 expr
.X_add_symbol
= section_symbol (info_seg
);
1040 expr
.X_add_number
= 0;
1041 emit_expr (&expr
, 4);
1043 /* Size of an address (offset portion). */
1044 out_byte (addr_size
);
1046 /* Size of a segment descriptor. */
1049 /* Align the header. */
1051 frag_align (ffs (2*addr_size
) - 1, 0, 0);
1053 for (s
= all_segs
; s
; s
= s
->next
)
1058 frag
= first_frag_for_seg (s
->seg
);
1059 beg
= symbol_new (fake_label_name
, s
->seg
, 0, frag
);
1060 s
->text_start
= beg
;
1062 frag
= last_frag_for_seg (s
->seg
);
1063 end
= symbol_new (fake_label_name
, s
->seg
, get_frag_fix (frag
), frag
);
1066 expr
.X_op
= O_symbol
;
1067 expr
.X_add_symbol
= beg
;
1068 expr
.X_add_number
= 0;
1069 emit_expr (&expr
, addr_size
);
1071 expr
.X_op
= O_subtract
;
1072 expr
.X_add_symbol
= end
;
1073 expr
.X_op_symbol
= beg
;
1074 expr
.X_add_number
= 0;
1075 emit_expr (&expr
, addr_size
);
1078 p
= frag_more (2 * addr_size
);
1079 md_number_to_chars (p
, 0, addr_size
);
1080 md_number_to_chars (p
+ addr_size
, 0, addr_size
);
1083 /* Emit data for .debug_abbrev. Note that this must be kept in
1084 sync with out_debug_info below. */
1087 out_debug_abbrev (abbrev_seg
)
1090 subseg_set (abbrev_seg
, 0);
1093 out_uleb128 (DW_TAG_compile_unit
);
1094 out_byte (DW_CHILDREN_no
);
1095 out_abbrev (DW_AT_stmt_list
, DW_FORM_data4
);
1096 if (all_segs
->next
== NULL
)
1098 out_abbrev (DW_AT_low_pc
, DW_FORM_addr
);
1099 out_abbrev (DW_AT_high_pc
, DW_FORM_addr
);
1101 out_abbrev (DW_AT_comp_dir
, DW_FORM_string
);
1102 out_abbrev (DW_AT_producer
, DW_FORM_string
);
1103 out_abbrev (DW_AT_language
, DW_FORM_data2
);
1107 /* Emit a description of this compilation unit for .debug_info. */
1110 out_debug_info (info_seg
, abbrev_seg
, line_seg
)
1118 symbolS
*info_start
;
1123 subseg_set (info_seg
, 0);
1125 info_start
= symbol_new_now();
1126 info_end
= symbol_make (fake_label_name
);
1128 /* Compilation Unit length. */
1129 expr
.X_op
= O_subtract
;
1130 expr
.X_add_symbol
= info_end
;
1131 expr
.X_op_symbol
= info_start
;
1132 expr
.X_add_number
= -4;
1133 emit_expr (&expr
, 4);
1135 /* DWARF version. */
1138 /* .debug_abbrev offset */
1139 expr
.X_op
= O_symbol
;
1140 expr
.X_add_symbol
= section_symbol (abbrev_seg
);
1141 expr
.X_add_number
= 0;
1142 emit_expr (&expr
, 4);
1144 /* Target address size. */
1145 out_byte (sizeof_address
);
1147 /* DW_TAG_compile_unit DIE abbrev */
1150 /* DW_AT_stmt_list */
1151 expr
.X_op
= O_symbol
;
1152 expr
.X_add_symbol
= section_symbol (line_seg
);
1153 expr
.X_add_number
= 0;
1154 emit_expr (&expr
, 4);
1156 /* These two attributes may only be emitted if all of the code is
1157 contiguous. Multiple sections are not that. */
1158 if (all_segs
->next
== NULL
)
1161 expr
.X_op
= O_symbol
;
1162 expr
.X_add_symbol
= all_segs
->text_start
;
1163 expr
.X_add_number
= 0;
1164 emit_expr (&expr
, sizeof_address
);
1167 expr
.X_op
= O_symbol
;
1168 expr
.X_add_symbol
= all_segs
->text_end
;
1169 expr
.X_add_number
= 0;
1170 emit_expr (&expr
, sizeof_address
);
1173 /* DW_AT_comp_dir */
1174 comp_dir
= getpwd ();
1175 len
= strlen (comp_dir
) + 1;
1176 p
= frag_more (len
);
1177 memcpy (p
, comp_dir
, len
);
1179 /* DW_AT_producer */
1180 sprintf (producer
, "GNU AS %s", VERSION
);
1181 len
= strlen (producer
) + 1;
1182 p
= frag_more (len
);
1183 memcpy (p
, producer
, len
);
1185 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1186 dwarf2 draft has no standard code for assembler. */
1187 out_two (DW_LANG_Mips_Assembler
);
1189 set_symbol_value_now (info_end
);
1198 /* If no debug information was recorded, nothing to do. */
1199 if (all_segs
== NULL
)
1202 /* Calculate the size of an address for the target machine. */
1203 #ifdef BFD_ASSEMBLER
1204 sizeof_address
= bfd_arch_bits_per_address (stdoutput
) / 8;
1210 /* Create and switch to the line number section. */
1211 line_seg
= subseg_new (".debug_line", 0);
1212 #ifdef BFD_ASSEMBLER
1213 bfd_set_section_flags (stdoutput
, line_seg
, SEC_READONLY
);
1216 /* For each subsection, chain the debug entries together. */
1217 for (s
= all_segs
; s
; s
= s
->next
)
1219 struct line_subseg
*ss
= s
->head
;
1220 struct line_entry
**ptail
= ss
->ptail
;
1222 while ((ss
= ss
->next
) != NULL
)
1229 out_debug_line (line_seg
);
1231 /* If this is assembler generated line info, we need .debug_info
1232 and .debug_abbrev sections as well. */
1233 if (debug_type
== DEBUG_DWARF2
)
1239 info_seg
= subseg_new (".debug_info", 0);
1240 abbrev_seg
= subseg_new (".debug_abbrev", 0);
1241 aranges_seg
= subseg_new (".debug_aranges", 0);
1243 #ifdef BFD_ASSEMBLER
1244 bfd_set_section_flags (stdoutput
, info_seg
, SEC_READONLY
);
1245 bfd_set_section_flags (stdoutput
, abbrev_seg
, SEC_READONLY
);
1246 bfd_set_section_flags (stdoutput
, aranges_seg
, SEC_READONLY
);
1249 record_alignment (aranges_seg
, ffs (2*sizeof_address
) - 1);
1251 out_debug_aranges (aranges_seg
, info_seg
);
1252 out_debug_abbrev (abbrev_seg
);
1253 out_debug_info (info_seg
, abbrev_seg
, line_seg
);
1264 dwarf2dbg_estimate_size_before_relax (frag
)
1265 fragS
*frag ATTRIBUTE_UNUSED
;
1267 as_fatal (_("dwarf2 is not supported for this object file format"));
1272 dwarf2dbg_relax_frag (frag
)
1273 fragS
*frag ATTRIBUTE_UNUSED
;
1275 as_fatal (_("dwarf2 is not supported for this object file format"));
1280 dwarf2dbg_convert_frag (frag
)
1281 fragS
*frag ATTRIBUTE_UNUSED
;
1283 as_fatal (_("dwarf2 is not supported for this object file format"));
1287 dwarf2_emit_insn (size
)
1288 int size ATTRIBUTE_UNUSED
;
1293 dwarf2_directive_file (dummy
)
1294 int dummy ATTRIBUTE_UNUSED
;
1296 as_fatal (_("dwarf2 is not supported for this object file format"));
1300 dwarf2_directive_loc (dummy
)
1301 int dummy ATTRIBUTE_UNUSED
;
1303 as_fatal (_("dwarf2 is not supported for this object file format"));
1305 #endif /* BFD_ASSEMBLER */