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)
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
23 /* Logical line numbers can be controlled by the compiler via the
27 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
28 [epilogue_begin] [is_stmt VALUE] [isa VALUE]
32 #include "safe-ctype.h"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
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) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
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"). */
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
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
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
110 /* Range of line offsets in a special line info. opcode. */
111 #ifndef DWARF2_LINE_RANGE
112 # define DWARF2_LINE_RANGE 14
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
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)
136 struct line_entry *next;
138 struct dwarf2_line_info loc;
142 struct line_subseg *next;
144 struct line_entry *head;
145 struct line_entry **ptail;
149 struct line_seg *next;
151 struct line_subseg *head;
156 /* Collects data for all line table entries during assembly. */
157 static struct line_seg *all_segs;
160 const char *filename;
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. */
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
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 = {
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_*. */
199 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
203 expr.X_op = O_symbol;
204 expr.X_add_symbol = symbol;
205 expr.X_add_number = 0;
206 emit_expr (&expr, size);
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)
229 s = (struct line_seg *) xmalloc (sizeof (*s));
236 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
238 if (ss->subseg == subseg)
240 if (ss->subseg > subseg)
244 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
248 ss->ptail = &ss->head;
253 last_subseg = subseg;
254 last_line_subseg = ss;
259 /* Record an entry for LOC occurring at LABEL. */
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));
272 ss = get_line_subseg (now_seg, now_subseg);
274 ss->ptail = &e->next;
277 /* Record an entry for LOC occurring at OFS within the current fragment. */
280 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
282 static unsigned int line = -1;
283 static unsigned int filenum = -1;
287 /* Early out for as-yet incomplete location information. */
288 if (loc->filenum == 0 || loc->line == 0)
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)
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
312 dwarf2_where (struct dwarf2_line_info *line)
314 if (debug_type == DEBUG_DWARF2)
317 as_where (&filename, &line->line);
318 line->filenum = get_filenum (filename, 0);
320 line->flags = DWARF2_FLAG_IS_STMT;
321 line->isa = current.isa;
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. */
331 dwarf2_set_isa (unsigned int 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. */
342 dwarf2_emit_insn (int size)
344 struct dwarf2_line_info loc;
346 if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
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
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. */
376 dwarf2_emit_label (symbolS *label)
378 struct dwarf2_line_info loc;
380 if (!dwarf2_loc_mark_labels)
382 if (S_GET_SEGMENT (label) != now_seg)
384 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
386 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
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
402 get_filenum (const char *filename, unsigned int num)
404 static unsigned int last_used, last_used_dir_len;
409 if (num == 0 && last_used)
411 if (! files[last_used].dir
412 && strcmp (filename, files[last_used].filename) == 0)
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)
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)
429 if (file == filename + 1)
432 dir_len = file - filename;
438 for (dir = 1; dir < dirs_in_use; ++dir)
439 if (strncmp (filename, dirs[dir], dir_len) == 0
440 && dirs[dir][dir_len] == '\0')
443 if (dir >= dirs_in_use)
445 if (dir >= dirs_allocated)
447 dirs_allocated = dir + 32;
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;
461 for (i = 1; i < files_in_use; ++i)
462 if (files[i].dir == dir
464 && strcmp (file, files[i].filename) == 0)
467 last_used_dir_len = dir_len;
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);
487 if (files_in_use < i + 1)
488 files_in_use = i + 1;
490 last_used_dir_len = dir_len;
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. */
502 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
508 /* Continue to accept a bare string and pass it off. */
510 if (*input_line_pointer == '"')
516 num = get_absolute_expression ();
517 filename = demand_copy_C_string (&filename_len);
518 if (filename == NULL)
520 demand_empty_rest_of_line ();
524 as_bad (_("file number less than one"));
528 if (num < (int) files_in_use && files[num].filename != 0)
530 as_bad (_("file number %ld already allocated"), (long) num);
534 get_filenum (filename, num);
540 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
542 offsetT filenum, line;
544 /* If we see two .loc directives in a row, force the first one to be
546 if (dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
547 dwarf2_emit_insn (0);
549 filenum = get_absolute_expression ();
551 line = get_absolute_expression ();
555 as_bad (_("file number less than one"));
558 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
560 as_bad (_("unassigned file number %ld"), (long) filenum);
564 current.filenum = filenum;
570 if (files[filenum].dir)
572 size_t dir_len = strlen (dirs[files[filenum].dir]);
573 size_t file_len = strlen (files[filenum].filename);
574 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
576 memcpy (cp, dirs[files[filenum].dir], dir_len);
577 INSERT_DIR_SEPARATOR (cp, dir_len);
578 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
579 cp[dir_len + file_len + 1] = '\0';
580 listing_source_file (cp);
583 listing_source_file (files[filenum].filename);
584 listing_source_line (line);
589 if (ISDIGIT (*input_line_pointer))
591 current.column = get_absolute_expression ();
595 while (ISALPHA (*input_line_pointer))
600 p = input_line_pointer;
601 c = get_symbol_end ();
603 if (strcmp (p, "basic_block") == 0)
605 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
606 *input_line_pointer = c;
608 else if (strcmp (p, "prologue_end") == 0)
610 current.flags |= DWARF2_FLAG_PROLOGUE_END;
611 *input_line_pointer = c;
613 else if (strcmp (p, "epilogue_begin") == 0)
615 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
616 *input_line_pointer = c;
618 else if (strcmp (p, "is_stmt") == 0)
620 *input_line_pointer = c;
621 value = get_absolute_expression ();
623 current.flags &= ~DWARF2_FLAG_IS_STMT;
625 current.flags |= DWARF2_FLAG_IS_STMT;
628 as_bad (_("is_stmt value not 0 or 1"));
632 else if (strcmp (p, "isa") == 0)
634 *input_line_pointer = c;
635 value = get_absolute_expression ();
640 as_bad (_("isa number less than zero"));
646 as_bad (_("unknown .loc sub-directive `%s'"), p);
647 *input_line_pointer = c;
654 demand_empty_rest_of_line ();
655 dwarf2_loc_directive_seen = TRUE;
659 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
661 offsetT value = get_absolute_expression ();
663 if (value != 0 && value != 1)
665 as_bad (_("expected 0 or 1"));
666 ignore_rest_of_line ();
670 dwarf2_loc_mark_labels = value != 0;
671 demand_empty_rest_of_line ();
676 first_frag_for_seg (segT seg)
678 return seg_info (seg)->frchainP->frch_root;
682 last_frag_for_seg (segT seg)
684 frchainS *f = seg_info (seg)->frchainP;
686 while (f->frch_next != NULL)
692 /* Emit a single byte into the current segment. */
697 FRAG_APPEND_1_CHAR (byte);
700 /* Emit a statement program opcode into the current segment. */
708 /* Emit a two-byte word into the current segment. */
713 md_number_to_chars (frag_more (2), data, 2);
716 /* Emit a four byte word into the current segment. */
721 md_number_to_chars (frag_more (4), data, 4);
724 /* Emit an unsigned "little-endian base 128" number. */
727 out_uleb128 (addressT value)
729 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
732 /* Emit a tuple for .debug_abbrev. */
735 out_abbrev (int name, int form)
741 /* Get the size of a fragment. */
744 get_frag_fix (fragS *frag, segT seg)
751 /* If a fragment is the last in the chain, special measures must be
752 taken to find its size before relaxation, since it may be pending
753 on some subsegment chain. */
754 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
755 if (fr->frch_last == frag)
756 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
761 /* Set an absolute address (may result in a relocation entry). */
764 out_set_addr (symbolS *sym)
768 out_opcode (DW_LNS_extended_op);
769 out_uleb128 (sizeof_address + 1);
771 out_opcode (DW_LNE_set_address);
772 expr.X_op = O_symbol;
773 expr.X_add_symbol = sym;
774 expr.X_add_number = 0;
775 emit_expr (&expr, sizeof_address);
778 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
779 static void scale_addr_delta (addressT *);
782 scale_addr_delta (addressT *addr_delta)
784 static int printed_this = 0;
785 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
788 as_bad("unaligned opcodes detected in executable segment");
791 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
794 #define scale_addr_delta(A)
797 /* Encode a pair of line and address skips as efficiently as possible.
798 Note that the line skip is signed, whereas the address skip is unsigned.
800 The following two routines *must* be kept in sync. This is
801 enforced by making emit_inc_line_addr abort if we do not emit
802 exactly the expected number of bytes. */
805 size_inc_line_addr (int line_delta, addressT addr_delta)
807 unsigned int tmp, opcode;
810 /* Scale the address delta by the minimum instruction length. */
811 scale_addr_delta (&addr_delta);
813 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
814 We cannot use special opcodes here, since we want the end_sequence
815 to emit the matrix entry. */
816 if (line_delta == INT_MAX)
818 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
821 len = 1 + sizeof_leb128 (addr_delta, 0);
825 /* Bias the line delta by the base. */
826 tmp = line_delta - DWARF2_LINE_BASE;
828 /* If the line increment is out of range of a special opcode, we
829 must encode it with DW_LNS_advance_line. */
830 if (tmp >= DWARF2_LINE_RANGE)
832 len = 1 + sizeof_leb128 (line_delta, 1);
834 tmp = 0 - DWARF2_LINE_BASE;
837 /* Bias the opcode by the special opcode base. */
838 tmp += DWARF2_LINE_OPCODE_BASE;
840 /* Avoid overflow when addr_delta is large. */
841 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
843 /* Try using a special opcode. */
844 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
848 /* Try using DW_LNS_const_add_pc followed by special op. */
849 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
854 /* Otherwise use DW_LNS_advance_pc. */
855 len += 1 + sizeof_leb128 (addr_delta, 0);
857 /* DW_LNS_copy or special opcode. */
864 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
866 unsigned int tmp, opcode;
870 /* Line number sequences cannot go backward in addresses. This means
871 we've incorrectly ordered the statements in the sequence. */
872 assert ((offsetT) addr_delta >= 0);
874 /* Scale the address delta by the minimum instruction length. */
875 scale_addr_delta (&addr_delta);
877 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
878 We cannot use special opcodes here, since we want the end_sequence
879 to emit the matrix entry. */
880 if (line_delta == INT_MAX)
882 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
883 *p++ = DW_LNS_const_add_pc;
886 *p++ = DW_LNS_advance_pc;
887 p += output_leb128 (p, addr_delta, 0);
890 *p++ = DW_LNS_extended_op;
892 *p++ = DW_LNE_end_sequence;
896 /* Bias the line delta by the base. */
897 tmp = line_delta - DWARF2_LINE_BASE;
899 /* If the line increment is out of range of a special opcode, we
900 must encode it with DW_LNS_advance_line. */
901 if (tmp >= DWARF2_LINE_RANGE)
903 *p++ = DW_LNS_advance_line;
904 p += output_leb128 (p, line_delta, 1);
907 tmp = 0 - DWARF2_LINE_BASE;
911 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
913 if (line_delta == 0 && addr_delta == 0)
919 /* Bias the opcode by the special opcode base. */
920 tmp += DWARF2_LINE_OPCODE_BASE;
922 /* Avoid overflow when addr_delta is large. */
923 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
925 /* Try using a special opcode. */
926 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
933 /* Try using DW_LNS_const_add_pc followed by special op. */
934 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
937 *p++ = DW_LNS_const_add_pc;
943 /* Otherwise use DW_LNS_advance_pc. */
944 *p++ = DW_LNS_advance_pc;
945 p += output_leb128 (p, addr_delta, 0);
956 /* Handy routine to combine calls to the above two routines. */
959 out_inc_line_addr (int line_delta, addressT addr_delta)
961 int len = size_inc_line_addr (line_delta, addr_delta);
962 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
965 /* Write out an alternative form of line and address skips using
966 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
967 line and address information, but it is required if linker relaxation
968 could change the code offsets. The following two routines *must* be
972 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
976 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
977 if (line_delta != INT_MAX)
978 len = 1 + sizeof_leb128 (line_delta, 1);
980 if (addr_delta > 50000)
982 /* DW_LNS_extended_op */
983 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
984 /* DW_LNE_set_address */
985 len += 1 + sizeof_address;
988 /* DW_LNS_fixed_advance_pc */
991 if (line_delta == INT_MAX)
992 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1002 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1007 char *end = p + len;
1009 /* Line number sequences cannot go backward in addresses. This means
1010 we've incorrectly ordered the statements in the sequence. */
1011 assert ((offsetT) addr_delta >= 0);
1013 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1014 if (line_delta != INT_MAX)
1016 *p++ = DW_LNS_advance_line;
1017 p += output_leb128 (p, line_delta, 1);
1020 exp = symbol_get_value_expression (frag->fr_symbol);
1021 line_seg = subseg_get (".debug_line", 0);
1023 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1024 advance the address by at most 64K. Linker relaxation (without
1025 which this function would not be used) could change the operand by
1026 an unknown amount. If the address increment is getting close to
1027 the limit, just reset the address. */
1028 if (addr_delta > 50000)
1033 assert (exp->X_op = O_subtract);
1034 to_sym = exp->X_add_symbol;
1036 *p++ = DW_LNS_extended_op;
1037 p += output_leb128 (p, sizeof_address + 1, 0);
1038 *p++ = DW_LNE_set_address;
1039 expr.X_op = O_symbol;
1040 expr.X_add_symbol = to_sym;
1041 expr.X_add_number = 0;
1042 subseg_change (line_seg, 0);
1043 emit_expr_fix (&expr, sizeof_address, frag, p);
1044 p += sizeof_address;
1048 *p++ = DW_LNS_fixed_advance_pc;
1049 subseg_change (line_seg, 0);
1050 emit_expr_fix (exp, 2, frag, p);
1054 if (line_delta == INT_MAX)
1056 *p++ = DW_LNS_extended_op;
1058 *p++ = DW_LNE_end_sequence;
1066 /* Generate a variant frag that we can use to relax address/line
1067 increments between fragments of the target segment. */
1070 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1075 expr.X_op = O_subtract;
1076 expr.X_add_symbol = to_sym;
1077 expr.X_op_symbol = from_sym;
1078 expr.X_add_number = 0;
1080 /* The maximum size of the frag is the line delta with a maximum
1081 sized address delta. */
1082 if (DWARF2_USE_FIXED_ADVANCE_PC)
1083 max_chars = size_fixed_inc_line_addr (line_delta,
1084 -DWARF2_LINE_MIN_INSN_LENGTH);
1086 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1088 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1089 make_expr_symbol (&expr), line_delta, NULL);
1092 /* The function estimates the size of a rs_dwarf2dbg variant frag
1093 based on the current values of the symbols. It is called before
1094 the relaxation loop. We set fr_subtype to the expected length. */
1097 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1102 addr_delta = resolve_symbol_value (frag->fr_symbol);
1103 if (DWARF2_USE_FIXED_ADVANCE_PC)
1104 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1106 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1108 frag->fr_subtype = size;
1113 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1114 current values of the symbols. fr_subtype is the current length
1115 of the frag. This returns the change in frag length. */
1118 dwarf2dbg_relax_frag (fragS *frag)
1120 int old_size, new_size;
1122 old_size = frag->fr_subtype;
1123 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1125 return new_size - old_size;
1128 /* This function converts a rs_dwarf2dbg variant frag into a normal
1129 fill frag. This is called after all relaxation has been done.
1130 fr_subtype will be the desired length of the frag. */
1133 dwarf2dbg_convert_frag (fragS *frag)
1137 addr_diff = resolve_symbol_value (frag->fr_symbol);
1139 /* fr_var carries the max_chars that we created the fragment with.
1140 fr_subtype carries the current expected length. We must, of
1141 course, have allocated enough memory earlier. */
1142 assert (frag->fr_var >= (int) frag->fr_subtype);
1144 if (DWARF2_USE_FIXED_ADVANCE_PC)
1145 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1146 frag->fr_literal + frag->fr_fix,
1149 emit_inc_line_addr (frag->fr_offset, addr_diff,
1150 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1152 frag->fr_fix += frag->fr_subtype;
1153 frag->fr_type = rs_fill;
1155 frag->fr_offset = 0;
1158 /* Generate .debug_line content for the chain of line number entries
1159 beginning at E, for segment SEG. */
1162 process_entries (segT seg, struct line_entry *e)
1164 unsigned filenum = 1;
1166 unsigned column = 0;
1168 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1169 fragS *last_frag = NULL, *frag;
1170 addressT last_frag_ofs = 0, frag_ofs;
1171 symbolS *last_lab = NULL, *lab;
1172 struct line_entry *next;
1178 if (filenum != e->loc.filenum)
1180 filenum = e->loc.filenum;
1181 out_opcode (DW_LNS_set_file);
1182 out_uleb128 (filenum);
1185 if (column != e->loc.column)
1187 column = e->loc.column;
1188 out_opcode (DW_LNS_set_column);
1189 out_uleb128 (column);
1192 if (isa != e->loc.isa)
1195 out_opcode (DW_LNS_set_isa);
1199 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1201 flags = e->loc.flags;
1202 out_opcode (DW_LNS_negate_stmt);
1205 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1206 out_opcode (DW_LNS_set_basic_block);
1208 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1209 out_opcode (DW_LNS_set_prologue_end);
1211 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1212 out_opcode (DW_LNS_set_epilogue_begin);
1214 /* Don't try to optimize away redundant entries; gdb wants two
1215 entries for a function where the code starts on the same line as
1216 the {, and there's no way to identify that case here. Trust gcc
1217 to optimize appropriately. */
1218 line_delta = e->loc.line - line;
1220 frag = symbol_get_frag (lab);
1221 frag_ofs = S_GET_VALUE (lab);
1223 if (last_frag == NULL)
1226 out_inc_line_addr (line_delta, 0);
1228 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1229 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1231 relax_inc_line_addr (line_delta, lab, last_lab);
1236 last_frag_ofs = frag_ofs;
1244 /* Emit a DW_LNE_end_sequence for the end of the section. */
1245 frag = last_frag_for_seg (seg);
1246 frag_ofs = get_frag_fix (frag, seg);
1247 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1248 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1251 lab = symbol_temp_new (seg, frag_ofs, frag);
1252 relax_inc_line_addr (INT_MAX, lab, last_lab);
1256 /* Emit the directory and file tables for .debug_line. */
1259 out_file_list (void)
1266 /* Emit directory list. */
1267 for (i = 1; i < dirs_in_use; ++i)
1269 dir = remap_debug_filename (dirs[i]);
1270 size = strlen (dir) + 1;
1271 cp = frag_more (size);
1272 memcpy (cp, dir, size);
1277 for (i = 1; i < files_in_use; ++i)
1279 if (files[i].filename == NULL)
1281 as_bad (_("unassigned file number %ld"), (long) i);
1282 /* Prevent a crash later, particularly for file 1. */
1283 files[i].filename = "";
1287 size = strlen (files[i].filename) + 1;
1288 cp = frag_more (size);
1289 memcpy (cp, files[i].filename, size);
1291 out_uleb128 (files[i].dir); /* directory number */
1292 out_uleb128 (0); /* last modification timestamp */
1293 out_uleb128 (0); /* filesize */
1296 /* Terminate filename list. */
1300 /* Switch to SEC and output a header length field. Return the size of
1301 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1302 to the end of the section. */
1305 out_header (asection *sec, expressionS *expr)
1310 subseg_set (sec, 0);
1311 start_sym = symbol_temp_new_now ();;
1312 end_sym = symbol_temp_make ();
1314 /* Total length of the information. */
1315 expr->X_op = O_subtract;
1316 expr->X_add_symbol = end_sym;
1317 expr->X_op_symbol = start_sym;
1319 switch (DWARF2_FORMAT (sec))
1321 case dwarf2_format_32bit:
1322 expr->X_add_number = -4;
1323 emit_expr (expr, 4);
1326 case dwarf2_format_64bit:
1327 expr->X_add_number = -12;
1329 emit_expr (expr, 8);
1332 case dwarf2_format_64bit_irix:
1333 expr->X_add_number = -8;
1334 emit_expr (expr, 8);
1338 as_fatal (_("internal error: unknown dwarf2 format"));
1342 /* Emit the collected .debug_line data. */
1345 out_debug_line (segT line_seg)
1348 symbolS *prologue_end;
1353 sizeof_offset = out_header (line_seg, &expr);
1354 line_end = expr.X_add_symbol;
1359 /* Length of the prologue following this length. */
1360 prologue_end = symbol_temp_make ();
1361 expr.X_add_symbol = prologue_end;
1362 expr.X_add_number = - (4 + 2 + 4);
1363 emit_expr (&expr, sizeof_offset);
1365 /* Parameters of the state machine. */
1366 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1367 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1368 out_byte (DWARF2_LINE_BASE);
1369 out_byte (DWARF2_LINE_RANGE);
1370 out_byte (DWARF2_LINE_OPCODE_BASE);
1372 /* Standard opcode lengths. */
1373 out_byte (0); /* DW_LNS_copy */
1374 out_byte (1); /* DW_LNS_advance_pc */
1375 out_byte (1); /* DW_LNS_advance_line */
1376 out_byte (1); /* DW_LNS_set_file */
1377 out_byte (1); /* DW_LNS_set_column */
1378 out_byte (0); /* DW_LNS_negate_stmt */
1379 out_byte (0); /* DW_LNS_set_basic_block */
1380 out_byte (0); /* DW_LNS_const_add_pc */
1381 out_byte (1); /* DW_LNS_fixed_advance_pc */
1382 out_byte (0); /* DW_LNS_set_prologue_end */
1383 out_byte (0); /* DW_LNS_set_epilogue_begin */
1384 out_byte (1); /* DW_LNS_set_isa */
1388 symbol_set_value_now (prologue_end);
1390 /* For each section, emit a statement program. */
1391 for (s = all_segs; s; s = s->next)
1392 process_entries (s->seg, s->head->head);
1394 symbol_set_value_now (line_end);
1398 out_debug_ranges (segT ranges_seg)
1400 unsigned int addr_size = sizeof_address;
1405 subseg_set (ranges_seg, 0);
1407 /* Base Address Entry. */
1408 for (i = 0; i < addr_size; i++)
1410 for (i = 0; i < addr_size; i++)
1413 /* Range List Entry. */
1414 for (s = all_segs; s; s = s->next)
1419 frag = first_frag_for_seg (s->seg);
1420 beg = symbol_temp_new (s->seg, 0, frag);
1421 s->text_start = beg;
1423 frag = last_frag_for_seg (s->seg);
1424 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1427 expr.X_op = O_symbol;
1428 expr.X_add_symbol = beg;
1429 expr.X_add_number = 0;
1430 emit_expr (&expr, addr_size);
1432 expr.X_op = O_symbol;
1433 expr.X_add_symbol = end;
1434 expr.X_add_number = 0;
1435 emit_expr (&expr, addr_size);
1438 /* End of Range Entry. */
1439 for (i = 0; i < addr_size; i++)
1441 for (i = 0; i < addr_size; i++)
1445 /* Emit data for .debug_aranges. */
1448 out_debug_aranges (segT aranges_seg, segT info_seg)
1450 unsigned int addr_size = sizeof_address;
1453 symbolS *aranges_end;
1457 sizeof_offset = out_header (aranges_seg, &expr);
1458 aranges_end = expr.X_add_symbol;
1463 /* Offset to .debug_info. */
1464 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1466 /* Size of an address (offset portion). */
1467 out_byte (addr_size);
1469 /* Size of a segment descriptor. */
1472 /* Align the header. */
1473 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1475 for (s = all_segs; s; s = s->next)
1480 frag = first_frag_for_seg (s->seg);
1481 beg = symbol_temp_new (s->seg, 0, frag);
1482 s->text_start = beg;
1484 frag = last_frag_for_seg (s->seg);
1485 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1488 expr.X_op = O_symbol;
1489 expr.X_add_symbol = beg;
1490 expr.X_add_number = 0;
1491 emit_expr (&expr, addr_size);
1493 expr.X_op = O_subtract;
1494 expr.X_add_symbol = end;
1495 expr.X_op_symbol = beg;
1496 expr.X_add_number = 0;
1497 emit_expr (&expr, addr_size);
1500 p = frag_more (2 * addr_size);
1501 md_number_to_chars (p, 0, addr_size);
1502 md_number_to_chars (p + addr_size, 0, addr_size);
1504 symbol_set_value_now (aranges_end);
1507 /* Emit data for .debug_abbrev. Note that this must be kept in
1508 sync with out_debug_info below. */
1511 out_debug_abbrev (segT abbrev_seg,
1512 segT info_seg ATTRIBUTE_UNUSED,
1513 segT line_seg ATTRIBUTE_UNUSED)
1515 subseg_set (abbrev_seg, 0);
1518 out_uleb128 (DW_TAG_compile_unit);
1519 out_byte (DW_CHILDREN_no);
1520 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1521 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1523 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1524 if (all_segs->next == NULL)
1526 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1527 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1531 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1532 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1534 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1536 out_abbrev (DW_AT_name, DW_FORM_string);
1537 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1538 out_abbrev (DW_AT_producer, DW_FORM_string);
1539 out_abbrev (DW_AT_language, DW_FORM_data2);
1542 /* Terminate the abbreviations for this compilation unit. */
1546 /* Emit a description of this compilation unit for .debug_info. */
1549 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1552 const char *comp_dir;
1553 const char *dirname;
1560 sizeof_offset = out_header (info_seg, &expr);
1561 info_end = expr.X_add_symbol;
1563 /* DWARF version. */
1566 /* .debug_abbrev offset */
1567 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1569 /* Target address size. */
1570 out_byte (sizeof_address);
1572 /* DW_TAG_compile_unit DIE abbrev */
1575 /* DW_AT_stmt_list */
1576 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
1577 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
1580 /* These two attributes are emitted if all of the code is contiguous. */
1581 if (all_segs->next == NULL)
1584 expr.X_op = O_symbol;
1585 expr.X_add_symbol = all_segs->text_start;
1586 expr.X_add_number = 0;
1587 emit_expr (&expr, sizeof_address);
1590 expr.X_op = O_symbol;
1591 expr.X_add_symbol = all_segs->text_end;
1592 expr.X_add_number = 0;
1593 emit_expr (&expr, sizeof_address);
1597 /* This attribute is emitted if the code is disjoint. */
1599 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1602 /* DW_AT_name. We don't have the actual file name that was present
1603 on the command line, so assume files[1] is the main input file.
1604 We're not supposed to get called unless at least one line number
1605 entry was emitted, so this should always be defined. */
1606 if (files_in_use == 0)
1610 dirname = remap_debug_filename (dirs[files[1].dir]);
1611 len = strlen (dirname);
1612 p = frag_more (len + 1);
1613 memcpy (p, dirname, len);
1614 INSERT_DIR_SEPARATOR (p, len);
1616 len = strlen (files[1].filename) + 1;
1617 p = frag_more (len);
1618 memcpy (p, files[1].filename, len);
1620 /* DW_AT_comp_dir */
1621 comp_dir = remap_debug_filename (getpwd ());
1622 len = strlen (comp_dir) + 1;
1623 p = frag_more (len);
1624 memcpy (p, comp_dir, len);
1626 /* DW_AT_producer */
1627 sprintf (producer, "GNU AS %s", VERSION);
1628 len = strlen (producer) + 1;
1629 p = frag_more (len);
1630 memcpy (p, producer, len);
1632 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1633 dwarf2 draft has no standard code for assembler. */
1634 out_two (DW_LANG_Mips_Assembler);
1636 symbol_set_value_now (info_end);
1639 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1640 were any .file/.loc directives, or --gdwarf2 was given, or if the
1641 file has a non-empty .debug_info section. If we emit .debug_line,
1642 and the .debug_info section is empty, we also emit .debug_info,
1643 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1644 there were any .file/.loc directives, or --gdwarf2 was given and
1645 there were any located instructions emitted. */
1648 dwarf2_finish (void)
1653 int emit_other_sections = 0;
1655 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1656 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1658 if (!all_segs && emit_other_sections)
1659 /* There is no line information and no non-empty .debug_info
1663 /* Calculate the size of an address for the target machine. */
1664 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1666 /* Create and switch to the line number section. */
1667 line_seg = subseg_new (".debug_line", 0);
1668 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1670 /* For each subsection, chain the debug entries together. */
1671 for (s = all_segs; s; s = s->next)
1673 struct line_subseg *ss = s->head;
1674 struct line_entry **ptail = ss->ptail;
1676 while ((ss = ss->next) != NULL)
1683 out_debug_line (line_seg);
1685 /* If this is assembler generated line info, and there is no
1686 debug_info already, we need .debug_info and .debug_abbrev
1687 sections as well. */
1688 if (emit_other_sections)
1696 info_seg = subseg_new (".debug_info", 0);
1697 abbrev_seg = subseg_new (".debug_abbrev", 0);
1698 aranges_seg = subseg_new (".debug_aranges", 0);
1700 bfd_set_section_flags (stdoutput, info_seg,
1701 SEC_READONLY | SEC_DEBUGGING);
1702 bfd_set_section_flags (stdoutput, abbrev_seg,
1703 SEC_READONLY | SEC_DEBUGGING);
1704 bfd_set_section_flags (stdoutput, aranges_seg,
1705 SEC_READONLY | SEC_DEBUGGING);
1707 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1709 if (all_segs->next == NULL)
1713 ranges_seg = subseg_new (".debug_ranges", 0);
1714 bfd_set_section_flags (stdoutput, ranges_seg,
1715 SEC_READONLY | SEC_DEBUGGING);
1716 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1717 out_debug_ranges (ranges_seg);
1720 out_debug_aranges (aranges_seg, info_seg);
1721 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
1722 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);