1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001 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. */
36 #ifdef HAVE_SYS_PARAM_H
37 #include <sys/param.h>
40 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
46 #include "dwarf2dbg.h"
49 #include "elf/dwarf2.h"
51 /* Since we can't generate the prolog until the body is complete, we
52 use three different subsegments for .debug_line: one holding the
53 prolog, one for the directory and filename info, and one for the
54 body ("statement program"). */
59 /* First special line opcde - leave room for the standard opcodes.
60 Note: If you want to change this, you'll have to update the
61 "standard_opcode_lengths" table that is emitted below in
63 #define DWARF2_LINE_OPCODE_BASE 10
65 #ifndef DWARF2_LINE_BASE
66 /* Minimum line offset in a special line info. opcode. This value
67 was chosen to give a reasonable range of values. */
68 # define DWARF2_LINE_BASE -5
71 /* Range of line offsets in a special line info. opcode. */
72 #ifndef DWARF2_LINE_RANGE
73 # define DWARF2_LINE_RANGE 14
76 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
77 /* Define the architecture-dependent minimum instruction length (in
78 bytes). This value should be rather too small than too big. */
79 # define DWARF2_LINE_MIN_INSN_LENGTH 1
82 /* Flag that indicates the initial value of the is_stmt_start flag.
83 In the present implementation, we do not mark any lines as
84 the beginning of a source statement, because that information
85 is not made available by the GCC front-end. */
86 #define DWARF2_LINE_DEFAULT_IS_STMT 1
88 /* Given a special op, return the line skip amount. */
89 #define SPECIAL_LINE(op) \
90 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
92 /* Given a special op, return the address skip amount (in units of
93 DWARF2_LINE_MIN_INSN_LENGTH. */
94 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
96 /* The maximum address skip amount that can be encoded with a special op. */
97 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
100 struct line_entry *next;
103 struct dwarf2_line_info loc;
107 struct line_subseg *next;
109 struct line_entry *head;
110 struct line_entry **ptail;
114 struct line_seg *next;
116 struct line_subseg *head;
121 /* Collects data for all line table entries during assembly. */
122 static struct line_seg *all_segs;
129 /* Table of files used by .debug_line. */
130 static struct file_entry *files;
131 static unsigned int files_in_use;
132 static unsigned int files_allocated;
134 /* True when we've seen a .loc directive recently. Used to avoid
135 doing work when there's nothing to do. */
136 static boolean loc_directive_seen;
138 /* Current location as indicated by the most recent .loc directive. */
139 static struct dwarf2_line_info current;
141 /* Fake label name. */
142 static char const fake_label_name[] = ".L0\001";
144 /* The size of an address on the target. */
145 static unsigned int sizeof_address;
147 static struct line_subseg *get_line_subseg PARAMS ((segT, subsegT));
148 static unsigned int get_filenum PARAMS ((const char *));
149 static struct frag *first_frag_for_seg PARAMS ((segT));
150 static struct frag *last_frag_for_seg PARAMS ((segT));
151 static void out_byte PARAMS ((int));
152 static void out_opcode PARAMS ((int));
153 static void out_two PARAMS ((int));
154 static void out_four PARAMS ((int));
155 static void out_abbrev PARAMS ((int, int));
156 static void out_uleb128 PARAMS ((addressT));
157 static symbolS *symbol_new_now PARAMS ((void));
158 static void set_symbol_value_now PARAMS ((symbolS *));
159 static offsetT get_frag_fix PARAMS ((fragS *));
160 static void out_set_addr PARAMS ((segT, fragS *, addressT));
161 static int size_inc_line_addr PARAMS ((int, addressT));
162 static void emit_inc_line_addr PARAMS ((int, addressT, char *, int));
163 static void out_inc_line_addr PARAMS ((int, addressT));
164 static void relax_inc_line_addr PARAMS ((int, segT, fragS *, addressT,
166 static void process_entries PARAMS ((segT, struct line_entry *));
167 static void out_file_list PARAMS ((void));
168 static void out_debug_line PARAMS ((segT));
169 static void out_debug_aranges PARAMS ((segT, segT));
170 static void out_debug_abbrev PARAMS ((segT));
171 static void out_debug_info PARAMS ((segT, segT, segT));
173 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
175 static struct line_subseg *
176 get_line_subseg (seg, subseg)
180 static segT last_seg;
181 static subsegT last_subseg;
182 static struct line_subseg *last_line_subseg;
185 struct line_subseg **pss, *ss;
187 if (seg == last_seg && subseg == last_subseg)
188 return last_line_subseg;
190 for (s = all_segs; s; s = s->next)
194 s = (struct line_seg *) xmalloc (sizeof (*s));
201 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
203 if (ss->subseg == subseg)
205 if (ss->subseg > subseg)
209 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
213 ss->ptail = &ss->head;
218 last_subseg = subseg;
219 last_line_subseg = ss;
224 /* Record an entry for LOC ocurring at OFS within the current fragment. */
227 dwarf2_gen_line_info (ofs, loc)
229 struct dwarf2_line_info *loc;
231 struct line_subseg *ss;
232 struct line_entry *e;
233 static unsigned int line = -1;
234 static unsigned int filenum = -1;
236 /* Early out for as-yet incomplete location information. */
237 if (loc->filenum == 0 || loc->line == 0)
240 /* Don't emit sequences of line symbols for the same line when the
241 symbols apply to assembler code. It is necessary to emit
242 duplicate line symbols when a compiler asks for them, because GDB
243 uses them to determine the end of the prologue. */
244 if (debug_type == DEBUG_DWARF2
245 && line == loc->line && filenum == loc->filenum)
249 filenum = loc->filenum;
251 e = (struct line_entry *) xmalloc (sizeof (*e));
257 ss = get_line_subseg (now_seg, now_subseg);
259 ss->ptail = &e->next;
264 struct dwarf2_line_info *line;
266 if (debug_type == DEBUG_DWARF2)
269 as_where (&filename, &line->line);
270 line->filenum = get_filenum (filename);
272 line->flags = DWARF2_FLAG_BEGIN_STMT;
278 /* Called for each machine instruction, or relatively atomic group of
279 machine instructions (ie built-in macro). The instruction or group
280 is SIZE bytes in length. If dwarf2 line number generation is called
281 for, emit a line statement appropriately. */
284 dwarf2_emit_insn (size)
287 struct dwarf2_line_info loc;
289 if (loc_directive_seen)
290 /* Use the last location established by a .loc directive, not
291 the value returned by dwarf2_where(). That calls as_where()
292 which will return either the logical input file name (foo.c)
293 or the physical input file name (foo.s) and not the file name
294 specified in the most recent .loc directive (eg foo.h). */
296 else if (debug_type != DEBUG_DWARF2)
299 dwarf2_where (& loc);
301 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
304 /* Get a .debug_line file number for FILENAME. */
307 get_filenum (filename)
308 const char *filename;
310 static unsigned int last_used;
314 if (strcmp (filename, files[last_used].filename) == 0)
317 for (i = 1; i < files_in_use; ++i)
318 if (strcmp (filename, files[i].filename) == 0)
321 if (i >= files_allocated)
323 unsigned int old = files_allocated;
325 files_allocated = i + 32;
326 files = (struct file_entry *)
327 xrealloc (files, (i + 32) * sizeof (struct file_entry));
329 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
332 files[i].filename = xstrdup (filename);
334 files_in_use = i + 1;
340 /* Handle the .file directive. */
343 dwarf2_directive_file (dummy)
344 int dummy ATTRIBUTE_UNUSED;
350 /* Continue to accept a bare string and pass it off. */
352 if (*input_line_pointer == '"')
358 num = get_absolute_expression ();
359 filename = demand_copy_C_string (&filename_len);
360 demand_empty_rest_of_line ();
364 as_bad (_("file number less than one"));
368 if (num < (int) files_in_use && files[num].filename != 0)
370 as_bad (_("file number %ld already allocated"), (long) num);
374 if (num >= (int) files_allocated)
376 unsigned int old = files_allocated;
378 files_allocated = num + 16;
379 files = (struct file_entry *)
380 xrealloc (files, (num + 16) * sizeof (struct file_entry));
382 /* Zero the new memory. */
383 memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
386 files[num].filename = filename;
388 files_in_use = num + 1;
392 dwarf2_directive_loc (dummy)
393 int dummy ATTRIBUTE_UNUSED;
395 offsetT filenum, line, column;
397 filenum = get_absolute_expression ();
399 line = get_absolute_expression ();
401 column = get_absolute_expression ();
402 demand_empty_rest_of_line ();
406 as_bad (_("file number less than one"));
409 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
411 as_bad (_("unassigned file number %ld"), (long) filenum);
415 current.filenum = filenum;
417 current.column = column;
418 current.flags = DWARF2_FLAG_BEGIN_STMT;
420 loc_directive_seen = true;
424 listing_source_line (line);
429 first_frag_for_seg (seg)
432 frchainS *f, *first = NULL;
434 for (f = frchain_root; f; f = f->frch_next)
435 if (f->frch_seg == seg
436 && (! first || first->frch_subseg > f->frch_subseg))
439 return first ? first->frch_root : NULL;
443 last_frag_for_seg (seg)
446 frchainS *f, *last = NULL;
448 for (f = frchain_root; f; f = f->frch_next)
449 if (f->frch_seg == seg
450 && (! last || last->frch_subseg < f->frch_subseg))
453 return last ? last->frch_last : NULL;
456 /* Emit a single byte into the current segment. */
462 FRAG_APPEND_1_CHAR (byte);
465 /* Emit a statement program opcode into the current segment. */
474 /* Emit a two-byte word into the current segment. */
480 md_number_to_chars (frag_more (2), data, 2);
483 /* Emit a four byte word into the current segment. */
489 md_number_to_chars (frag_more (4), data, 4);
492 /* Emit an unsigned "little-endian base 128" number. */
498 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
501 /* Emit a tuple for .debug_abbrev. */
504 out_abbrev (name, form)
511 /* Create a new fake symbol whose value is the current position. */
516 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
519 /* Set the value of SYM to the current position in the current segment. */
522 set_symbol_value_now (sym)
525 S_SET_SEGMENT (sym, now_seg);
526 S_SET_VALUE (sym, frag_now_fix ());
527 symbol_set_frag (sym, frag_now);
530 /* Get the size of a fragment. */
541 /* If a fragment is the last in the chain, special measures must be
542 taken to find its size before relaxation, since it may be pending
543 on some subsegment chain. */
544 for (fr = frchain_root; fr; fr = fr->frch_next)
545 if (fr->frch_last == frag)
547 long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
548 return (((char *) obstack_next_free (&fr->frch_obstack)
549 - frag->fr_literal) + ~align_mask) & align_mask;
555 /* Set an absolute address (may result in a relocation entry). */
558 out_set_addr (seg, frag, ofs)
566 sym = symbol_new (fake_label_name, seg, ofs, frag);
568 out_opcode (DW_LNS_extended_op);
569 out_uleb128 (sizeof_address + 1);
571 out_opcode (DW_LNE_set_address);
572 expr.X_op = O_symbol;
573 expr.X_add_symbol = sym;
574 expr.X_add_number = 0;
575 emit_expr (&expr, sizeof_address);
578 /* Encode a pair of line and address skips as efficiently as possible.
579 Note that the line skip is signed, whereas the address skip is unsigned.
581 The following two routines *must* be kept in sync. This is
582 enforced by making emit_inc_line_addr abort if we do not emit
583 exactly the expected number of bytes. */
586 size_inc_line_addr (line_delta, addr_delta)
590 unsigned int tmp, opcode;
593 /* Scale the address delta by the minimum instruction length. */
594 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
595 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
596 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
599 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
600 We cannot use special opcodes here, since we want the end_sequence
601 to emit the matrix entry. */
602 if (line_delta == INT_MAX)
604 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
607 len = 1 + sizeof_leb128 (addr_delta, 0);
611 /* Bias the line delta by the base. */
612 tmp = line_delta - DWARF2_LINE_BASE;
614 /* If the line increment is out of range of a special opcode, we
615 must encode it with DW_LNS_advance_line. */
616 if (tmp >= DWARF2_LINE_RANGE)
618 len = 1 + sizeof_leb128 (line_delta, 1);
620 tmp = 0 - DWARF2_LINE_BASE;
623 /* Bias the opcode by the special opcode base. */
624 tmp += DWARF2_LINE_OPCODE_BASE;
626 /* Avoid overflow when addr_delta is large. */
627 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
629 /* Try using a special opcode. */
630 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
634 /* Try using DW_LNS_const_add_pc followed by special op. */
635 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
640 /* Otherwise use DW_LNS_advance_pc. */
641 len += 1 + sizeof_leb128 (addr_delta, 0);
643 /* DW_LNS_copy or special opcode. */
650 emit_inc_line_addr (line_delta, addr_delta, p, len)
656 unsigned int tmp, opcode;
660 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
661 /* Scale the address delta by the minimum instruction length. */
662 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
663 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
665 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
666 We cannot use special opcodes here, since we want the end_sequence
667 to emit the matrix entry. */
668 if (line_delta == INT_MAX)
670 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
671 *p++ = DW_LNS_const_add_pc;
674 *p++ = DW_LNS_advance_pc;
675 p += output_leb128 (p, addr_delta, 0);
678 *p++ = DW_LNS_extended_op;
680 *p++ = DW_LNE_end_sequence;
684 /* Bias the line delta by the base. */
685 tmp = line_delta - DWARF2_LINE_BASE;
687 /* If the line increment is out of range of a special opcode, we
688 must encode it with DW_LNS_advance_line. */
689 if (tmp >= DWARF2_LINE_RANGE)
691 *p++ = DW_LNS_advance_line;
692 p += output_leb128 (p, line_delta, 1);
694 /* Prettier, I think, to use DW_LNS_copy instead of a
695 "line +0, addr +0" special opcode. */
703 tmp = 0 - DWARF2_LINE_BASE;
707 /* Bias the opcode by the special opcode base. */
708 tmp += DWARF2_LINE_OPCODE_BASE;
710 /* Avoid overflow when addr_delta is large. */
711 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
713 /* Try using a special opcode. */
714 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
721 /* Try using DW_LNS_const_add_pc followed by special op. */
722 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
725 *p++ = DW_LNS_const_add_pc;
731 /* Otherwise use DW_LNS_advance_pc. */
732 *p++ = DW_LNS_advance_pc;
733 p += output_leb128 (p, addr_delta, 0);
744 /* Handy routine to combine calls to the above two routines. */
747 out_inc_line_addr (line_delta, addr_delta)
751 int len = size_inc_line_addr (line_delta, addr_delta);
752 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
755 /* Generate a variant frag that we can use to relax address/line
756 increments between fragments of the target segment. */
759 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
762 fragS *to_frag, *from_frag;
763 addressT to_ofs, from_ofs;
765 symbolS *to_sym, *from_sym;
769 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
770 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
772 expr.X_op = O_subtract;
773 expr.X_add_symbol = to_sym;
774 expr.X_op_symbol = from_sym;
775 expr.X_add_number = 0;
777 /* The maximum size of the frag is the line delta with a maximum
778 sized address delta. */
779 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
781 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
782 make_expr_symbol (&expr), line_delta, NULL);
785 /* The function estimates the size of a rs_dwarf2dbg variant frag
786 based on the current values of the symbols. It is called before
787 the relaxation loop. We set fr_subtype to the expected length. */
790 dwarf2dbg_estimate_size_before_relax (frag)
796 addr_delta = resolve_symbol_value (frag->fr_symbol);
797 size = size_inc_line_addr (frag->fr_offset, addr_delta);
799 frag->fr_subtype = size;
804 /* This function relaxes a rs_dwarf2dbg variant frag based on the
805 current values of the symbols. fr_subtype is the current length
806 of the frag. This returns the change in frag length. */
809 dwarf2dbg_relax_frag (frag)
812 int old_size, new_size;
814 old_size = frag->fr_subtype;
815 new_size = dwarf2dbg_estimate_size_before_relax (frag);
817 return new_size - old_size;
820 /* This function converts a rs_dwarf2dbg variant frag into a normal
821 fill frag. This is called after all relaxation has been done.
822 fr_subtype will be the desired length of the frag. */
825 dwarf2dbg_convert_frag (frag)
830 addr_diff = resolve_symbol_value (frag->fr_symbol);
832 /* fr_var carries the max_chars that we created the fragment with.
833 fr_subtype carries the current expected length. We must, of
834 course, have allocated enough memory earlier. */
835 assert (frag->fr_var >= (int) frag->fr_subtype);
837 emit_inc_line_addr (frag->fr_offset, addr_diff,
838 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
840 frag->fr_fix += frag->fr_subtype;
841 frag->fr_type = rs_fill;
846 /* Generate .debug_line content for the chain of line number entries
847 beginning at E, for segment SEG. */
850 process_entries (seg, e)
852 struct line_entry *e;
854 unsigned filenum = 1;
857 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
860 addressT frag_ofs = 0;
861 addressT last_frag_ofs;
862 struct line_entry *next;
868 if (filenum != e->loc.filenum)
870 filenum = e->loc.filenum;
871 out_opcode (DW_LNS_set_file);
872 out_uleb128 (filenum);
876 if (column != e->loc.column)
878 column = e->loc.column;
879 out_opcode (DW_LNS_set_column);
880 out_uleb128 (column);
884 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
886 flags = e->loc.flags;
887 out_opcode (DW_LNS_negate_stmt);
891 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
893 out_opcode (DW_LNS_set_basic_block);
897 /* Don't try to optimize away redundant entries; gdb wants two
898 entries for a function where the code starts on the same line as
899 the {, and there's no way to identify that case here. Trust gcc
900 to optimize appropriately. */
901 if (1 /* line != e->loc.line || changed */)
903 int line_delta = e->loc.line - line;
906 out_set_addr (seg, e->frag, e->frag_ofs);
907 out_inc_line_addr (line_delta, 0);
909 else if (frag == e->frag)
910 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
912 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
916 frag_ofs = e->frag_ofs;
919 else if (frag == NULL)
921 out_set_addr (seg, e->frag, e->frag_ofs);
923 frag_ofs = e->frag_ofs;
931 /* Emit a DW_LNE_end_sequence for the end of the section. */
932 last_frag = last_frag_for_seg (seg);
933 last_frag_ofs = get_frag_fix (last_frag);
934 if (frag == last_frag)
935 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
937 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
941 /* Emit the directory and file tables for .debug_line. */
950 /* Terminate directory list. */
953 for (i = 1; i < files_in_use; ++i)
955 if (files[i].filename == NULL)
957 as_bad (_("unassigned file number %ld"), (long) i);
961 size = strlen (files[i].filename) + 1;
962 cp = frag_more (size);
963 memcpy (cp, files[i].filename, size);
965 out_uleb128 (files[i].dir); /* directory number */
966 out_uleb128 (0); /* last modification timestamp */
967 out_uleb128 (0); /* filesize */
970 /* Terminate filename list. */
974 /* Emit the collected .debug_line data. */
977 out_debug_line (line_seg)
982 symbolS *prologue_end;
986 subseg_set (line_seg, 0);
988 line_start = symbol_new_now ();
989 prologue_end = symbol_make (fake_label_name);
990 line_end = symbol_make (fake_label_name);
992 /* Total length of the information for this compilation unit. */
993 expr.X_op = O_subtract;
994 expr.X_add_symbol = line_end;
995 expr.X_op_symbol = line_start;
996 expr.X_add_number = -4;
997 emit_expr (&expr, 4);
1002 /* Length of the prologue following this length. */
1003 expr.X_op = O_subtract;
1004 expr.X_add_symbol = prologue_end;
1005 expr.X_op_symbol = line_start;
1006 expr.X_add_number = - (4 + 2 + 4);
1007 emit_expr (&expr, 4);
1009 /* Parameters of the state machine. */
1010 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1011 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1012 out_byte (DWARF2_LINE_BASE);
1013 out_byte (DWARF2_LINE_RANGE);
1014 out_byte (DWARF2_LINE_OPCODE_BASE);
1016 /* Standard opcode lengths. */
1017 out_byte (0); /* DW_LNS_copy */
1018 out_byte (1); /* DW_LNS_advance_pc */
1019 out_byte (1); /* DW_LNS_advance_line */
1020 out_byte (1); /* DW_LNS_set_file */
1021 out_byte (1); /* DW_LNS_set_column */
1022 out_byte (0); /* DW_LNS_negate_stmt */
1023 out_byte (0); /* DW_LNS_set_basic_block */
1024 out_byte (0); /* DW_LNS_const_add_pc */
1025 out_byte (1); /* DW_LNS_fixed_advance_pc */
1029 set_symbol_value_now (prologue_end);
1031 /* For each section, emit a statement program. */
1032 for (s = all_segs; s; s = s->next)
1033 process_entries (s->seg, s->head->head);
1035 set_symbol_value_now (line_end);
1038 /* Emit data for .debug_aranges. */
1041 out_debug_aranges (aranges_seg, info_seg)
1045 unsigned int addr_size = sizeof_address;
1046 addressT size, skip;
1051 size = 4 + 2 + 4 + 1 + 1;
1053 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1054 if (skip == 2 * addr_size)
1058 for (s = all_segs; s; s = s->next)
1059 size += 2 * addr_size;
1061 size += 2 * addr_size;
1063 subseg_set (aranges_seg, 0);
1065 /* Length of the compilation unit. */
1066 out_four (size - 4);
1071 /* Offset to .debug_info. */
1072 expr.X_op = O_symbol;
1073 expr.X_add_symbol = section_symbol (info_seg);
1074 expr.X_add_number = 0;
1075 emit_expr (&expr, 4);
1077 /* Size of an address (offset portion). */
1078 out_byte (addr_size);
1080 /* Size of a segment descriptor. */
1083 /* Align the header. */
1085 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1087 for (s = all_segs; s; s = s->next)
1092 frag = first_frag_for_seg (s->seg);
1093 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1094 s->text_start = beg;
1096 frag = last_frag_for_seg (s->seg);
1097 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1100 expr.X_op = O_symbol;
1101 expr.X_add_symbol = beg;
1102 expr.X_add_number = 0;
1103 emit_expr (&expr, addr_size);
1105 expr.X_op = O_subtract;
1106 expr.X_add_symbol = end;
1107 expr.X_op_symbol = beg;
1108 expr.X_add_number = 0;
1109 emit_expr (&expr, addr_size);
1112 p = frag_more (2 * addr_size);
1113 md_number_to_chars (p, 0, addr_size);
1114 md_number_to_chars (p + addr_size, 0, addr_size);
1117 /* Emit data for .debug_abbrev. Note that this must be kept in
1118 sync with out_debug_info below. */
1121 out_debug_abbrev (abbrev_seg)
1124 subseg_set (abbrev_seg, 0);
1127 out_uleb128 (DW_TAG_compile_unit);
1128 out_byte (DW_CHILDREN_no);
1129 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1130 if (all_segs->next == NULL)
1132 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1133 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1135 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1136 out_abbrev (DW_AT_producer, DW_FORM_string);
1137 out_abbrev (DW_AT_language, DW_FORM_data2);
1140 /* Terminate the abbreviations for this compilation unit. */
1144 /* Emit a description of this compilation unit for .debug_info. */
1147 out_debug_info (info_seg, abbrev_seg, line_seg)
1155 symbolS *info_start;
1160 subseg_set (info_seg, 0);
1162 info_start = symbol_new_now ();
1163 info_end = symbol_make (fake_label_name);
1165 /* Compilation Unit length. */
1166 expr.X_op = O_subtract;
1167 expr.X_add_symbol = info_end;
1168 expr.X_op_symbol = info_start;
1169 expr.X_add_number = -4;
1170 emit_expr (&expr, 4);
1172 /* DWARF version. */
1175 /* .debug_abbrev offset */
1176 expr.X_op = O_symbol;
1177 expr.X_add_symbol = section_symbol (abbrev_seg);
1178 expr.X_add_number = 0;
1179 emit_expr (&expr, 4);
1181 /* Target address size. */
1182 out_byte (sizeof_address);
1184 /* DW_TAG_compile_unit DIE abbrev */
1187 /* DW_AT_stmt_list */
1188 expr.X_op = O_symbol;
1189 expr.X_add_symbol = section_symbol (line_seg);
1190 expr.X_add_number = 0;
1191 emit_expr (&expr, 4);
1193 /* These two attributes may only be emitted if all of the code is
1194 contiguous. Multiple sections are not that. */
1195 if (all_segs->next == NULL)
1198 expr.X_op = O_symbol;
1199 expr.X_add_symbol = all_segs->text_start;
1200 expr.X_add_number = 0;
1201 emit_expr (&expr, sizeof_address);
1204 expr.X_op = O_symbol;
1205 expr.X_add_symbol = all_segs->text_end;
1206 expr.X_add_number = 0;
1207 emit_expr (&expr, sizeof_address);
1210 /* DW_AT_comp_dir */
1211 comp_dir = getpwd ();
1212 len = strlen (comp_dir) + 1;
1213 p = frag_more (len);
1214 memcpy (p, comp_dir, len);
1216 /* DW_AT_producer */
1217 sprintf (producer, "GNU AS %s", VERSION);
1218 len = strlen (producer) + 1;
1219 p = frag_more (len);
1220 memcpy (p, producer, len);
1222 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1223 dwarf2 draft has no standard code for assembler. */
1224 out_two (DW_LANG_Mips_Assembler);
1226 set_symbol_value_now (info_end);
1235 /* If no debug information was recorded, nothing to do. */
1236 if (all_segs == NULL && files_in_use <= 1)
1239 /* Calculate the size of an address for the target machine. */
1240 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1242 /* Create and switch to the line number section. */
1243 line_seg = subseg_new (".debug_line", 0);
1244 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1246 /* For each subsection, chain the debug entries together. */
1247 for (s = all_segs; s; s = s->next)
1249 struct line_subseg *ss = s->head;
1250 struct line_entry **ptail = ss->ptail;
1252 while ((ss = ss->next) != NULL)
1259 out_debug_line (line_seg);
1261 /* If this is assembler generated line info, we need .debug_info
1262 and .debug_abbrev sections as well. */
1263 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1269 info_seg = subseg_new (".debug_info", 0);
1270 abbrev_seg = subseg_new (".debug_abbrev", 0);
1271 aranges_seg = subseg_new (".debug_aranges", 0);
1273 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1274 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1275 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1277 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1279 out_debug_aranges (aranges_seg, info_seg);
1280 out_debug_abbrev (abbrev_seg);
1281 out_debug_info (info_seg, abbrev_seg, line_seg);
1292 dwarf2dbg_estimate_size_before_relax (frag)
1293 fragS *frag ATTRIBUTE_UNUSED;
1295 as_fatal (_("dwarf2 is not supported for this object file format"));
1300 dwarf2dbg_relax_frag (frag)
1301 fragS *frag ATTRIBUTE_UNUSED;
1303 as_fatal (_("dwarf2 is not supported for this object file format"));
1308 dwarf2dbg_convert_frag (frag)
1309 fragS *frag ATTRIBUTE_UNUSED;
1311 as_fatal (_("dwarf2 is not supported for this object file format"));
1315 dwarf2_emit_insn (size)
1316 int size ATTRIBUTE_UNUSED;
1321 dwarf2_directive_file (dummy)
1322 int dummy ATTRIBUTE_UNUSED;
1328 dwarf2_directive_loc (dummy)
1329 int dummy ATTRIBUTE_UNUSED;
1331 as_fatal (_("dwarf2 is not supported for this object file format"));
1333 #endif /* BFD_ASSEMBLER */