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)
291 /* Use the last location established by a .loc directive, not
292 the value returned by dwarf2_where(). That calls as_where()
293 which will return either the logical input file name (foo.c)
294 or the physical input file name (foo.s) and not the file name
295 specified in the most recent .loc directive (eg foo.h). */
298 /* Unless we generate DWARF2 debugging information for each
299 assembler line, we only emit one line symbol for one LOC. */
300 if (debug_type != DEBUG_DWARF2)
301 loc_directive_seen = false;
303 else if (debug_type != DEBUG_DWARF2)
306 dwarf2_where (& loc);
308 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
311 /* Get a .debug_line file number for FILENAME. */
314 get_filenum (filename)
315 const char *filename;
317 static unsigned int last_used;
321 if (strcmp (filename, files[last_used].filename) == 0)
324 for (i = 1; i < files_in_use; ++i)
325 if (strcmp (filename, files[i].filename) == 0)
328 if (i >= files_allocated)
330 unsigned int old = files_allocated;
332 files_allocated = i + 32;
333 files = (struct file_entry *)
334 xrealloc (files, (i + 32) * sizeof (struct file_entry));
336 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
339 files[i].filename = xstrdup (filename);
341 files_in_use = i + 1;
347 /* Handle the .file directive. */
350 dwarf2_directive_file (dummy)
351 int dummy ATTRIBUTE_UNUSED;
357 /* Continue to accept a bare string and pass it off. */
359 if (*input_line_pointer == '"')
365 num = get_absolute_expression ();
366 filename = demand_copy_C_string (&filename_len);
367 demand_empty_rest_of_line ();
371 as_bad (_("file number less than one"));
375 if (num < (int) files_in_use && files[num].filename != 0)
377 as_bad (_("file number %ld already allocated"), (long) num);
381 if (num >= (int) files_allocated)
383 unsigned int old = files_allocated;
385 files_allocated = num + 16;
386 files = (struct file_entry *)
387 xrealloc (files, (num + 16) * sizeof (struct file_entry));
389 /* Zero the new memory. */
390 memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
393 files[num].filename = filename;
395 files_in_use = num + 1;
399 dwarf2_directive_loc (dummy)
400 int dummy ATTRIBUTE_UNUSED;
402 offsetT filenum, line, column;
404 filenum = get_absolute_expression ();
406 line = get_absolute_expression ();
408 column = get_absolute_expression ();
409 demand_empty_rest_of_line ();
413 as_bad (_("file number less than one"));
416 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
418 as_bad (_("unassigned file number %ld"), (long) filenum);
422 current.filenum = filenum;
424 current.column = column;
425 current.flags = DWARF2_FLAG_BEGIN_STMT;
427 loc_directive_seen = true;
432 listing_source_file (files[filenum].filename);
433 listing_source_line (line);
439 first_frag_for_seg (seg)
442 frchainS *f, *first = NULL;
444 for (f = frchain_root; f; f = f->frch_next)
445 if (f->frch_seg == seg
446 && (! first || first->frch_subseg > f->frch_subseg))
449 return first ? first->frch_root : NULL;
453 last_frag_for_seg (seg)
456 frchainS *f, *last = NULL;
458 for (f = frchain_root; f; f = f->frch_next)
459 if (f->frch_seg == seg
460 && (! last || last->frch_subseg < f->frch_subseg))
463 return last ? last->frch_last : NULL;
466 /* Emit a single byte into the current segment. */
472 FRAG_APPEND_1_CHAR (byte);
475 /* Emit a statement program opcode into the current segment. */
484 /* Emit a two-byte word into the current segment. */
490 md_number_to_chars (frag_more (2), data, 2);
493 /* Emit a four byte word into the current segment. */
499 md_number_to_chars (frag_more (4), data, 4);
502 /* Emit an unsigned "little-endian base 128" number. */
508 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
511 /* Emit a tuple for .debug_abbrev. */
514 out_abbrev (name, form)
521 /* Create a new fake symbol whose value is the current position. */
526 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
529 /* Set the value of SYM to the current position in the current segment. */
532 set_symbol_value_now (sym)
535 S_SET_SEGMENT (sym, now_seg);
536 S_SET_VALUE (sym, frag_now_fix ());
537 symbol_set_frag (sym, frag_now);
540 /* Get the size of a fragment. */
551 /* If a fragment is the last in the chain, special measures must be
552 taken to find its size before relaxation, since it may be pending
553 on some subsegment chain. */
554 for (fr = frchain_root; fr; fr = fr->frch_next)
555 if (fr->frch_last == frag)
557 long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
558 return (((char *) obstack_next_free (&fr->frch_obstack)
559 - frag->fr_literal) + ~align_mask) & align_mask;
565 /* Set an absolute address (may result in a relocation entry). */
568 out_set_addr (seg, frag, ofs)
576 sym = symbol_new (fake_label_name, seg, ofs, frag);
578 out_opcode (DW_LNS_extended_op);
579 out_uleb128 (sizeof_address + 1);
581 out_opcode (DW_LNE_set_address);
582 expr.X_op = O_symbol;
583 expr.X_add_symbol = sym;
584 expr.X_add_number = 0;
585 emit_expr (&expr, sizeof_address);
588 /* Encode a pair of line and address skips as efficiently as possible.
589 Note that the line skip is signed, whereas the address skip is unsigned.
591 The following two routines *must* be kept in sync. This is
592 enforced by making emit_inc_line_addr abort if we do not emit
593 exactly the expected number of bytes. */
596 size_inc_line_addr (line_delta, addr_delta)
600 unsigned int tmp, opcode;
603 /* Scale the address delta by the minimum instruction length. */
604 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
605 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
606 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
609 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
610 We cannot use special opcodes here, since we want the end_sequence
611 to emit the matrix entry. */
612 if (line_delta == INT_MAX)
614 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
617 len = 1 + sizeof_leb128 (addr_delta, 0);
621 /* Bias the line delta by the base. */
622 tmp = line_delta - DWARF2_LINE_BASE;
624 /* If the line increment is out of range of a special opcode, we
625 must encode it with DW_LNS_advance_line. */
626 if (tmp >= DWARF2_LINE_RANGE)
628 len = 1 + sizeof_leb128 (line_delta, 1);
630 tmp = 0 - DWARF2_LINE_BASE;
633 /* Bias the opcode by the special opcode base. */
634 tmp += DWARF2_LINE_OPCODE_BASE;
636 /* Avoid overflow when addr_delta is large. */
637 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
639 /* Try using a special opcode. */
640 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
644 /* Try using DW_LNS_const_add_pc followed by special op. */
645 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
650 /* Otherwise use DW_LNS_advance_pc. */
651 len += 1 + sizeof_leb128 (addr_delta, 0);
653 /* DW_LNS_copy or special opcode. */
660 emit_inc_line_addr (line_delta, addr_delta, p, len)
666 unsigned int tmp, opcode;
670 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
671 /* Scale the address delta by the minimum instruction length. */
672 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
673 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
675 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
676 We cannot use special opcodes here, since we want the end_sequence
677 to emit the matrix entry. */
678 if (line_delta == INT_MAX)
680 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
681 *p++ = DW_LNS_const_add_pc;
684 *p++ = DW_LNS_advance_pc;
685 p += output_leb128 (p, addr_delta, 0);
688 *p++ = DW_LNS_extended_op;
690 *p++ = DW_LNE_end_sequence;
694 /* Bias the line delta by the base. */
695 tmp = line_delta - DWARF2_LINE_BASE;
697 /* If the line increment is out of range of a special opcode, we
698 must encode it with DW_LNS_advance_line. */
699 if (tmp >= DWARF2_LINE_RANGE)
701 *p++ = DW_LNS_advance_line;
702 p += output_leb128 (p, line_delta, 1);
704 /* Prettier, I think, to use DW_LNS_copy instead of a
705 "line +0, addr +0" special opcode. */
713 tmp = 0 - DWARF2_LINE_BASE;
717 /* Bias the opcode by the special opcode base. */
718 tmp += DWARF2_LINE_OPCODE_BASE;
720 /* Avoid overflow when addr_delta is large. */
721 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
723 /* Try using a special opcode. */
724 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
731 /* Try using DW_LNS_const_add_pc followed by special op. */
732 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
735 *p++ = DW_LNS_const_add_pc;
741 /* Otherwise use DW_LNS_advance_pc. */
742 *p++ = DW_LNS_advance_pc;
743 p += output_leb128 (p, addr_delta, 0);
754 /* Handy routine to combine calls to the above two routines. */
757 out_inc_line_addr (line_delta, addr_delta)
761 int len = size_inc_line_addr (line_delta, addr_delta);
762 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
765 /* Generate a variant frag that we can use to relax address/line
766 increments between fragments of the target segment. */
769 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
772 fragS *to_frag, *from_frag;
773 addressT to_ofs, from_ofs;
775 symbolS *to_sym, *from_sym;
779 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
780 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
782 expr.X_op = O_subtract;
783 expr.X_add_symbol = to_sym;
784 expr.X_op_symbol = from_sym;
785 expr.X_add_number = 0;
787 /* The maximum size of the frag is the line delta with a maximum
788 sized address delta. */
789 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
791 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
792 make_expr_symbol (&expr), line_delta, NULL);
795 /* The function estimates the size of a rs_dwarf2dbg variant frag
796 based on the current values of the symbols. It is called before
797 the relaxation loop. We set fr_subtype to the expected length. */
800 dwarf2dbg_estimate_size_before_relax (frag)
806 addr_delta = resolve_symbol_value (frag->fr_symbol);
807 size = size_inc_line_addr (frag->fr_offset, addr_delta);
809 frag->fr_subtype = size;
814 /* This function relaxes a rs_dwarf2dbg variant frag based on the
815 current values of the symbols. fr_subtype is the current length
816 of the frag. This returns the change in frag length. */
819 dwarf2dbg_relax_frag (frag)
822 int old_size, new_size;
824 old_size = frag->fr_subtype;
825 new_size = dwarf2dbg_estimate_size_before_relax (frag);
827 return new_size - old_size;
830 /* This function converts a rs_dwarf2dbg variant frag into a normal
831 fill frag. This is called after all relaxation has been done.
832 fr_subtype will be the desired length of the frag. */
835 dwarf2dbg_convert_frag (frag)
840 addr_diff = resolve_symbol_value (frag->fr_symbol);
842 /* fr_var carries the max_chars that we created the fragment with.
843 fr_subtype carries the current expected length. We must, of
844 course, have allocated enough memory earlier. */
845 assert (frag->fr_var >= (int) frag->fr_subtype);
847 emit_inc_line_addr (frag->fr_offset, addr_diff,
848 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
850 frag->fr_fix += frag->fr_subtype;
851 frag->fr_type = rs_fill;
856 /* Generate .debug_line content for the chain of line number entries
857 beginning at E, for segment SEG. */
860 process_entries (seg, e)
862 struct line_entry *e;
864 unsigned filenum = 1;
867 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
870 addressT frag_ofs = 0;
871 addressT last_frag_ofs;
872 struct line_entry *next;
878 if (filenum != e->loc.filenum)
880 filenum = e->loc.filenum;
881 out_opcode (DW_LNS_set_file);
882 out_uleb128 (filenum);
886 if (column != e->loc.column)
888 column = e->loc.column;
889 out_opcode (DW_LNS_set_column);
890 out_uleb128 (column);
894 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
896 flags = e->loc.flags;
897 out_opcode (DW_LNS_negate_stmt);
901 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
903 out_opcode (DW_LNS_set_basic_block);
907 /* Don't try to optimize away redundant entries; gdb wants two
908 entries for a function where the code starts on the same line as
909 the {, and there's no way to identify that case here. Trust gcc
910 to optimize appropriately. */
911 if (1 /* line != e->loc.line || changed */)
913 int line_delta = e->loc.line - line;
916 out_set_addr (seg, e->frag, e->frag_ofs);
917 out_inc_line_addr (line_delta, 0);
919 else if (frag == e->frag)
920 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
922 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
926 frag_ofs = e->frag_ofs;
929 else if (frag == NULL)
931 out_set_addr (seg, e->frag, e->frag_ofs);
933 frag_ofs = e->frag_ofs;
941 /* Emit a DW_LNE_end_sequence for the end of the section. */
942 last_frag = last_frag_for_seg (seg);
943 last_frag_ofs = get_frag_fix (last_frag);
944 if (frag == last_frag)
945 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
947 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
951 /* Emit the directory and file tables for .debug_line. */
960 /* Terminate directory list. */
963 for (i = 1; i < files_in_use; ++i)
965 if (files[i].filename == NULL)
967 as_bad (_("unassigned file number %ld"), (long) i);
971 size = strlen (files[i].filename) + 1;
972 cp = frag_more (size);
973 memcpy (cp, files[i].filename, size);
975 out_uleb128 (files[i].dir); /* directory number */
976 out_uleb128 (0); /* last modification timestamp */
977 out_uleb128 (0); /* filesize */
980 /* Terminate filename list. */
984 /* Emit the collected .debug_line data. */
987 out_debug_line (line_seg)
992 symbolS *prologue_end;
996 subseg_set (line_seg, 0);
998 line_start = symbol_new_now ();
999 prologue_end = symbol_make (fake_label_name);
1000 line_end = symbol_make (fake_label_name);
1002 /* Total length of the information for this compilation unit. */
1003 expr.X_op = O_subtract;
1004 expr.X_add_symbol = line_end;
1005 expr.X_op_symbol = line_start;
1006 expr.X_add_number = -4;
1007 emit_expr (&expr, 4);
1012 /* Length of the prologue following this length. */
1013 expr.X_op = O_subtract;
1014 expr.X_add_symbol = prologue_end;
1015 expr.X_op_symbol = line_start;
1016 expr.X_add_number = - (4 + 2 + 4);
1017 emit_expr (&expr, 4);
1019 /* Parameters of the state machine. */
1020 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1021 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1022 out_byte (DWARF2_LINE_BASE);
1023 out_byte (DWARF2_LINE_RANGE);
1024 out_byte (DWARF2_LINE_OPCODE_BASE);
1026 /* Standard opcode lengths. */
1027 out_byte (0); /* DW_LNS_copy */
1028 out_byte (1); /* DW_LNS_advance_pc */
1029 out_byte (1); /* DW_LNS_advance_line */
1030 out_byte (1); /* DW_LNS_set_file */
1031 out_byte (1); /* DW_LNS_set_column */
1032 out_byte (0); /* DW_LNS_negate_stmt */
1033 out_byte (0); /* DW_LNS_set_basic_block */
1034 out_byte (0); /* DW_LNS_const_add_pc */
1035 out_byte (1); /* DW_LNS_fixed_advance_pc */
1039 set_symbol_value_now (prologue_end);
1041 /* For each section, emit a statement program. */
1042 for (s = all_segs; s; s = s->next)
1043 process_entries (s->seg, s->head->head);
1045 set_symbol_value_now (line_end);
1048 /* Emit data for .debug_aranges. */
1051 out_debug_aranges (aranges_seg, info_seg)
1055 unsigned int addr_size = sizeof_address;
1056 addressT size, skip;
1061 size = 4 + 2 + 4 + 1 + 1;
1063 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1064 if (skip == 2 * addr_size)
1068 for (s = all_segs; s; s = s->next)
1069 size += 2 * addr_size;
1071 size += 2 * addr_size;
1073 subseg_set (aranges_seg, 0);
1075 /* Length of the compilation unit. */
1076 out_four (size - 4);
1081 /* Offset to .debug_info. */
1082 expr.X_op = O_symbol;
1083 expr.X_add_symbol = section_symbol (info_seg);
1084 expr.X_add_number = 0;
1085 emit_expr (&expr, 4);
1087 /* Size of an address (offset portion). */
1088 out_byte (addr_size);
1090 /* Size of a segment descriptor. */
1093 /* Align the header. */
1095 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1097 for (s = all_segs; s; s = s->next)
1102 frag = first_frag_for_seg (s->seg);
1103 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1104 s->text_start = beg;
1106 frag = last_frag_for_seg (s->seg);
1107 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1110 expr.X_op = O_symbol;
1111 expr.X_add_symbol = beg;
1112 expr.X_add_number = 0;
1113 emit_expr (&expr, addr_size);
1115 expr.X_op = O_subtract;
1116 expr.X_add_symbol = end;
1117 expr.X_op_symbol = beg;
1118 expr.X_add_number = 0;
1119 emit_expr (&expr, addr_size);
1122 p = frag_more (2 * addr_size);
1123 md_number_to_chars (p, 0, addr_size);
1124 md_number_to_chars (p + addr_size, 0, addr_size);
1127 /* Emit data for .debug_abbrev. Note that this must be kept in
1128 sync with out_debug_info below. */
1131 out_debug_abbrev (abbrev_seg)
1134 subseg_set (abbrev_seg, 0);
1137 out_uleb128 (DW_TAG_compile_unit);
1138 out_byte (DW_CHILDREN_no);
1139 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1140 if (all_segs->next == NULL)
1142 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1143 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1145 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1146 out_abbrev (DW_AT_producer, DW_FORM_string);
1147 out_abbrev (DW_AT_language, DW_FORM_data2);
1150 /* Terminate the abbreviations for this compilation unit. */
1154 /* Emit a description of this compilation unit for .debug_info. */
1157 out_debug_info (info_seg, abbrev_seg, line_seg)
1165 symbolS *info_start;
1170 subseg_set (info_seg, 0);
1172 info_start = symbol_new_now ();
1173 info_end = symbol_make (fake_label_name);
1175 /* Compilation Unit length. */
1176 expr.X_op = O_subtract;
1177 expr.X_add_symbol = info_end;
1178 expr.X_op_symbol = info_start;
1179 expr.X_add_number = -4;
1180 emit_expr (&expr, 4);
1182 /* DWARF version. */
1185 /* .debug_abbrev offset */
1186 expr.X_op = O_symbol;
1187 expr.X_add_symbol = section_symbol (abbrev_seg);
1188 expr.X_add_number = 0;
1189 emit_expr (&expr, 4);
1191 /* Target address size. */
1192 out_byte (sizeof_address);
1194 /* DW_TAG_compile_unit DIE abbrev */
1197 /* DW_AT_stmt_list */
1198 expr.X_op = O_symbol;
1199 expr.X_add_symbol = section_symbol (line_seg);
1200 expr.X_add_number = 0;
1201 emit_expr (&expr, 4);
1203 /* These two attributes may only be emitted if all of the code is
1204 contiguous. Multiple sections are not that. */
1205 if (all_segs->next == NULL)
1208 expr.X_op = O_symbol;
1209 expr.X_add_symbol = all_segs->text_start;
1210 expr.X_add_number = 0;
1211 emit_expr (&expr, sizeof_address);
1214 expr.X_op = O_symbol;
1215 expr.X_add_symbol = all_segs->text_end;
1216 expr.X_add_number = 0;
1217 emit_expr (&expr, sizeof_address);
1220 /* DW_AT_comp_dir */
1221 comp_dir = getpwd ();
1222 len = strlen (comp_dir) + 1;
1223 p = frag_more (len);
1224 memcpy (p, comp_dir, len);
1226 /* DW_AT_producer */
1227 sprintf (producer, "GNU AS %s", VERSION);
1228 len = strlen (producer) + 1;
1229 p = frag_more (len);
1230 memcpy (p, producer, len);
1232 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1233 dwarf2 draft has no standard code for assembler. */
1234 out_two (DW_LANG_Mips_Assembler);
1236 set_symbol_value_now (info_end);
1245 /* If no debug information was recorded, nothing to do. */
1246 if (all_segs == NULL && files_in_use <= 1)
1249 /* Calculate the size of an address for the target machine. */
1250 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1252 /* Create and switch to the line number section. */
1253 line_seg = subseg_new (".debug_line", 0);
1254 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1256 /* For each subsection, chain the debug entries together. */
1257 for (s = all_segs; s; s = s->next)
1259 struct line_subseg *ss = s->head;
1260 struct line_entry **ptail = ss->ptail;
1262 while ((ss = ss->next) != NULL)
1269 out_debug_line (line_seg);
1271 /* If this is assembler generated line info, we need .debug_info
1272 and .debug_abbrev sections as well. */
1273 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1279 info_seg = subseg_new (".debug_info", 0);
1280 abbrev_seg = subseg_new (".debug_abbrev", 0);
1281 aranges_seg = subseg_new (".debug_aranges", 0);
1283 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1284 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1285 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1287 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1289 out_debug_aranges (aranges_seg, info_seg);
1290 out_debug_abbrev (abbrev_seg);
1291 out_debug_info (info_seg, abbrev_seg, line_seg);
1302 dwarf2dbg_estimate_size_before_relax (frag)
1303 fragS *frag ATTRIBUTE_UNUSED;
1305 as_fatal (_("dwarf2 is not supported for this object file format"));
1310 dwarf2dbg_relax_frag (frag)
1311 fragS *frag ATTRIBUTE_UNUSED;
1313 as_fatal (_("dwarf2 is not supported for this object file format"));
1318 dwarf2dbg_convert_frag (frag)
1319 fragS *frag ATTRIBUTE_UNUSED;
1321 as_fatal (_("dwarf2 is not supported for this object file format"));
1325 dwarf2_emit_insn (size)
1326 int size ATTRIBUTE_UNUSED;
1331 dwarf2_directive_file (dummy)
1332 int dummy ATTRIBUTE_UNUSED;
1338 dwarf2_directive_loc (dummy)
1339 int dummy ATTRIBUTE_UNUSED;
1341 as_fatal (_("dwarf2 is not supported for this object file format"));
1343 #endif /* BFD_ASSEMBLER */