* configure.in (FLAGS_FOR_TARGET): Remove -nostdinc and -isystem
[binutils.git] / gas / dwarf2dbg.c
blob6e622067031f072704a128a8ba94dafbfa8f147f
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)
10 any later version.
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
20 02111-1307, USA. */
22 /* Logical line numbers can be controlled by the compiler via the
23 following two directives:
25 .file FILENO "file.c"
26 .loc FILENO LINENO [COLUMN]
28 FILENO is the filenumber. */
30 #include "ansidecl.h"
31 #include "as.h"
33 #ifdef HAVE_LIMITS_H
34 #include <limits.h>
35 #else
36 #ifdef HAVE_SYS_PARAM_H
37 #include <sys/param.h>
38 #endif
39 #ifndef INT_MAX
40 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
41 #endif
42 #endif
44 #ifdef BFD_ASSEMBLER
46 #include "dwarf2dbg.h"
47 #include "subsegs.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"). */
55 #define DL_PROLOG 0
56 #define DL_FILES 1
57 #define DL_BODY 2
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
62 dwarf2_finish(). */
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
69 #endif
71 /* Range of line offsets in a special line info. opcode. */
72 #ifndef DWARF2_LINE_RANGE
73 # define DWARF2_LINE_RANGE 14
74 #endif
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
80 #endif
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)
99 struct line_entry {
100 struct line_entry *next;
101 fragS *frag;
102 addressT frag_ofs;
103 struct dwarf2_line_info loc;
106 struct line_subseg {
107 struct line_subseg *next;
108 subsegT subseg;
109 struct line_entry *head;
110 struct line_entry **ptail;
113 struct line_seg {
114 struct line_seg *next;
115 segT seg;
116 struct line_subseg *head;
117 symbolS *text_start;
118 symbolS *text_end;
121 /* Collects data for all line table entries during assembly. */
122 static struct line_seg *all_segs;
124 struct file_entry {
125 char *filename;
126 unsigned int dir;
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,
165 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)
177 segT seg;
178 subsegT subseg;
180 static segT last_seg;
181 static subsegT last_subseg;
182 static struct line_subseg *last_line_subseg;
184 struct line_seg *s;
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)
191 if (s->seg == seg)
192 goto found_seg;
194 s = (struct line_seg *) xmalloc (sizeof (*s));
195 s->next = all_segs;
196 s->seg = seg;
197 s->head = NULL;
198 all_segs = s;
200 found_seg:
201 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
203 if (ss->subseg == subseg)
204 goto found_subseg;
205 if (ss->subseg > subseg)
206 break;
209 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
210 ss->next = *pss;
211 ss->subseg = subseg;
212 ss->head = NULL;
213 ss->ptail = &ss->head;
214 *pss = ss;
216 found_subseg:
217 last_seg = seg;
218 last_subseg = subseg;
219 last_line_subseg = ss;
221 return ss;
224 /* Record an entry for LOC ocurring at OFS within the current fragment. */
226 void
227 dwarf2_gen_line_info (ofs, loc)
228 addressT ofs;
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)
238 return;
240 /* Don't emit sequences of line symbols for the same line. */
241 if (line == loc->line && filenum == loc->filenum)
242 return;
244 line = loc->line;
245 filenum = loc->filenum;
247 e = (struct line_entry *) xmalloc (sizeof (*e));
248 e->next = NULL;
249 e->frag = frag_now;
250 e->frag_ofs = ofs;
251 e->loc = *loc;
253 ss = get_line_subseg (now_seg, now_subseg);
254 *ss->ptail = e;
255 ss->ptail = &e->next;
258 void
259 dwarf2_where (line)
260 struct dwarf2_line_info *line;
262 if (debug_type == DEBUG_DWARF2)
264 char *filename;
265 as_where (&filename, &line->line);
266 line->filenum = get_filenum (filename);
267 line->column = 0;
268 line->flags = DWARF2_FLAG_BEGIN_STMT;
270 else
271 *line = current;
274 /* Called for each machine instruction, or relatively atomic group of
275 machine instructions (ie built-in macro). The instruction or group
276 is SIZE bytes in length. If dwarf2 line number generation is called
277 for, emit a line statement appropriately. */
279 void
280 dwarf2_emit_insn (size)
281 int size;
283 struct dwarf2_line_info loc;
285 if (debug_type != DEBUG_DWARF2 && ! loc_directive_seen)
286 return;
287 loc_directive_seen = false;
289 dwarf2_where (&loc);
290 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
293 /* Get a .debug_line file number for FILENAME. */
295 static unsigned int
296 get_filenum (filename)
297 const char *filename;
299 static unsigned int last_used;
300 unsigned int i;
302 if (last_used)
303 if (strcmp (filename, files[last_used].filename) == 0)
304 return last_used;
306 for (i = 1; i < files_in_use; ++i)
307 if (strcmp (filename, files[i].filename) == 0)
308 return i;
310 if (i >= files_allocated)
312 unsigned int old = files_allocated;
314 files_allocated = i + 32;
315 files = (struct file_entry *)
316 xrealloc (files, (i + 32) * sizeof (struct file_entry));
318 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
321 files[i].filename = xstrdup (filename);
322 files[i].dir = 0;
323 files_in_use = i + 1;
324 last_used = i;
326 return i;
329 /* Handle the .file directive. */
331 void
332 dwarf2_directive_file (dummy)
333 int dummy ATTRIBUTE_UNUSED;
335 offsetT num;
336 char *filename;
337 int filename_len;
339 /* Continue to accept a bare string and pass it off. */
340 SKIP_WHITESPACE ();
341 if (*input_line_pointer == '"')
343 s_app_file (0);
344 return;
347 num = get_absolute_expression ();
348 filename = demand_copy_C_string (&filename_len);
349 demand_empty_rest_of_line ();
351 if (num < 1)
353 as_bad (_("file number less than one"));
354 return;
357 if (num < (int) files_in_use && files[num].filename != 0)
359 as_bad (_("file number %ld already allocated"), (long) num);
360 return;
363 if (num >= (int) files_allocated)
365 unsigned int old = files_allocated;
367 files_allocated = num + 16;
368 files = (struct file_entry *)
369 xrealloc (files, (num + 16) * sizeof (struct file_entry));
371 /* Zero the new memory. */
372 memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
375 files[num].filename = filename;
376 files[num].dir = 0;
377 files_in_use = num + 1;
380 void
381 dwarf2_directive_loc (dummy)
382 int dummy ATTRIBUTE_UNUSED;
384 offsetT filenum, line, column;
386 filenum = get_absolute_expression ();
387 SKIP_WHITESPACE ();
388 line = get_absolute_expression ();
389 SKIP_WHITESPACE ();
390 column = get_absolute_expression ();
391 demand_empty_rest_of_line ();
393 if (filenum < 1)
395 as_bad (_("file number less than one"));
396 return;
398 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
400 as_bad (_("unassigned file number %ld"), (long) filenum);
401 return;
404 current.filenum = filenum;
405 current.line = line;
406 current.column = column;
407 current.flags = DWARF2_FLAG_BEGIN_STMT;
409 loc_directive_seen = true;
411 #ifndef NO_LISTING
412 if (listing)
413 listing_source_line (line);
414 #endif
417 static struct frag *
418 first_frag_for_seg (seg)
419 segT seg;
421 frchainS *f, *first = NULL;
423 for (f = frchain_root; f; f = f->frch_next)
424 if (f->frch_seg == seg
425 && (! first || first->frch_subseg > f->frch_subseg))
426 first = f;
428 return first ? first->frch_root : NULL;
431 static struct frag *
432 last_frag_for_seg (seg)
433 segT seg;
435 frchainS *f, *last = NULL;
437 for (f = frchain_root; f; f = f->frch_next)
438 if (f->frch_seg == seg
439 && (! last || last->frch_subseg < f->frch_subseg))
440 last= f;
442 return last ? last->frch_last : NULL;
445 /* Emit a single byte into the current segment. */
447 static inline void
448 out_byte (byte)
449 int byte;
451 FRAG_APPEND_1_CHAR (byte);
454 /* Emit a statement program opcode into the current segment. */
456 static inline void
457 out_opcode (opc)
458 int opc;
460 out_byte (opc);
463 /* Emit a two-byte word into the current segment. */
465 static inline void
466 out_two (data)
467 int data;
469 md_number_to_chars (frag_more (2), data, 2);
472 /* Emit a four byte word into the current segment. */
474 static inline void
475 out_four (data)
476 int data;
478 md_number_to_chars (frag_more (4), data, 4);
481 /* Emit an unsigned "little-endian base 128" number. */
483 static void
484 out_uleb128 (value)
485 addressT value;
487 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
490 /* Emit a tuple for .debug_abbrev. */
492 static inline void
493 out_abbrev (name, form)
494 int name, form;
496 out_uleb128 (name);
497 out_uleb128 (form);
500 /* Create a new fake symbol whose value is the current position. */
502 static symbolS *
503 symbol_new_now ()
505 return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
508 /* Set the value of SYM to the current position in the current segment. */
510 static void
511 set_symbol_value_now (sym)
512 symbolS *sym;
514 S_SET_SEGMENT (sym, now_seg);
515 S_SET_VALUE (sym, frag_now_fix ());
516 symbol_set_frag (sym, frag_now);
519 /* Get the size of a fragment. */
521 static offsetT
522 get_frag_fix (frag)
523 fragS *frag;
525 frchainS *fr;
527 if (frag->fr_next)
528 return frag->fr_fix;
530 /* If a fragment is the last in the chain, special measures must be
531 taken to find its size before relaxation, since it may be pending
532 on some subsegment chain. */
533 for (fr = frchain_root; fr; fr = fr->frch_next)
534 if (fr->frch_last == frag)
536 long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
537 return (((char *) obstack_next_free (&fr->frch_obstack)
538 - frag->fr_literal) + ~align_mask) & align_mask;
541 abort ();
544 /* Set an absolute address (may result in a relocation entry). */
546 static void
547 out_set_addr (seg, frag, ofs)
548 segT seg;
549 fragS *frag;
550 addressT ofs;
552 expressionS expr;
553 symbolS *sym;
555 sym = symbol_new (fake_label_name, seg, ofs, frag);
557 out_opcode (DW_LNS_extended_op);
558 out_uleb128 (sizeof_address + 1);
560 out_opcode (DW_LNE_set_address);
561 expr.X_op = O_symbol;
562 expr.X_add_symbol = sym;
563 expr.X_add_number = 0;
564 emit_expr (&expr, sizeof_address);
567 /* Encode a pair of line and address skips as efficiently as possible.
568 Note that the line skip is signed, whereas the address skip is unsigned.
570 The following two routines *must* be kept in sync. This is
571 enforced by making emit_inc_line_addr abort if we do not emit
572 exactly the expected number of bytes. */
574 static int
575 size_inc_line_addr (line_delta, addr_delta)
576 int line_delta;
577 addressT addr_delta;
579 unsigned int tmp, opcode;
580 int len = 0;
582 /* Scale the address delta by the minimum instruction length. */
583 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
584 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
585 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
586 #endif
588 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
589 We cannot use special opcodes here, since we want the end_sequence
590 to emit the matrix entry. */
591 if (line_delta == INT_MAX)
593 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
594 len = 1;
595 else
596 len = 1 + sizeof_leb128 (addr_delta, 0);
597 return len + 3;
600 /* Bias the line delta by the base. */
601 tmp = line_delta - DWARF2_LINE_BASE;
603 /* If the line increment is out of range of a special opcode, we
604 must encode it with DW_LNS_advance_line. */
605 if (tmp >= DWARF2_LINE_RANGE)
607 len = 1 + sizeof_leb128 (line_delta, 1);
608 line_delta = 0;
609 tmp = 0 - DWARF2_LINE_BASE;
612 /* Bias the opcode by the special opcode base. */
613 tmp += DWARF2_LINE_OPCODE_BASE;
615 /* Avoid overflow when addr_delta is large. */
616 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
618 /* Try using a special opcode. */
619 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
620 if (opcode <= 255)
621 return len + 1;
623 /* Try using DW_LNS_const_add_pc followed by special op. */
624 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
625 if (opcode <= 255)
626 return len + 2;
629 /* Otherwise use DW_LNS_advance_pc. */
630 len += 1 + sizeof_leb128 (addr_delta, 0);
632 /* DW_LNS_copy or special opcode. */
633 len += 1;
635 return len;
638 static void
639 emit_inc_line_addr (line_delta, addr_delta, p, len)
640 int line_delta;
641 addressT addr_delta;
642 char *p;
643 int len;
645 unsigned int tmp, opcode;
646 int need_copy = 0;
647 char *end = p + len;
649 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
650 /* Scale the address delta by the minimum instruction length. */
651 assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
652 addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
653 #endif
654 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
655 We cannot use special opcodes here, since we want the end_sequence
656 to emit the matrix entry. */
657 if (line_delta == INT_MAX)
659 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
660 *p++ = DW_LNS_const_add_pc;
661 else
663 *p++ = DW_LNS_advance_pc;
664 p += output_leb128 (p, addr_delta, 0);
667 *p++ = DW_LNS_extended_op;
668 *p++ = 1;
669 *p++ = DW_LNE_end_sequence;
670 goto done;
673 /* Bias the line delta by the base. */
674 tmp = line_delta - DWARF2_LINE_BASE;
676 /* If the line increment is out of range of a special opcode, we
677 must encode it with DW_LNS_advance_line. */
678 if (tmp >= DWARF2_LINE_RANGE)
680 *p++ = DW_LNS_advance_line;
681 p += output_leb128 (p, line_delta, 1);
683 /* Prettier, I think, to use DW_LNS_copy instead of a
684 "line +0, addr +0" special opcode. */
685 if (addr_delta == 0)
687 *p++ = DW_LNS_copy;
688 goto done;
691 line_delta = 0;
692 tmp = 0 - DWARF2_LINE_BASE;
693 need_copy = 1;
696 /* Bias the opcode by the special opcode base. */
697 tmp += DWARF2_LINE_OPCODE_BASE;
699 /* Avoid overflow when addr_delta is large. */
700 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
702 /* Try using a special opcode. */
703 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
704 if (opcode <= 255)
706 *p++ = opcode;
707 goto done;
710 /* Try using DW_LNS_const_add_pc followed by special op. */
711 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
712 if (opcode <= 255)
714 *p++ = DW_LNS_const_add_pc;
715 *p++ = opcode;
716 goto done;
720 /* Otherwise use DW_LNS_advance_pc. */
721 *p++ = DW_LNS_advance_pc;
722 p += output_leb128 (p, addr_delta, 0);
724 if (need_copy)
725 *p++ = DW_LNS_copy;
726 else
727 *p++ = tmp;
729 done:
730 assert (p == end);
733 /* Handy routine to combine calls to the above two routines. */
735 static void
736 out_inc_line_addr (line_delta, addr_delta)
737 int line_delta;
738 addressT addr_delta;
740 int len = size_inc_line_addr (line_delta, addr_delta);
741 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
744 /* Generate a variant frag that we can use to relax address/line
745 increments between fragments of the target segment. */
747 static void
748 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
749 int line_delta;
750 segT seg;
751 fragS *to_frag, *from_frag;
752 addressT to_ofs, from_ofs;
754 symbolS *to_sym, *from_sym;
755 expressionS expr;
756 int max_chars;
758 to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
759 from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
761 expr.X_op = O_subtract;
762 expr.X_add_symbol = to_sym;
763 expr.X_op_symbol = from_sym;
764 expr.X_add_number = 0;
766 /* The maximum size of the frag is the line delta with a maximum
767 sized address delta. */
768 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
770 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
771 make_expr_symbol (&expr), line_delta, NULL);
774 /* The function estimates the size of a rs_dwarf2dbg variant frag
775 based on the current values of the symbols. It is called before
776 the relaxation loop. We set fr_subtype to the expected length. */
779 dwarf2dbg_estimate_size_before_relax (frag)
780 fragS *frag;
782 offsetT addr_delta;
783 int size;
785 addr_delta = resolve_symbol_value (frag->fr_symbol);
786 size = size_inc_line_addr (frag->fr_offset, addr_delta);
788 frag->fr_subtype = size;
790 return size;
793 /* This function relaxes a rs_dwarf2dbg variant frag based on the
794 current values of the symbols. fr_subtype is the current length
795 of the frag. This returns the change in frag length. */
798 dwarf2dbg_relax_frag (frag)
799 fragS *frag;
801 int old_size, new_size;
803 old_size = frag->fr_subtype;
804 new_size = dwarf2dbg_estimate_size_before_relax (frag);
806 return new_size - old_size;
809 /* This function converts a rs_dwarf2dbg variant frag into a normal
810 fill frag. This is called after all relaxation has been done.
811 fr_subtype will be the desired length of the frag. */
813 void
814 dwarf2dbg_convert_frag (frag)
815 fragS *frag;
817 offsetT addr_diff;
819 addr_diff = resolve_symbol_value (frag->fr_symbol);
821 /* fr_var carries the max_chars that we created the fragment with.
822 fr_subtype carries the current expected length. We must, of
823 course, have allocated enough memory earlier. */
824 assert (frag->fr_var >= (int) frag->fr_subtype);
826 emit_inc_line_addr (frag->fr_offset, addr_diff,
827 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
829 frag->fr_fix += frag->fr_subtype;
830 frag->fr_type = rs_fill;
831 frag->fr_var = 0;
832 frag->fr_offset = 0;
835 /* Generate .debug_line content for the chain of line number entries
836 beginning at E, for segment SEG. */
838 static void
839 process_entries (seg, e)
840 segT seg;
841 struct line_entry *e;
843 unsigned filenum = 1;
844 unsigned line = 1;
845 unsigned column = 0;
846 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
847 fragS *frag = NULL;
848 fragS *last_frag;
849 addressT frag_ofs = 0;
850 addressT last_frag_ofs;
851 struct line_entry *next;
853 while (e)
855 int changed = 0;
857 if (filenum != e->loc.filenum)
859 filenum = e->loc.filenum;
860 out_opcode (DW_LNS_set_file);
861 out_uleb128 (filenum);
862 changed = 1;
865 if (column != e->loc.column)
867 column = e->loc.column;
868 out_opcode (DW_LNS_set_column);
869 out_uleb128 (column);
870 changed = 1;
873 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
875 flags = e->loc.flags;
876 out_opcode (DW_LNS_negate_stmt);
877 changed = 1;
880 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
882 out_opcode (DW_LNS_set_basic_block);
883 changed = 1;
886 /* Don't try to optimize away redundant entries; gdb wants two
887 entries for a function where the code starts on the same line as
888 the {, and there's no way to identify that case here. Trust gcc
889 to optimize appropriately. */
890 if (1 /* line != e->loc.line || changed */)
892 int line_delta = e->loc.line - line;
893 if (frag == NULL)
895 out_set_addr (seg, e->frag, e->frag_ofs);
896 out_inc_line_addr (line_delta, 0);
898 else if (frag == e->frag)
899 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
900 else
901 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
902 frag, frag_ofs);
904 frag = e->frag;
905 frag_ofs = e->frag_ofs;
906 line = e->loc.line;
908 else if (frag == NULL)
910 out_set_addr (seg, e->frag, e->frag_ofs);
911 frag = e->frag;
912 frag_ofs = e->frag_ofs;
915 next = e->next;
916 free (e);
917 e = next;
920 /* Emit a DW_LNE_end_sequence for the end of the section. */
921 last_frag = last_frag_for_seg (seg);
922 last_frag_ofs = get_frag_fix (last_frag);
923 if (frag == last_frag)
924 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
925 else
926 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
927 frag, frag_ofs);
930 /* Emit the directory and file tables for .debug_line. */
932 static void
933 out_file_list ()
935 size_t size;
936 char *cp;
937 unsigned int i;
939 /* Terminate directory list. */
940 out_byte ('\0');
942 for (i = 1; i < files_in_use; ++i)
944 if (files[i].filename == NULL)
946 as_bad (_("unassigned file number %ld"), (long) i);
947 continue;
950 size = strlen (files[i].filename) + 1;
951 cp = frag_more (size);
952 memcpy (cp, files[i].filename, size);
954 out_uleb128 (files[i].dir); /* directory number */
955 out_uleb128 (0); /* last modification timestamp */
956 out_uleb128 (0); /* filesize */
959 /* Terminate filename list. */
960 out_byte (0);
963 /* Emit the collected .debug_line data. */
965 static void
966 out_debug_line (line_seg)
967 segT line_seg;
969 expressionS expr;
970 symbolS *line_start;
971 symbolS *prologue_end;
972 symbolS *line_end;
973 struct line_seg *s;
975 subseg_set (line_seg, 0);
977 line_start = symbol_new_now ();
978 prologue_end = symbol_make (fake_label_name);
979 line_end = symbol_make (fake_label_name);
981 /* Total length of the information for this compilation unit. */
982 expr.X_op = O_subtract;
983 expr.X_add_symbol = line_end;
984 expr.X_op_symbol = line_start;
985 expr.X_add_number = -4;
986 emit_expr (&expr, 4);
988 /* Version. */
989 out_two (2);
991 /* Length of the prologue following this length. */
992 expr.X_op = O_subtract;
993 expr.X_add_symbol = prologue_end;
994 expr.X_op_symbol = line_start;
995 expr.X_add_number = - (4 + 2 + 4);
996 emit_expr (&expr, 4);
998 /* Parameters of the state machine. */
999 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1000 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1001 out_byte (DWARF2_LINE_BASE);
1002 out_byte (DWARF2_LINE_RANGE);
1003 out_byte (DWARF2_LINE_OPCODE_BASE);
1005 /* Standard opcode lengths. */
1006 out_byte (0); /* DW_LNS_copy */
1007 out_byte (1); /* DW_LNS_advance_pc */
1008 out_byte (1); /* DW_LNS_advance_line */
1009 out_byte (1); /* DW_LNS_set_file */
1010 out_byte (1); /* DW_LNS_set_column */
1011 out_byte (0); /* DW_LNS_negate_stmt */
1012 out_byte (0); /* DW_LNS_set_basic_block */
1013 out_byte (0); /* DW_LNS_const_add_pc */
1014 out_byte (1); /* DW_LNS_fixed_advance_pc */
1016 out_file_list ();
1018 set_symbol_value_now (prologue_end);
1020 /* For each section, emit a statement program. */
1021 for (s = all_segs; s; s = s->next)
1022 process_entries (s->seg, s->head->head);
1024 set_symbol_value_now (line_end);
1027 /* Emit data for .debug_aranges. */
1029 static void
1030 out_debug_aranges (aranges_seg, info_seg)
1031 segT aranges_seg;
1032 segT info_seg;
1034 unsigned int addr_size = sizeof_address;
1035 addressT size, skip;
1036 struct line_seg *s;
1037 expressionS expr;
1038 char *p;
1040 size = 4 + 2 + 4 + 1 + 1;
1042 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1043 if (skip == 2 * addr_size)
1044 skip = 0;
1045 size += skip;
1047 for (s = all_segs; s; s = s->next)
1048 size += 2 * addr_size;
1050 size += 2 * addr_size;
1052 subseg_set (aranges_seg, 0);
1054 /* Length of the compilation unit. */
1055 out_four (size - 4);
1057 /* Version. */
1058 out_two (2);
1060 /* Offset to .debug_info. */
1061 expr.X_op = O_symbol;
1062 expr.X_add_symbol = section_symbol (info_seg);
1063 expr.X_add_number = 0;
1064 emit_expr (&expr, 4);
1066 /* Size of an address (offset portion). */
1067 out_byte (addr_size);
1069 /* Size of a segment descriptor. */
1070 out_byte (0);
1072 /* Align the header. */
1073 if (skip)
1074 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1076 for (s = all_segs; s; s = s->next)
1078 fragS *frag;
1079 symbolS *beg, *end;
1081 frag = first_frag_for_seg (s->seg);
1082 beg = symbol_new (fake_label_name, s->seg, 0, frag);
1083 s->text_start = beg;
1085 frag = last_frag_for_seg (s->seg);
1086 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1087 s->text_end = end;
1089 expr.X_op = O_symbol;
1090 expr.X_add_symbol = beg;
1091 expr.X_add_number = 0;
1092 emit_expr (&expr, addr_size);
1094 expr.X_op = O_subtract;
1095 expr.X_add_symbol = end;
1096 expr.X_op_symbol = beg;
1097 expr.X_add_number = 0;
1098 emit_expr (&expr, addr_size);
1101 p = frag_more (2 * addr_size);
1102 md_number_to_chars (p, 0, addr_size);
1103 md_number_to_chars (p + addr_size, 0, addr_size);
1106 /* Emit data for .debug_abbrev. Note that this must be kept in
1107 sync with out_debug_info below. */
1109 static void
1110 out_debug_abbrev (abbrev_seg)
1111 segT abbrev_seg;
1113 subseg_set (abbrev_seg, 0);
1115 out_uleb128 (1);
1116 out_uleb128 (DW_TAG_compile_unit);
1117 out_byte (DW_CHILDREN_no);
1118 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1119 if (all_segs->next == NULL)
1121 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1122 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1124 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1125 out_abbrev (DW_AT_producer, DW_FORM_string);
1126 out_abbrev (DW_AT_language, DW_FORM_data2);
1127 out_abbrev (0, 0);
1129 /* Terminate the abbreviations for this compilation unit. */
1130 out_byte (0);
1133 /* Emit a description of this compilation unit for .debug_info. */
1135 static void
1136 out_debug_info (info_seg, abbrev_seg, line_seg)
1137 segT info_seg;
1138 segT abbrev_seg;
1139 segT line_seg;
1141 char producer[128];
1142 char *comp_dir;
1143 expressionS expr;
1144 symbolS *info_start;
1145 symbolS *info_end;
1146 char *p;
1147 int len;
1149 subseg_set (info_seg, 0);
1151 info_start = symbol_new_now ();
1152 info_end = symbol_make (fake_label_name);
1154 /* Compilation Unit length. */
1155 expr.X_op = O_subtract;
1156 expr.X_add_symbol = info_end;
1157 expr.X_op_symbol = info_start;
1158 expr.X_add_number = -4;
1159 emit_expr (&expr, 4);
1161 /* DWARF version. */
1162 out_two (2);
1164 /* .debug_abbrev offset */
1165 expr.X_op = O_symbol;
1166 expr.X_add_symbol = section_symbol (abbrev_seg);
1167 expr.X_add_number = 0;
1168 emit_expr (&expr, 4);
1170 /* Target address size. */
1171 out_byte (sizeof_address);
1173 /* DW_TAG_compile_unit DIE abbrev */
1174 out_uleb128 (1);
1176 /* DW_AT_stmt_list */
1177 expr.X_op = O_symbol;
1178 expr.X_add_symbol = section_symbol (line_seg);
1179 expr.X_add_number = 0;
1180 emit_expr (&expr, 4);
1182 /* These two attributes may only be emitted if all of the code is
1183 contiguous. Multiple sections are not that. */
1184 if (all_segs->next == NULL)
1186 /* DW_AT_low_pc */
1187 expr.X_op = O_symbol;
1188 expr.X_add_symbol = all_segs->text_start;
1189 expr.X_add_number = 0;
1190 emit_expr (&expr, sizeof_address);
1192 /* DW_AT_high_pc */
1193 expr.X_op = O_symbol;
1194 expr.X_add_symbol = all_segs->text_end;
1195 expr.X_add_number = 0;
1196 emit_expr (&expr, sizeof_address);
1199 /* DW_AT_comp_dir */
1200 comp_dir = getpwd ();
1201 len = strlen (comp_dir) + 1;
1202 p = frag_more (len);
1203 memcpy (p, comp_dir, len);
1205 /* DW_AT_producer */
1206 sprintf (producer, "GNU AS %s", VERSION);
1207 len = strlen (producer) + 1;
1208 p = frag_more (len);
1209 memcpy (p, producer, len);
1211 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1212 dwarf2 draft has no standard code for assembler. */
1213 out_two (DW_LANG_Mips_Assembler);
1215 set_symbol_value_now (info_end);
1218 void
1219 dwarf2_finish ()
1221 segT line_seg;
1222 struct line_seg *s;
1224 /* If no debug information was recorded, nothing to do. */
1225 if (all_segs == NULL && files_in_use <= 1)
1226 return;
1228 /* Calculate the size of an address for the target machine. */
1229 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1231 /* Create and switch to the line number section. */
1232 line_seg = subseg_new (".debug_line", 0);
1233 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1235 /* For each subsection, chain the debug entries together. */
1236 for (s = all_segs; s; s = s->next)
1238 struct line_subseg *ss = s->head;
1239 struct line_entry **ptail = ss->ptail;
1241 while ((ss = ss->next) != NULL)
1243 *ptail = ss->head;
1244 ptail = ss->ptail;
1248 out_debug_line (line_seg);
1250 /* If this is assembler generated line info, we need .debug_info
1251 and .debug_abbrev sections as well. */
1252 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1254 segT abbrev_seg;
1255 segT info_seg;
1256 segT aranges_seg;
1258 info_seg = subseg_new (".debug_info", 0);
1259 abbrev_seg = subseg_new (".debug_abbrev", 0);
1260 aranges_seg = subseg_new (".debug_aranges", 0);
1262 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1263 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1264 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1266 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1268 out_debug_aranges (aranges_seg, info_seg);
1269 out_debug_abbrev (abbrev_seg);
1270 out_debug_info (info_seg, abbrev_seg, line_seg);
1274 #else
1275 void
1276 dwarf2_finish ()
1281 dwarf2dbg_estimate_size_before_relax (frag)
1282 fragS *frag ATTRIBUTE_UNUSED;
1284 as_fatal (_("dwarf2 is not supported for this object file format"));
1285 return 0;
1289 dwarf2dbg_relax_frag (frag)
1290 fragS *frag ATTRIBUTE_UNUSED;
1292 as_fatal (_("dwarf2 is not supported for this object file format"));
1293 return 0;
1296 void
1297 dwarf2dbg_convert_frag (frag)
1298 fragS *frag ATTRIBUTE_UNUSED;
1300 as_fatal (_("dwarf2 is not supported for this object file format"));
1303 void
1304 dwarf2_emit_insn (size)
1305 int size ATTRIBUTE_UNUSED;
1309 void
1310 dwarf2_directive_file (dummy)
1311 int dummy ATTRIBUTE_UNUSED;
1313 s_app_file (0);
1316 void
1317 dwarf2_directive_loc (dummy)
1318 int dummy ATTRIBUTE_UNUSED;
1320 as_fatal (_("dwarf2 is not supported for this object file format"));
1322 #endif /* BFD_ASSEMBLER */