fixes for host gcc 4.6.1
[zpugcc/jano.git] / toolchain / binutils / gas / dwarf2dbg.c
blob3336453a4eeffabbd37fec150f362751c474d4b2
1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004 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 #include "dwarf2dbg.h"
45 #include <filenames.h>
47 #ifndef DWARF2_FORMAT
48 # define DWARF2_FORMAT() dwarf2_format_32bit
49 #endif
51 #ifndef DWARF2_ADDR_SIZE
52 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
53 #endif
55 #ifdef BFD_ASSEMBLER
57 #include "subsegs.h"
59 #include "elf/dwarf2.h"
61 /* Since we can't generate the prolog until the body is complete, we
62 use three different subsegments for .debug_line: one holding the
63 prolog, one for the directory and filename info, and one for the
64 body ("statement program"). */
65 #define DL_PROLOG 0
66 #define DL_FILES 1
67 #define DL_BODY 2
69 /* First special line opcde - leave room for the standard opcodes.
70 Note: If you want to change this, you'll have to update the
71 "standard_opcode_lengths" table that is emitted below in
72 dwarf2_finish(). */
73 #define DWARF2_LINE_OPCODE_BASE 10
75 #ifndef DWARF2_LINE_BASE
76 /* Minimum line offset in a special line info. opcode. This value
77 was chosen to give a reasonable range of values. */
78 # define DWARF2_LINE_BASE -5
79 #endif
81 /* Range of line offsets in a special line info. opcode. */
82 #ifndef DWARF2_LINE_RANGE
83 # define DWARF2_LINE_RANGE 14
84 #endif
86 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
87 /* Define the architecture-dependent minimum instruction length (in
88 bytes). This value should be rather too small than too big. */
89 # define DWARF2_LINE_MIN_INSN_LENGTH 1
90 #endif
92 /* Flag that indicates the initial value of the is_stmt_start flag.
93 In the present implementation, we do not mark any lines as
94 the beginning of a source statement, because that information
95 is not made available by the GCC front-end. */
96 #define DWARF2_LINE_DEFAULT_IS_STMT 1
98 /* Given a special op, return the line skip amount. */
99 #define SPECIAL_LINE(op) \
100 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
102 /* Given a special op, return the address skip amount (in units of
103 DWARF2_LINE_MIN_INSN_LENGTH. */
104 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
106 /* The maximum address skip amount that can be encoded with a special op. */
107 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
109 struct line_entry {
110 struct line_entry *next;
111 fragS *frag;
112 addressT frag_ofs;
113 struct dwarf2_line_info loc;
116 struct line_subseg {
117 struct line_subseg *next;
118 subsegT subseg;
119 struct line_entry *head;
120 struct line_entry **ptail;
123 struct line_seg {
124 struct line_seg *next;
125 segT seg;
126 struct line_subseg *head;
127 symbolS *text_start;
128 symbolS *text_end;
131 /* Collects data for all line table entries during assembly. */
132 static struct line_seg *all_segs;
134 struct file_entry {
135 const char *filename;
136 unsigned int dir;
139 /* Table of files used by .debug_line. */
140 static struct file_entry *files;
141 static unsigned int files_in_use;
142 static unsigned int files_allocated;
144 /* Table of directories used by .debug_line. */
145 static char **dirs;
146 static unsigned int dirs_in_use;
147 static unsigned int dirs_allocated;
149 /* TRUE when we've seen a .loc directive recently. Used to avoid
150 doing work when there's nothing to do. */
151 static bfd_boolean loc_directive_seen;
153 /* Current location as indicated by the most recent .loc directive. */
154 static struct dwarf2_line_info current;
156 /* The size of an address on the target. */
157 static unsigned int sizeof_address;
159 static struct line_subseg *get_line_subseg (segT, subsegT);
160 static unsigned int get_filenum (const char *, unsigned int);
161 static struct frag *first_frag_for_seg (segT);
162 static struct frag *last_frag_for_seg (segT);
163 static void out_byte (int);
164 static void out_opcode (int);
165 static void out_two (int);
166 static void out_four (int);
167 static void out_abbrev (int, int);
168 static void out_uleb128 (addressT);
169 static offsetT get_frag_fix (fragS *);
170 static void out_set_addr (segT, fragS *, addressT);
171 static int size_inc_line_addr (int, addressT);
172 static void emit_inc_line_addr (int, addressT, char *, int);
173 static void out_inc_line_addr (int, addressT);
174 static void relax_inc_line_addr (int, segT, fragS *, addressT,
175 fragS *, addressT);
176 static void process_entries (segT, struct line_entry *);
177 static void out_file_list (void);
178 static void out_debug_line (segT);
179 static void out_debug_aranges (segT, segT);
180 static void out_debug_abbrev (segT);
181 static void out_debug_info (segT, segT, segT);
183 #ifndef TC_DWARF2_EMIT_OFFSET
184 # define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
185 static void generic_dwarf2_emit_offset (symbolS *, unsigned int);
187 /* Create an offset to .dwarf2_*. */
189 static void
190 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
192 expressionS expr;
194 expr.X_op = O_symbol;
195 expr.X_add_symbol = symbol;
196 expr.X_add_number = 0;
197 emit_expr (&expr, size);
199 #endif
201 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
203 static struct line_subseg *
204 get_line_subseg (segT seg, subsegT subseg)
206 static segT last_seg;
207 static subsegT last_subseg;
208 static struct line_subseg *last_line_subseg;
210 struct line_seg *s;
211 struct line_subseg **pss, *ss;
213 if (seg == last_seg && subseg == last_subseg)
214 return last_line_subseg;
216 for (s = all_segs; s; s = s->next)
217 if (s->seg == seg)
218 goto found_seg;
220 s = (struct line_seg *) xmalloc (sizeof (*s));
221 s->next = all_segs;
222 s->seg = seg;
223 s->head = NULL;
224 all_segs = s;
226 found_seg:
227 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
229 if (ss->subseg == subseg)
230 goto found_subseg;
231 if (ss->subseg > subseg)
232 break;
235 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
236 ss->next = *pss;
237 ss->subseg = subseg;
238 ss->head = NULL;
239 ss->ptail = &ss->head;
240 *pss = ss;
242 found_subseg:
243 last_seg = seg;
244 last_subseg = subseg;
245 last_line_subseg = ss;
247 return ss;
250 /* Record an entry for LOC occurring at OFS within the current fragment. */
252 void
253 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
255 struct line_subseg *ss;
256 struct line_entry *e;
257 static unsigned int line = -1;
258 static unsigned int filenum = -1;
260 /* Early out for as-yet incomplete location information. */
261 if (loc->filenum == 0 || loc->line == 0)
262 return;
264 /* Don't emit sequences of line symbols for the same line when the
265 symbols apply to assembler code. It is necessary to emit
266 duplicate line symbols when a compiler asks for them, because GDB
267 uses them to determine the end of the prologue. */
268 if (debug_type == DEBUG_DWARF2
269 && line == loc->line && filenum == loc->filenum)
270 return;
272 line = loc->line;
273 filenum = loc->filenum;
275 e = (struct line_entry *) xmalloc (sizeof (*e));
276 e->next = NULL;
277 e->frag = frag_now;
278 e->frag_ofs = ofs;
279 e->loc = *loc;
281 ss = get_line_subseg (now_seg, now_subseg);
282 *ss->ptail = e;
283 ss->ptail = &e->next;
286 void
287 dwarf2_where (struct dwarf2_line_info *line)
289 if (debug_type == DEBUG_DWARF2)
291 char *filename;
292 as_where (&filename, &line->line);
293 line->filenum = get_filenum (filename, 0);
294 line->column = 0;
295 line->flags = DWARF2_FLAG_BEGIN_STMT;
297 else
298 *line = current;
301 /* Called for each machine instruction, or relatively atomic group of
302 machine instructions (ie built-in macro). The instruction or group
303 is SIZE bytes in length. If dwarf2 line number generation is called
304 for, emit a line statement appropriately. */
306 void
307 dwarf2_emit_insn (int size)
309 struct dwarf2_line_info loc;
311 if (loc_directive_seen)
313 /* Use the last location established by a .loc directive, not
314 the value returned by dwarf2_where(). That calls as_where()
315 which will return either the logical input file name (foo.c)
316 or the physical input file name (foo.s) and not the file name
317 specified in the most recent .loc directive (eg foo.h). */
318 loc = current;
320 /* Unless we generate DWARF2 debugging information for each
321 assembler line, we only emit one line symbol for one LOC. */
322 if (debug_type != DEBUG_DWARF2)
323 loc_directive_seen = FALSE;
325 else if (debug_type != DEBUG_DWARF2)
326 return;
327 else
328 dwarf2_where (& loc);
330 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
333 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
334 allocate it on that file table slot, otherwise return the first
335 empty one. */
337 static unsigned int
338 get_filenum (const char *filename, unsigned int num)
340 static unsigned int last_used, last_used_dir_len;
341 const char *file;
342 size_t dir_len;
343 unsigned int i, dir;
345 if (num == 0 && last_used)
347 if (! files[last_used].dir
348 && strcmp (filename, files[last_used].filename) == 0)
349 return last_used;
350 if (files[last_used].dir
351 && strncmp (filename, dirs[files[last_used].dir],
352 last_used_dir_len) == 0
353 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
354 && strcmp (filename + last_used_dir_len + 1,
355 files[last_used].filename) == 0)
356 return last_used;
359 file = lbasename (filename);
360 /* Don't make empty string from / or A: from A:/ . */
361 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
362 if (file <= filename + 3)
363 file = filename;
364 #else
365 if (file == filename + 1)
366 file = filename;
367 #endif
368 dir_len = file - filename;
370 dir = 0;
371 if (dir_len)
373 --dir_len;
374 for (dir = 1; dir < dirs_in_use; ++dir)
375 if (strncmp (filename, dirs[dir], dir_len) == 0
376 && dirs[dir][dir_len] == '\0')
377 break;
379 if (dir >= dirs_in_use)
381 if (dir >= dirs_allocated)
383 dirs_allocated = dir + 32;
384 dirs = (char **)
385 xrealloc (dirs, (dir + 32) * sizeof (const char *));
388 dirs[dir] = xmalloc (dir_len + 1);
389 memcpy (dirs[dir], filename, dir_len);
390 dirs[dir][dir_len] = '\0';
391 dirs_in_use = dir + 1;
395 if (num == 0)
397 for (i = 1; i < files_in_use; ++i)
398 if (files[i].dir == dir
399 && files[i].filename
400 && strcmp (file, files[i].filename) == 0)
402 last_used = i;
403 last_used_dir_len = dir_len;
404 return i;
407 else
408 i = num;
410 if (i >= files_allocated)
412 unsigned int old = files_allocated;
414 files_allocated = i + 32;
415 files = (struct file_entry *)
416 xrealloc (files, (i + 32) * sizeof (struct file_entry));
418 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
421 files[i].filename = num ? file : xstrdup (file);
422 files[i].dir = dir;
423 files_in_use = i + 1;
424 last_used = i;
425 last_used_dir_len = dir_len;
427 return i;
430 /* Handle two forms of .file directive:
431 - Pass .file "source.c" to s_app_file
432 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
434 If an entry is added to the file table, return a pointer to the filename. */
436 char *
437 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
439 offsetT num;
440 char *filename;
441 int filename_len;
443 /* Continue to accept a bare string and pass it off. */
444 SKIP_WHITESPACE ();
445 if (*input_line_pointer == '"')
447 s_app_file (0);
448 return NULL;
451 num = get_absolute_expression ();
452 filename = demand_copy_C_string (&filename_len);
453 demand_empty_rest_of_line ();
455 if (num < 1)
457 as_bad (_("file number less than one"));
458 return NULL;
461 if (num < (int) files_in_use && files[num].filename != 0)
463 as_bad (_("file number %ld already allocated"), (long) num);
464 return NULL;
467 get_filenum (filename, num);
469 return filename;
472 void
473 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
475 offsetT filenum, line, column;
477 filenum = get_absolute_expression ();
478 SKIP_WHITESPACE ();
479 line = get_absolute_expression ();
480 SKIP_WHITESPACE ();
481 column = get_absolute_expression ();
482 demand_empty_rest_of_line ();
484 if (filenum < 1)
486 as_bad (_("file number less than one"));
487 return;
489 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
491 as_bad (_("unassigned file number %ld"), (long) filenum);
492 return;
495 current.filenum = filenum;
496 current.line = line;
497 current.column = column;
498 current.flags = DWARF2_FLAG_BEGIN_STMT;
500 loc_directive_seen = TRUE;
502 #ifndef NO_LISTING
503 if (listing)
505 if (files[filenum].dir)
507 size_t dir_len = strlen (dirs[files[filenum].dir]);
508 size_t file_len = strlen (files[filenum].filename);
509 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
511 memcpy (cp, dirs[files[filenum].dir], dir_len);
512 cp[dir_len] = '/';
513 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
514 cp[dir_len + file_len + 1] = '\0';
515 listing_source_file (cp);
517 else
518 listing_source_file (files[filenum].filename);
519 listing_source_line (line);
521 #endif
524 static struct frag *
525 first_frag_for_seg (segT seg)
527 frchainS *f, *first = NULL;
529 for (f = frchain_root; f; f = f->frch_next)
530 if (f->frch_seg == seg
531 && (! first || first->frch_subseg > f->frch_subseg))
532 first = f;
534 return first ? first->frch_root : NULL;
537 static struct frag *
538 last_frag_for_seg (segT seg)
540 frchainS *f, *last = NULL;
542 for (f = frchain_root; f; f = f->frch_next)
543 if (f->frch_seg == seg
544 && (! last || last->frch_subseg < f->frch_subseg))
545 last= f;
547 return last ? last->frch_last : NULL;
550 /* Emit a single byte into the current segment. */
552 static inline void
553 out_byte (int byte)
555 FRAG_APPEND_1_CHAR (byte);
558 /* Emit a statement program opcode into the current segment. */
560 static inline void
561 out_opcode (int opc)
563 out_byte (opc);
566 /* Emit a two-byte word into the current segment. */
568 static inline void
569 out_two (int data)
571 md_number_to_chars (frag_more (2), data, 2);
574 /* Emit a four byte word into the current segment. */
576 static inline void
577 out_four (int data)
579 md_number_to_chars (frag_more (4), data, 4);
582 /* Emit an unsigned "little-endian base 128" number. */
584 static void
585 out_uleb128 (addressT value)
587 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
590 /* Emit a tuple for .debug_abbrev. */
592 static inline void
593 out_abbrev (int name, int form)
595 out_uleb128 (name);
596 out_uleb128 (form);
599 /* Get the size of a fragment. */
601 static offsetT
602 get_frag_fix (fragS *frag)
604 frchainS *fr;
606 if (frag->fr_next)
607 return frag->fr_fix;
609 /* If a fragment is the last in the chain, special measures must be
610 taken to find its size before relaxation, since it may be pending
611 on some subsegment chain. */
612 for (fr = frchain_root; fr; fr = fr->frch_next)
613 if (fr->frch_last == frag)
614 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
616 abort ();
619 /* Set an absolute address (may result in a relocation entry). */
621 static void
622 out_set_addr (segT seg, fragS *frag, addressT ofs)
624 expressionS expr;
625 symbolS *sym;
627 sym = symbol_temp_new (seg, ofs, frag);
629 out_opcode (DW_LNS_extended_op);
630 out_uleb128 (sizeof_address + 1);
632 out_opcode (DW_LNE_set_address);
633 expr.X_op = O_symbol;
634 expr.X_add_symbol = sym;
635 expr.X_add_number = 0;
636 emit_expr (&expr, sizeof_address);
639 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
640 static void scale_addr_delta (addressT *);
642 static void
643 scale_addr_delta (addressT *addr_delta)
645 static int printed_this = 0;
646 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
648 if (!printed_this)
649 as_bad("unaligned opcodes detected in executable segment");
650 printed_this = 1;
652 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
654 #else
655 #define scale_addr_delta(A)
656 #endif
658 /* Encode a pair of line and address skips as efficiently as possible.
659 Note that the line skip is signed, whereas the address skip is unsigned.
661 The following two routines *must* be kept in sync. This is
662 enforced by making emit_inc_line_addr abort if we do not emit
663 exactly the expected number of bytes. */
665 static int
666 size_inc_line_addr (int line_delta, addressT addr_delta)
668 unsigned int tmp, opcode;
669 int len = 0;
671 /* Scale the address delta by the minimum instruction length. */
672 scale_addr_delta (&addr_delta);
674 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
675 We cannot use special opcodes here, since we want the end_sequence
676 to emit the matrix entry. */
677 if (line_delta == INT_MAX)
679 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
680 len = 1;
681 else
682 len = 1 + sizeof_leb128 (addr_delta, 0);
683 return len + 3;
686 /* Bias the line delta by the base. */
687 tmp = line_delta - DWARF2_LINE_BASE;
689 /* If the line increment is out of range of a special opcode, we
690 must encode it with DW_LNS_advance_line. */
691 if (tmp >= DWARF2_LINE_RANGE)
693 len = 1 + sizeof_leb128 (line_delta, 1);
694 line_delta = 0;
695 tmp = 0 - DWARF2_LINE_BASE;
698 /* Bias the opcode by the special opcode base. */
699 tmp += DWARF2_LINE_OPCODE_BASE;
701 /* Avoid overflow when addr_delta is large. */
702 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
704 /* Try using a special opcode. */
705 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
706 if (opcode <= 255)
707 return len + 1;
709 /* Try using DW_LNS_const_add_pc followed by special op. */
710 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
711 if (opcode <= 255)
712 return len + 2;
715 /* Otherwise use DW_LNS_advance_pc. */
716 len += 1 + sizeof_leb128 (addr_delta, 0);
718 /* DW_LNS_copy or special opcode. */
719 len += 1;
721 return len;
724 static void
725 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
727 unsigned int tmp, opcode;
728 int need_copy = 0;
729 char *end = p + len;
731 /* Scale the address delta by the minimum instruction length. */
732 scale_addr_delta (&addr_delta);
734 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
735 We cannot use special opcodes here, since we want the end_sequence
736 to emit the matrix entry. */
737 if (line_delta == INT_MAX)
739 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
740 *p++ = DW_LNS_const_add_pc;
741 else
743 *p++ = DW_LNS_advance_pc;
744 p += output_leb128 (p, addr_delta, 0);
747 *p++ = DW_LNS_extended_op;
748 *p++ = 1;
749 *p++ = DW_LNE_end_sequence;
750 goto done;
753 /* Bias the line delta by the base. */
754 tmp = line_delta - DWARF2_LINE_BASE;
756 /* If the line increment is out of range of a special opcode, we
757 must encode it with DW_LNS_advance_line. */
758 if (tmp >= DWARF2_LINE_RANGE)
760 *p++ = DW_LNS_advance_line;
761 p += output_leb128 (p, line_delta, 1);
763 /* Prettier, I think, to use DW_LNS_copy instead of a
764 "line +0, addr +0" special opcode. */
765 if (addr_delta == 0)
767 *p++ = DW_LNS_copy;
768 goto done;
771 line_delta = 0;
772 tmp = 0 - DWARF2_LINE_BASE;
773 need_copy = 1;
776 /* Bias the opcode by the special opcode base. */
777 tmp += DWARF2_LINE_OPCODE_BASE;
779 /* Avoid overflow when addr_delta is large. */
780 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
782 /* Try using a special opcode. */
783 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
784 if (opcode <= 255)
786 *p++ = opcode;
787 goto done;
790 /* Try using DW_LNS_const_add_pc followed by special op. */
791 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
792 if (opcode <= 255)
794 *p++ = DW_LNS_const_add_pc;
795 *p++ = opcode;
796 goto done;
800 /* Otherwise use DW_LNS_advance_pc. */
801 *p++ = DW_LNS_advance_pc;
802 p += output_leb128 (p, addr_delta, 0);
804 if (need_copy)
805 *p++ = DW_LNS_copy;
806 else
807 *p++ = tmp;
809 done:
810 assert (p == end);
813 /* Handy routine to combine calls to the above two routines. */
815 static void
816 out_inc_line_addr (int line_delta, addressT addr_delta)
818 int len = size_inc_line_addr (line_delta, addr_delta);
819 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
822 /* Generate a variant frag that we can use to relax address/line
823 increments between fragments of the target segment. */
825 static void
826 relax_inc_line_addr (int line_delta, segT seg,
827 fragS *to_frag, addressT to_ofs,
828 fragS *from_frag, addressT from_ofs)
830 symbolS *to_sym, *from_sym;
831 expressionS expr;
832 int max_chars;
834 to_sym = symbol_temp_new (seg, to_ofs, to_frag);
835 from_sym = symbol_temp_new (seg, from_ofs, from_frag);
837 expr.X_op = O_subtract;
838 expr.X_add_symbol = to_sym;
839 expr.X_op_symbol = from_sym;
840 expr.X_add_number = 0;
842 /* The maximum size of the frag is the line delta with a maximum
843 sized address delta. */
844 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
846 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
847 make_expr_symbol (&expr), line_delta, NULL);
850 /* The function estimates the size of a rs_dwarf2dbg variant frag
851 based on the current values of the symbols. It is called before
852 the relaxation loop. We set fr_subtype to the expected length. */
855 dwarf2dbg_estimate_size_before_relax (fragS *frag)
857 offsetT addr_delta;
858 int size;
860 addr_delta = resolve_symbol_value (frag->fr_symbol);
861 size = size_inc_line_addr (frag->fr_offset, addr_delta);
863 frag->fr_subtype = size;
865 return size;
868 /* This function relaxes a rs_dwarf2dbg variant frag based on the
869 current values of the symbols. fr_subtype is the current length
870 of the frag. This returns the change in frag length. */
873 dwarf2dbg_relax_frag (fragS *frag)
875 int old_size, new_size;
877 old_size = frag->fr_subtype;
878 new_size = dwarf2dbg_estimate_size_before_relax (frag);
880 return new_size - old_size;
883 /* This function converts a rs_dwarf2dbg variant frag into a normal
884 fill frag. This is called after all relaxation has been done.
885 fr_subtype will be the desired length of the frag. */
887 void
888 dwarf2dbg_convert_frag (fragS *frag)
890 offsetT addr_diff;
892 addr_diff = resolve_symbol_value (frag->fr_symbol);
894 /* fr_var carries the max_chars that we created the fragment with.
895 fr_subtype carries the current expected length. We must, of
896 course, have allocated enough memory earlier. */
897 assert (frag->fr_var >= (int) frag->fr_subtype);
899 emit_inc_line_addr (frag->fr_offset, addr_diff,
900 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
902 frag->fr_fix += frag->fr_subtype;
903 frag->fr_type = rs_fill;
904 frag->fr_var = 0;
905 frag->fr_offset = 0;
908 /* Generate .debug_line content for the chain of line number entries
909 beginning at E, for segment SEG. */
911 static void
912 process_entries (segT seg, struct line_entry *e)
914 unsigned filenum = 1;
915 unsigned line = 1;
916 unsigned column = 0;
917 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
918 fragS *frag = NULL;
919 fragS *last_frag;
920 addressT frag_ofs = 0;
921 addressT last_frag_ofs;
922 struct line_entry *next;
924 while (e)
926 int changed = 0;
928 if (filenum != e->loc.filenum)
930 filenum = e->loc.filenum;
931 out_opcode (DW_LNS_set_file);
932 out_uleb128 (filenum);
933 changed = 1;
936 if (column != e->loc.column)
938 column = e->loc.column;
939 out_opcode (DW_LNS_set_column);
940 out_uleb128 (column);
941 changed = 1;
944 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
946 flags = e->loc.flags;
947 out_opcode (DW_LNS_negate_stmt);
948 changed = 1;
951 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
953 out_opcode (DW_LNS_set_basic_block);
954 changed = 1;
957 /* Don't try to optimize away redundant entries; gdb wants two
958 entries for a function where the code starts on the same line as
959 the {, and there's no way to identify that case here. Trust gcc
960 to optimize appropriately. */
961 if (1 /* line != e->loc.line || changed */)
963 int line_delta = e->loc.line - line;
964 if (frag == NULL)
966 out_set_addr (seg, e->frag, e->frag_ofs);
967 out_inc_line_addr (line_delta, 0);
969 else if (frag == e->frag)
970 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
971 else
972 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
973 frag, frag_ofs);
975 frag = e->frag;
976 frag_ofs = e->frag_ofs;
977 line = e->loc.line;
979 else if (frag == NULL)
981 out_set_addr (seg, e->frag, e->frag_ofs);
982 frag = e->frag;
983 frag_ofs = e->frag_ofs;
986 next = e->next;
987 free (e);
988 e = next;
991 /* Emit a DW_LNE_end_sequence for the end of the section. */
992 last_frag = last_frag_for_seg (seg);
993 last_frag_ofs = get_frag_fix (last_frag);
994 if (frag == last_frag)
995 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
996 else
997 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
998 frag, frag_ofs);
1001 /* Emit the directory and file tables for .debug_line. */
1003 static void
1004 out_file_list (void)
1006 size_t size;
1007 char *cp;
1008 unsigned int i;
1010 /* Emit directory list. */
1011 for (i = 1; i < dirs_in_use; ++i)
1013 size = strlen (dirs[i]) + 1;
1014 cp = frag_more (size);
1015 memcpy (cp, dirs[i], size);
1017 /* Terminate it. */
1018 out_byte ('\0');
1020 for (i = 1; i < files_in_use; ++i)
1022 if (files[i].filename == NULL)
1024 as_bad (_("unassigned file number %ld"), (long) i);
1025 /* Prevent a crash later, particularly for file 1. */
1026 files[i].filename = "";
1027 continue;
1030 size = strlen (files[i].filename) + 1;
1031 cp = frag_more (size);
1032 memcpy (cp, files[i].filename, size);
1034 out_uleb128 (files[i].dir); /* directory number */
1035 out_uleb128 (0); /* last modification timestamp */
1036 out_uleb128 (0); /* filesize */
1039 /* Terminate filename list. */
1040 out_byte (0);
1043 /* Emit the collected .debug_line data. */
1045 static void
1046 out_debug_line (segT line_seg)
1048 expressionS expr;
1049 symbolS *line_start;
1050 symbolS *prologue_end;
1051 symbolS *line_end;
1052 struct line_seg *s;
1053 enum dwarf2_format d2f;
1054 int sizeof_offset;
1056 subseg_set (line_seg, 0);
1058 line_start = symbol_temp_new_now ();
1059 prologue_end = symbol_temp_make ();
1060 line_end = symbol_temp_make ();
1062 /* Total length of the information for this compilation unit. */
1063 expr.X_op = O_subtract;
1064 expr.X_add_symbol = line_end;
1065 expr.X_op_symbol = line_start;
1067 d2f = DWARF2_FORMAT ();
1068 if (d2f == dwarf2_format_32bit)
1070 expr.X_add_number = -4;
1071 emit_expr (&expr, 4);
1072 sizeof_offset = 4;
1074 else if (d2f == dwarf2_format_64bit)
1076 expr.X_add_number = -12;
1077 out_four (-1);
1078 emit_expr (&expr, 8);
1079 sizeof_offset = 8;
1081 else if (d2f == dwarf2_format_64bit_irix)
1083 expr.X_add_number = -8;
1084 emit_expr (&expr, 8);
1085 sizeof_offset = 8;
1087 else
1089 as_fatal (_("internal error: unknown dwarf2 format"));
1092 /* Version. */
1093 out_two (2);
1095 /* Length of the prologue following this length. */
1096 expr.X_op = O_subtract;
1097 expr.X_add_symbol = prologue_end;
1098 expr.X_op_symbol = line_start;
1099 expr.X_add_number = - (4 + 2 + 4);
1100 emit_expr (&expr, sizeof_offset);
1102 /* Parameters of the state machine. */
1103 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1104 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1105 out_byte (DWARF2_LINE_BASE);
1106 out_byte (DWARF2_LINE_RANGE);
1107 out_byte (DWARF2_LINE_OPCODE_BASE);
1109 /* Standard opcode lengths. */
1110 out_byte (0); /* DW_LNS_copy */
1111 out_byte (1); /* DW_LNS_advance_pc */
1112 out_byte (1); /* DW_LNS_advance_line */
1113 out_byte (1); /* DW_LNS_set_file */
1114 out_byte (1); /* DW_LNS_set_column */
1115 out_byte (0); /* DW_LNS_negate_stmt */
1116 out_byte (0); /* DW_LNS_set_basic_block */
1117 out_byte (0); /* DW_LNS_const_add_pc */
1118 out_byte (1); /* DW_LNS_fixed_advance_pc */
1120 out_file_list ();
1122 symbol_set_value_now (prologue_end);
1124 /* For each section, emit a statement program. */
1125 for (s = all_segs; s; s = s->next)
1126 process_entries (s->seg, s->head->head);
1128 symbol_set_value_now (line_end);
1131 /* Emit data for .debug_aranges. */
1133 static void
1134 out_debug_aranges (segT aranges_seg, segT info_seg)
1136 unsigned int addr_size = sizeof_address;
1137 addressT size, skip;
1138 struct line_seg *s;
1139 expressionS expr;
1140 char *p;
1142 size = 4 + 2 + 4 + 1 + 1;
1144 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1145 if (skip == 2 * addr_size)
1146 skip = 0;
1147 size += skip;
1149 for (s = all_segs; s; s = s->next)
1150 size += 2 * addr_size;
1152 size += 2 * addr_size;
1154 subseg_set (aranges_seg, 0);
1156 /* Length of the compilation unit. */
1157 out_four (size - 4);
1159 /* Version. */
1160 out_two (2);
1162 /* Offset to .debug_info. */
1163 /* ??? sizeof_offset */
1164 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
1166 /* Size of an address (offset portion). */
1167 out_byte (addr_size);
1169 /* Size of a segment descriptor. */
1170 out_byte (0);
1172 /* Align the header. */
1173 if (skip)
1174 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1176 for (s = all_segs; s; s = s->next)
1178 fragS *frag;
1179 symbolS *beg, *end;
1181 frag = first_frag_for_seg (s->seg);
1182 beg = symbol_temp_new (s->seg, 0, frag);
1183 s->text_start = beg;
1185 frag = last_frag_for_seg (s->seg);
1186 end = symbol_temp_new (s->seg, get_frag_fix (frag), frag);
1187 s->text_end = end;
1189 expr.X_op = O_symbol;
1190 expr.X_add_symbol = beg;
1191 expr.X_add_number = 0;
1192 emit_expr (&expr, addr_size);
1194 expr.X_op = O_subtract;
1195 expr.X_add_symbol = end;
1196 expr.X_op_symbol = beg;
1197 expr.X_add_number = 0;
1198 emit_expr (&expr, addr_size);
1201 p = frag_more (2 * addr_size);
1202 md_number_to_chars (p, 0, addr_size);
1203 md_number_to_chars (p + addr_size, 0, addr_size);
1206 /* Emit data for .debug_abbrev. Note that this must be kept in
1207 sync with out_debug_info below. */
1209 static void
1210 out_debug_abbrev (segT abbrev_seg)
1212 subseg_set (abbrev_seg, 0);
1214 out_uleb128 (1);
1215 out_uleb128 (DW_TAG_compile_unit);
1216 out_byte (DW_CHILDREN_no);
1217 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1218 if (all_segs->next == NULL)
1220 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1221 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1223 out_abbrev (DW_AT_name, DW_FORM_string);
1224 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1225 out_abbrev (DW_AT_producer, DW_FORM_string);
1226 out_abbrev (DW_AT_language, DW_FORM_data2);
1227 out_abbrev (0, 0);
1229 /* Terminate the abbreviations for this compilation unit. */
1230 out_byte (0);
1233 /* Emit a description of this compilation unit for .debug_info. */
1235 static void
1236 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg)
1238 char producer[128];
1239 char *comp_dir;
1240 expressionS expr;
1241 symbolS *info_start;
1242 symbolS *info_end;
1243 char *p;
1244 int len;
1245 enum dwarf2_format d2f;
1246 int sizeof_offset;
1248 subseg_set (info_seg, 0);
1250 info_start = symbol_temp_new_now ();
1251 info_end = symbol_temp_make ();
1253 /* Compilation Unit length. */
1254 expr.X_op = O_subtract;
1255 expr.X_add_symbol = info_end;
1256 expr.X_op_symbol = info_start;
1258 d2f = DWARF2_FORMAT ();
1259 if (d2f == dwarf2_format_32bit)
1261 expr.X_add_number = -4;
1262 emit_expr (&expr, 4);
1263 sizeof_offset = 4;
1265 else if (d2f == dwarf2_format_64bit)
1267 expr.X_add_number = -12;
1268 out_four (-1);
1269 emit_expr (&expr, 8);
1270 sizeof_offset = 8;
1272 else if (d2f == dwarf2_format_64bit_irix)
1274 expr.X_add_number = -8;
1275 emit_expr (&expr, 8);
1276 sizeof_offset = 8;
1278 else
1280 as_fatal (_("internal error: unknown dwarf2 format"));
1283 /* DWARF version. */
1284 out_two (2);
1286 /* .debug_abbrev offset */
1287 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1289 /* Target address size. */
1290 out_byte (sizeof_address);
1292 /* DW_TAG_compile_unit DIE abbrev */
1293 out_uleb128 (1);
1295 /* DW_AT_stmt_list */
1296 /* ??? sizeof_offset */
1297 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
1299 /* These two attributes may only be emitted if all of the code is
1300 contiguous. Multiple sections are not that. */
1301 if (all_segs->next == NULL)
1303 /* DW_AT_low_pc */
1304 expr.X_op = O_symbol;
1305 expr.X_add_symbol = all_segs->text_start;
1306 expr.X_add_number = 0;
1307 emit_expr (&expr, sizeof_address);
1309 /* DW_AT_high_pc */
1310 expr.X_op = O_symbol;
1311 expr.X_add_symbol = all_segs->text_end;
1312 expr.X_add_number = 0;
1313 emit_expr (&expr, sizeof_address);
1316 /* DW_AT_name. We don't have the actual file name that was present
1317 on the command line, so assume files[1] is the main input file.
1318 We're not supposed to get called unless at least one line number
1319 entry was emitted, so this should always be defined. */
1320 if (!files || files_in_use < 1)
1321 abort ();
1322 if (files[1].dir)
1324 len = strlen (dirs[files[1].dir]);
1325 p = frag_more (len + 1);
1326 memcpy (p, dirs[files[1].dir], len);
1327 p[len] = '/';
1329 len = strlen (files[1].filename) + 1;
1330 p = frag_more (len);
1331 memcpy (p, files[1].filename, len);
1333 /* DW_AT_comp_dir */
1334 comp_dir = getpwd ();
1335 len = strlen (comp_dir) + 1;
1336 p = frag_more (len);
1337 memcpy (p, comp_dir, len);
1339 /* DW_AT_producer */
1340 sprintf (producer, "GNU AS %s", VERSION);
1341 len = strlen (producer) + 1;
1342 p = frag_more (len);
1343 memcpy (p, producer, len);
1345 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1346 dwarf2 draft has no standard code for assembler. */
1347 out_two (DW_LANG_Mips_Assembler);
1349 symbol_set_value_now (info_end);
1352 void
1353 dwarf2_finish (void)
1355 segT line_seg;
1356 struct line_seg *s;
1358 /* We don't need to do anything unless:
1359 - Some debug information was recorded via .file/.loc
1360 - or, we are generating DWARF2 information ourself (--gdwarf2)
1361 - or, there is a user-provided .debug_info section which could
1362 reference the file table in the .debug_line section we generate
1363 below. */
1364 if (all_segs == NULL
1365 && debug_type != DEBUG_DWARF2
1366 && bfd_get_section_by_name (stdoutput, ".debug_info") == NULL)
1367 return;
1369 /* Calculate the size of an address for the target machine. */
1370 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1372 /* Create and switch to the line number section. */
1373 line_seg = subseg_new (".debug_line", 0);
1374 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1376 /* For each subsection, chain the debug entries together. */
1377 for (s = all_segs; s; s = s->next)
1379 struct line_subseg *ss = s->head;
1380 struct line_entry **ptail = ss->ptail;
1382 while ((ss = ss->next) != NULL)
1384 *ptail = ss->head;
1385 ptail = ss->ptail;
1389 out_debug_line (line_seg);
1391 /* If this is assembler generated line info, we need .debug_info
1392 and .debug_abbrev sections as well. */
1393 if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1395 segT abbrev_seg;
1396 segT info_seg;
1397 segT aranges_seg;
1399 info_seg = subseg_new (".debug_info", 0);
1400 abbrev_seg = subseg_new (".debug_abbrev", 0);
1401 aranges_seg = subseg_new (".debug_aranges", 0);
1403 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1404 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1405 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1407 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1409 out_debug_aranges (aranges_seg, info_seg);
1410 out_debug_abbrev (abbrev_seg);
1411 out_debug_info (info_seg, abbrev_seg, line_seg);
1415 #else
1416 void
1417 dwarf2_finish ()
1422 dwarf2dbg_estimate_size_before_relax (frag)
1423 fragS *frag ATTRIBUTE_UNUSED;
1425 as_fatal (_("dwarf2 is not supported for this object file format"));
1426 return 0;
1430 dwarf2dbg_relax_frag (frag)
1431 fragS *frag ATTRIBUTE_UNUSED;
1433 as_fatal (_("dwarf2 is not supported for this object file format"));
1434 return 0;
1437 void
1438 dwarf2dbg_convert_frag (frag)
1439 fragS *frag ATTRIBUTE_UNUSED;
1441 as_fatal (_("dwarf2 is not supported for this object file format"));
1444 void
1445 dwarf2_emit_insn (size)
1446 int size ATTRIBUTE_UNUSED;
1450 char *
1451 dwarf2_directive_file (dummy)
1452 int dummy ATTRIBUTE_UNUSED;
1454 s_app_file (0);
1455 return NULL;
1458 void
1459 dwarf2_directive_loc (dummy)
1460 int dummy ATTRIBUTE_UNUSED;
1462 as_fatal (_("dwarf2 is not supported for this object file format"));
1464 #endif /* BFD_ASSEMBLER */