daily update
[binutils.git] / gas / dwarf2dbg.c
blobb7857f2caa4c600fa969a99616e359b2f81dace4
1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* Logical line numbers can be controlled by the compiler via the
24 following directives:
26 .file FILENO "file.c"
27 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
28 [epilogue_begin] [is_stmt VALUE] [isa VALUE]
31 #include "as.h"
32 #include "safe-ctype.h"
34 #ifdef HAVE_LIMITS_H
35 #include <limits.h>
36 #else
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
39 #endif
40 #ifndef INT_MAX
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
42 #endif
43 #endif
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
57 do \
58 { \
59 if (offset > 1 \
60 && string[0] != 0 \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
63 else \
64 string [offset] = '/'; \
65 } \
66 while (0)
67 #else
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
69 #endif
71 #ifndef DWARF2_FORMAT
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
73 #endif
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
77 #endif
79 #include "subsegs.h"
81 #include "elf/dwarf2.h"
83 /* Since we can't generate the prolog until the body is complete, we
84 use three different subsegments for .debug_line: one holding the
85 prolog, one for the directory and filename info, and one for the
86 body ("statement program"). */
87 #define DL_PROLOG 0
88 #define DL_FILES 1
89 #define DL_BODY 2
91 /* If linker relaxation might change offsets in the code, the DWARF special
92 opcodes and variable-length operands cannot be used. If this macro is
93 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
94 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
95 # define DWARF2_USE_FIXED_ADVANCE_PC 0
96 #endif
98 /* First special line opcde - leave room for the standard opcodes.
99 Note: If you want to change this, you'll have to update the
100 "standard_opcode_lengths" table that is emitted below in
101 out_debug_line(). */
102 #define DWARF2_LINE_OPCODE_BASE 13
104 #ifndef DWARF2_LINE_BASE
105 /* Minimum line offset in a special line info. opcode. This value
106 was chosen to give a reasonable range of values. */
107 # define DWARF2_LINE_BASE -5
108 #endif
110 /* Range of line offsets in a special line info. opcode. */
111 #ifndef DWARF2_LINE_RANGE
112 # define DWARF2_LINE_RANGE 14
113 #endif
115 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
116 /* Define the architecture-dependent minimum instruction length (in
117 bytes). This value should be rather too small than too big. */
118 # define DWARF2_LINE_MIN_INSN_LENGTH 1
119 #endif
121 /* Flag that indicates the initial value of the is_stmt_start flag. */
122 #define DWARF2_LINE_DEFAULT_IS_STMT 1
124 /* Given a special op, return the line skip amount. */
125 #define SPECIAL_LINE(op) \
126 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
128 /* Given a special op, return the address skip amount (in units of
129 DWARF2_LINE_MIN_INSN_LENGTH. */
130 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
132 /* The maximum address skip amount that can be encoded with a special op. */
133 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
135 struct line_entry {
136 struct line_entry *next;
137 symbolS *label;
138 struct dwarf2_line_info loc;
141 struct line_subseg {
142 struct line_subseg *next;
143 subsegT subseg;
144 struct line_entry *head;
145 struct line_entry **ptail;
148 struct line_seg {
149 struct line_seg *next;
150 segT seg;
151 struct line_subseg *head;
152 symbolS *text_start;
153 symbolS *text_end;
156 /* Collects data for all line table entries during assembly. */
157 static struct line_seg *all_segs;
159 struct file_entry {
160 const char *filename;
161 unsigned int dir;
164 /* Table of files used by .debug_line. */
165 static struct file_entry *files;
166 static unsigned int files_in_use;
167 static unsigned int files_allocated;
169 /* Table of directories used by .debug_line. */
170 static char **dirs;
171 static unsigned int dirs_in_use;
172 static unsigned int dirs_allocated;
174 /* TRUE when we've seen a .loc directive recently. Used to avoid
175 doing work when there's nothing to do. */
176 bfd_boolean dwarf2_loc_directive_seen;
178 /* TRUE when we're supposed to set the basic block mark whenever a
179 label is seen. */
180 bfd_boolean dwarf2_loc_mark_labels;
182 /* Current location as indicated by the most recent .loc directive. */
183 static struct dwarf2_line_info current = {
184 1, 1, 0, 0,
185 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0
188 /* The size of an address on the target. */
189 static unsigned int sizeof_address;
191 static unsigned int get_filenum (const char *, unsigned int);
193 #ifndef TC_DWARF2_EMIT_OFFSET
194 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
196 /* Create an offset to .dwarf2_*. */
198 static void
199 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
201 expressionS expr;
203 expr.X_op = O_symbol;
204 expr.X_add_symbol = symbol;
205 expr.X_add_number = 0;
206 emit_expr (&expr, size);
208 #endif
210 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
212 static struct line_subseg *
213 get_line_subseg (segT seg, subsegT subseg)
215 static segT last_seg;
216 static subsegT last_subseg;
217 static struct line_subseg *last_line_subseg;
219 struct line_seg **ps, *s;
220 struct line_subseg **pss, *ss;
222 if (seg == last_seg && subseg == last_subseg)
223 return last_line_subseg;
225 for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next)
226 if (s->seg == seg)
227 goto found_seg;
229 s = (struct line_seg *) xmalloc (sizeof (*s));
230 s->next = NULL;
231 s->seg = seg;
232 s->head = NULL;
233 *ps = s;
235 found_seg:
236 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
238 if (ss->subseg == subseg)
239 goto found_subseg;
240 if (ss->subseg > subseg)
241 break;
244 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
245 ss->next = *pss;
246 ss->subseg = subseg;
247 ss->head = NULL;
248 ss->ptail = &ss->head;
249 *pss = ss;
251 found_subseg:
252 last_seg = seg;
253 last_subseg = subseg;
254 last_line_subseg = ss;
256 return ss;
259 /* Record an entry for LOC occurring at LABEL. */
261 static void
262 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
264 struct line_subseg *ss;
265 struct line_entry *e;
267 e = (struct line_entry *) xmalloc (sizeof (*e));
268 e->next = NULL;
269 e->label = label;
270 e->loc = *loc;
272 ss = get_line_subseg (now_seg, now_subseg);
273 *ss->ptail = e;
274 ss->ptail = &e->next;
277 /* Record an entry for LOC occurring at OFS within the current fragment. */
279 void
280 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
282 static unsigned int line = -1;
283 static unsigned int filenum = -1;
285 symbolS *sym;
287 /* Early out for as-yet incomplete location information. */
288 if (loc->filenum == 0 || loc->line == 0)
289 return;
291 /* Don't emit sequences of line symbols for the same line when the
292 symbols apply to assembler code. It is necessary to emit
293 duplicate line symbols when a compiler asks for them, because GDB
294 uses them to determine the end of the prologue. */
295 if (debug_type == DEBUG_DWARF2
296 && line == loc->line && filenum == loc->filenum)
297 return;
299 line = loc->line;
300 filenum = loc->filenum;
302 sym = symbol_temp_new (now_seg, ofs, frag_now);
303 dwarf2_gen_line_info_1 (sym, loc);
306 /* Returns the current source information. If .file directives have
307 been encountered, the info for the corresponding source file is
308 returned. Otherwise, the info for the assembly source file is
309 returned. */
311 void
312 dwarf2_where (struct dwarf2_line_info *line)
314 if (debug_type == DEBUG_DWARF2)
316 char *filename;
317 as_where (&filename, &line->line);
318 line->filenum = get_filenum (filename, 0);
319 line->column = 0;
320 line->flags = DWARF2_FLAG_IS_STMT;
321 line->isa = current.isa;
323 else
324 *line = current;
327 /* A hook to allow the target backend to inform the line number state
328 machine of isa changes when assembler debug info is enabled. */
330 void
331 dwarf2_set_isa (unsigned int isa)
333 current.isa = isa;
336 /* Called for each machine instruction, or relatively atomic group of
337 machine instructions (ie built-in macro). The instruction or group
338 is SIZE bytes in length. If dwarf2 line number generation is called
339 for, emit a line statement appropriately. */
341 void
342 dwarf2_emit_insn (int size)
344 struct dwarf2_line_info loc;
346 if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
347 return;
349 dwarf2_where (&loc);
351 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
352 dwarf2_consume_line_info ();
355 /* Called after the current line information has been either used with
356 dwarf2_gen_line_info or saved with a machine instruction for later use.
357 This resets the state of the line number information to reflect that
358 it has been used. */
360 void
361 dwarf2_consume_line_info (void)
363 /* Unless we generate DWARF2 debugging information for each
364 assembler line, we only emit one line symbol for one LOC. */
365 dwarf2_loc_directive_seen = FALSE;
367 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
368 | DWARF2_FLAG_PROLOGUE_END
369 | DWARF2_FLAG_EPILOGUE_BEGIN);
372 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
373 is enabled, emit a basic block marker. */
375 void
376 dwarf2_emit_label (symbolS *label)
378 struct dwarf2_line_info loc;
380 if (!dwarf2_loc_mark_labels)
381 return;
382 if (S_GET_SEGMENT (label) != now_seg)
383 return;
384 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
385 return;
386 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
387 return;
389 dwarf2_where (&loc);
391 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
393 dwarf2_gen_line_info_1 (label, &loc);
394 dwarf2_consume_line_info ();
397 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
398 allocate it on that file table slot, otherwise return the first
399 empty one. */
401 static unsigned int
402 get_filenum (const char *filename, unsigned int num)
404 static unsigned int last_used, last_used_dir_len;
405 const char *file;
406 size_t dir_len;
407 unsigned int i, dir;
409 if (num == 0 && last_used)
411 if (! files[last_used].dir
412 && strcmp (filename, files[last_used].filename) == 0)
413 return last_used;
414 if (files[last_used].dir
415 && strncmp (filename, dirs[files[last_used].dir],
416 last_used_dir_len) == 0
417 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
418 && strcmp (filename + last_used_dir_len + 1,
419 files[last_used].filename) == 0)
420 return last_used;
423 file = lbasename (filename);
424 /* Don't make empty string from / or A: from A:/ . */
425 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
426 if (file <= filename + 3)
427 file = filename;
428 #else
429 if (file == filename + 1)
430 file = filename;
431 #endif
432 dir_len = file - filename;
434 dir = 0;
435 if (dir_len)
437 --dir_len;
438 for (dir = 1; dir < dirs_in_use; ++dir)
439 if (strncmp (filename, dirs[dir], dir_len) == 0
440 && dirs[dir][dir_len] == '\0')
441 break;
443 if (dir >= dirs_in_use)
445 if (dir >= dirs_allocated)
447 dirs_allocated = dir + 32;
448 dirs = (char **)
449 xrealloc (dirs, (dir + 32) * sizeof (const char *));
452 dirs[dir] = xmalloc (dir_len + 1);
453 memcpy (dirs[dir], filename, dir_len);
454 dirs[dir][dir_len] = '\0';
455 dirs_in_use = dir + 1;
459 if (num == 0)
461 for (i = 1; i < files_in_use; ++i)
462 if (files[i].dir == dir
463 && files[i].filename
464 && strcmp (file, files[i].filename) == 0)
466 last_used = i;
467 last_used_dir_len = dir_len;
468 return i;
471 else
472 i = num;
474 if (i >= files_allocated)
476 unsigned int old = files_allocated;
478 files_allocated = i + 32;
479 files = (struct file_entry *)
480 xrealloc (files, (i + 32) * sizeof (struct file_entry));
482 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
485 files[i].filename = num ? file : xstrdup (file);
486 files[i].dir = dir;
487 if (files_in_use < i + 1)
488 files_in_use = i + 1;
489 last_used = i;
490 last_used_dir_len = dir_len;
492 return i;
495 /* Handle two forms of .file directive:
496 - Pass .file "source.c" to s_app_file
497 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
499 If an entry is added to the file table, return a pointer to the filename. */
501 char *
502 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
504 offsetT num;
505 char *filename;
506 int filename_len;
508 /* Continue to accept a bare string and pass it off. */
509 SKIP_WHITESPACE ();
510 if (*input_line_pointer == '"')
512 s_app_file (0);
513 return NULL;
516 num = get_absolute_expression ();
517 filename = demand_copy_C_string (&filename_len);
518 if (filename == NULL)
519 return NULL;
520 demand_empty_rest_of_line ();
522 if (num < 1)
524 as_bad (_("file number less than one"));
525 return NULL;
528 /* A .file directive implies compiler generated debug information is
529 being supplied. Turn off gas generated debug info. */
530 debug_type = DEBUG_NONE;
532 if (num < (int) files_in_use && files[num].filename != 0)
534 as_bad (_("file number %ld already allocated"), (long) num);
535 return NULL;
538 get_filenum (filename, num);
540 return filename;
543 void
544 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
546 offsetT filenum, line;
548 /* If we see two .loc directives in a row, force the first one to be
549 output now. */
550 if (dwarf2_loc_directive_seen)
551 dwarf2_emit_insn (0);
553 filenum = get_absolute_expression ();
554 SKIP_WHITESPACE ();
555 line = get_absolute_expression ();
557 if (filenum < 1)
559 as_bad (_("file number less than one"));
560 return;
562 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
564 as_bad (_("unassigned file number %ld"), (long) filenum);
565 return;
568 current.filenum = filenum;
569 current.line = line;
571 #ifndef NO_LISTING
572 if (listing)
574 if (files[filenum].dir)
576 size_t dir_len = strlen (dirs[files[filenum].dir]);
577 size_t file_len = strlen (files[filenum].filename);
578 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
580 memcpy (cp, dirs[files[filenum].dir], dir_len);
581 INSERT_DIR_SEPARATOR (cp, dir_len);
582 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
583 cp[dir_len + file_len + 1] = '\0';
584 listing_source_file (cp);
586 else
587 listing_source_file (files[filenum].filename);
588 listing_source_line (line);
590 #endif
592 SKIP_WHITESPACE ();
593 if (ISDIGIT (*input_line_pointer))
595 current.column = get_absolute_expression ();
596 SKIP_WHITESPACE ();
599 while (ISALPHA (*input_line_pointer))
601 char *p, c;
602 offsetT value;
604 p = input_line_pointer;
605 c = get_symbol_end ();
607 if (strcmp (p, "basic_block") == 0)
609 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
610 *input_line_pointer = c;
612 else if (strcmp (p, "prologue_end") == 0)
614 current.flags |= DWARF2_FLAG_PROLOGUE_END;
615 *input_line_pointer = c;
617 else if (strcmp (p, "epilogue_begin") == 0)
619 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
620 *input_line_pointer = c;
622 else if (strcmp (p, "is_stmt") == 0)
624 *input_line_pointer = c;
625 value = get_absolute_expression ();
626 if (value == 0)
627 current.flags &= ~DWARF2_FLAG_IS_STMT;
628 else if (value == 1)
629 current.flags |= DWARF2_FLAG_IS_STMT;
630 else
632 as_bad (_("is_stmt value not 0 or 1"));
633 return;
636 else if (strcmp (p, "isa") == 0)
638 *input_line_pointer = c;
639 value = get_absolute_expression ();
640 if (value >= 0)
641 current.isa = value;
642 else
644 as_bad (_("isa number less than zero"));
645 return;
648 else
650 as_bad (_("unknown .loc sub-directive `%s'"), p);
651 *input_line_pointer = c;
652 return;
655 SKIP_WHITESPACE ();
658 demand_empty_rest_of_line ();
659 dwarf2_loc_directive_seen = TRUE;
660 debug_type = DEBUG_NONE;
663 void
664 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
666 offsetT value = get_absolute_expression ();
668 if (value != 0 && value != 1)
670 as_bad (_("expected 0 or 1"));
671 ignore_rest_of_line ();
673 else
675 dwarf2_loc_mark_labels = value != 0;
676 demand_empty_rest_of_line ();
680 static struct frag *
681 first_frag_for_seg (segT seg)
683 return seg_info (seg)->frchainP->frch_root;
686 static struct frag *
687 last_frag_for_seg (segT seg)
689 frchainS *f = seg_info (seg)->frchainP;
691 while (f->frch_next != NULL)
692 f = f->frch_next;
694 return f->frch_last;
697 /* Emit a single byte into the current segment. */
699 static inline void
700 out_byte (int byte)
702 FRAG_APPEND_1_CHAR (byte);
705 /* Emit a statement program opcode into the current segment. */
707 static inline void
708 out_opcode (int opc)
710 out_byte (opc);
713 /* Emit a two-byte word into the current segment. */
715 static inline void
716 out_two (int data)
718 md_number_to_chars (frag_more (2), data, 2);
721 /* Emit a four byte word into the current segment. */
723 static inline void
724 out_four (int data)
726 md_number_to_chars (frag_more (4), data, 4);
729 /* Emit an unsigned "little-endian base 128" number. */
731 static void
732 out_uleb128 (addressT value)
734 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
737 /* Emit a tuple for .debug_abbrev. */
739 static inline void
740 out_abbrev (int name, int form)
742 out_uleb128 (name);
743 out_uleb128 (form);
746 /* Get the size of a fragment. */
748 static offsetT
749 get_frag_fix (fragS *frag, segT seg)
751 frchainS *fr;
753 if (frag->fr_next)
754 return frag->fr_fix;
756 /* If a fragment is the last in the chain, special measures must be
757 taken to find its size before relaxation, since it may be pending
758 on some subsegment chain. */
759 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
760 if (fr->frch_last == frag)
761 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
763 abort ();
766 /* Set an absolute address (may result in a relocation entry). */
768 static void
769 out_set_addr (symbolS *sym)
771 expressionS expr;
773 out_opcode (DW_LNS_extended_op);
774 out_uleb128 (sizeof_address + 1);
776 out_opcode (DW_LNE_set_address);
777 expr.X_op = O_symbol;
778 expr.X_add_symbol = sym;
779 expr.X_add_number = 0;
780 emit_expr (&expr, sizeof_address);
783 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
784 static void scale_addr_delta (addressT *);
786 static void
787 scale_addr_delta (addressT *addr_delta)
789 static int printed_this = 0;
790 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
792 if (!printed_this)
793 as_bad("unaligned opcodes detected in executable segment");
794 printed_this = 1;
796 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
798 #else
799 #define scale_addr_delta(A)
800 #endif
802 /* Encode a pair of line and address skips as efficiently as possible.
803 Note that the line skip is signed, whereas the address skip is unsigned.
805 The following two routines *must* be kept in sync. This is
806 enforced by making emit_inc_line_addr abort if we do not emit
807 exactly the expected number of bytes. */
809 static int
810 size_inc_line_addr (int line_delta, addressT addr_delta)
812 unsigned int tmp, opcode;
813 int len = 0;
815 /* Scale the address delta by the minimum instruction length. */
816 scale_addr_delta (&addr_delta);
818 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
819 We cannot use special opcodes here, since we want the end_sequence
820 to emit the matrix entry. */
821 if (line_delta == INT_MAX)
823 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
824 len = 1;
825 else
826 len = 1 + sizeof_leb128 (addr_delta, 0);
827 return len + 3;
830 /* Bias the line delta by the base. */
831 tmp = line_delta - DWARF2_LINE_BASE;
833 /* If the line increment is out of range of a special opcode, we
834 must encode it with DW_LNS_advance_line. */
835 if (tmp >= DWARF2_LINE_RANGE)
837 len = 1 + sizeof_leb128 (line_delta, 1);
838 line_delta = 0;
839 tmp = 0 - DWARF2_LINE_BASE;
842 /* Bias the opcode by the special opcode base. */
843 tmp += DWARF2_LINE_OPCODE_BASE;
845 /* Avoid overflow when addr_delta is large. */
846 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
848 /* Try using a special opcode. */
849 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
850 if (opcode <= 255)
851 return len + 1;
853 /* Try using DW_LNS_const_add_pc followed by special op. */
854 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
855 if (opcode <= 255)
856 return len + 2;
859 /* Otherwise use DW_LNS_advance_pc. */
860 len += 1 + sizeof_leb128 (addr_delta, 0);
862 /* DW_LNS_copy or special opcode. */
863 len += 1;
865 return len;
868 static void
869 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
871 unsigned int tmp, opcode;
872 int need_copy = 0;
873 char *end = p + len;
875 /* Line number sequences cannot go backward in addresses. This means
876 we've incorrectly ordered the statements in the sequence. */
877 assert ((offsetT) addr_delta >= 0);
879 /* Scale the address delta by the minimum instruction length. */
880 scale_addr_delta (&addr_delta);
882 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
883 We cannot use special opcodes here, since we want the end_sequence
884 to emit the matrix entry. */
885 if (line_delta == INT_MAX)
887 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
888 *p++ = DW_LNS_const_add_pc;
889 else
891 *p++ = DW_LNS_advance_pc;
892 p += output_leb128 (p, addr_delta, 0);
895 *p++ = DW_LNS_extended_op;
896 *p++ = 1;
897 *p++ = DW_LNE_end_sequence;
898 goto done;
901 /* Bias the line delta by the base. */
902 tmp = line_delta - DWARF2_LINE_BASE;
904 /* If the line increment is out of range of a special opcode, we
905 must encode it with DW_LNS_advance_line. */
906 if (tmp >= DWARF2_LINE_RANGE)
908 *p++ = DW_LNS_advance_line;
909 p += output_leb128 (p, line_delta, 1);
911 line_delta = 0;
912 tmp = 0 - DWARF2_LINE_BASE;
913 need_copy = 1;
916 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
917 special opcode. */
918 if (line_delta == 0 && addr_delta == 0)
920 *p++ = DW_LNS_copy;
921 goto done;
924 /* Bias the opcode by the special opcode base. */
925 tmp += DWARF2_LINE_OPCODE_BASE;
927 /* Avoid overflow when addr_delta is large. */
928 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
930 /* Try using a special opcode. */
931 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
932 if (opcode <= 255)
934 *p++ = opcode;
935 goto done;
938 /* Try using DW_LNS_const_add_pc followed by special op. */
939 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
940 if (opcode <= 255)
942 *p++ = DW_LNS_const_add_pc;
943 *p++ = opcode;
944 goto done;
948 /* Otherwise use DW_LNS_advance_pc. */
949 *p++ = DW_LNS_advance_pc;
950 p += output_leb128 (p, addr_delta, 0);
952 if (need_copy)
953 *p++ = DW_LNS_copy;
954 else
955 *p++ = tmp;
957 done:
958 assert (p == end);
961 /* Handy routine to combine calls to the above two routines. */
963 static void
964 out_inc_line_addr (int line_delta, addressT addr_delta)
966 int len = size_inc_line_addr (line_delta, addr_delta);
967 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
970 /* Write out an alternative form of line and address skips using
971 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
972 line and address information, but it is required if linker relaxation
973 could change the code offsets. The following two routines *must* be
974 kept in sync. */
976 static int
977 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
979 int len = 0;
981 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
982 if (line_delta != INT_MAX)
983 len = 1 + sizeof_leb128 (line_delta, 1);
985 if (addr_delta > 50000)
987 /* DW_LNS_extended_op */
988 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
989 /* DW_LNE_set_address */
990 len += 1 + sizeof_address;
992 else
993 /* DW_LNS_fixed_advance_pc */
994 len += 3;
996 if (line_delta == INT_MAX)
997 /* DW_LNS_extended_op + DW_LNE_end_sequence */
998 len += 3;
999 else
1000 /* DW_LNS_copy */
1001 len += 1;
1003 return len;
1006 static void
1007 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1008 char *p, int len)
1010 expressionS *exp;
1011 segT line_seg;
1012 char *end = p + len;
1014 /* Line number sequences cannot go backward in addresses. This means
1015 we've incorrectly ordered the statements in the sequence. */
1016 assert ((offsetT) addr_delta >= 0);
1018 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1019 if (line_delta != INT_MAX)
1021 *p++ = DW_LNS_advance_line;
1022 p += output_leb128 (p, line_delta, 1);
1025 exp = symbol_get_value_expression (frag->fr_symbol);
1026 line_seg = subseg_get (".debug_line", 0);
1028 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1029 advance the address by at most 64K. Linker relaxation (without
1030 which this function would not be used) could change the operand by
1031 an unknown amount. If the address increment is getting close to
1032 the limit, just reset the address. */
1033 if (addr_delta > 50000)
1035 symbolS *to_sym;
1036 expressionS expr;
1038 assert (exp->X_op = O_subtract);
1039 to_sym = exp->X_add_symbol;
1041 *p++ = DW_LNS_extended_op;
1042 p += output_leb128 (p, sizeof_address + 1, 0);
1043 *p++ = DW_LNE_set_address;
1044 expr.X_op = O_symbol;
1045 expr.X_add_symbol = to_sym;
1046 expr.X_add_number = 0;
1047 subseg_change (line_seg, 0);
1048 emit_expr_fix (&expr, sizeof_address, frag, p);
1049 p += sizeof_address;
1051 else
1053 *p++ = DW_LNS_fixed_advance_pc;
1054 subseg_change (line_seg, 0);
1055 emit_expr_fix (exp, 2, frag, p);
1056 p += 2;
1059 if (line_delta == INT_MAX)
1061 *p++ = DW_LNS_extended_op;
1062 *p++ = 1;
1063 *p++ = DW_LNE_end_sequence;
1065 else
1066 *p++ = DW_LNS_copy;
1068 assert (p == end);
1071 /* Generate a variant frag that we can use to relax address/line
1072 increments between fragments of the target segment. */
1074 static void
1075 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1077 expressionS expr;
1078 int max_chars;
1080 expr.X_op = O_subtract;
1081 expr.X_add_symbol = to_sym;
1082 expr.X_op_symbol = from_sym;
1083 expr.X_add_number = 0;
1085 /* The maximum size of the frag is the line delta with a maximum
1086 sized address delta. */
1087 if (DWARF2_USE_FIXED_ADVANCE_PC)
1088 max_chars = size_fixed_inc_line_addr (line_delta,
1089 -DWARF2_LINE_MIN_INSN_LENGTH);
1090 else
1091 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1093 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1094 make_expr_symbol (&expr), line_delta, NULL);
1097 /* The function estimates the size of a rs_dwarf2dbg variant frag
1098 based on the current values of the symbols. It is called before
1099 the relaxation loop. We set fr_subtype to the expected length. */
1102 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1104 offsetT addr_delta;
1105 int size;
1107 addr_delta = resolve_symbol_value (frag->fr_symbol);
1108 if (DWARF2_USE_FIXED_ADVANCE_PC)
1109 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1110 else
1111 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1113 frag->fr_subtype = size;
1115 return size;
1118 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1119 current values of the symbols. fr_subtype is the current length
1120 of the frag. This returns the change in frag length. */
1123 dwarf2dbg_relax_frag (fragS *frag)
1125 int old_size, new_size;
1127 old_size = frag->fr_subtype;
1128 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1130 return new_size - old_size;
1133 /* This function converts a rs_dwarf2dbg variant frag into a normal
1134 fill frag. This is called after all relaxation has been done.
1135 fr_subtype will be the desired length of the frag. */
1137 void
1138 dwarf2dbg_convert_frag (fragS *frag)
1140 offsetT addr_diff;
1142 addr_diff = resolve_symbol_value (frag->fr_symbol);
1144 /* fr_var carries the max_chars that we created the fragment with.
1145 fr_subtype carries the current expected length. We must, of
1146 course, have allocated enough memory earlier. */
1147 assert (frag->fr_var >= (int) frag->fr_subtype);
1149 if (DWARF2_USE_FIXED_ADVANCE_PC)
1150 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1151 frag->fr_literal + frag->fr_fix,
1152 frag->fr_subtype);
1153 else
1154 emit_inc_line_addr (frag->fr_offset, addr_diff,
1155 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1157 frag->fr_fix += frag->fr_subtype;
1158 frag->fr_type = rs_fill;
1159 frag->fr_var = 0;
1160 frag->fr_offset = 0;
1163 /* Generate .debug_line content for the chain of line number entries
1164 beginning at E, for segment SEG. */
1166 static void
1167 process_entries (segT seg, struct line_entry *e)
1169 unsigned filenum = 1;
1170 unsigned line = 1;
1171 unsigned column = 0;
1172 unsigned isa = 0;
1173 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1174 fragS *last_frag = NULL, *frag;
1175 addressT last_frag_ofs = 0, frag_ofs;
1176 symbolS *last_lab = NULL, *lab;
1177 struct line_entry *next;
1181 int line_delta;
1183 if (filenum != e->loc.filenum)
1185 filenum = e->loc.filenum;
1186 out_opcode (DW_LNS_set_file);
1187 out_uleb128 (filenum);
1190 if (column != e->loc.column)
1192 column = e->loc.column;
1193 out_opcode (DW_LNS_set_column);
1194 out_uleb128 (column);
1197 if (isa != e->loc.isa)
1199 isa = e->loc.isa;
1200 out_opcode (DW_LNS_set_isa);
1201 out_uleb128 (isa);
1204 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1206 flags = e->loc.flags;
1207 out_opcode (DW_LNS_negate_stmt);
1210 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1211 out_opcode (DW_LNS_set_basic_block);
1213 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1214 out_opcode (DW_LNS_set_prologue_end);
1216 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1217 out_opcode (DW_LNS_set_epilogue_begin);
1219 /* Don't try to optimize away redundant entries; gdb wants two
1220 entries for a function where the code starts on the same line as
1221 the {, and there's no way to identify that case here. Trust gcc
1222 to optimize appropriately. */
1223 line_delta = e->loc.line - line;
1224 lab = e->label;
1225 frag = symbol_get_frag (lab);
1226 frag_ofs = S_GET_VALUE (lab);
1228 if (last_frag == NULL)
1230 out_set_addr (lab);
1231 out_inc_line_addr (line_delta, 0);
1233 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1234 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1235 else
1236 relax_inc_line_addr (line_delta, lab, last_lab);
1238 line = e->loc.line;
1239 last_lab = lab;
1240 last_frag = frag;
1241 last_frag_ofs = frag_ofs;
1243 next = e->next;
1244 free (e);
1245 e = next;
1247 while (e);
1249 /* Emit a DW_LNE_end_sequence for the end of the section. */
1250 frag = last_frag_for_seg (seg);
1251 frag_ofs = get_frag_fix (frag, seg);
1252 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1253 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1254 else
1256 lab = symbol_temp_new (seg, frag_ofs, frag);
1257 relax_inc_line_addr (INT_MAX, lab, last_lab);
1261 /* Emit the directory and file tables for .debug_line. */
1263 static void
1264 out_file_list (void)
1266 size_t size;
1267 const char *dir;
1268 char *cp;
1269 unsigned int i;
1271 /* Emit directory list. */
1272 for (i = 1; i < dirs_in_use; ++i)
1274 dir = remap_debug_filename (dirs[i]);
1275 size = strlen (dir) + 1;
1276 cp = frag_more (size);
1277 memcpy (cp, dir, size);
1279 /* Terminate it. */
1280 out_byte ('\0');
1282 for (i = 1; i < files_in_use; ++i)
1284 if (files[i].filename == NULL)
1286 as_bad (_("unassigned file number %ld"), (long) i);
1287 /* Prevent a crash later, particularly for file 1. */
1288 files[i].filename = "";
1289 continue;
1292 size = strlen (files[i].filename) + 1;
1293 cp = frag_more (size);
1294 memcpy (cp, files[i].filename, size);
1296 out_uleb128 (files[i].dir); /* directory number */
1297 out_uleb128 (0); /* last modification timestamp */
1298 out_uleb128 (0); /* filesize */
1301 /* Terminate filename list. */
1302 out_byte (0);
1305 /* Switch to SEC and output a header length field. Return the size of
1306 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1307 to the end of the section. */
1309 static int
1310 out_header (asection *sec, expressionS *expr)
1312 symbolS *start_sym;
1313 symbolS *end_sym;
1315 subseg_set (sec, 0);
1316 start_sym = symbol_temp_new_now ();;
1317 end_sym = symbol_temp_make ();
1319 /* Total length of the information. */
1320 expr->X_op = O_subtract;
1321 expr->X_add_symbol = end_sym;
1322 expr->X_op_symbol = start_sym;
1324 switch (DWARF2_FORMAT (sec))
1326 case dwarf2_format_32bit:
1327 expr->X_add_number = -4;
1328 emit_expr (expr, 4);
1329 return 4;
1331 case dwarf2_format_64bit:
1332 expr->X_add_number = -12;
1333 out_four (-1);
1334 emit_expr (expr, 8);
1335 return 8;
1337 case dwarf2_format_64bit_irix:
1338 expr->X_add_number = -8;
1339 emit_expr (expr, 8);
1340 return 8;
1343 as_fatal (_("internal error: unknown dwarf2 format"));
1344 return 0;
1347 /* Emit the collected .debug_line data. */
1349 static void
1350 out_debug_line (segT line_seg)
1352 expressionS expr;
1353 symbolS *prologue_end;
1354 symbolS *line_end;
1355 struct line_seg *s;
1356 int sizeof_offset;
1358 sizeof_offset = out_header (line_seg, &expr);
1359 line_end = expr.X_add_symbol;
1361 /* Version. */
1362 out_two (2);
1364 /* Length of the prologue following this length. */
1365 prologue_end = symbol_temp_make ();
1366 expr.X_add_symbol = prologue_end;
1367 expr.X_add_number = - (4 + 2 + 4);
1368 emit_expr (&expr, sizeof_offset);
1370 /* Parameters of the state machine. */
1371 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1372 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1373 out_byte (DWARF2_LINE_BASE);
1374 out_byte (DWARF2_LINE_RANGE);
1375 out_byte (DWARF2_LINE_OPCODE_BASE);
1377 /* Standard opcode lengths. */
1378 out_byte (0); /* DW_LNS_copy */
1379 out_byte (1); /* DW_LNS_advance_pc */
1380 out_byte (1); /* DW_LNS_advance_line */
1381 out_byte (1); /* DW_LNS_set_file */
1382 out_byte (1); /* DW_LNS_set_column */
1383 out_byte (0); /* DW_LNS_negate_stmt */
1384 out_byte (0); /* DW_LNS_set_basic_block */
1385 out_byte (0); /* DW_LNS_const_add_pc */
1386 out_byte (1); /* DW_LNS_fixed_advance_pc */
1387 out_byte (0); /* DW_LNS_set_prologue_end */
1388 out_byte (0); /* DW_LNS_set_epilogue_begin */
1389 out_byte (1); /* DW_LNS_set_isa */
1391 out_file_list ();
1393 symbol_set_value_now (prologue_end);
1395 /* For each section, emit a statement program. */
1396 for (s = all_segs; s; s = s->next)
1397 process_entries (s->seg, s->head->head);
1399 symbol_set_value_now (line_end);
1402 static void
1403 out_debug_ranges (segT ranges_seg)
1405 unsigned int addr_size = sizeof_address;
1406 struct line_seg *s;
1407 expressionS expr;
1408 unsigned int i;
1410 subseg_set (ranges_seg, 0);
1412 /* Base Address Entry. */
1413 for (i = 0; i < addr_size; i++)
1414 out_byte (0xff);
1415 for (i = 0; i < addr_size; i++)
1416 out_byte (0);
1418 /* Range List Entry. */
1419 for (s = all_segs; s; s = s->next)
1421 fragS *frag;
1422 symbolS *beg, *end;
1424 frag = first_frag_for_seg (s->seg);
1425 beg = symbol_temp_new (s->seg, 0, frag);
1426 s->text_start = beg;
1428 frag = last_frag_for_seg (s->seg);
1429 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1430 s->text_end = end;
1432 expr.X_op = O_symbol;
1433 expr.X_add_symbol = beg;
1434 expr.X_add_number = 0;
1435 emit_expr (&expr, addr_size);
1437 expr.X_op = O_symbol;
1438 expr.X_add_symbol = end;
1439 expr.X_add_number = 0;
1440 emit_expr (&expr, addr_size);
1443 /* End of Range Entry. */
1444 for (i = 0; i < addr_size; i++)
1445 out_byte (0);
1446 for (i = 0; i < addr_size; i++)
1447 out_byte (0);
1450 /* Emit data for .debug_aranges. */
1452 static void
1453 out_debug_aranges (segT aranges_seg, segT info_seg)
1455 unsigned int addr_size = sizeof_address;
1456 struct line_seg *s;
1457 expressionS expr;
1458 symbolS *aranges_end;
1459 char *p;
1460 int sizeof_offset;
1462 sizeof_offset = out_header (aranges_seg, &expr);
1463 aranges_end = expr.X_add_symbol;
1465 /* Version. */
1466 out_two (2);
1468 /* Offset to .debug_info. */
1469 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1471 /* Size of an address (offset portion). */
1472 out_byte (addr_size);
1474 /* Size of a segment descriptor. */
1475 out_byte (0);
1477 /* Align the header. */
1478 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1480 for (s = all_segs; s; s = s->next)
1482 fragS *frag;
1483 symbolS *beg, *end;
1485 frag = first_frag_for_seg (s->seg);
1486 beg = symbol_temp_new (s->seg, 0, frag);
1487 s->text_start = beg;
1489 frag = last_frag_for_seg (s->seg);
1490 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1491 s->text_end = end;
1493 expr.X_op = O_symbol;
1494 expr.X_add_symbol = beg;
1495 expr.X_add_number = 0;
1496 emit_expr (&expr, addr_size);
1498 expr.X_op = O_subtract;
1499 expr.X_add_symbol = end;
1500 expr.X_op_symbol = beg;
1501 expr.X_add_number = 0;
1502 emit_expr (&expr, addr_size);
1505 p = frag_more (2 * addr_size);
1506 md_number_to_chars (p, 0, addr_size);
1507 md_number_to_chars (p + addr_size, 0, addr_size);
1509 symbol_set_value_now (aranges_end);
1512 /* Emit data for .debug_abbrev. Note that this must be kept in
1513 sync with out_debug_info below. */
1515 static void
1516 out_debug_abbrev (segT abbrev_seg,
1517 segT info_seg ATTRIBUTE_UNUSED,
1518 segT line_seg ATTRIBUTE_UNUSED)
1520 subseg_set (abbrev_seg, 0);
1522 out_uleb128 (1);
1523 out_uleb128 (DW_TAG_compile_unit);
1524 out_byte (DW_CHILDREN_no);
1525 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1526 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1527 else
1528 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1529 if (all_segs->next == NULL)
1531 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1532 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1534 else
1536 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1537 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1538 else
1539 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1541 out_abbrev (DW_AT_name, DW_FORM_string);
1542 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1543 out_abbrev (DW_AT_producer, DW_FORM_string);
1544 out_abbrev (DW_AT_language, DW_FORM_data2);
1545 out_abbrev (0, 0);
1547 /* Terminate the abbreviations for this compilation unit. */
1548 out_byte (0);
1551 /* Emit a description of this compilation unit for .debug_info. */
1553 static void
1554 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1556 char producer[128];
1557 const char *comp_dir;
1558 const char *dirname;
1559 expressionS expr;
1560 symbolS *info_end;
1561 char *p;
1562 int len;
1563 int sizeof_offset;
1565 sizeof_offset = out_header (info_seg, &expr);
1566 info_end = expr.X_add_symbol;
1568 /* DWARF version. */
1569 out_two (2);
1571 /* .debug_abbrev offset */
1572 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1574 /* Target address size. */
1575 out_byte (sizeof_address);
1577 /* DW_TAG_compile_unit DIE abbrev */
1578 out_uleb128 (1);
1580 /* DW_AT_stmt_list */
1581 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
1582 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
1583 ? 4 : 8));
1585 /* These two attributes are emitted if all of the code is contiguous. */
1586 if (all_segs->next == NULL)
1588 /* DW_AT_low_pc */
1589 expr.X_op = O_symbol;
1590 expr.X_add_symbol = all_segs->text_start;
1591 expr.X_add_number = 0;
1592 emit_expr (&expr, sizeof_address);
1594 /* DW_AT_high_pc */
1595 expr.X_op = O_symbol;
1596 expr.X_add_symbol = all_segs->text_end;
1597 expr.X_add_number = 0;
1598 emit_expr (&expr, sizeof_address);
1600 else
1602 /* This attribute is emitted if the code is disjoint. */
1603 /* DW_AT_ranges. */
1604 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1607 /* DW_AT_name. We don't have the actual file name that was present
1608 on the command line, so assume files[1] is the main input file.
1609 We're not supposed to get called unless at least one line number
1610 entry was emitted, so this should always be defined. */
1611 if (files_in_use == 0)
1612 abort ();
1613 if (files[1].dir)
1615 dirname = remap_debug_filename (dirs[files[1].dir]);
1616 len = strlen (dirname);
1617 p = frag_more (len + 1);
1618 memcpy (p, dirname, len);
1619 INSERT_DIR_SEPARATOR (p, len);
1621 len = strlen (files[1].filename) + 1;
1622 p = frag_more (len);
1623 memcpy (p, files[1].filename, len);
1625 /* DW_AT_comp_dir */
1626 comp_dir = remap_debug_filename (getpwd ());
1627 len = strlen (comp_dir) + 1;
1628 p = frag_more (len);
1629 memcpy (p, comp_dir, len);
1631 /* DW_AT_producer */
1632 sprintf (producer, "GNU AS %s", VERSION);
1633 len = strlen (producer) + 1;
1634 p = frag_more (len);
1635 memcpy (p, producer, len);
1637 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1638 dwarf2 draft has no standard code for assembler. */
1639 out_two (DW_LANG_Mips_Assembler);
1641 symbol_set_value_now (info_end);
1644 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1645 were any .file/.loc directives, or --gdwarf2 was given, or if the
1646 file has a non-empty .debug_info section. If we emit .debug_line,
1647 and the .debug_info section is empty, we also emit .debug_info,
1648 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1649 there were any .file/.loc directives, or --gdwarf2 was given and
1650 there were any located instructions emitted. */
1652 void
1653 dwarf2_finish (void)
1655 segT line_seg;
1656 struct line_seg *s;
1657 segT info_seg;
1658 int emit_other_sections = 0;
1660 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1661 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1663 if (!all_segs && emit_other_sections)
1664 /* There is no line information and no non-empty .debug_info
1665 section. */
1666 return;
1668 /* Calculate the size of an address for the target machine. */
1669 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1671 /* Create and switch to the line number section. */
1672 line_seg = subseg_new (".debug_line", 0);
1673 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1675 /* For each subsection, chain the debug entries together. */
1676 for (s = all_segs; s; s = s->next)
1678 struct line_subseg *ss = s->head;
1679 struct line_entry **ptail = ss->ptail;
1681 while ((ss = ss->next) != NULL)
1683 *ptail = ss->head;
1684 ptail = ss->ptail;
1688 out_debug_line (line_seg);
1690 /* If this is assembler generated line info, and there is no
1691 debug_info already, we need .debug_info and .debug_abbrev
1692 sections as well. */
1693 if (emit_other_sections)
1695 segT abbrev_seg;
1696 segT aranges_seg;
1697 segT ranges_seg;
1699 assert (all_segs);
1701 info_seg = subseg_new (".debug_info", 0);
1702 abbrev_seg = subseg_new (".debug_abbrev", 0);
1703 aranges_seg = subseg_new (".debug_aranges", 0);
1705 bfd_set_section_flags (stdoutput, info_seg,
1706 SEC_READONLY | SEC_DEBUGGING);
1707 bfd_set_section_flags (stdoutput, abbrev_seg,
1708 SEC_READONLY | SEC_DEBUGGING);
1709 bfd_set_section_flags (stdoutput, aranges_seg,
1710 SEC_READONLY | SEC_DEBUGGING);
1712 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1714 if (all_segs->next == NULL)
1715 ranges_seg = NULL;
1716 else
1718 ranges_seg = subseg_new (".debug_ranges", 0);
1719 bfd_set_section_flags (stdoutput, ranges_seg,
1720 SEC_READONLY | SEC_DEBUGGING);
1721 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1722 out_debug_ranges (ranges_seg);
1725 out_debug_aranges (aranges_seg, info_seg);
1726 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
1727 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);