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. */
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 /* Correlate file numbers as given by the user in .file/.loc directives
135 with the file numbers used in the output debug info. */
136 static unsigned int *user_filenum;
137 static unsigned int user_filenum_allocated;
139 /* True when we've seen a .loc directive recently. Used to avoid
140 doing work when there's nothing to do. */
141 static boolean loc_directive_seen;
143 /* Current location as indicated by the most recent .loc directive. */
144 static struct dwarf2_line_info current;
146 /* Fake label name. */
147 static char const fake_label_name[] = ".L0\001";
149 /* The size of an address on the target. */
150 static unsigned int sizeof_address;
152 static struct line_subseg *get_line_subseg PARAMS ((segT, subsegT));
153 static unsigned int get_filenum PARAMS ((const char *));
154 static struct frag *first_frag_for_seg PARAMS ((segT));
155 static struct frag *last_frag_for_seg PARAMS ((segT));
156 static void out_byte PARAMS ((int));
157 static void out_opcode PARAMS ((int));
158 static void out_two PARAMS ((int));
159 static void out_four PARAMS ((int));
160 static void out_abbrev PARAMS ((int, int));
161 static void out_uleb128 PARAMS ((addressT));
162 static symbolS *symbol_new_now PARAMS ((void));
163 static void set_symbol_value_now PARAMS ((symbolS *));
164 static offsetT get_frag_fix PARAMS ((fragS *));
165 static void out_set_addr PARAMS ((segT, fragS *, addressT));
166 static int size_inc_line_addr PARAMS ((int, addressT));
167 static void emit_inc_line_addr PARAMS ((int, addressT, char *, int));
168 static void out_inc_line_addr PARAMS ((int, addressT));
169 static void relax_inc_line_addr PARAMS ((int, segT, fragS *, addressT,
171 static void process_entries PARAMS ((segT, struct line_entry *));
172 static void out_file_list PARAMS ((void));
173 static void out_debug_line PARAMS ((segT));
174 static void out_debug_aranges PARAMS ((segT, segT));
175 static void out_debug_abbrev PARAMS ((segT));
176 static void out_debug_info PARAMS ((segT, segT, segT));
178 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
180 static struct line_subseg *
181 get_line_subseg (seg, subseg)
185 static segT last_seg;
186 static subsegT last_subseg;
187 static struct line_subseg *last_line_subseg;
190 struct line_subseg **pss, *ss;
192 if (seg == last_seg && subseg == last_subseg)
193 return last_line_subseg;
195 for (s = all_segs; s; s = s->next)
199 s = (struct line_seg *) xmalloc (sizeof (*s));
206 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
208 if (ss->subseg == subseg)
210 if (ss->subseg > subseg)
214 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
218 ss->ptail = &ss->head;
223 last_subseg = subseg;
224 last_line_subseg = ss;
229 /* Record an entry for LOC ocurring at OFS within the current fragment. */
232 dwarf2_gen_line_info (ofs, loc)
234 struct dwarf2_line_info *loc;
236 struct line_subseg *ss;
237 struct line_entry *e;
239 /* Early out for as-yet incomplete location information. */
240 if (loc->filenum == 0 || loc->line == 0)
243 e = (struct line_entry *) xmalloc (sizeof (*e));
249 ss = get_line_subseg (now_seg, now_subseg);
251 ss->ptail = &e->next;
256 struct dwarf2_line_info *line;
258 if (debug_type == DEBUG_DWARF2)
261 as_where (&filename, &line->line);
262 line->filenum = get_filenum (filename);
264 line->flags = DWARF2_FLAG_BEGIN_STMT;
270 /* Called for each machine instruction, or relatively atomic group of
271 machine instructions (ie built-in macro). The instruction or group
272 is SIZE bytes in length. If dwarf2 line number generation is called
273 for, emit a line statement appropriately. */
276 dwarf2_emit_insn (size)
279 struct dwarf2_line_info loc;
281 if (debug_type != DEBUG_DWARF2 && ! loc_directive_seen)
283 loc_directive_seen = false;
286 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
289 /* Get a .debug_line file number for FILENAME. */
292 get_filenum (filename)
293 const char *filename;
295 static unsigned int last_used;
299 if (strcmp (filename, files[last_used].filename) == 0)
302 for (i = 1; i < files_in_use; ++i)
303 if (strcmp (filename, files[i].filename) == 0)
306 if (i >= files_allocated)
308 files_allocated = i + 32;
309 files = (struct file_entry *)
310 xrealloc (files, (i + 32) * sizeof (struct file_entry));
313 files[i].filename = xstrdup (filename);
315 files_in_use = i + 1;
321 /* Handle the .file directive. */
324 dwarf2_directive_file (dummy)
325 int dummy ATTRIBUTE_UNUSED;
328 const char *filename;
331 /* Continue to accept a bare string and pass it off. */
333 if (*input_line_pointer == '"')
339 num = get_absolute_expression ();
340 filename = demand_copy_C_string (&filename_len);
341 demand_empty_rest_of_line ();
345 as_bad (_("File number less than zero"));
349 if (num >= (int) user_filenum_allocated)
351 unsigned int old = user_filenum_allocated;
353 user_filenum_allocated = num + 16;
354 user_filenum = (unsigned int *)
355 xrealloc (user_filenum, (num + 16) * sizeof (unsigned int));
357 /* Zero the new memory. */
358 memset (user_filenum + old, 0, (num + 16 - old) * sizeof (unsigned int));
361 user_filenum[num] = get_filenum (filename);
365 dwarf2_directive_loc (dummy)
366 int dummy ATTRIBUTE_UNUSED;
368 offsetT filenum, line, column;
370 filenum = get_absolute_expression ();
372 line = get_absolute_expression ();
374 column = get_absolute_expression ();
375 demand_empty_rest_of_line ();
379 as_bad (_("File number less than zero"));
382 if (filenum >= (int) user_filenum_allocated
383 || user_filenum[filenum] == 0)
385 as_bad (_("Unassigned file number %ld"), (long) filenum);
389 current.filenum = user_filenum[filenum];
391 current.column = column;
392 current.flags = DWARF2_FLAG_BEGIN_STMT;
394 loc_directive_seen = true;
398 listing_source_line (line);
403 first_frag_for_seg (seg)
406 frchainS *f, *first = NULL;
408 for (f = frchain_root; f; f = f->frch_next)
409 if (f->frch_seg == seg
410 && (! first || first->frch_subseg > f->frch_subseg))
413 return first ? first->frch_root : NULL;
417 last_frag_for_seg (seg)
420 frchainS *f, *last = NULL;
422 for (f = frchain_root; f; f = f->frch_next)
423 if (f->frch_seg == seg
424 && (! last || last->frch_subseg < f->frch_subseg))
427 return last ? last->frch_last : NULL;
430 /* Emit a single byte into the current segment. */
436 FRAG_APPEND_1_CHAR (byte);
439 /* Emit a statement program opcode into the current segment. */
448 /* Emit a two-byte word into the current segment. */
454 md_number_to_chars (frag_more (2), data, 2);
457 /* Emit a four byte word into the current segment. */
463 md_number_to_chars (frag_more (4), data, 4);
466 /* Emit an unsigned "little-endian base 128" number. */
472 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
475 /* Emit a tuple for .debug_abbrev. */
478 out_abbrev (name, form)
485 /* Create a new fake symbol whose value is the current position. */
490 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
493 /* Set the value of SYM to the current position in the current segment. */
496 set_symbol_value_now (sym)
499 S_SET_SEGMENT (sym, now_seg);
500 S_SET_VALUE (sym, frag_now_fix ());
501 symbol_set_frag (sym, frag_now);
504 /* Get the size of a fragment. */
515 /* If a fragment is the last in the chain, special measures must be
516 taken to find its size before relaxation, since it may be pending
517 on some subsegment chain. */
518 for (fr = frchain_root; fr; fr = fr->frch_next)
519 if (fr->frch_last == frag)
521 return ((char *) obstack_next_free (&fr->frch_obstack)
528 /* Set an absolute address (may result in a relocation entry). */
531 out_set_addr (seg, frag, ofs)
539 sym = symbol_new (fake_label_name, seg, ofs, frag);
541 out_opcode (DW_LNS_extended_op);
542 out_uleb128 (sizeof_address + 1);
544 out_opcode (DW_LNE_set_address);
545 expr.X_op = O_symbol;
546 expr.X_add_symbol = sym;
547 expr.X_add_number = 0;
548 emit_expr (&expr, sizeof_address);
551 /* Encode a pair of line and address skips as efficiently as possible.
552 Note that the line skip is signed, whereas the address skip is unsigned.
554 The following two routines *must* be kept in sync. This is
555 enforced by making emit_inc_line_addr abort if we do not emit
556 exactly the expected number of bytes. */
559 size_inc_line_addr (line_delta, addr_delta)
563 unsigned int tmp, opcode;
566 /* Scale the address delta by the minimum instruction length. */
567 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
568 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
569 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
572 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
573 We cannot use special opcodes here, since we want the end_sequence
574 to emit the matrix entry. */
575 if (line_delta == INT_MAX)
577 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
580 len = 1 + sizeof_leb128 (addr_delta, 0);
584 /* Bias the line delta by the base. */
585 tmp = line_delta - DWARF2_LINE_BASE;
587 /* If the line increment is out of range of a special opcode, we
588 must encode it with DW_LNS_advance_line. */
589 if (tmp >= DWARF2_LINE_RANGE)
591 len = 1 + sizeof_leb128 (line_delta, 1);
593 tmp = 0 - DWARF2_LINE_BASE;
596 /* Bias the opcode by the special opcode base. */
597 tmp += DWARF2_LINE_OPCODE_BASE;
599 /* Avoid overflow when addr_delta is large. */
600 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
602 /* Try using a special opcode. */
603 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
607 /* Try using DW_LNS_const_add_pc followed by special op. */
608 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
613 /* Otherwise use DW_LNS_advance_pc. */
614 len += 1 + sizeof_leb128 (addr_delta, 0);
616 /* DW_LNS_copy or special opcode. */
623 emit_inc_line_addr (line_delta, addr_delta, p, len)
629 unsigned int tmp, opcode;
633 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
634 /* Scale the address delta by the minimum instruction length. */
635 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
636 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
638 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
639 We cannot use special opcodes here, since we want the end_sequence
640 to emit the matrix entry. */
641 if (line_delta == INT_MAX)
643 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
644 *p++ = DW_LNS_const_add_pc;
647 *p++ = DW_LNS_advance_pc;
648 p += output_leb128 (p, addr_delta, 0);
651 *p++ = DW_LNS_extended_op;
653 *p++ = DW_LNE_end_sequence;
657 /* Bias the line delta by the base. */
658 tmp = line_delta - DWARF2_LINE_BASE;
660 /* If the line increment is out of range of a special opcode, we
661 must encode it with DW_LNS_advance_line. */
662 if (tmp >= DWARF2_LINE_RANGE)
664 *p++ = DW_LNS_advance_line;
665 p += output_leb128 (p, line_delta, 1);
667 /* Prettier, I think, to use DW_LNS_copy instead of a
668 "line +0, addr +0" special opcode. */
676 tmp = 0 - DWARF2_LINE_BASE;
680 /* Bias the opcode by the special opcode base. */
681 tmp += DWARF2_LINE_OPCODE_BASE;
683 /* Avoid overflow when addr_delta is large. */
684 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
686 /* Try using a special opcode. */
687 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
694 /* Try using DW_LNS_const_add_pc followed by special op. */
695 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
698 *p++ = DW_LNS_const_add_pc;
704 /* Otherwise use DW_LNS_advance_pc. */
705 *p++ = DW_LNS_advance_pc;
706 p += output_leb128 (p, addr_delta, 0);
717 /* Handy routine to combine calls to the above two routines. */
720 out_inc_line_addr (line_delta, addr_delta)
724 int len = size_inc_line_addr (line_delta, addr_delta);
725 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
728 /* Generate a variant frag that we can use to relax address/line
729 increments between fragments of the target segment. */
732 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
735 fragS *to_frag, *from_frag;
736 addressT to_ofs, from_ofs;
738 symbolS *to_sym, *from_sym;
742 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
743 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
745 expr.X_op = O_subtract;
746 expr.X_add_symbol = to_sym;
747 expr.X_op_symbol = from_sym;
748 expr.X_add_number = 0;
750 /* The maximum size of the frag is the line delta with a maximum
751 sized address delta. */
752 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
754 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
755 make_expr_symbol (&expr), line_delta, NULL);
758 /* The function estimates the size of a rs_dwarf2dbg variant frag
759 based on the current values of the symbols. It is called before
760 the relaxation loop. We set fr_subtype to the expected length. */
763 dwarf2dbg_estimate_size_before_relax (frag)
769 addr_delta = resolve_symbol_value (frag->fr_symbol, 0);
770 size = size_inc_line_addr (frag->fr_offset, addr_delta);
772 frag->fr_subtype = size;
777 /* This function relaxes a rs_dwarf2dbg variant frag based on the
778 current values of the symbols. fr_subtype is the current length
779 of the frag. This returns the change in frag length. */
782 dwarf2dbg_relax_frag (frag)
785 int old_size, new_size;
787 old_size = frag->fr_subtype;
788 new_size = dwarf2dbg_estimate_size_before_relax (frag);
790 return new_size - old_size;
793 /* This function converts a rs_dwarf2dbg variant frag into a normal
794 fill frag. This is called after all relaxation has been done.
795 fr_subtype will be the desired length of the frag. */
798 dwarf2dbg_convert_frag (frag)
803 addr_diff = resolve_symbol_value (frag->fr_symbol, 1);
805 /* fr_var carries the max_chars that we created the fragment with.
806 fr_subtype carries the current expected length. We must, of
807 course, have allocated enough memory earlier. */
808 assert (frag->fr_var >= (int) frag->fr_subtype);
810 emit_inc_line_addr (frag->fr_offset, addr_diff,
811 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
813 frag->fr_fix += frag->fr_subtype;
814 frag->fr_type = rs_fill;
819 /* Generate .debug_line content for the chain of line number entries
820 beginning at E, for segment SEG. */
823 process_entries (seg, e)
825 struct line_entry *e;
827 unsigned filenum = 1;
830 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
833 addressT frag_ofs = 0;
834 addressT last_frag_ofs;
835 struct line_entry *next;
841 if (filenum != e->loc.filenum)
843 filenum = e->loc.filenum;
844 out_opcode (DW_LNS_set_file);
845 out_uleb128 (filenum);
849 if (column != e->loc.column)
851 column = e->loc.column;
852 out_opcode (DW_LNS_set_column);
853 out_uleb128 (column);
857 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
859 flags = e->loc.flags;
860 out_opcode (DW_LNS_negate_stmt);
864 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
866 out_opcode (DW_LNS_set_basic_block);
870 if (line != e->loc.line || changed)
872 int line_delta = e->loc.line - line;
875 out_set_addr (seg, e->frag, e->frag_ofs);
876 out_inc_line_addr (line_delta, 0);
878 else if (frag == e->frag)
879 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
881 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
885 frag_ofs = e->frag_ofs;
888 else if (frag == NULL)
890 out_set_addr (seg, e->frag, e->frag_ofs);
892 frag_ofs = e->frag_ofs;
900 /* Emit a DW_LNE_end_sequence for the end of the section. */
901 last_frag = last_frag_for_seg (seg);
902 last_frag_ofs = get_frag_fix (last_frag);
903 if (frag == last_frag)
904 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
906 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
910 /* Emit the directory and file tables for .debug_line. */
919 /* Terminate directory list. */
922 for (i = 1; i < files_in_use; ++i)
924 size = strlen (files[i].filename) + 1;
925 cp = frag_more (size);
926 memcpy (cp, files[i].filename, size);
928 out_uleb128 (files[i].dir); /* directory number */
929 out_uleb128 (0); /* last modification timestamp */
930 out_uleb128 (0); /* filesize */
933 /* Terminate filename list. */
937 /* Emit the collected .debug_line data. */
940 out_debug_line (line_seg)
945 symbolS *prologue_end;
949 subseg_set (line_seg, 0);
951 line_start = symbol_new_now ();
952 prologue_end = symbol_make (fake_label_name);
953 line_end = symbol_make (fake_label_name);
955 /* Total length of the information for this compilation unit. */
956 expr.X_op = O_subtract;
957 expr.X_add_symbol = line_end;
958 expr.X_op_symbol = line_start;
959 expr.X_add_number = -4;
960 emit_expr (&expr, 4);
965 /* Length of the prologue following this length. */
966 expr.X_op = O_subtract;
967 expr.X_add_symbol = prologue_end;
968 expr.X_op_symbol = line_start;
969 expr.X_add_number = - (4 + 2 + 4);
970 emit_expr (&expr, 4);
972 /* Parameters of the state machine. */
973 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
974 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
975 out_byte (DWARF2_LINE_BASE);
976 out_byte (DWARF2_LINE_RANGE);
977 out_byte (DWARF2_LINE_OPCODE_BASE);
979 /* Standard opcode lengths. */
980 out_byte (0); /* DW_LNS_copy */
981 out_byte (1); /* DW_LNS_advance_pc */
982 out_byte (1); /* DW_LNS_advance_line */
983 out_byte (1); /* DW_LNS_set_file */
984 out_byte (1); /* DW_LNS_set_column */
985 out_byte (0); /* DW_LNS_negate_stmt */
986 out_byte (0); /* DW_LNS_set_basic_block */
987 out_byte (0); /* DW_LNS_const_add_pc */
988 out_byte (1); /* DW_LNS_fixed_advance_pc */
992 set_symbol_value_now (prologue_end);
994 /* For each section, emit a statement program. */
995 for (s = all_segs; s; s = s->next)
996 process_entries (s->seg, s->head->head);
998 set_symbol_value_now (line_end);
1001 /* Emit data for .debug_aranges. */
1004 out_debug_aranges (aranges_seg, info_seg)
1008 unsigned int addr_size = sizeof_address;
1009 addressT size, skip;
1014 size = 4 + 2 + 4 + 1 + 1;
1016 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1017 if (skip == 2 * addr_size)
1021 for (s = all_segs; s; s = s->next)
1022 size += 2 * addr_size;
1024 size += 2 * addr_size;
1026 subseg_set (aranges_seg, 0);
1028 /* Length of the compilation unit. */
1029 out_four (size - 4);
1034 /* Offset to .debug_info. */
1035 expr.X_op = O_symbol;
1036 expr.X_add_symbol = section_symbol (info_seg);
1037 expr.X_add_number = 0;
1038 emit_expr (&expr, 4);
1040 /* Size of an address (offset portion). */
1041 out_byte (addr_size);
1043 /* Size of a segment descriptor. */
1046 /* Align the header. */
1048 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1050 for (s = all_segs; s; s = s->next)
1055 frag = first_frag_for_seg (s->seg);
1056 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1057 s->text_start = beg;
1059 frag = last_frag_for_seg (s->seg);
1060 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1063 expr.X_op = O_symbol;
1064 expr.X_add_symbol = beg;
1065 expr.X_add_number = 0;
1066 emit_expr (&expr, addr_size);
1068 expr.X_op = O_subtract;
1069 expr.X_add_symbol = end;
1070 expr.X_op_symbol = beg;
1071 expr.X_add_number = 0;
1072 emit_expr (&expr, addr_size);
1075 p = frag_more (2 * addr_size);
1076 md_number_to_chars (p, 0, addr_size);
1077 md_number_to_chars (p + addr_size, 0, addr_size);
1080 /* Emit data for .debug_abbrev. Note that this must be kept in
1081 sync with out_debug_info below. */
1084 out_debug_abbrev (abbrev_seg)
1087 subseg_set (abbrev_seg, 0);
1090 out_uleb128 (DW_TAG_compile_unit);
1091 out_byte (DW_CHILDREN_no);
1092 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1093 if (all_segs->next == NULL)
1095 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1096 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1098 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1099 out_abbrev (DW_AT_producer, DW_FORM_string);
1100 out_abbrev (DW_AT_language, DW_FORM_data2);
1104 /* Emit a description of this compilation unit for .debug_info. */
1107 out_debug_info (info_seg, abbrev_seg, line_seg)
1115 symbolS *info_start;
1120 subseg_set (info_seg, 0);
1122 info_start = symbol_new_now ();
1123 info_end = symbol_make (fake_label_name);
1125 /* Compilation Unit length. */
1126 expr.X_op = O_subtract;
1127 expr.X_add_symbol = info_end;
1128 expr.X_op_symbol = info_start;
1129 expr.X_add_number = -4;
1130 emit_expr (&expr, 4);
1132 /* DWARF version. */
1135 /* .debug_abbrev offset */
1136 expr.X_op = O_symbol;
1137 expr.X_add_symbol = section_symbol (abbrev_seg);
1138 expr.X_add_number = 0;
1139 emit_expr (&expr, 4);
1141 /* Target address size. */
1142 out_byte (sizeof_address);
1144 /* DW_TAG_compile_unit DIE abbrev */
1147 /* DW_AT_stmt_list */
1148 expr.X_op = O_symbol;
1149 expr.X_add_symbol = section_symbol (line_seg);
1150 expr.X_add_number = 0;
1151 emit_expr (&expr, 4);
1153 /* These two attributes may only be emitted if all of the code is
1154 contiguous. Multiple sections are not that. */
1155 if (all_segs->next == NULL)
1158 expr.X_op = O_symbol;
1159 expr.X_add_symbol = all_segs->text_start;
1160 expr.X_add_number = 0;
1161 emit_expr (&expr, sizeof_address);
1164 expr.X_op = O_symbol;
1165 expr.X_add_symbol = all_segs->text_end;
1166 expr.X_add_number = 0;
1167 emit_expr (&expr, sizeof_address);
1170 /* DW_AT_comp_dir */
1171 comp_dir = getpwd ();
1172 len = strlen (comp_dir) + 1;
1173 p = frag_more (len);
1174 memcpy (p, comp_dir, len);
1176 /* DW_AT_producer */
1177 sprintf (producer, "GNU AS %s", VERSION);
1178 len = strlen (producer) + 1;
1179 p = frag_more (len);
1180 memcpy (p, producer, len);
1182 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1183 dwarf2 draft has no standard code for assembler. */
1184 out_two (DW_LANG_Mips_Assembler);
1186 set_symbol_value_now (info_end);
1195 /* If no debug information was recorded, nothing to do. */
1196 if (all_segs == NULL)
1199 /* Calculate the size of an address for the target machine. */
1200 #ifdef BFD_ASSEMBLER
1201 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1207 /* Create and switch to the line number section. */
1208 line_seg = subseg_new (".debug_line", 0);
1209 #ifdef BFD_ASSEMBLER
1210 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1213 /* For each subsection, chain the debug entries together. */
1214 for (s = all_segs; s; s = s->next)
1216 struct line_subseg *ss = s->head;
1217 struct line_entry **ptail = ss->ptail;
1219 while ((ss = ss->next) != NULL)
1226 out_debug_line (line_seg);
1228 /* If this is assembler generated line info, we need .debug_info
1229 and .debug_abbrev sections as well. */
1230 if (debug_type == DEBUG_DWARF2)
1236 info_seg = subseg_new (".debug_info", 0);
1237 abbrev_seg = subseg_new (".debug_abbrev", 0);
1238 aranges_seg = subseg_new (".debug_aranges", 0);
1240 #ifdef BFD_ASSEMBLER
1241 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1242 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1243 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1246 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1248 out_debug_aranges (aranges_seg, info_seg);
1249 out_debug_abbrev (abbrev_seg);
1250 out_debug_info (info_seg, abbrev_seg, line_seg);
1261 dwarf2dbg_estimate_size_before_relax (frag)
1262 fragS *frag ATTRIBUTE_UNUSED;
1264 as_fatal (_("dwarf2 is not supported for this object file format"));
1269 dwarf2dbg_relax_frag (frag)
1270 fragS *frag ATTRIBUTE_UNUSED;
1272 as_fatal (_("dwarf2 is not supported for this object file format"));
1277 dwarf2dbg_convert_frag (frag)
1278 fragS *frag ATTRIBUTE_UNUSED;
1280 as_fatal (_("dwarf2 is not supported for this object file format"));
1284 dwarf2_emit_insn (size)
1285 int size ATTRIBUTE_UNUSED;
1290 dwarf2_directive_file (dummy)
1291 int dummy ATTRIBUTE_UNUSED;
1293 as_fatal (_("dwarf2 is not supported for this object file format"));
1297 dwarf2_directive_loc (dummy)
1298 int dummy ATTRIBUTE_UNUSED;
1300 as_fatal (_("dwarf2 is not supported for this object file format"));
1302 #endif /* BFD_ASSEMBLER */