1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002 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)
44 #include "dwarf2dbg.h"
47 #define DWARF2_FORMAT() dwarf2_format_32bit
54 #include "elf/dwarf2.h"
56 /* Since we can't generate the prolog until the body is complete, we
57 use three different subsegments for .debug_line: one holding the
58 prolog, one for the directory and filename info, and one for the
59 body ("statement program"). */
64 /* First special line opcde - leave room for the standard opcodes.
65 Note: If you want to change this, you'll have to update the
66 "standard_opcode_lengths" table that is emitted below in
68 #define DWARF2_LINE_OPCODE_BASE 10
70 #ifndef DWARF2_LINE_BASE
71 /* Minimum line offset in a special line info. opcode. This value
72 was chosen to give a reasonable range of values. */
73 # define DWARF2_LINE_BASE -5
76 /* Range of line offsets in a special line info. opcode. */
77 #ifndef DWARF2_LINE_RANGE
78 # define DWARF2_LINE_RANGE 14
81 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
82 /* Define the architecture-dependent minimum instruction length (in
83 bytes). This value should be rather too small than too big. */
84 # define DWARF2_LINE_MIN_INSN_LENGTH 1
87 /* Flag that indicates the initial value of the is_stmt_start flag.
88 In the present implementation, we do not mark any lines as
89 the beginning of a source statement, because that information
90 is not made available by the GCC front-end. */
91 #define DWARF2_LINE_DEFAULT_IS_STMT 1
93 /* Given a special op, return the line skip amount. */
94 #define SPECIAL_LINE(op) \
95 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
97 /* Given a special op, return the address skip amount (in units of
98 DWARF2_LINE_MIN_INSN_LENGTH. */
99 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
101 /* The maximum address skip amount that can be encoded with a special op. */
102 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
105 struct line_entry *next;
108 struct dwarf2_line_info loc;
112 struct line_subseg *next;
114 struct line_entry *head;
115 struct line_entry **ptail;
119 struct line_seg *next;
121 struct line_subseg *head;
126 /* Collects data for all line table entries during assembly. */
127 static struct line_seg *all_segs;
134 /* Table of files used by .debug_line. */
135 static struct file_entry *files;
136 static unsigned int files_in_use;
137 static unsigned int files_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;
238 static unsigned int line = -1;
239 static unsigned int filenum = -1;
241 /* Early out for as-yet incomplete location information. */
242 if (loc->filenum == 0 || loc->line == 0)
245 /* Don't emit sequences of line symbols for the same line when the
246 symbols apply to assembler code. It is necessary to emit
247 duplicate line symbols when a compiler asks for them, because GDB
248 uses them to determine the end of the prologue. */
249 if (debug_type == DEBUG_DWARF2
250 && line == loc->line && filenum == loc->filenum)
254 filenum = loc->filenum;
256 e = (struct line_entry *) xmalloc (sizeof (*e));
262 ss = get_line_subseg (now_seg, now_subseg);
264 ss->ptail = &e->next;
269 struct dwarf2_line_info *line;
271 if (debug_type == DEBUG_DWARF2)
274 as_where (&filename, &line->line);
275 line->filenum = get_filenum (filename);
277 line->flags = DWARF2_FLAG_BEGIN_STMT;
283 /* Called for each machine instruction, or relatively atomic group of
284 machine instructions (ie built-in macro). The instruction or group
285 is SIZE bytes in length. If dwarf2 line number generation is called
286 for, emit a line statement appropriately. */
289 dwarf2_emit_insn (size)
292 struct dwarf2_line_info loc;
294 if (loc_directive_seen)
296 /* Use the last location established by a .loc directive, not
297 the value returned by dwarf2_where(). That calls as_where()
298 which will return either the logical input file name (foo.c)
299 or the physical input file name (foo.s) and not the file name
300 specified in the most recent .loc directive (eg foo.h). */
303 /* Unless we generate DWARF2 debugging information for each
304 assembler line, we only emit one line symbol for one LOC. */
305 if (debug_type != DEBUG_DWARF2)
306 loc_directive_seen = false;
308 else if (debug_type != DEBUG_DWARF2)
311 dwarf2_where (& loc);
313 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
316 /* Get a .debug_line file number for FILENAME. */
319 get_filenum (filename)
320 const char *filename;
322 static unsigned int last_used;
326 if (strcmp (filename, files[last_used].filename) == 0)
329 for (i = 1; i < files_in_use; ++i)
330 if (strcmp (filename, files[i].filename) == 0)
333 if (i >= files_allocated)
335 unsigned int old = files_allocated;
337 files_allocated = i + 32;
338 files = (struct file_entry *)
339 xrealloc (files, (i + 32) * sizeof (struct file_entry));
341 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
344 files[i].filename = xstrdup (filename);
346 files_in_use = i + 1;
352 /* Handle two forms of .file directive:
353 - Pass .file "source.c" to s_app_file
354 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
356 If an entry is added to the file table, return a pointer to the filename. */
359 dwarf2_directive_file (dummy)
360 int dummy ATTRIBUTE_UNUSED;
366 /* Continue to accept a bare string and pass it off. */
368 if (*input_line_pointer == '"')
374 num = get_absolute_expression ();
375 filename = demand_copy_C_string (&filename_len);
376 demand_empty_rest_of_line ();
380 as_bad (_("file number less than one"));
384 if (num < (int) files_in_use && files[num].filename != 0)
386 as_bad (_("file number %ld already allocated"), (long) num);
390 if (num >= (int) files_allocated)
392 unsigned int old = files_allocated;
394 files_allocated = num + 16;
395 files = (struct file_entry *)
396 xrealloc (files, (num + 16) * sizeof (struct file_entry));
398 /* Zero the new memory. */
399 memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
402 files[num].filename = filename;
404 files_in_use = num + 1;
410 dwarf2_directive_loc (dummy)
411 int dummy ATTRIBUTE_UNUSED;
413 offsetT filenum, line, column;
415 filenum = get_absolute_expression ();
417 line = get_absolute_expression ();
419 column = get_absolute_expression ();
420 demand_empty_rest_of_line ();
424 as_bad (_("file number less than one"));
427 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
429 as_bad (_("unassigned file number %ld"), (long) filenum);
433 current.filenum = filenum;
435 current.column = column;
436 current.flags = DWARF2_FLAG_BEGIN_STMT;
438 loc_directive_seen = true;
443 listing_source_file (files[filenum].filename);
444 listing_source_line (line);
450 first_frag_for_seg (seg)
453 frchainS *f, *first = NULL;
455 for (f = frchain_root; f; f = f->frch_next)
456 if (f->frch_seg == seg
457 && (! first || first->frch_subseg > f->frch_subseg))
460 return first ? first->frch_root : NULL;
464 last_frag_for_seg (seg)
467 frchainS *f, *last = NULL;
469 for (f = frchain_root; f; f = f->frch_next)
470 if (f->frch_seg == seg
471 && (! last || last->frch_subseg < f->frch_subseg))
474 return last ? last->frch_last : NULL;
477 /* Emit a single byte into the current segment. */
483 FRAG_APPEND_1_CHAR (byte);
486 /* Emit a statement program opcode into the current segment. */
495 /* Emit a two-byte word into the current segment. */
501 md_number_to_chars (frag_more (2), data, 2);
504 /* Emit a four byte word into the current segment. */
510 md_number_to_chars (frag_more (4), data, 4);
513 /* Emit an unsigned "little-endian base 128" number. */
519 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
522 /* Emit a tuple for .debug_abbrev. */
525 out_abbrev (name, form)
532 /* Create a new fake symbol whose value is the current position. */
537 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
540 /* Set the value of SYM to the current position in the current segment. */
543 set_symbol_value_now (sym)
546 S_SET_SEGMENT (sym, now_seg);
547 S_SET_VALUE (sym, frag_now_fix ());
548 symbol_set_frag (sym, frag_now);
551 /* Get the size of a fragment. */
562 /* If a fragment is the last in the chain, special measures must be
563 taken to find its size before relaxation, since it may be pending
564 on some subsegment chain. */
565 for (fr = frchain_root; fr; fr = fr->frch_next)
566 if (fr->frch_last == frag)
568 long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
569 return (((char *) obstack_next_free (&fr->frch_obstack)
570 - frag->fr_literal) + ~align_mask) & align_mask;
576 /* Set an absolute address (may result in a relocation entry). */
579 out_set_addr (seg, frag, ofs)
587 sym = symbol_new (fake_label_name, seg, ofs, frag);
589 out_opcode (DW_LNS_extended_op);
590 out_uleb128 (sizeof_address + 1);
592 out_opcode (DW_LNE_set_address);
593 expr.X_op = O_symbol;
594 expr.X_add_symbol = sym;
595 expr.X_add_number = 0;
596 emit_expr (&expr, sizeof_address);
599 /* Encode a pair of line and address skips as efficiently as possible.
600 Note that the line skip is signed, whereas the address skip is unsigned.
602 The following two routines *must* be kept in sync. This is
603 enforced by making emit_inc_line_addr abort if we do not emit
604 exactly the expected number of bytes. */
607 size_inc_line_addr (line_delta, addr_delta)
611 unsigned int tmp, opcode;
614 /* Scale the address delta by the minimum instruction length. */
615 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
616 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
617 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
620 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
621 We cannot use special opcodes here, since we want the end_sequence
622 to emit the matrix entry. */
623 if (line_delta == INT_MAX)
625 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
628 len = 1 + sizeof_leb128 (addr_delta, 0);
632 /* Bias the line delta by the base. */
633 tmp = line_delta - DWARF2_LINE_BASE;
635 /* If the line increment is out of range of a special opcode, we
636 must encode it with DW_LNS_advance_line. */
637 if (tmp >= DWARF2_LINE_RANGE)
639 len = 1 + sizeof_leb128 (line_delta, 1);
641 tmp = 0 - DWARF2_LINE_BASE;
644 /* Bias the opcode by the special opcode base. */
645 tmp += DWARF2_LINE_OPCODE_BASE;
647 /* Avoid overflow when addr_delta is large. */
648 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
650 /* Try using a special opcode. */
651 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
655 /* Try using DW_LNS_const_add_pc followed by special op. */
656 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
661 /* Otherwise use DW_LNS_advance_pc. */
662 len += 1 + sizeof_leb128 (addr_delta, 0);
664 /* DW_LNS_copy or special opcode. */
671 emit_inc_line_addr (line_delta, addr_delta, p, len)
677 unsigned int tmp, opcode;
681 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
682 /* Scale the address delta by the minimum instruction length. */
683 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
684 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
686 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
687 We cannot use special opcodes here, since we want the end_sequence
688 to emit the matrix entry. */
689 if (line_delta == INT_MAX)
691 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
692 *p++ = DW_LNS_const_add_pc;
695 *p++ = DW_LNS_advance_pc;
696 p += output_leb128 (p, addr_delta, 0);
699 *p++ = DW_LNS_extended_op;
701 *p++ = DW_LNE_end_sequence;
705 /* Bias the line delta by the base. */
706 tmp = line_delta - DWARF2_LINE_BASE;
708 /* If the line increment is out of range of a special opcode, we
709 must encode it with DW_LNS_advance_line. */
710 if (tmp >= DWARF2_LINE_RANGE)
712 *p++ = DW_LNS_advance_line;
713 p += output_leb128 (p, line_delta, 1);
715 /* Prettier, I think, to use DW_LNS_copy instead of a
716 "line +0, addr +0" special opcode. */
724 tmp = 0 - DWARF2_LINE_BASE;
728 /* Bias the opcode by the special opcode base. */
729 tmp += DWARF2_LINE_OPCODE_BASE;
731 /* Avoid overflow when addr_delta is large. */
732 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
734 /* Try using a special opcode. */
735 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
742 /* Try using DW_LNS_const_add_pc followed by special op. */
743 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
746 *p++ = DW_LNS_const_add_pc;
752 /* Otherwise use DW_LNS_advance_pc. */
753 *p++ = DW_LNS_advance_pc;
754 p += output_leb128 (p, addr_delta, 0);
765 /* Handy routine to combine calls to the above two routines. */
768 out_inc_line_addr (line_delta, addr_delta)
772 int len = size_inc_line_addr (line_delta, addr_delta);
773 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
776 /* Generate a variant frag that we can use to relax address/line
777 increments between fragments of the target segment. */
780 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
783 fragS *to_frag, *from_frag;
784 addressT to_ofs, from_ofs;
786 symbolS *to_sym, *from_sym;
790 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
791 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
793 expr.X_op = O_subtract;
794 expr.X_add_symbol = to_sym;
795 expr.X_op_symbol = from_sym;
796 expr.X_add_number = 0;
798 /* The maximum size of the frag is the line delta with a maximum
799 sized address delta. */
800 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
802 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
803 make_expr_symbol (&expr), line_delta, NULL);
806 /* The function estimates the size of a rs_dwarf2dbg variant frag
807 based on the current values of the symbols. It is called before
808 the relaxation loop. We set fr_subtype to the expected length. */
811 dwarf2dbg_estimate_size_before_relax (frag)
817 addr_delta = resolve_symbol_value (frag->fr_symbol);
818 size = size_inc_line_addr (frag->fr_offset, addr_delta);
820 frag->fr_subtype = size;
825 /* This function relaxes a rs_dwarf2dbg variant frag based on the
826 current values of the symbols. fr_subtype is the current length
827 of the frag. This returns the change in frag length. */
830 dwarf2dbg_relax_frag (frag)
833 int old_size, new_size;
835 old_size = frag->fr_subtype;
836 new_size = dwarf2dbg_estimate_size_before_relax (frag);
838 return new_size - old_size;
841 /* This function converts a rs_dwarf2dbg variant frag into a normal
842 fill frag. This is called after all relaxation has been done.
843 fr_subtype will be the desired length of the frag. */
846 dwarf2dbg_convert_frag (frag)
851 addr_diff = resolve_symbol_value (frag->fr_symbol);
853 /* fr_var carries the max_chars that we created the fragment with.
854 fr_subtype carries the current expected length. We must, of
855 course, have allocated enough memory earlier. */
856 assert (frag->fr_var >= (int) frag->fr_subtype);
858 emit_inc_line_addr (frag->fr_offset, addr_diff,
859 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
861 frag->fr_fix += frag->fr_subtype;
862 frag->fr_type = rs_fill;
867 /* Generate .debug_line content for the chain of line number entries
868 beginning at E, for segment SEG. */
871 process_entries (seg, e)
873 struct line_entry *e;
875 unsigned filenum = 1;
878 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
881 addressT frag_ofs = 0;
882 addressT last_frag_ofs;
883 struct line_entry *next;
889 if (filenum != e->loc.filenum)
891 filenum = e->loc.filenum;
892 out_opcode (DW_LNS_set_file);
893 out_uleb128 (filenum);
897 if (column != e->loc.column)
899 column = e->loc.column;
900 out_opcode (DW_LNS_set_column);
901 out_uleb128 (column);
905 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
907 flags = e->loc.flags;
908 out_opcode (DW_LNS_negate_stmt);
912 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
914 out_opcode (DW_LNS_set_basic_block);
918 /* Don't try to optimize away redundant entries; gdb wants two
919 entries for a function where the code starts on the same line as
920 the {, and there's no way to identify that case here. Trust gcc
921 to optimize appropriately. */
922 if (1 /* line != e->loc.line || changed */)
924 int line_delta = e->loc.line - line;
927 out_set_addr (seg, e->frag, e->frag_ofs);
928 out_inc_line_addr (line_delta, 0);
930 else if (frag == e->frag)
931 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
933 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
937 frag_ofs = e->frag_ofs;
940 else if (frag == NULL)
942 out_set_addr (seg, e->frag, e->frag_ofs);
944 frag_ofs = e->frag_ofs;
952 /* Emit a DW_LNE_end_sequence for the end of the section. */
953 last_frag = last_frag_for_seg (seg);
954 last_frag_ofs = get_frag_fix (last_frag);
955 if (frag == last_frag)
956 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
958 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
962 /* Emit the directory and file tables for .debug_line. */
971 /* Terminate directory list. */
974 for (i = 1; i < files_in_use; ++i)
976 if (files[i].filename == NULL)
978 as_bad (_("unassigned file number %ld"), (long) i);
982 size = strlen (files[i].filename) + 1;
983 cp = frag_more (size);
984 memcpy (cp, files[i].filename, size);
986 out_uleb128 (files[i].dir); /* directory number */
987 out_uleb128 (0); /* last modification timestamp */
988 out_uleb128 (0); /* filesize */
991 /* Terminate filename list. */
995 /* Emit the collected .debug_line data. */
998 out_debug_line (line_seg)
1002 symbolS *line_start;
1003 symbolS *prologue_end;
1006 enum dwarf2_format d2f;
1009 subseg_set (line_seg, 0);
1011 line_start = symbol_new_now ();
1012 prologue_end = symbol_make (fake_label_name);
1013 line_end = symbol_make (fake_label_name);
1015 /* Total length of the information for this compilation unit. */
1016 expr.X_op = O_subtract;
1017 expr.X_add_symbol = line_end;
1018 expr.X_op_symbol = line_start;
1020 d2f = DWARF2_FORMAT ();
1021 if (d2f == dwarf2_format_32bit)
1023 expr.X_add_number = -4;
1024 emit_expr (&expr, 4);
1027 else if (d2f == dwarf2_format_64bit)
1029 expr.X_add_number = -12;
1031 emit_expr (&expr, 8);
1034 else if (d2f == dwarf2_format_64bit_irix)
1036 expr.X_add_number = -8;
1037 emit_expr (&expr, 8);
1042 as_fatal (_("internal error: unknown dwarf2 format"));
1048 /* Length of the prologue following this length. */
1049 expr.X_op = O_subtract;
1050 expr.X_add_symbol = prologue_end;
1051 expr.X_op_symbol = line_start;
1052 expr.X_add_number = - (4 + 2 + 4);
1053 emit_expr (&expr, sizeof_offset);
1055 /* Parameters of the state machine. */
1056 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1057 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1058 out_byte (DWARF2_LINE_BASE);
1059 out_byte (DWARF2_LINE_RANGE);
1060 out_byte (DWARF2_LINE_OPCODE_BASE);
1062 /* Standard opcode lengths. */
1063 out_byte (0); /* DW_LNS_copy */
1064 out_byte (1); /* DW_LNS_advance_pc */
1065 out_byte (1); /* DW_LNS_advance_line */
1066 out_byte (1); /* DW_LNS_set_file */
1067 out_byte (1); /* DW_LNS_set_column */
1068 out_byte (0); /* DW_LNS_negate_stmt */
1069 out_byte (0); /* DW_LNS_set_basic_block */
1070 out_byte (0); /* DW_LNS_const_add_pc */
1071 out_byte (1); /* DW_LNS_fixed_advance_pc */
1075 set_symbol_value_now (prologue_end);
1077 /* For each section, emit a statement program. */
1078 for (s = all_segs; s; s = s->next)
1079 process_entries (s->seg, s->head->head);
1081 set_symbol_value_now (line_end);
1084 /* Emit data for .debug_aranges. */
1087 out_debug_aranges (aranges_seg, info_seg)
1091 unsigned int addr_size = sizeof_address;
1092 addressT size, skip;
1097 size = 4 + 2 + 4 + 1 + 1;
1099 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1100 if (skip == 2 * addr_size)
1104 for (s = all_segs; s; s = s->next)
1105 size += 2 * addr_size;
1107 size += 2 * addr_size;
1109 subseg_set (aranges_seg, 0);
1111 /* Length of the compilation unit. */
1112 out_four (size - 4);
1117 /* Offset to .debug_info. */
1118 expr.X_op = O_symbol;
1119 expr.X_add_symbol = section_symbol (info_seg);
1120 expr.X_add_number = 0;
1121 emit_expr (&expr, 4);
1123 /* Size of an address (offset portion). */
1124 out_byte (addr_size);
1126 /* Size of a segment descriptor. */
1129 /* Align the header. */
1131 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1133 for (s = all_segs; s; s = s->next)
1138 frag = first_frag_for_seg (s->seg);
1139 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1140 s->text_start = beg;
1142 frag = last_frag_for_seg (s->seg);
1143 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1146 expr.X_op = O_symbol;
1147 expr.X_add_symbol = beg;
1148 expr.X_add_number = 0;
1149 emit_expr (&expr, addr_size);
1151 expr.X_op = O_subtract;
1152 expr.X_add_symbol = end;
1153 expr.X_op_symbol = beg;
1154 expr.X_add_number = 0;
1155 emit_expr (&expr, addr_size);
1158 p = frag_more (2 * addr_size);
1159 md_number_to_chars (p, 0, addr_size);
1160 md_number_to_chars (p + addr_size, 0, addr_size);
1163 /* Emit data for .debug_abbrev. Note that this must be kept in
1164 sync with out_debug_info below. */
1167 out_debug_abbrev (abbrev_seg)
1170 subseg_set (abbrev_seg, 0);
1173 out_uleb128 (DW_TAG_compile_unit);
1174 out_byte (DW_CHILDREN_no);
1175 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1176 if (all_segs->next == NULL)
1178 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1179 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1181 out_abbrev (DW_AT_name, DW_FORM_string);
1182 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1183 out_abbrev (DW_AT_producer, DW_FORM_string);
1184 out_abbrev (DW_AT_language, DW_FORM_data2);
1187 /* Terminate the abbreviations for this compilation unit. */
1191 /* Emit a description of this compilation unit for .debug_info. */
1194 out_debug_info (info_seg, abbrev_seg, line_seg)
1202 symbolS *info_start;
1206 enum dwarf2_format d2f;
1209 subseg_set (info_seg, 0);
1211 info_start = symbol_new_now ();
1212 info_end = symbol_make (fake_label_name);
1214 /* Compilation Unit length. */
1215 expr.X_op = O_subtract;
1216 expr.X_add_symbol = info_end;
1217 expr.X_op_symbol = info_start;
1219 d2f = DWARF2_FORMAT ();
1220 if (d2f == dwarf2_format_32bit)
1222 expr.X_add_number = -4;
1223 emit_expr (&expr, 4);
1226 else if (d2f == dwarf2_format_64bit)
1228 expr.X_add_number = -12;
1230 emit_expr (&expr, 8);
1233 else if (d2f == dwarf2_format_64bit_irix)
1235 expr.X_add_number = -8;
1236 emit_expr (&expr, 8);
1241 as_fatal (_("internal error: unknown dwarf2 format"));
1244 /* DWARF version. */
1247 /* .debug_abbrev offset */
1248 expr.X_op = O_symbol;
1249 expr.X_add_symbol = section_symbol (abbrev_seg);
1250 expr.X_add_number = 0;
1251 emit_expr (&expr, sizeof_offset);
1253 /* Target address size. */
1254 out_byte (sizeof_address);
1256 /* DW_TAG_compile_unit DIE abbrev */
1259 /* DW_AT_stmt_list */
1260 expr.X_op = O_symbol;
1261 expr.X_add_symbol = section_symbol (line_seg);
1262 expr.X_add_number = 0;
1263 emit_expr (&expr, 4);
1265 /* These two attributes may only be emitted if all of the code is
1266 contiguous. Multiple sections are not that. */
1267 if (all_segs->next == NULL)
1270 expr.X_op = O_symbol;
1271 expr.X_add_symbol = all_segs->text_start;
1272 expr.X_add_number = 0;
1273 emit_expr (&expr, sizeof_address);
1276 expr.X_op = O_symbol;
1277 expr.X_add_symbol = all_segs->text_end;
1278 expr.X_add_number = 0;
1279 emit_expr (&expr, sizeof_address);
1282 /* DW_AT_name. We don't have the actual file name that was present
1283 on the command line, so assume files[1] is the main input file.
1284 We're not supposed to get called unless at least one line number
1285 entry was emitted, so this should always be defined. */
1286 if (!files || files_in_use < 1)
1288 len = strlen (files[1].filename) + 1;
1289 p = frag_more (len);
1290 memcpy (p, files[1].filename, len);
1292 /* DW_AT_comp_dir */
1293 comp_dir = getpwd ();
1294 len = strlen (comp_dir) + 1;
1295 p = frag_more (len);
1296 memcpy (p, comp_dir, len);
1298 /* DW_AT_producer */
1299 sprintf (producer, "GNU AS %s", VERSION);
1300 len = strlen (producer) + 1;
1301 p = frag_more (len);
1302 memcpy (p, producer, len);
1304 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1305 dwarf2 draft has no standard code for assembler. */
1306 out_two (DW_LANG_Mips_Assembler);
1308 set_symbol_value_now (info_end);
1317 /* We don't need to do anything unless:
1318 - Some debug information was recorded via .file/.loc
1319 - or, we are generating DWARF2 information ourself (--gdwarf2)
1320 - or, there is a user-provided .debug_info section which could
1321 reference the file table in the .debug_line section we generate
1323 if (all_segs == NULL
1324 && debug_type != DEBUG_DWARF2
1325 && bfd_get_section_by_name (stdoutput, ".debug_info") == NULL)
1328 /* Calculate the size of an address for the target machine. */
1329 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1331 /* Create and switch to the line number section. */
1332 line_seg = subseg_new (".debug_line", 0);
1333 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1335 /* For each subsection, chain the debug entries together. */
1336 for (s = all_segs; s; s = s->next)
1338 struct line_subseg *ss = s->head;
1339 struct line_entry **ptail = ss->ptail;
1341 while ((ss = ss->next) != NULL)
1348 out_debug_line (line_seg);
1350 /* If this is assembler generated line info, we need .debug_info
1351 and .debug_abbrev sections as well. */
1352 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1358 info_seg = subseg_new (".debug_info", 0);
1359 abbrev_seg = subseg_new (".debug_abbrev", 0);
1360 aranges_seg = subseg_new (".debug_aranges", 0);
1362 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1363 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1364 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1366 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1368 out_debug_aranges (aranges_seg, info_seg);
1369 out_debug_abbrev (abbrev_seg);
1370 out_debug_info (info_seg, abbrev_seg, line_seg);
1381 dwarf2dbg_estimate_size_before_relax (frag)
1382 fragS *frag ATTRIBUTE_UNUSED;
1384 as_fatal (_("dwarf2 is not supported for this object file format"));
1389 dwarf2dbg_relax_frag (frag)
1390 fragS *frag ATTRIBUTE_UNUSED;
1392 as_fatal (_("dwarf2 is not supported for this object file format"));
1397 dwarf2dbg_convert_frag (frag)
1398 fragS *frag ATTRIBUTE_UNUSED;
1400 as_fatal (_("dwarf2 is not supported for this object file format"));
1404 dwarf2_emit_insn (size)
1405 int size ATTRIBUTE_UNUSED;
1410 dwarf2_directive_file (dummy)
1411 int dummy ATTRIBUTE_UNUSED;
1418 dwarf2_directive_loc (dummy)
1419 int dummy ATTRIBUTE_UNUSED;
1421 as_fatal (_("dwarf2 is not supported for this object file format"));
1423 #endif /* BFD_ASSEMBLER */