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 (debug_type != DEBUG_DWARF2 && ! loc_directive_seen)
291 loc_directive_seen = false;
293 /* Use the last location established by a .loc directive, not
294 the value returned by dwarf2_where(). That calls as_where()
295 which will return either the logical input file name (foo.c)
296 or the physical input file name (foo.s) and not the file name
297 specified in the most recent .loc directive (eg foo.h). */
299 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
302 /* Get a .debug_line file number for FILENAME. */
305 get_filenum (filename)
306 const char *filename;
308 static unsigned int last_used;
312 if (strcmp (filename, files[last_used].filename) == 0)
315 for (i = 1; i < files_in_use; ++i)
316 if (strcmp (filename, files[i].filename) == 0)
319 if (i >= files_allocated)
321 unsigned int old = files_allocated;
323 files_allocated = i + 32;
324 files = (struct file_entry *)
325 xrealloc (files, (i + 32) * sizeof (struct file_entry));
327 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
330 files[i].filename = xstrdup (filename);
332 files_in_use = i + 1;
338 /* Handle the .file directive. */
341 dwarf2_directive_file (dummy)
342 int dummy ATTRIBUTE_UNUSED;
348 /* Continue to accept a bare string and pass it off. */
350 if (*input_line_pointer == '"')
356 num = get_absolute_expression ();
357 filename = demand_copy_C_string (&filename_len);
358 demand_empty_rest_of_line ();
362 as_bad (_("file number less than one"));
366 if (num < (int) files_in_use && files[num].filename != 0)
368 as_bad (_("file number %ld already allocated"), (long) num);
372 if (num >= (int) files_allocated)
374 unsigned int old = files_allocated;
376 files_allocated = num + 16;
377 files = (struct file_entry *)
378 xrealloc (files, (num + 16) * sizeof (struct file_entry));
380 /* Zero the new memory. */
381 memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
384 files[num].filename = filename;
386 files_in_use = num + 1;
390 dwarf2_directive_loc (dummy)
391 int dummy ATTRIBUTE_UNUSED;
393 offsetT filenum, line, column;
395 filenum = get_absolute_expression ();
397 line = get_absolute_expression ();
399 column = get_absolute_expression ();
400 demand_empty_rest_of_line ();
404 as_bad (_("file number less than one"));
407 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
409 as_bad (_("unassigned file number %ld"), (long) filenum);
413 current.filenum = filenum;
415 current.column = column;
416 current.flags = DWARF2_FLAG_BEGIN_STMT;
418 loc_directive_seen = true;
422 listing_source_line (line);
427 first_frag_for_seg (seg)
430 frchainS *f, *first = NULL;
432 for (f = frchain_root; f; f = f->frch_next)
433 if (f->frch_seg == seg
434 && (! first || first->frch_subseg > f->frch_subseg))
437 return first ? first->frch_root : NULL;
441 last_frag_for_seg (seg)
444 frchainS *f, *last = NULL;
446 for (f = frchain_root; f; f = f->frch_next)
447 if (f->frch_seg == seg
448 && (! last || last->frch_subseg < f->frch_subseg))
451 return last ? last->frch_last : NULL;
454 /* Emit a single byte into the current segment. */
460 FRAG_APPEND_1_CHAR (byte);
463 /* Emit a statement program opcode into the current segment. */
472 /* Emit a two-byte word into the current segment. */
478 md_number_to_chars (frag_more (2), data, 2);
481 /* Emit a four byte word into the current segment. */
487 md_number_to_chars (frag_more (4), data, 4);
490 /* Emit an unsigned "little-endian base 128" number. */
496 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
499 /* Emit a tuple for .debug_abbrev. */
502 out_abbrev (name, form)
509 /* Create a new fake symbol whose value is the current position. */
514 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
517 /* Set the value of SYM to the current position in the current segment. */
520 set_symbol_value_now (sym)
523 S_SET_SEGMENT (sym, now_seg);
524 S_SET_VALUE (sym, frag_now_fix ());
525 symbol_set_frag (sym, frag_now);
528 /* Get the size of a fragment. */
539 /* If a fragment is the last in the chain, special measures must be
540 taken to find its size before relaxation, since it may be pending
541 on some subsegment chain. */
542 for (fr = frchain_root; fr; fr = fr->frch_next)
543 if (fr->frch_last == frag)
545 long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
546 return (((char *) obstack_next_free (&fr->frch_obstack)
547 - frag->fr_literal) + ~align_mask) & align_mask;
553 /* Set an absolute address (may result in a relocation entry). */
556 out_set_addr (seg, frag, ofs)
564 sym = symbol_new (fake_label_name, seg, ofs, frag);
566 out_opcode (DW_LNS_extended_op);
567 out_uleb128 (sizeof_address + 1);
569 out_opcode (DW_LNE_set_address);
570 expr.X_op = O_symbol;
571 expr.X_add_symbol = sym;
572 expr.X_add_number = 0;
573 emit_expr (&expr, sizeof_address);
576 /* Encode a pair of line and address skips as efficiently as possible.
577 Note that the line skip is signed, whereas the address skip is unsigned.
579 The following two routines *must* be kept in sync. This is
580 enforced by making emit_inc_line_addr abort if we do not emit
581 exactly the expected number of bytes. */
584 size_inc_line_addr (line_delta, addr_delta)
588 unsigned int tmp, opcode;
591 /* Scale the address delta by the minimum instruction length. */
592 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
593 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
594 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
597 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
598 We cannot use special opcodes here, since we want the end_sequence
599 to emit the matrix entry. */
600 if (line_delta == INT_MAX)
602 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
605 len = 1 + sizeof_leb128 (addr_delta, 0);
609 /* Bias the line delta by the base. */
610 tmp = line_delta - DWARF2_LINE_BASE;
612 /* If the line increment is out of range of a special opcode, we
613 must encode it with DW_LNS_advance_line. */
614 if (tmp >= DWARF2_LINE_RANGE)
616 len = 1 + sizeof_leb128 (line_delta, 1);
618 tmp = 0 - DWARF2_LINE_BASE;
621 /* Bias the opcode by the special opcode base. */
622 tmp += DWARF2_LINE_OPCODE_BASE;
624 /* Avoid overflow when addr_delta is large. */
625 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
627 /* Try using a special opcode. */
628 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
632 /* Try using DW_LNS_const_add_pc followed by special op. */
633 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
638 /* Otherwise use DW_LNS_advance_pc. */
639 len += 1 + sizeof_leb128 (addr_delta, 0);
641 /* DW_LNS_copy or special opcode. */
648 emit_inc_line_addr (line_delta, addr_delta, p, len)
654 unsigned int tmp, opcode;
658 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
659 /* Scale the address delta by the minimum instruction length. */
660 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
661 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
663 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
664 We cannot use special opcodes here, since we want the end_sequence
665 to emit the matrix entry. */
666 if (line_delta == INT_MAX)
668 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
669 *p++ = DW_LNS_const_add_pc;
672 *p++ = DW_LNS_advance_pc;
673 p += output_leb128 (p, addr_delta, 0);
676 *p++ = DW_LNS_extended_op;
678 *p++ = DW_LNE_end_sequence;
682 /* Bias the line delta by the base. */
683 tmp = line_delta - DWARF2_LINE_BASE;
685 /* If the line increment is out of range of a special opcode, we
686 must encode it with DW_LNS_advance_line. */
687 if (tmp >= DWARF2_LINE_RANGE)
689 *p++ = DW_LNS_advance_line;
690 p += output_leb128 (p, line_delta, 1);
692 /* Prettier, I think, to use DW_LNS_copy instead of a
693 "line +0, addr +0" special opcode. */
701 tmp = 0 - DWARF2_LINE_BASE;
705 /* Bias the opcode by the special opcode base. */
706 tmp += DWARF2_LINE_OPCODE_BASE;
708 /* Avoid overflow when addr_delta is large. */
709 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
711 /* Try using a special opcode. */
712 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
719 /* Try using DW_LNS_const_add_pc followed by special op. */
720 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
723 *p++ = DW_LNS_const_add_pc;
729 /* Otherwise use DW_LNS_advance_pc. */
730 *p++ = DW_LNS_advance_pc;
731 p += output_leb128 (p, addr_delta, 0);
742 /* Handy routine to combine calls to the above two routines. */
745 out_inc_line_addr (line_delta, addr_delta)
749 int len = size_inc_line_addr (line_delta, addr_delta);
750 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
753 /* Generate a variant frag that we can use to relax address/line
754 increments between fragments of the target segment. */
757 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
760 fragS *to_frag, *from_frag;
761 addressT to_ofs, from_ofs;
763 symbolS *to_sym, *from_sym;
767 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
768 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
770 expr.X_op = O_subtract;
771 expr.X_add_symbol = to_sym;
772 expr.X_op_symbol = from_sym;
773 expr.X_add_number = 0;
775 /* The maximum size of the frag is the line delta with a maximum
776 sized address delta. */
777 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
779 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
780 make_expr_symbol (&expr), line_delta, NULL);
783 /* The function estimates the size of a rs_dwarf2dbg variant frag
784 based on the current values of the symbols. It is called before
785 the relaxation loop. We set fr_subtype to the expected length. */
788 dwarf2dbg_estimate_size_before_relax (frag)
794 addr_delta = resolve_symbol_value (frag->fr_symbol);
795 size = size_inc_line_addr (frag->fr_offset, addr_delta);
797 frag->fr_subtype = size;
802 /* This function relaxes a rs_dwarf2dbg variant frag based on the
803 current values of the symbols. fr_subtype is the current length
804 of the frag. This returns the change in frag length. */
807 dwarf2dbg_relax_frag (frag)
810 int old_size, new_size;
812 old_size = frag->fr_subtype;
813 new_size = dwarf2dbg_estimate_size_before_relax (frag);
815 return new_size - old_size;
818 /* This function converts a rs_dwarf2dbg variant frag into a normal
819 fill frag. This is called after all relaxation has been done.
820 fr_subtype will be the desired length of the frag. */
823 dwarf2dbg_convert_frag (frag)
828 addr_diff = resolve_symbol_value (frag->fr_symbol);
830 /* fr_var carries the max_chars that we created the fragment with.
831 fr_subtype carries the current expected length. We must, of
832 course, have allocated enough memory earlier. */
833 assert (frag->fr_var >= (int) frag->fr_subtype);
835 emit_inc_line_addr (frag->fr_offset, addr_diff,
836 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
838 frag->fr_fix += frag->fr_subtype;
839 frag->fr_type = rs_fill;
844 /* Generate .debug_line content for the chain of line number entries
845 beginning at E, for segment SEG. */
848 process_entries (seg, e)
850 struct line_entry *e;
852 unsigned filenum = 1;
855 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
858 addressT frag_ofs = 0;
859 addressT last_frag_ofs;
860 struct line_entry *next;
866 if (filenum != e->loc.filenum)
868 filenum = e->loc.filenum;
869 out_opcode (DW_LNS_set_file);
870 out_uleb128 (filenum);
874 if (column != e->loc.column)
876 column = e->loc.column;
877 out_opcode (DW_LNS_set_column);
878 out_uleb128 (column);
882 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
884 flags = e->loc.flags;
885 out_opcode (DW_LNS_negate_stmt);
889 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
891 out_opcode (DW_LNS_set_basic_block);
895 /* Don't try to optimize away redundant entries; gdb wants two
896 entries for a function where the code starts on the same line as
897 the {, and there's no way to identify that case here. Trust gcc
898 to optimize appropriately. */
899 if (1 /* line != e->loc.line || changed */)
901 int line_delta = e->loc.line - line;
904 out_set_addr (seg, e->frag, e->frag_ofs);
905 out_inc_line_addr (line_delta, 0);
907 else if (frag == e->frag)
908 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
910 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
914 frag_ofs = e->frag_ofs;
917 else if (frag == NULL)
919 out_set_addr (seg, e->frag, e->frag_ofs);
921 frag_ofs = e->frag_ofs;
929 /* Emit a DW_LNE_end_sequence for the end of the section. */
930 last_frag = last_frag_for_seg (seg);
931 last_frag_ofs = get_frag_fix (last_frag);
932 if (frag == last_frag)
933 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
935 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
939 /* Emit the directory and file tables for .debug_line. */
948 /* Terminate directory list. */
951 for (i = 1; i < files_in_use; ++i)
953 if (files[i].filename == NULL)
955 as_bad (_("unassigned file number %ld"), (long) i);
959 size = strlen (files[i].filename) + 1;
960 cp = frag_more (size);
961 memcpy (cp, files[i].filename, size);
963 out_uleb128 (files[i].dir); /* directory number */
964 out_uleb128 (0); /* last modification timestamp */
965 out_uleb128 (0); /* filesize */
968 /* Terminate filename list. */
972 /* Emit the collected .debug_line data. */
975 out_debug_line (line_seg)
980 symbolS *prologue_end;
984 subseg_set (line_seg, 0);
986 line_start = symbol_new_now ();
987 prologue_end = symbol_make (fake_label_name);
988 line_end = symbol_make (fake_label_name);
990 /* Total length of the information for this compilation unit. */
991 expr.X_op = O_subtract;
992 expr.X_add_symbol = line_end;
993 expr.X_op_symbol = line_start;
994 expr.X_add_number = -4;
995 emit_expr (&expr, 4);
1000 /* Length of the prologue following this length. */
1001 expr.X_op = O_subtract;
1002 expr.X_add_symbol = prologue_end;
1003 expr.X_op_symbol = line_start;
1004 expr.X_add_number = - (4 + 2 + 4);
1005 emit_expr (&expr, 4);
1007 /* Parameters of the state machine. */
1008 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1009 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1010 out_byte (DWARF2_LINE_BASE);
1011 out_byte (DWARF2_LINE_RANGE);
1012 out_byte (DWARF2_LINE_OPCODE_BASE);
1014 /* Standard opcode lengths. */
1015 out_byte (0); /* DW_LNS_copy */
1016 out_byte (1); /* DW_LNS_advance_pc */
1017 out_byte (1); /* DW_LNS_advance_line */
1018 out_byte (1); /* DW_LNS_set_file */
1019 out_byte (1); /* DW_LNS_set_column */
1020 out_byte (0); /* DW_LNS_negate_stmt */
1021 out_byte (0); /* DW_LNS_set_basic_block */
1022 out_byte (0); /* DW_LNS_const_add_pc */
1023 out_byte (1); /* DW_LNS_fixed_advance_pc */
1027 set_symbol_value_now (prologue_end);
1029 /* For each section, emit a statement program. */
1030 for (s = all_segs; s; s = s->next)
1031 process_entries (s->seg, s->head->head);
1033 set_symbol_value_now (line_end);
1036 /* Emit data for .debug_aranges. */
1039 out_debug_aranges (aranges_seg, info_seg)
1043 unsigned int addr_size = sizeof_address;
1044 addressT size, skip;
1049 size = 4 + 2 + 4 + 1 + 1;
1051 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1052 if (skip == 2 * addr_size)
1056 for (s = all_segs; s; s = s->next)
1057 size += 2 * addr_size;
1059 size += 2 * addr_size;
1061 subseg_set (aranges_seg, 0);
1063 /* Length of the compilation unit. */
1064 out_four (size - 4);
1069 /* Offset to .debug_info. */
1070 expr.X_op = O_symbol;
1071 expr.X_add_symbol = section_symbol (info_seg);
1072 expr.X_add_number = 0;
1073 emit_expr (&expr, 4);
1075 /* Size of an address (offset portion). */
1076 out_byte (addr_size);
1078 /* Size of a segment descriptor. */
1081 /* Align the header. */
1083 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1085 for (s = all_segs; s; s = s->next)
1090 frag = first_frag_for_seg (s->seg);
1091 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1092 s->text_start = beg;
1094 frag = last_frag_for_seg (s->seg);
1095 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1098 expr.X_op = O_symbol;
1099 expr.X_add_symbol = beg;
1100 expr.X_add_number = 0;
1101 emit_expr (&expr, addr_size);
1103 expr.X_op = O_subtract;
1104 expr.X_add_symbol = end;
1105 expr.X_op_symbol = beg;
1106 expr.X_add_number = 0;
1107 emit_expr (&expr, addr_size);
1110 p = frag_more (2 * addr_size);
1111 md_number_to_chars (p, 0, addr_size);
1112 md_number_to_chars (p + addr_size, 0, addr_size);
1115 /* Emit data for .debug_abbrev. Note that this must be kept in
1116 sync with out_debug_info below. */
1119 out_debug_abbrev (abbrev_seg)
1122 subseg_set (abbrev_seg, 0);
1125 out_uleb128 (DW_TAG_compile_unit);
1126 out_byte (DW_CHILDREN_no);
1127 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1128 if (all_segs->next == NULL)
1130 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1131 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1133 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1134 out_abbrev (DW_AT_producer, DW_FORM_string);
1135 out_abbrev (DW_AT_language, DW_FORM_data2);
1138 /* Terminate the abbreviations for this compilation unit. */
1142 /* Emit a description of this compilation unit for .debug_info. */
1145 out_debug_info (info_seg, abbrev_seg, line_seg)
1153 symbolS *info_start;
1158 subseg_set (info_seg, 0);
1160 info_start = symbol_new_now ();
1161 info_end = symbol_make (fake_label_name);
1163 /* Compilation Unit length. */
1164 expr.X_op = O_subtract;
1165 expr.X_add_symbol = info_end;
1166 expr.X_op_symbol = info_start;
1167 expr.X_add_number = -4;
1168 emit_expr (&expr, 4);
1170 /* DWARF version. */
1173 /* .debug_abbrev offset */
1174 expr.X_op = O_symbol;
1175 expr.X_add_symbol = section_symbol (abbrev_seg);
1176 expr.X_add_number = 0;
1177 emit_expr (&expr, 4);
1179 /* Target address size. */
1180 out_byte (sizeof_address);
1182 /* DW_TAG_compile_unit DIE abbrev */
1185 /* DW_AT_stmt_list */
1186 expr.X_op = O_symbol;
1187 expr.X_add_symbol = section_symbol (line_seg);
1188 expr.X_add_number = 0;
1189 emit_expr (&expr, 4);
1191 /* These two attributes may only be emitted if all of the code is
1192 contiguous. Multiple sections are not that. */
1193 if (all_segs->next == NULL)
1196 expr.X_op = O_symbol;
1197 expr.X_add_symbol = all_segs->text_start;
1198 expr.X_add_number = 0;
1199 emit_expr (&expr, sizeof_address);
1202 expr.X_op = O_symbol;
1203 expr.X_add_symbol = all_segs->text_end;
1204 expr.X_add_number = 0;
1205 emit_expr (&expr, sizeof_address);
1208 /* DW_AT_comp_dir */
1209 comp_dir = getpwd ();
1210 len = strlen (comp_dir) + 1;
1211 p = frag_more (len);
1212 memcpy (p, comp_dir, len);
1214 /* DW_AT_producer */
1215 sprintf (producer, "GNU AS %s", VERSION);
1216 len = strlen (producer) + 1;
1217 p = frag_more (len);
1218 memcpy (p, producer, len);
1220 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1221 dwarf2 draft has no standard code for assembler. */
1222 out_two (DW_LANG_Mips_Assembler);
1224 set_symbol_value_now (info_end);
1233 /* If no debug information was recorded, nothing to do. */
1234 if (all_segs == NULL && files_in_use <= 1)
1237 /* Calculate the size of an address for the target machine. */
1238 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1240 /* Create and switch to the line number section. */
1241 line_seg = subseg_new (".debug_line", 0);
1242 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1244 /* For each subsection, chain the debug entries together. */
1245 for (s = all_segs; s; s = s->next)
1247 struct line_subseg *ss = s->head;
1248 struct line_entry **ptail = ss->ptail;
1250 while ((ss = ss->next) != NULL)
1257 out_debug_line (line_seg);
1259 /* If this is assembler generated line info, we need .debug_info
1260 and .debug_abbrev sections as well. */
1261 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1267 info_seg = subseg_new (".debug_info", 0);
1268 abbrev_seg = subseg_new (".debug_abbrev", 0);
1269 aranges_seg = subseg_new (".debug_aranges", 0);
1271 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1272 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1273 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1275 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1277 out_debug_aranges (aranges_seg, info_seg);
1278 out_debug_abbrev (abbrev_seg);
1279 out_debug_info (info_seg, abbrev_seg, line_seg);
1290 dwarf2dbg_estimate_size_before_relax (frag)
1291 fragS *frag ATTRIBUTE_UNUSED;
1293 as_fatal (_("dwarf2 is not supported for this object file format"));
1298 dwarf2dbg_relax_frag (frag)
1299 fragS *frag ATTRIBUTE_UNUSED;
1301 as_fatal (_("dwarf2 is not supported for this object file format"));
1306 dwarf2dbg_convert_frag (frag)
1307 fragS *frag ATTRIBUTE_UNUSED;
1309 as_fatal (_("dwarf2 is not supported for this object file format"));
1313 dwarf2_emit_insn (size)
1314 int size ATTRIBUTE_UNUSED;
1319 dwarf2_directive_file (dummy)
1320 int dummy ATTRIBUTE_UNUSED;
1326 dwarf2_directive_loc (dummy)
1327 int dummy ATTRIBUTE_UNUSED;
1329 as_fatal (_("dwarf2 is not supported for this object file format"));
1331 #endif /* BFD_ASSEMBLER */