daily update
[binutils.git] / gas / dwarf2dbg.c
blob39e434c012fea69c0eb0314c606db26a40dfae81
1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
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() 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 static bfd_boolean 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 struct line_subseg *get_line_subseg (segT, subsegT);
192 static unsigned int get_filenum (const char *, unsigned int);
193 static struct frag *first_frag_for_seg (segT);
194 static struct frag *last_frag_for_seg (segT);
195 static void out_byte (int);
196 static void out_opcode (int);
197 static void out_two (int);
198 static void out_four (int);
199 static void out_abbrev (int, int);
200 static void out_uleb128 (addressT);
201 static void out_sleb128 (addressT);
202 static offsetT get_frag_fix (fragS *, segT);
203 static void out_set_addr (symbolS *);
204 static int size_inc_line_addr (int, addressT);
205 static void emit_inc_line_addr (int, addressT, char *, int);
206 static void out_inc_line_addr (int, addressT);
207 static void out_fixed_inc_line_addr (int, symbolS *, symbolS *);
208 static void relax_inc_line_addr (int, symbolS *, symbolS *);
209 static void process_entries (segT, struct line_entry *);
210 static void out_file_list (void);
211 static void out_debug_line (segT);
212 static void out_debug_aranges (segT, segT);
213 static void out_debug_abbrev (segT);
215 #ifndef TC_DWARF2_EMIT_OFFSET
216 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
218 /* Create an offset to .dwarf2_*. */
220 static void
221 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
223 expressionS expr;
225 expr.X_op = O_symbol;
226 expr.X_add_symbol = symbol;
227 expr.X_add_number = 0;
228 emit_expr (&expr, size);
230 #endif
232 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
234 static struct line_subseg *
235 get_line_subseg (segT seg, subsegT subseg)
237 static segT last_seg;
238 static subsegT last_subseg;
239 static struct line_subseg *last_line_subseg;
241 struct line_seg **ps, *s;
242 struct line_subseg **pss, *ss;
244 if (seg == last_seg && subseg == last_subseg)
245 return last_line_subseg;
247 for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next)
248 if (s->seg == seg)
249 goto found_seg;
251 s = (struct line_seg *) xmalloc (sizeof (*s));
252 s->next = NULL;
253 s->seg = seg;
254 s->head = NULL;
255 *ps = s;
257 found_seg:
258 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
260 if (ss->subseg == subseg)
261 goto found_subseg;
262 if (ss->subseg > subseg)
263 break;
266 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
267 ss->next = *pss;
268 ss->subseg = subseg;
269 ss->head = NULL;
270 ss->ptail = &ss->head;
271 *pss = ss;
273 found_subseg:
274 last_seg = seg;
275 last_subseg = subseg;
276 last_line_subseg = ss;
278 return ss;
281 /* Record an entry for LOC occurring at LABEL. */
283 static void
284 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
286 struct line_subseg *ss;
287 struct line_entry *e;
289 e = (struct line_entry *) xmalloc (sizeof (*e));
290 e->next = NULL;
291 e->label = label;
292 e->loc = *loc;
294 ss = get_line_subseg (now_seg, now_subseg);
295 *ss->ptail = e;
296 ss->ptail = &e->next;
299 /* Record an entry for LOC occurring at OFS within the current fragment. */
301 void
302 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
304 static unsigned int line = -1;
305 static unsigned int filenum = -1;
307 symbolS *sym;
309 /* Early out for as-yet incomplete location information. */
310 if (loc->filenum == 0 || loc->line == 0)
311 return;
313 /* Don't emit sequences of line symbols for the same line when the
314 symbols apply to assembler code. It is necessary to emit
315 duplicate line symbols when a compiler asks for them, because GDB
316 uses them to determine the end of the prologue. */
317 if (debug_type == DEBUG_DWARF2
318 && line == loc->line && filenum == loc->filenum)
319 return;
321 line = loc->line;
322 filenum = loc->filenum;
324 sym = symbol_temp_new (now_seg, ofs, frag_now);
325 dwarf2_gen_line_info_1 (sym, loc);
328 /* Returns the current source information. If .file directives have
329 been encountered, the info for the corresponding source file is
330 returned. Otherwise, the info for the assembly source file is
331 returned. */
333 void
334 dwarf2_where (struct dwarf2_line_info *line)
336 if (debug_type == DEBUG_DWARF2)
338 char *filename;
339 as_where (&filename, &line->line);
340 line->filenum = get_filenum (filename, 0);
341 line->column = 0;
342 line->flags = DWARF2_FLAG_IS_STMT;
343 line->isa = current.isa;
345 else
346 *line = current;
349 /* A hook to allow the target backend to inform the line number state
350 machine of isa changes when assembler debug info is enabled. */
352 void
353 dwarf2_set_isa (unsigned int isa)
355 current.isa = isa;
358 /* Called for each machine instruction, or relatively atomic group of
359 machine instructions (ie built-in macro). The instruction or group
360 is SIZE bytes in length. If dwarf2 line number generation is called
361 for, emit a line statement appropriately. */
363 void
364 dwarf2_emit_insn (int size)
366 struct dwarf2_line_info loc;
368 if (loc_directive_seen)
370 /* Use the last location established by a .loc directive, not
371 the value returned by dwarf2_where(). That calls as_where()
372 which will return either the logical input file name (foo.c)
373 or the physical input file name (foo.s) and not the file name
374 specified in the most recent .loc directive (eg foo.h). */
375 loc = current;
377 /* Unless we generate DWARF2 debugging information for each
378 assembler line, we only emit one line symbol for one LOC. */
379 if (debug_type != DEBUG_DWARF2)
380 loc_directive_seen = FALSE;
382 else if (debug_type != DEBUG_DWARF2)
383 return;
384 else
385 dwarf2_where (&loc);
387 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
389 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
390 | DWARF2_FLAG_PROLOGUE_END
391 | DWARF2_FLAG_EPILOGUE_BEGIN);
394 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
395 is enabled, emit a basic block marker. */
397 void
398 dwarf2_emit_label (symbolS *label)
400 struct dwarf2_line_info loc;
402 if (!dwarf2_loc_mark_labels)
403 return;
404 if (S_GET_SEGMENT (label) != now_seg)
405 return;
406 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
407 return;
409 if (debug_type == DEBUG_DWARF2)
410 dwarf2_where (&loc);
411 else
413 loc = current;
414 loc_directive_seen = FALSE;
417 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
419 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
420 | DWARF2_FLAG_PROLOGUE_END
421 | DWARF2_FLAG_EPILOGUE_BEGIN);
423 dwarf2_gen_line_info_1 (label, &loc);
426 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
427 allocate it on that file table slot, otherwise return the first
428 empty one. */
430 static unsigned int
431 get_filenum (const char *filename, unsigned int num)
433 static unsigned int last_used, last_used_dir_len;
434 const char *file;
435 size_t dir_len;
436 unsigned int i, dir;
438 if (num == 0 && last_used)
440 if (! files[last_used].dir
441 && strcmp (filename, files[last_used].filename) == 0)
442 return last_used;
443 if (files[last_used].dir
444 && strncmp (filename, dirs[files[last_used].dir],
445 last_used_dir_len) == 0
446 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
447 && strcmp (filename + last_used_dir_len + 1,
448 files[last_used].filename) == 0)
449 return last_used;
452 file = lbasename (filename);
453 /* Don't make empty string from / or A: from A:/ . */
454 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
455 if (file <= filename + 3)
456 file = filename;
457 #else
458 if (file == filename + 1)
459 file = filename;
460 #endif
461 dir_len = file - filename;
463 dir = 0;
464 if (dir_len)
466 --dir_len;
467 for (dir = 1; dir < dirs_in_use; ++dir)
468 if (strncmp (filename, dirs[dir], dir_len) == 0
469 && dirs[dir][dir_len] == '\0')
470 break;
472 if (dir >= dirs_in_use)
474 if (dir >= dirs_allocated)
476 dirs_allocated = dir + 32;
477 dirs = (char **)
478 xrealloc (dirs, (dir + 32) * sizeof (const char *));
481 dirs[dir] = xmalloc (dir_len + 1);
482 memcpy (dirs[dir], filename, dir_len);
483 dirs[dir][dir_len] = '\0';
484 dirs_in_use = dir + 1;
488 if (num == 0)
490 for (i = 1; i < files_in_use; ++i)
491 if (files[i].dir == dir
492 && files[i].filename
493 && strcmp (file, files[i].filename) == 0)
495 last_used = i;
496 last_used_dir_len = dir_len;
497 return i;
500 else
501 i = num;
503 if (i >= files_allocated)
505 unsigned int old = files_allocated;
507 files_allocated = i + 32;
508 files = (struct file_entry *)
509 xrealloc (files, (i + 32) * sizeof (struct file_entry));
511 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
514 files[i].filename = num ? file : xstrdup (file);
515 files[i].dir = dir;
516 if (files_in_use < i + 1)
517 files_in_use = i + 1;
518 last_used = i;
519 last_used_dir_len = dir_len;
521 return i;
524 /* Handle two forms of .file directive:
525 - Pass .file "source.c" to s_app_file
526 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
528 If an entry is added to the file table, return a pointer to the filename. */
530 char *
531 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
533 offsetT num;
534 char *filename;
535 int filename_len;
537 /* Continue to accept a bare string and pass it off. */
538 SKIP_WHITESPACE ();
539 if (*input_line_pointer == '"')
541 s_app_file (0);
542 return NULL;
545 num = get_absolute_expression ();
546 filename = demand_copy_C_string (&filename_len);
547 if (filename == NULL)
548 return NULL;
549 demand_empty_rest_of_line ();
551 if (num < 1)
553 as_bad (_("file number less than one"));
554 return NULL;
557 if (num < (int) files_in_use && files[num].filename != 0)
559 as_bad (_("file number %ld already allocated"), (long) num);
560 return NULL;
563 get_filenum (filename, num);
565 return filename;
568 void
569 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
571 offsetT filenum, line;
573 /* If we see two .loc directives in a row, force the first one to be
574 output now. */
575 if (loc_directive_seen)
576 dwarf2_emit_insn (0);
578 filenum = get_absolute_expression ();
579 SKIP_WHITESPACE ();
580 line = get_absolute_expression ();
582 if (filenum < 1)
584 as_bad (_("file number less than one"));
585 return;
587 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
589 as_bad (_("unassigned file number %ld"), (long) filenum);
590 return;
593 current.filenum = filenum;
594 current.line = line;
596 #ifndef NO_LISTING
597 if (listing)
599 if (files[filenum].dir)
601 size_t dir_len = strlen (dirs[files[filenum].dir]);
602 size_t file_len = strlen (files[filenum].filename);
603 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
605 memcpy (cp, dirs[files[filenum].dir], dir_len);
606 INSERT_DIR_SEPARATOR (cp, dir_len);
607 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
608 cp[dir_len + file_len + 1] = '\0';
609 listing_source_file (cp);
611 else
612 listing_source_file (files[filenum].filename);
613 listing_source_line (line);
615 #endif
617 SKIP_WHITESPACE ();
618 if (ISDIGIT (*input_line_pointer))
620 current.column = get_absolute_expression ();
621 SKIP_WHITESPACE ();
624 while (ISALPHA (*input_line_pointer))
626 char *p, c;
627 offsetT value;
629 p = input_line_pointer;
630 c = get_symbol_end ();
632 if (strcmp (p, "basic_block") == 0)
634 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
635 *input_line_pointer = c;
637 else if (strcmp (p, "prologue_end") == 0)
639 current.flags |= DWARF2_FLAG_PROLOGUE_END;
640 *input_line_pointer = c;
642 else if (strcmp (p, "epilogue_begin") == 0)
644 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
645 *input_line_pointer = c;
647 else if (strcmp (p, "is_stmt") == 0)
649 *input_line_pointer = c;
650 value = get_absolute_expression ();
651 if (value == 0)
652 current.flags &= ~DWARF2_FLAG_IS_STMT;
653 else if (value == 1)
654 current.flags |= DWARF2_FLAG_IS_STMT;
655 else
657 as_bad (_("is_stmt value not 0 or 1"));
658 return;
661 else if (strcmp (p, "isa") == 0)
663 *input_line_pointer = c;
664 value = get_absolute_expression ();
665 if (value >= 0)
666 current.isa = value;
667 else
669 as_bad (_("isa number less than zero"));
670 return;
673 else
675 as_bad (_("unknown .loc sub-directive `%s'"), p);
676 *input_line_pointer = c;
677 return;
680 SKIP_WHITESPACE ();
683 demand_empty_rest_of_line ();
684 loc_directive_seen = TRUE;
687 void
688 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
690 offsetT value = get_absolute_expression ();
692 if (value != 0 && value != 1)
694 as_bad (_("expected 0 or 1"));
695 ignore_rest_of_line ();
697 else
699 dwarf2_loc_mark_labels = value != 0;
700 demand_empty_rest_of_line ();
704 static struct frag *
705 first_frag_for_seg (segT seg)
707 return seg_info (seg)->frchainP->frch_root;
710 static struct frag *
711 last_frag_for_seg (segT seg)
713 frchainS *f = seg_info (seg)->frchainP;
715 while (f->frch_next != NULL)
716 f = f->frch_next;
718 return f->frch_last;
721 /* Emit a single byte into the current segment. */
723 static inline void
724 out_byte (int byte)
726 FRAG_APPEND_1_CHAR (byte);
729 /* Emit a statement program opcode into the current segment. */
731 static inline void
732 out_opcode (int opc)
734 out_byte (opc);
737 /* Emit a two-byte word into the current segment. */
739 static inline void
740 out_two (int data)
742 md_number_to_chars (frag_more (2), data, 2);
745 /* Emit a four byte word into the current segment. */
747 static inline void
748 out_four (int data)
750 md_number_to_chars (frag_more (4), data, 4);
753 /* Emit an unsigned "little-endian base 128" number. */
755 static void
756 out_uleb128 (addressT value)
758 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
761 /* Emit a signed "little-endian base 128" number. */
763 static void
764 out_sleb128 (addressT value)
766 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
769 /* Emit a tuple for .debug_abbrev. */
771 static inline void
772 out_abbrev (int name, int form)
774 out_uleb128 (name);
775 out_uleb128 (form);
778 /* Get the size of a fragment. */
780 static offsetT
781 get_frag_fix (fragS *frag, segT seg)
783 frchainS *fr;
785 if (frag->fr_next)
786 return frag->fr_fix;
788 /* If a fragment is the last in the chain, special measures must be
789 taken to find its size before relaxation, since it may be pending
790 on some subsegment chain. */
791 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
792 if (fr->frch_last == frag)
793 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
795 abort ();
798 /* Set an absolute address (may result in a relocation entry). */
800 static void
801 out_set_addr (symbolS *sym)
803 expressionS expr;
805 out_opcode (DW_LNS_extended_op);
806 out_uleb128 (sizeof_address + 1);
808 out_opcode (DW_LNE_set_address);
809 expr.X_op = O_symbol;
810 expr.X_add_symbol = sym;
811 expr.X_add_number = 0;
812 emit_expr (&expr, sizeof_address);
815 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
816 static void scale_addr_delta (addressT *);
818 static void
819 scale_addr_delta (addressT *addr_delta)
821 static int printed_this = 0;
822 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
824 if (!printed_this)
825 as_bad("unaligned opcodes detected in executable segment");
826 printed_this = 1;
828 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
830 #else
831 #define scale_addr_delta(A)
832 #endif
834 /* Encode a pair of line and address skips as efficiently as possible.
835 Note that the line skip is signed, whereas the address skip is unsigned.
837 The following two routines *must* be kept in sync. This is
838 enforced by making emit_inc_line_addr abort if we do not emit
839 exactly the expected number of bytes. */
841 static int
842 size_inc_line_addr (int line_delta, addressT addr_delta)
844 unsigned int tmp, opcode;
845 int len = 0;
847 /* Scale the address delta by the minimum instruction length. */
848 scale_addr_delta (&addr_delta);
850 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
851 We cannot use special opcodes here, since we want the end_sequence
852 to emit the matrix entry. */
853 if (line_delta == INT_MAX)
855 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
856 len = 1;
857 else
858 len = 1 + sizeof_leb128 (addr_delta, 0);
859 return len + 3;
862 /* Bias the line delta by the base. */
863 tmp = line_delta - DWARF2_LINE_BASE;
865 /* If the line increment is out of range of a special opcode, we
866 must encode it with DW_LNS_advance_line. */
867 if (tmp >= DWARF2_LINE_RANGE)
869 len = 1 + sizeof_leb128 (line_delta, 1);
870 line_delta = 0;
871 tmp = 0 - DWARF2_LINE_BASE;
874 /* Bias the opcode by the special opcode base. */
875 tmp += DWARF2_LINE_OPCODE_BASE;
877 /* Avoid overflow when addr_delta is large. */
878 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
880 /* Try using a special opcode. */
881 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
882 if (opcode <= 255)
883 return len + 1;
885 /* Try using DW_LNS_const_add_pc followed by special op. */
886 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
887 if (opcode <= 255)
888 return len + 2;
891 /* Otherwise use DW_LNS_advance_pc. */
892 len += 1 + sizeof_leb128 (addr_delta, 0);
894 /* DW_LNS_copy or special opcode. */
895 len += 1;
897 return len;
900 static void
901 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
903 unsigned int tmp, opcode;
904 int need_copy = 0;
905 char *end = p + len;
907 /* Line number sequences cannot go backward in addresses. This means
908 we've incorrectly ordered the statements in the sequence. */
909 assert ((offsetT) addr_delta >= 0);
911 /* Scale the address delta by the minimum instruction length. */
912 scale_addr_delta (&addr_delta);
914 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
915 We cannot use special opcodes here, since we want the end_sequence
916 to emit the matrix entry. */
917 if (line_delta == INT_MAX)
919 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
920 *p++ = DW_LNS_const_add_pc;
921 else
923 *p++ = DW_LNS_advance_pc;
924 p += output_leb128 (p, addr_delta, 0);
927 *p++ = DW_LNS_extended_op;
928 *p++ = 1;
929 *p++ = DW_LNE_end_sequence;
930 goto done;
933 /* Bias the line delta by the base. */
934 tmp = line_delta - DWARF2_LINE_BASE;
936 /* If the line increment is out of range of a special opcode, we
937 must encode it with DW_LNS_advance_line. */
938 if (tmp >= DWARF2_LINE_RANGE)
940 *p++ = DW_LNS_advance_line;
941 p += output_leb128 (p, line_delta, 1);
943 line_delta = 0;
944 tmp = 0 - DWARF2_LINE_BASE;
945 need_copy = 1;
948 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
949 special opcode. */
950 if (line_delta == 0 && addr_delta == 0)
952 *p++ = DW_LNS_copy;
953 goto done;
956 /* Bias the opcode by the special opcode base. */
957 tmp += DWARF2_LINE_OPCODE_BASE;
959 /* Avoid overflow when addr_delta is large. */
960 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
962 /* Try using a special opcode. */
963 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
964 if (opcode <= 255)
966 *p++ = opcode;
967 goto done;
970 /* Try using DW_LNS_const_add_pc followed by special op. */
971 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
972 if (opcode <= 255)
974 *p++ = DW_LNS_const_add_pc;
975 *p++ = opcode;
976 goto done;
980 /* Otherwise use DW_LNS_advance_pc. */
981 *p++ = DW_LNS_advance_pc;
982 p += output_leb128 (p, addr_delta, 0);
984 if (need_copy)
985 *p++ = DW_LNS_copy;
986 else
987 *p++ = tmp;
989 done:
990 assert (p == end);
993 /* Handy routine to combine calls to the above two routines. */
995 static void
996 out_inc_line_addr (int line_delta, addressT addr_delta)
998 int len = size_inc_line_addr (line_delta, addr_delta);
999 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1002 /* Write out an alternative form of line and address skips using
1003 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1004 line and address information, but it helps support linker relaxation that
1005 changes the code offsets. */
1007 static void
1008 out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1010 expressionS expr;
1012 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1013 if (line_delta == INT_MAX)
1015 out_opcode (DW_LNS_fixed_advance_pc);
1016 expr.X_op = O_subtract;
1017 expr.X_add_symbol = to_sym;
1018 expr.X_op_symbol = from_sym;
1019 expr.X_add_number = 0;
1020 emit_expr (&expr, 2);
1022 out_opcode (DW_LNS_extended_op);
1023 out_byte (1);
1024 out_opcode (DW_LNE_end_sequence);
1025 return;
1028 out_opcode (DW_LNS_advance_line);
1029 out_sleb128 (line_delta);
1031 out_opcode (DW_LNS_fixed_advance_pc);
1032 expr.X_op = O_subtract;
1033 expr.X_add_symbol = to_sym;
1034 expr.X_op_symbol = from_sym;
1035 expr.X_add_number = 0;
1036 emit_expr (&expr, 2);
1038 out_opcode (DW_LNS_copy);
1041 /* Generate a variant frag that we can use to relax address/line
1042 increments between fragments of the target segment. */
1044 static void
1045 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1047 expressionS expr;
1048 int max_chars;
1050 expr.X_op = O_subtract;
1051 expr.X_add_symbol = to_sym;
1052 expr.X_op_symbol = from_sym;
1053 expr.X_add_number = 0;
1055 /* The maximum size of the frag is the line delta with a maximum
1056 sized address delta. */
1057 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1059 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1060 make_expr_symbol (&expr), line_delta, NULL);
1063 /* The function estimates the size of a rs_dwarf2dbg variant frag
1064 based on the current values of the symbols. It is called before
1065 the relaxation loop. We set fr_subtype to the expected length. */
1068 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1070 offsetT addr_delta;
1071 int size;
1073 addr_delta = resolve_symbol_value (frag->fr_symbol);
1074 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1076 frag->fr_subtype = size;
1078 return size;
1081 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1082 current values of the symbols. fr_subtype is the current length
1083 of the frag. This returns the change in frag length. */
1086 dwarf2dbg_relax_frag (fragS *frag)
1088 int old_size, new_size;
1090 old_size = frag->fr_subtype;
1091 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1093 return new_size - old_size;
1096 /* This function converts a rs_dwarf2dbg variant frag into a normal
1097 fill frag. This is called after all relaxation has been done.
1098 fr_subtype will be the desired length of the frag. */
1100 void
1101 dwarf2dbg_convert_frag (fragS *frag)
1103 offsetT addr_diff;
1105 addr_diff = resolve_symbol_value (frag->fr_symbol);
1107 /* fr_var carries the max_chars that we created the fragment with.
1108 fr_subtype carries the current expected length. We must, of
1109 course, have allocated enough memory earlier. */
1110 assert (frag->fr_var >= (int) frag->fr_subtype);
1112 emit_inc_line_addr (frag->fr_offset, addr_diff,
1113 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1115 frag->fr_fix += frag->fr_subtype;
1116 frag->fr_type = rs_fill;
1117 frag->fr_var = 0;
1118 frag->fr_offset = 0;
1121 /* Generate .debug_line content for the chain of line number entries
1122 beginning at E, for segment SEG. */
1124 static void
1125 process_entries (segT seg, struct line_entry *e)
1127 unsigned filenum = 1;
1128 unsigned line = 1;
1129 unsigned column = 0;
1130 unsigned isa = 0;
1131 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1132 fragS *last_frag = NULL, *frag;
1133 addressT last_frag_ofs = 0, frag_ofs;
1134 symbolS *last_lab = NULL, *lab;
1135 struct line_entry *next;
1139 int line_delta;
1141 if (filenum != e->loc.filenum)
1143 filenum = e->loc.filenum;
1144 out_opcode (DW_LNS_set_file);
1145 out_uleb128 (filenum);
1148 if (column != e->loc.column)
1150 column = e->loc.column;
1151 out_opcode (DW_LNS_set_column);
1152 out_uleb128 (column);
1155 if (isa != e->loc.isa)
1157 isa = e->loc.isa;
1158 out_opcode (DW_LNS_set_isa);
1159 out_uleb128 (isa);
1162 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1164 flags = e->loc.flags;
1165 out_opcode (DW_LNS_negate_stmt);
1168 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1169 out_opcode (DW_LNS_set_basic_block);
1171 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1172 out_opcode (DW_LNS_set_prologue_end);
1174 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1175 out_opcode (DW_LNS_set_epilogue_begin);
1177 /* Don't try to optimize away redundant entries; gdb wants two
1178 entries for a function where the code starts on the same line as
1179 the {, and there's no way to identify that case here. Trust gcc
1180 to optimize appropriately. */
1181 line_delta = e->loc.line - line;
1182 lab = e->label;
1183 frag = symbol_get_frag (lab);
1184 frag_ofs = S_GET_VALUE (lab);
1186 if (last_frag == NULL)
1188 out_set_addr (lab);
1189 out_inc_line_addr (line_delta, 0);
1191 else if (DWARF2_USE_FIXED_ADVANCE_PC)
1192 out_fixed_inc_line_addr (line_delta, lab, last_lab);
1193 else if (frag == last_frag)
1194 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1195 else
1196 relax_inc_line_addr (line_delta, lab, last_lab);
1198 line = e->loc.line;
1199 last_lab = lab;
1200 last_frag = frag;
1201 last_frag_ofs = frag_ofs;
1203 next = e->next;
1204 free (e);
1205 e = next;
1207 while (e);
1209 /* Emit a DW_LNE_end_sequence for the end of the section. */
1210 frag = last_frag_for_seg (seg);
1211 frag_ofs = get_frag_fix (frag, seg);
1212 if (DWARF2_USE_FIXED_ADVANCE_PC)
1214 lab = symbol_temp_new (seg, frag_ofs, frag);
1215 out_fixed_inc_line_addr (INT_MAX, lab, last_lab);
1217 else if (frag == last_frag)
1218 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1219 else
1221 lab = symbol_temp_new (seg, frag_ofs, frag);
1222 relax_inc_line_addr (INT_MAX, lab, last_lab);
1226 /* Emit the directory and file tables for .debug_line. */
1228 static void
1229 out_file_list (void)
1231 size_t size;
1232 const char *dir;
1233 char *cp;
1234 unsigned int i;
1236 /* Emit directory list. */
1237 for (i = 1; i < dirs_in_use; ++i)
1239 dir = remap_debug_filename (dirs[i]);
1240 size = strlen (dir) + 1;
1241 cp = frag_more (size);
1242 memcpy (cp, dir, size);
1244 /* Terminate it. */
1245 out_byte ('\0');
1247 for (i = 1; i < files_in_use; ++i)
1249 if (files[i].filename == NULL)
1251 as_bad (_("unassigned file number %ld"), (long) i);
1252 /* Prevent a crash later, particularly for file 1. */
1253 files[i].filename = "";
1254 continue;
1257 size = strlen (files[i].filename) + 1;
1258 cp = frag_more (size);
1259 memcpy (cp, files[i].filename, size);
1261 out_uleb128 (files[i].dir); /* directory number */
1262 out_uleb128 (0); /* last modification timestamp */
1263 out_uleb128 (0); /* filesize */
1266 /* Terminate filename list. */
1267 out_byte (0);
1270 /* Emit the collected .debug_line data. */
1272 static void
1273 out_debug_line (segT line_seg)
1275 expressionS expr;
1276 symbolS *line_start;
1277 symbolS *prologue_end;
1278 symbolS *line_end;
1279 struct line_seg *s;
1280 enum dwarf2_format d2f;
1281 int sizeof_offset;
1283 subseg_set (line_seg, 0);
1285 line_start = symbol_temp_new_now ();
1286 prologue_end = symbol_temp_make ();
1287 line_end = symbol_temp_make ();
1289 /* Total length of the information for this compilation unit. */
1290 expr.X_op = O_subtract;
1291 expr.X_add_symbol = line_end;
1292 expr.X_op_symbol = line_start;
1294 d2f = DWARF2_FORMAT ();
1295 if (d2f == dwarf2_format_32bit)
1297 expr.X_add_number = -4;
1298 emit_expr (&expr, 4);
1299 sizeof_offset = 4;
1301 else if (d2f == dwarf2_format_64bit)
1303 expr.X_add_number = -12;
1304 out_four (-1);
1305 emit_expr (&expr, 8);
1306 sizeof_offset = 8;
1308 else if (d2f == dwarf2_format_64bit_irix)
1310 expr.X_add_number = -8;
1311 emit_expr (&expr, 8);
1312 sizeof_offset = 8;
1314 else
1316 as_fatal (_("internal error: unknown dwarf2 format"));
1319 /* Version. */
1320 out_two (2);
1322 /* Length of the prologue following this length. */
1323 expr.X_op = O_subtract;
1324 expr.X_add_symbol = prologue_end;
1325 expr.X_op_symbol = line_start;
1326 expr.X_add_number = - (4 + 2 + 4);
1327 emit_expr (&expr, sizeof_offset);
1329 /* Parameters of the state machine. */
1330 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1331 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1332 out_byte (DWARF2_LINE_BASE);
1333 out_byte (DWARF2_LINE_RANGE);
1334 out_byte (DWARF2_LINE_OPCODE_BASE);
1336 /* Standard opcode lengths. */
1337 out_byte (0); /* DW_LNS_copy */
1338 out_byte (1); /* DW_LNS_advance_pc */
1339 out_byte (1); /* DW_LNS_advance_line */
1340 out_byte (1); /* DW_LNS_set_file */
1341 out_byte (1); /* DW_LNS_set_column */
1342 out_byte (0); /* DW_LNS_negate_stmt */
1343 out_byte (0); /* DW_LNS_set_basic_block */
1344 out_byte (0); /* DW_LNS_const_add_pc */
1345 out_byte (1); /* DW_LNS_fixed_advance_pc */
1346 out_byte (0); /* DW_LNS_set_prologue_end */
1347 out_byte (0); /* DW_LNS_set_epilogue_begin */
1348 out_byte (1); /* DW_LNS_set_isa */
1350 out_file_list ();
1352 symbol_set_value_now (prologue_end);
1354 /* For each section, emit a statement program. */
1355 for (s = all_segs; s; s = s->next)
1356 process_entries (s->seg, s->head->head);
1358 symbol_set_value_now (line_end);
1361 static void
1362 out_debug_ranges (segT ranges_seg)
1364 unsigned int addr_size = sizeof_address;
1365 struct line_seg *s;
1366 expressionS expr;
1367 unsigned int i;
1369 subseg_set (ranges_seg, 0);
1371 /* Base Address Entry. */
1372 for (i = 0; i < addr_size; i++)
1373 out_byte (0xff);
1374 for (i = 0; i < addr_size; i++)
1375 out_byte (0);
1377 /* Range List Entry. */
1378 for (s = all_segs; s; s = s->next)
1380 fragS *frag;
1381 symbolS *beg, *end;
1383 frag = first_frag_for_seg (s->seg);
1384 beg = symbol_temp_new (s->seg, 0, frag);
1385 s->text_start = beg;
1387 frag = last_frag_for_seg (s->seg);
1388 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1389 s->text_end = end;
1391 expr.X_op = O_symbol;
1392 expr.X_add_symbol = beg;
1393 expr.X_add_number = 0;
1394 emit_expr (&expr, addr_size);
1396 expr.X_op = O_symbol;
1397 expr.X_add_symbol = end;
1398 expr.X_add_number = 0;
1399 emit_expr (&expr, addr_size);
1402 /* End of Range Entry. */
1403 for (i = 0; i < addr_size; i++)
1404 out_byte (0);
1405 for (i = 0; i < addr_size; i++)
1406 out_byte (0);
1409 /* Emit data for .debug_aranges. */
1411 static void
1412 out_debug_aranges (segT aranges_seg, segT info_seg)
1414 unsigned int addr_size = sizeof_address;
1415 addressT size, skip;
1416 struct line_seg *s;
1417 expressionS expr;
1418 char *p;
1420 size = 4 + 2 + 4 + 1 + 1;
1422 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1423 if (skip == 2 * addr_size)
1424 skip = 0;
1425 size += skip;
1427 for (s = all_segs; s; s = s->next)
1428 size += 2 * addr_size;
1430 size += 2 * addr_size;
1432 subseg_set (aranges_seg, 0);
1434 /* Length of the compilation unit. */
1435 out_four (size - 4);
1437 /* Version. */
1438 out_two (2);
1440 /* Offset to .debug_info. */
1441 /* ??? sizeof_offset */
1442 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
1444 /* Size of an address (offset portion). */
1445 out_byte (addr_size);
1447 /* Size of a segment descriptor. */
1448 out_byte (0);
1450 /* Align the header. */
1451 if (skip)
1452 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1454 for (s = all_segs; s; s = s->next)
1456 fragS *frag;
1457 symbolS *beg, *end;
1459 frag = first_frag_for_seg (s->seg);
1460 beg = symbol_temp_new (s->seg, 0, frag);
1461 s->text_start = beg;
1463 frag = last_frag_for_seg (s->seg);
1464 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1465 s->text_end = end;
1467 expr.X_op = O_symbol;
1468 expr.X_add_symbol = beg;
1469 expr.X_add_number = 0;
1470 emit_expr (&expr, addr_size);
1472 expr.X_op = O_subtract;
1473 expr.X_add_symbol = end;
1474 expr.X_op_symbol = beg;
1475 expr.X_add_number = 0;
1476 emit_expr (&expr, addr_size);
1479 p = frag_more (2 * addr_size);
1480 md_number_to_chars (p, 0, addr_size);
1481 md_number_to_chars (p + addr_size, 0, addr_size);
1484 /* Emit data for .debug_abbrev. Note that this must be kept in
1485 sync with out_debug_info below. */
1487 static void
1488 out_debug_abbrev (segT abbrev_seg)
1490 subseg_set (abbrev_seg, 0);
1492 out_uleb128 (1);
1493 out_uleb128 (DW_TAG_compile_unit);
1494 out_byte (DW_CHILDREN_no);
1495 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1496 if (all_segs->next == NULL)
1498 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1499 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1501 else
1503 if (DWARF2_FORMAT () == dwarf2_format_32bit)
1504 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1505 else
1506 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1508 out_abbrev (DW_AT_name, DW_FORM_string);
1509 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1510 out_abbrev (DW_AT_producer, DW_FORM_string);
1511 out_abbrev (DW_AT_language, DW_FORM_data2);
1512 out_abbrev (0, 0);
1514 /* Terminate the abbreviations for this compilation unit. */
1515 out_byte (0);
1518 /* Emit a description of this compilation unit for .debug_info. */
1520 static void
1521 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1523 char producer[128];
1524 const char *comp_dir;
1525 const char *dirname;
1526 expressionS expr;
1527 symbolS *info_start;
1528 symbolS *info_end;
1529 char *p;
1530 int len;
1531 enum dwarf2_format d2f;
1532 int sizeof_offset;
1534 subseg_set (info_seg, 0);
1536 info_start = symbol_temp_new_now ();
1537 info_end = symbol_temp_make ();
1539 /* Compilation Unit length. */
1540 expr.X_op = O_subtract;
1541 expr.X_add_symbol = info_end;
1542 expr.X_op_symbol = info_start;
1544 d2f = DWARF2_FORMAT ();
1545 if (d2f == dwarf2_format_32bit)
1547 expr.X_add_number = -4;
1548 emit_expr (&expr, 4);
1549 sizeof_offset = 4;
1551 else if (d2f == dwarf2_format_64bit)
1553 expr.X_add_number = -12;
1554 out_four (-1);
1555 emit_expr (&expr, 8);
1556 sizeof_offset = 8;
1558 else if (d2f == dwarf2_format_64bit_irix)
1560 expr.X_add_number = -8;
1561 emit_expr (&expr, 8);
1562 sizeof_offset = 8;
1564 else
1566 as_fatal (_("internal error: unknown dwarf2 format"));
1569 /* DWARF version. */
1570 out_two (2);
1572 /* .debug_abbrev offset */
1573 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1575 /* Target address size. */
1576 out_byte (sizeof_address);
1578 /* DW_TAG_compile_unit DIE abbrev */
1579 out_uleb128 (1);
1581 /* DW_AT_stmt_list */
1582 /* ??? sizeof_offset */
1583 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
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 || files_in_use < 1)
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);
1727 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);