1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999-2013 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [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)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION 2
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation output version 2 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION 2
109 /* Since we can't generate the prolog until the body is complete, we
110 use three different subsegments for .debug_line: one holding the
111 prolog, one for the directory and filename info, and one for the
112 body ("statement program"). */
117 /* If linker relaxation might change offsets in the code, the DWARF special
118 opcodes and variable-length operands cannot be used. If this macro is
119 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
120 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
121 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
124 /* First special line opcde - leave room for the standard opcodes.
125 Note: If you want to change this, you'll have to update the
126 "standard_opcode_lengths" table that is emitted below in
128 #define DWARF2_LINE_OPCODE_BASE 13
130 #ifndef DWARF2_LINE_BASE
131 /* Minimum line offset in a special line info. opcode. This value
132 was chosen to give a reasonable range of values. */
133 # define DWARF2_LINE_BASE -5
136 /* Range of line offsets in a special line info. opcode. */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE 14
141 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
142 /* Define the architecture-dependent minimum instruction length (in
143 bytes). This value should be rather too small than too big. */
144 # define DWARF2_LINE_MIN_INSN_LENGTH 1
147 /* Flag that indicates the initial value of the is_stmt_start flag. */
148 #define DWARF2_LINE_DEFAULT_IS_STMT 1
150 /* Given a special op, return the line skip amount. */
151 #define SPECIAL_LINE(op) \
152 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
154 /* Given a special op, return the address skip amount (in units of
155 DWARF2_LINE_MIN_INSN_LENGTH. */
156 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
158 /* The maximum address skip amount that can be encoded with a special op. */
159 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
162 struct line_entry *next;
164 struct dwarf2_line_info loc;
168 struct line_subseg *next;
170 struct line_entry *head;
171 struct line_entry **ptail;
175 struct line_seg *next;
177 struct line_subseg *head;
182 /* Collects data for all line table entries during assembly. */
183 static struct line_seg *all_segs;
184 /* Hash used to quickly lookup a segment by name, avoiding the need to search
185 through the all_segs list. */
186 static struct hash_control *all_segs_hash;
187 static struct line_seg **last_seg_ptr;
190 const char *filename;
194 /* Table of files used by .debug_line. */
195 static struct file_entry *files;
196 static unsigned int files_in_use;
197 static unsigned int files_allocated;
199 /* Table of directories used by .debug_line. */
201 static unsigned int dirs_in_use;
202 static unsigned int dirs_allocated;
204 /* TRUE when we've seen a .loc directive recently. Used to avoid
205 doing work when there's nothing to do. */
206 bfd_boolean dwarf2_loc_directive_seen;
208 /* TRUE when we're supposed to set the basic block mark whenever a
210 bfd_boolean dwarf2_loc_mark_labels;
212 /* Current location as indicated by the most recent .loc directive. */
213 static struct dwarf2_line_info current = {
215 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
219 /* Lines that are at the same location as CURRENT, and which are waiting
221 static struct line_entry *pending_lines, **pending_lines_tail = &pending_lines;
223 /* The size of an address on the target. */
224 static unsigned int sizeof_address;
226 static unsigned int get_filenum (const char *, unsigned int);
228 #ifndef TC_DWARF2_EMIT_OFFSET
229 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
231 /* Create an offset to .dwarf2_*. */
234 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
239 exp.X_add_symbol = symbol;
240 exp.X_add_number = 0;
241 emit_expr (&exp, size);
245 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
247 static struct line_subseg *
248 get_line_subseg (segT seg, subsegT subseg)
250 static segT last_seg;
251 static subsegT last_subseg;
252 static struct line_subseg *last_line_subseg;
255 struct line_subseg **pss, *lss;
257 if (seg == last_seg && subseg == last_subseg)
258 return last_line_subseg;
260 s = (struct line_seg *) hash_find (all_segs_hash, seg->name);
263 s = (struct line_seg *) xmalloc (sizeof (*s));
268 last_seg_ptr = &s->next;
269 hash_insert (all_segs_hash, seg->name, s);
271 gas_assert (seg == s->seg);
273 for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
275 if (lss->subseg == subseg)
277 if (lss->subseg > subseg)
281 lss = (struct line_subseg *) xmalloc (sizeof (*lss));
283 lss->subseg = subseg;
285 lss->ptail = &lss->head;
290 last_subseg = subseg;
291 last_line_subseg = lss;
296 /* Push LOC onto the pending lines list. */
299 dwarf2_push_line (struct dwarf2_line_info *loc)
301 struct line_entry *e;
303 e = (struct line_entry *) xmalloc (sizeof (*e));
308 *pending_lines_tail = e;
309 pending_lines_tail = &(*pending_lines_tail)->next;
312 /* Emit all pending line information. LABEL is the label with which the
313 lines should be associated, or null if they should be associated with
314 the current position. */
317 dwarf2_flush_pending_lines (symbolS *label)
321 struct line_subseg *lss;
322 struct line_entry *e;
325 label = symbol_temp_new_now ();
327 for (e = pending_lines; e; e = e->next)
330 lss = get_line_subseg (now_seg, now_subseg);
331 *lss->ptail = pending_lines;
332 lss->ptail = pending_lines_tail;
334 pending_lines = NULL;
335 pending_lines_tail = &pending_lines;
339 /* Record an entry for LOC occurring at OFS within the current fragment. */
342 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
344 static unsigned int line = -1;
345 static unsigned int filenum = -1;
347 /* Early out for as-yet incomplete location information. */
348 if (loc->filenum == 0 || loc->line == 0)
351 /* Don't emit sequences of line symbols for the same line when the
352 symbols apply to assembler code. It is necessary to emit
353 duplicate line symbols when a compiler asks for them, because GDB
354 uses them to determine the end of the prologue. */
355 if (debug_type == DEBUG_DWARF2
356 && line == loc->line && filenum == loc->filenum)
360 filenum = loc->filenum;
362 dwarf2_push_line (loc);
367 /* Use a non-fake name for the line number location,
368 so that it can be referred to by relocations. */
369 sprintf (name, ".Loc.%u.%u", line, filenum);
370 dwarf2_flush_pending_lines (symbol_new (name, now_seg, ofs, frag_now));
373 dwarf2_flush_pending_lines (symbol_temp_new (now_seg, ofs, frag_now));
376 /* Returns the current source information. If .file directives have
377 been encountered, the info for the corresponding source file is
378 returned. Otherwise, the info for the assembly source file is
382 dwarf2_where (struct dwarf2_line_info *line)
384 if (debug_type == DEBUG_DWARF2)
387 as_where (&filename, &line->line);
388 line->filenum = get_filenum (filename, 0);
390 line->flags = DWARF2_FLAG_IS_STMT;
391 line->isa = current.isa;
392 line->discriminator = current.discriminator;
398 /* A hook to allow the target backend to inform the line number state
399 machine of isa changes when assembler debug info is enabled. */
402 dwarf2_set_isa (unsigned int isa)
407 /* Called for each machine instruction, or relatively atomic group of
408 machine instructions (ie built-in macro). The instruction or group
409 is SIZE bytes in length. If dwarf2 line number generation is called
410 for, emit a line statement appropriately. */
413 dwarf2_emit_insn (int size)
415 struct dwarf2_line_info loc;
417 if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
422 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
423 dwarf2_consume_line_info ();
426 /* Called after the current line information has been either used with
427 dwarf2_gen_line_info or saved with a machine instruction for later use.
428 This resets the state of the line number information to reflect that
432 dwarf2_consume_line_info (void)
434 /* If the consumer has stashed the current location away for later use,
435 assume that any earlier location information should be associated
437 dwarf2_flush_pending_lines (NULL);
439 /* Unless we generate DWARF2 debugging information for each
440 assembler line, we only emit one line symbol for one LOC. */
441 dwarf2_loc_directive_seen = FALSE;
443 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
444 | DWARF2_FLAG_PROLOGUE_END
445 | DWARF2_FLAG_EPILOGUE_BEGIN);
446 current.discriminator = 0;
449 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
450 is enabled, emit a basic block marker. */
453 dwarf2_emit_label (symbolS *label)
455 struct dwarf2_line_info loc;
457 if (!dwarf2_loc_mark_labels)
459 if (S_GET_SEGMENT (label) != now_seg)
461 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
463 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
468 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
470 dwarf2_push_line (&loc);
471 dwarf2_flush_pending_lines (label);
472 dwarf2_consume_line_info ();
475 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
476 allocate it on that file table slot, otherwise return the first
480 get_filenum (const char *filename, unsigned int num)
482 static unsigned int last_used, last_used_dir_len;
487 if (num == 0 && last_used)
489 if (! files[last_used].dir
490 && filename_cmp (filename, files[last_used].filename) == 0)
492 if (files[last_used].dir
493 && filename_ncmp (filename, dirs[files[last_used].dir],
494 last_used_dir_len) == 0
495 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
496 && filename_cmp (filename + last_used_dir_len + 1,
497 files[last_used].filename) == 0)
501 file = lbasename (filename);
502 /* Don't make empty string from / or A: from A:/ . */
503 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
504 if (file <= filename + 3)
507 if (file == filename + 1)
510 dir_len = file - filename;
515 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
518 for (dir = 1; dir < dirs_in_use; ++dir)
519 if (filename_ncmp (filename, dirs[dir], dir_len) == 0
520 && dirs[dir][dir_len] == '\0')
523 if (dir >= dirs_in_use)
525 if (dir >= dirs_allocated)
527 dirs_allocated = dir + 32;
529 xrealloc (dirs, (dir + 32) * sizeof (const char *));
532 dirs[dir] = (char *) xmalloc (dir_len + 1);
533 memcpy (dirs[dir], filename, dir_len);
534 dirs[dir][dir_len] = '\0';
535 dirs_in_use = dir + 1;
541 for (i = 1; i < files_in_use; ++i)
542 if (files[i].dir == dir
544 && filename_cmp (file, files[i].filename) == 0)
547 last_used_dir_len = dir_len;
554 if (i >= files_allocated)
556 unsigned int old = files_allocated;
558 files_allocated = i + 32;
559 files = (struct file_entry *)
560 xrealloc (files, (i + 32) * sizeof (struct file_entry));
562 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
565 files[i].filename = num ? file : xstrdup (file);
567 if (files_in_use < i + 1)
568 files_in_use = i + 1;
570 last_used_dir_len = dir_len;
575 /* Handle two forms of .file directive:
576 - Pass .file "source.c" to s_app_file
577 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
579 If an entry is added to the file table, return a pointer to the filename. */
582 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
588 /* Continue to accept a bare string and pass it off. */
590 if (*input_line_pointer == '"')
596 num = get_absolute_expression ();
597 filename = demand_copy_C_string (&filename_len);
598 if (filename == NULL)
600 demand_empty_rest_of_line ();
604 as_bad (_("file number less than one"));
608 /* A .file directive implies compiler generated debug information is
609 being supplied. Turn off gas generated debug info. */
610 debug_type = DEBUG_NONE;
612 if (num < (int) files_in_use && files[num].filename != 0)
614 as_bad (_("file number %ld already allocated"), (long) num);
618 get_filenum (filename, num);
624 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
626 offsetT filenum, line;
628 /* If we see two .loc directives in a row, force the first one to be
630 if (dwarf2_loc_directive_seen)
631 dwarf2_push_line (¤t);
633 filenum = get_absolute_expression ();
635 line = get_absolute_expression ();
639 as_bad (_("file number less than one"));
642 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
644 as_bad (_("unassigned file number %ld"), (long) filenum);
648 current.filenum = filenum;
650 current.discriminator = 0;
655 if (files[filenum].dir)
657 size_t dir_len = strlen (dirs[files[filenum].dir]);
658 size_t file_len = strlen (files[filenum].filename);
659 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
661 memcpy (cp, dirs[files[filenum].dir], dir_len);
662 INSERT_DIR_SEPARATOR (cp, dir_len);
663 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
664 cp[dir_len + file_len + 1] = '\0';
665 listing_source_file (cp);
668 listing_source_file (files[filenum].filename);
669 listing_source_line (line);
674 if (ISDIGIT (*input_line_pointer))
676 current.column = get_absolute_expression ();
680 while (ISALPHA (*input_line_pointer))
685 p = input_line_pointer;
686 c = get_symbol_end ();
688 if (strcmp (p, "basic_block") == 0)
690 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
691 *input_line_pointer = c;
693 else if (strcmp (p, "prologue_end") == 0)
695 current.flags |= DWARF2_FLAG_PROLOGUE_END;
696 *input_line_pointer = c;
698 else if (strcmp (p, "epilogue_begin") == 0)
700 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
701 *input_line_pointer = c;
703 else if (strcmp (p, "is_stmt") == 0)
705 *input_line_pointer = c;
706 value = get_absolute_expression ();
708 current.flags &= ~DWARF2_FLAG_IS_STMT;
710 current.flags |= DWARF2_FLAG_IS_STMT;
713 as_bad (_("is_stmt value not 0 or 1"));
717 else if (strcmp (p, "isa") == 0)
719 *input_line_pointer = c;
720 value = get_absolute_expression ();
725 as_bad (_("isa number less than zero"));
729 else if (strcmp (p, "discriminator") == 0)
731 *input_line_pointer = c;
732 value = get_absolute_expression ();
734 current.discriminator = value;
737 as_bad (_("discriminator less than zero"));
743 as_bad (_("unknown .loc sub-directive `%s'"), p);
744 *input_line_pointer = c;
751 demand_empty_rest_of_line ();
752 dwarf2_loc_directive_seen = TRUE;
753 debug_type = DEBUG_NONE;
757 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
759 offsetT value = get_absolute_expression ();
761 if (value != 0 && value != 1)
763 as_bad (_("expected 0 or 1"));
764 ignore_rest_of_line ();
768 dwarf2_loc_mark_labels = value != 0;
769 demand_empty_rest_of_line ();
774 first_frag_for_seg (segT seg)
776 return seg_info (seg)->frchainP->frch_root;
780 last_frag_for_seg (segT seg)
782 frchainS *f = seg_info (seg)->frchainP;
784 while (f->frch_next != NULL)
790 /* Emit a single byte into the current segment. */
795 FRAG_APPEND_1_CHAR (byte);
798 /* Emit a statement program opcode into the current segment. */
806 /* Emit a two-byte word into the current segment. */
811 md_number_to_chars (frag_more (2), data, 2);
814 /* Emit a four byte word into the current segment. */
819 md_number_to_chars (frag_more (4), data, 4);
822 /* Emit an unsigned "little-endian base 128" number. */
825 out_uleb128 (addressT value)
827 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
830 /* Emit a signed "little-endian base 128" number. */
833 out_leb128 (addressT value)
835 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
838 /* Emit a tuple for .debug_abbrev. */
841 out_abbrev (int name, int form)
847 /* Get the size of a fragment. */
850 get_frag_fix (fragS *frag, segT seg)
857 /* If a fragment is the last in the chain, special measures must be
858 taken to find its size before relaxation, since it may be pending
859 on some subsegment chain. */
860 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
861 if (fr->frch_last == frag)
862 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
867 /* Set an absolute address (may result in a relocation entry). */
870 out_set_addr (symbolS *sym)
874 out_opcode (DW_LNS_extended_op);
875 out_uleb128 (sizeof_address + 1);
877 out_opcode (DW_LNE_set_address);
879 exp.X_add_symbol = sym;
880 exp.X_add_number = 0;
881 emit_expr (&exp, sizeof_address);
884 static void scale_addr_delta (addressT *);
887 scale_addr_delta (addressT *addr_delta)
889 static int printed_this = 0;
890 if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
892 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
894 as_bad("unaligned opcodes detected in executable segment");
897 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
901 /* Encode a pair of line and address skips as efficiently as possible.
902 Note that the line skip is signed, whereas the address skip is unsigned.
904 The following two routines *must* be kept in sync. This is
905 enforced by making emit_inc_line_addr abort if we do not emit
906 exactly the expected number of bytes. */
909 size_inc_line_addr (int line_delta, addressT addr_delta)
911 unsigned int tmp, opcode;
914 /* Scale the address delta by the minimum instruction length. */
915 scale_addr_delta (&addr_delta);
917 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
918 We cannot use special opcodes here, since we want the end_sequence
919 to emit the matrix entry. */
920 if (line_delta == INT_MAX)
922 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
925 len = 1 + sizeof_leb128 (addr_delta, 0);
929 /* Bias the line delta by the base. */
930 tmp = line_delta - DWARF2_LINE_BASE;
932 /* If the line increment is out of range of a special opcode, we
933 must encode it with DW_LNS_advance_line. */
934 if (tmp >= DWARF2_LINE_RANGE)
936 len = 1 + sizeof_leb128 (line_delta, 1);
938 tmp = 0 - DWARF2_LINE_BASE;
941 /* Bias the opcode by the special opcode base. */
942 tmp += DWARF2_LINE_OPCODE_BASE;
944 /* Avoid overflow when addr_delta is large. */
945 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
947 /* Try using a special opcode. */
948 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
952 /* Try using DW_LNS_const_add_pc followed by special op. */
953 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
958 /* Otherwise use DW_LNS_advance_pc. */
959 len += 1 + sizeof_leb128 (addr_delta, 0);
961 /* DW_LNS_copy or special opcode. */
968 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
970 unsigned int tmp, opcode;
974 /* Line number sequences cannot go backward in addresses. This means
975 we've incorrectly ordered the statements in the sequence. */
976 gas_assert ((offsetT) addr_delta >= 0);
978 /* Scale the address delta by the minimum instruction length. */
979 scale_addr_delta (&addr_delta);
981 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
982 We cannot use special opcodes here, since we want the end_sequence
983 to emit the matrix entry. */
984 if (line_delta == INT_MAX)
986 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
987 *p++ = DW_LNS_const_add_pc;
990 *p++ = DW_LNS_advance_pc;
991 p += output_leb128 (p, addr_delta, 0);
994 *p++ = DW_LNS_extended_op;
996 *p++ = DW_LNE_end_sequence;
1000 /* Bias the line delta by the base. */
1001 tmp = line_delta - DWARF2_LINE_BASE;
1003 /* If the line increment is out of range of a special opcode, we
1004 must encode it with DW_LNS_advance_line. */
1005 if (tmp >= DWARF2_LINE_RANGE)
1007 *p++ = DW_LNS_advance_line;
1008 p += output_leb128 (p, line_delta, 1);
1011 tmp = 0 - DWARF2_LINE_BASE;
1015 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1017 if (line_delta == 0 && addr_delta == 0)
1023 /* Bias the opcode by the special opcode base. */
1024 tmp += DWARF2_LINE_OPCODE_BASE;
1026 /* Avoid overflow when addr_delta is large. */
1027 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1029 /* Try using a special opcode. */
1030 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1037 /* Try using DW_LNS_const_add_pc followed by special op. */
1038 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1041 *p++ = DW_LNS_const_add_pc;
1047 /* Otherwise use DW_LNS_advance_pc. */
1048 *p++ = DW_LNS_advance_pc;
1049 p += output_leb128 (p, addr_delta, 0);
1057 gas_assert (p == end);
1060 /* Handy routine to combine calls to the above two routines. */
1063 out_inc_line_addr (int line_delta, addressT addr_delta)
1065 int len = size_inc_line_addr (line_delta, addr_delta);
1066 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1069 /* Write out an alternative form of line and address skips using
1070 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1071 line and address information, but it is required if linker relaxation
1072 could change the code offsets. The following two routines *must* be
1074 #define ADDR_DELTA_LIMIT 50000
1077 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1081 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1082 if (line_delta != INT_MAX)
1083 len = 1 + sizeof_leb128 (line_delta, 1);
1085 if (addr_delta > ADDR_DELTA_LIMIT)
1087 /* DW_LNS_extended_op */
1088 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1089 /* DW_LNE_set_address */
1090 len += 1 + sizeof_address;
1093 /* DW_LNS_fixed_advance_pc */
1096 if (line_delta == INT_MAX)
1097 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1107 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1111 char *end = p + len;
1113 /* Line number sequences cannot go backward in addresses. This means
1114 we've incorrectly ordered the statements in the sequence. */
1115 gas_assert ((offsetT) addr_delta >= 0);
1117 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1118 gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
1120 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1121 if (line_delta != INT_MAX)
1123 *p++ = DW_LNS_advance_line;
1124 p += output_leb128 (p, line_delta, 1);
1127 pexp = symbol_get_value_expression (frag->fr_symbol);
1129 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1130 advance the address by at most 64K. Linker relaxation (without
1131 which this function would not be used) could change the operand by
1132 an unknown amount. If the address increment is getting close to
1133 the limit, just reset the address. */
1134 if (addr_delta > ADDR_DELTA_LIMIT)
1139 gas_assert (pexp->X_op == O_subtract);
1140 to_sym = pexp->X_add_symbol;
1142 *p++ = DW_LNS_extended_op;
1143 p += output_leb128 (p, sizeof_address + 1, 0);
1144 *p++ = DW_LNE_set_address;
1145 exp.X_op = O_symbol;
1146 exp.X_add_symbol = to_sym;
1147 exp.X_add_number = 0;
1148 emit_expr_fix (&exp, sizeof_address, frag, p);
1149 p += sizeof_address;
1153 *p++ = DW_LNS_fixed_advance_pc;
1154 emit_expr_fix (pexp, 2, frag, p);
1158 if (line_delta == INT_MAX)
1160 *p++ = DW_LNS_extended_op;
1162 *p++ = DW_LNE_end_sequence;
1167 gas_assert (p == end);
1170 /* Generate a variant frag that we can use to relax address/line
1171 increments between fragments of the target segment. */
1174 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1179 exp.X_op = O_subtract;
1180 exp.X_add_symbol = to_sym;
1181 exp.X_op_symbol = from_sym;
1182 exp.X_add_number = 0;
1184 /* The maximum size of the frag is the line delta with a maximum
1185 sized address delta. */
1186 if (DWARF2_USE_FIXED_ADVANCE_PC)
1187 max_chars = size_fixed_inc_line_addr (line_delta,
1188 -DWARF2_LINE_MIN_INSN_LENGTH);
1190 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1192 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1193 make_expr_symbol (&exp), line_delta, NULL);
1196 /* The function estimates the size of a rs_dwarf2dbg variant frag
1197 based on the current values of the symbols. It is called before
1198 the relaxation loop. We set fr_subtype to the expected length. */
1201 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1206 addr_delta = resolve_symbol_value (frag->fr_symbol);
1207 if (DWARF2_USE_FIXED_ADVANCE_PC)
1208 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1210 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1212 frag->fr_subtype = size;
1217 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1218 current values of the symbols. fr_subtype is the current length
1219 of the frag. This returns the change in frag length. */
1222 dwarf2dbg_relax_frag (fragS *frag)
1224 int old_size, new_size;
1226 old_size = frag->fr_subtype;
1227 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1229 return new_size - old_size;
1232 /* This function converts a rs_dwarf2dbg variant frag into a normal
1233 fill frag. This is called after all relaxation has been done.
1234 fr_subtype will be the desired length of the frag. */
1237 dwarf2dbg_convert_frag (fragS *frag)
1241 if (DWARF2_USE_FIXED_ADVANCE_PC)
1243 /* If linker relaxation is enabled then the distance bewteen the two
1244 symbols in the frag->fr_symbol expression might change. Hence we
1245 cannot rely upon the value computed by resolve_symbol_value.
1246 Instead we leave the expression unfinalized and allow
1247 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1248 relocation) that will allow the linker to correctly compute the
1249 actual address difference. We have to use a fixed line advance for
1250 this as we cannot (easily) relocate leb128 encoded values. */
1251 int saved_finalize_syms = finalize_syms;
1254 addr_diff = resolve_symbol_value (frag->fr_symbol);
1255 finalize_syms = saved_finalize_syms;
1258 addr_diff = resolve_symbol_value (frag->fr_symbol);
1260 /* fr_var carries the max_chars that we created the fragment with.
1261 fr_subtype carries the current expected length. We must, of
1262 course, have allocated enough memory earlier. */
1263 gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1265 if (DWARF2_USE_FIXED_ADVANCE_PC)
1266 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1267 frag->fr_literal + frag->fr_fix,
1270 emit_inc_line_addr (frag->fr_offset, addr_diff,
1271 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1273 frag->fr_fix += frag->fr_subtype;
1274 frag->fr_type = rs_fill;
1276 frag->fr_offset = 0;
1279 /* Generate .debug_line content for the chain of line number entries
1280 beginning at E, for segment SEG. */
1283 process_entries (segT seg, struct line_entry *e)
1285 unsigned filenum = 1;
1287 unsigned column = 0;
1289 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1290 fragS *last_frag = NULL, *frag;
1291 addressT last_frag_ofs = 0, frag_ofs;
1292 symbolS *last_lab = NULL, *lab;
1293 struct line_entry *next;
1295 if (flag_dwarf_sections)
1298 const char * sec_name;
1300 /* Switch to the relevent sub-section before we start to emit
1301 the line number table.
1303 FIXME: These sub-sections do not have a normal Line Number
1304 Program Header, thus strictly speaking they are not valid
1305 DWARF sections. Unfortunately the DWARF standard assumes
1306 a one-to-one relationship between compilation units and
1307 line number tables. Thus we have to have a .debug_line
1308 section, as well as our sub-sections, and we have to ensure
1309 that all of the sub-sections are merged into a proper
1310 .debug_line section before a debugger sees them. */
1312 sec_name = bfd_get_section_name (stdoutput, seg);
1313 if (strcmp (sec_name, ".text") != 0)
1317 len = strlen (sec_name);
1318 name = xmalloc (len + 11 + 2);
1319 sprintf (name, ".debug_line%s", sec_name);
1320 subseg_set (subseg_get (name, FALSE), 0);
1323 /* Don't create a .debug_line.text section -
1324 that is redundant. Instead just switch back to the
1325 normal .debug_line section. */
1326 subseg_set (subseg_get (".debug_line", FALSE), 0);
1333 if (filenum != e->loc.filenum)
1335 filenum = e->loc.filenum;
1336 out_opcode (DW_LNS_set_file);
1337 out_uleb128 (filenum);
1340 if (column != e->loc.column)
1342 column = e->loc.column;
1343 out_opcode (DW_LNS_set_column);
1344 out_uleb128 (column);
1347 if (e->loc.discriminator != 0)
1349 out_opcode (DW_LNS_extended_op);
1350 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1351 out_opcode (DW_LNE_set_discriminator);
1352 out_uleb128 (e->loc.discriminator);
1355 if (isa != e->loc.isa)
1358 out_opcode (DW_LNS_set_isa);
1362 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1364 flags = e->loc.flags;
1365 out_opcode (DW_LNS_negate_stmt);
1368 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1369 out_opcode (DW_LNS_set_basic_block);
1371 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1372 out_opcode (DW_LNS_set_prologue_end);
1374 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1375 out_opcode (DW_LNS_set_epilogue_begin);
1377 /* Don't try to optimize away redundant entries; gdb wants two
1378 entries for a function where the code starts on the same line as
1379 the {, and there's no way to identify that case here. Trust gcc
1380 to optimize appropriately. */
1381 line_delta = e->loc.line - line;
1383 frag = symbol_get_frag (lab);
1384 frag_ofs = S_GET_VALUE (lab);
1386 if (last_frag == NULL)
1389 out_inc_line_addr (line_delta, 0);
1391 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1392 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1394 relax_inc_line_addr (line_delta, lab, last_lab);
1399 last_frag_ofs = frag_ofs;
1407 /* Emit a DW_LNE_end_sequence for the end of the section. */
1408 frag = last_frag_for_seg (seg);
1409 frag_ofs = get_frag_fix (frag, seg);
1410 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1411 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1414 lab = symbol_temp_new (seg, frag_ofs, frag);
1415 relax_inc_line_addr (INT_MAX, lab, last_lab);
1419 /* Emit the directory and file tables for .debug_line. */
1422 out_file_list (void)
1429 /* Emit directory list. */
1430 for (i = 1; i < dirs_in_use; ++i)
1432 dir = remap_debug_filename (dirs[i]);
1433 size = strlen (dir) + 1;
1434 cp = frag_more (size);
1435 memcpy (cp, dir, size);
1440 for (i = 1; i < files_in_use; ++i)
1442 const char *fullfilename;
1444 if (files[i].filename == NULL)
1446 as_bad (_("unassigned file number %ld"), (long) i);
1447 /* Prevent a crash later, particularly for file 1. */
1448 files[i].filename = "";
1452 fullfilename = DWARF2_FILE_NAME (files[i].filename,
1453 files[i].dir ? dirs [files [i].dir] : "");
1454 size = strlen (fullfilename) + 1;
1455 cp = frag_more (size);
1456 memcpy (cp, fullfilename, size);
1458 out_uleb128 (files[i].dir); /* directory number */
1459 /* Output the last modification timestamp. */
1460 out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1461 files[i].dir ? dirs [files [i].dir] : ""));
1462 /* Output the filesize. */
1463 out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1464 files[i].dir ? dirs [files [i].dir] : ""));
1467 /* Terminate filename list. */
1471 /* Switch to SEC and output a header length field. Return the size of
1472 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1473 to the end of the section. */
1476 out_header (asection *sec, expressionS *exp)
1481 subseg_set (sec, 0);
1482 start_sym = symbol_temp_new_now ();
1483 end_sym = symbol_temp_make ();
1485 /* Total length of the information. */
1486 exp->X_op = O_subtract;
1487 exp->X_add_symbol = end_sym;
1488 exp->X_op_symbol = start_sym;
1490 switch (DWARF2_FORMAT (sec))
1492 case dwarf2_format_32bit:
1493 exp->X_add_number = -4;
1497 case dwarf2_format_64bit:
1498 exp->X_add_number = -12;
1503 case dwarf2_format_64bit_irix:
1504 exp->X_add_number = -8;
1509 as_fatal (_("internal error: unknown dwarf2 format"));
1513 /* Emit the collected .debug_line data. */
1516 out_debug_line (segT line_seg)
1519 symbolS *prologue_end;
1524 sizeof_offset = out_header (line_seg, &exp);
1525 line_end = exp.X_add_symbol;
1528 out_two (DWARF2_LINE_VERSION);
1530 /* Length of the prologue following this length. */
1531 prologue_end = symbol_temp_make ();
1532 exp.X_add_symbol = prologue_end;
1533 exp.X_add_number = - (4 + 2 + 4);
1534 emit_expr (&exp, sizeof_offset);
1536 /* Parameters of the state machine. */
1537 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1538 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1539 out_byte (DWARF2_LINE_BASE);
1540 out_byte (DWARF2_LINE_RANGE);
1541 out_byte (DWARF2_LINE_OPCODE_BASE);
1543 /* Standard opcode lengths. */
1544 out_byte (0); /* DW_LNS_copy */
1545 out_byte (1); /* DW_LNS_advance_pc */
1546 out_byte (1); /* DW_LNS_advance_line */
1547 out_byte (1); /* DW_LNS_set_file */
1548 out_byte (1); /* DW_LNS_set_column */
1549 out_byte (0); /* DW_LNS_negate_stmt */
1550 out_byte (0); /* DW_LNS_set_basic_block */
1551 out_byte (0); /* DW_LNS_const_add_pc */
1552 out_byte (1); /* DW_LNS_fixed_advance_pc */
1553 out_byte (0); /* DW_LNS_set_prologue_end */
1554 out_byte (0); /* DW_LNS_set_epilogue_begin */
1555 out_byte (1); /* DW_LNS_set_isa */
1559 symbol_set_value_now (prologue_end);
1561 /* For each section, emit a statement program. */
1562 for (s = all_segs; s; s = s->next)
1563 if (SEG_NORMAL (s->seg))
1564 process_entries (s->seg, s->head->head);
1566 as_warn ("dwarf line number information for %s ignored",
1567 segment_name (s->seg));
1569 if (flag_dwarf_sections)
1570 /* We have to switch to the special .debug_line_end section
1571 before emitting the end-of-debug_line symbol. The linker
1572 script arranges for this section to be placed after all the
1573 (potentially garbage collected) .debug_line.<foo> sections.
1574 This section contains the line_end symbol which is used to
1575 compute the size of the linked .debug_line section, as seen
1576 in the DWARF Line Number header. */
1577 subseg_set (subseg_get (".debug_line_end", FALSE), 0);
1579 symbol_set_value_now (line_end);
1583 out_debug_ranges (segT ranges_seg)
1585 unsigned int addr_size = sizeof_address;
1590 subseg_set (ranges_seg, 0);
1592 /* Base Address Entry. */
1593 for (i = 0; i < addr_size; i++)
1595 for (i = 0; i < addr_size; i++)
1598 /* Range List Entry. */
1599 for (s = all_segs; s; s = s->next)
1604 frag = first_frag_for_seg (s->seg);
1605 beg = symbol_temp_new (s->seg, 0, frag);
1606 s->text_start = beg;
1608 frag = last_frag_for_seg (s->seg);
1609 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1612 exp.X_op = O_symbol;
1613 exp.X_add_symbol = beg;
1614 exp.X_add_number = 0;
1615 emit_expr (&exp, addr_size);
1617 exp.X_op = O_symbol;
1618 exp.X_add_symbol = end;
1619 exp.X_add_number = 0;
1620 emit_expr (&exp, addr_size);
1623 /* End of Range Entry. */
1624 for (i = 0; i < addr_size; i++)
1626 for (i = 0; i < addr_size; i++)
1630 /* Emit data for .debug_aranges. */
1633 out_debug_aranges (segT aranges_seg, segT info_seg)
1635 unsigned int addr_size = sizeof_address;
1638 symbolS *aranges_end;
1642 sizeof_offset = out_header (aranges_seg, &exp);
1643 aranges_end = exp.X_add_symbol;
1646 out_two (DWARF2_ARANGES_VERSION);
1648 /* Offset to .debug_info. */
1649 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1651 /* Size of an address (offset portion). */
1652 out_byte (addr_size);
1654 /* Size of a segment descriptor. */
1657 /* Align the header. */
1658 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1660 for (s = all_segs; s; s = s->next)
1665 frag = first_frag_for_seg (s->seg);
1666 beg = symbol_temp_new (s->seg, 0, frag);
1667 s->text_start = beg;
1669 frag = last_frag_for_seg (s->seg);
1670 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1673 exp.X_op = O_symbol;
1674 exp.X_add_symbol = beg;
1675 exp.X_add_number = 0;
1676 emit_expr (&exp, addr_size);
1678 exp.X_op = O_subtract;
1679 exp.X_add_symbol = end;
1680 exp.X_op_symbol = beg;
1681 exp.X_add_number = 0;
1682 emit_expr (&exp, addr_size);
1685 p = frag_more (2 * addr_size);
1686 md_number_to_chars (p, 0, addr_size);
1687 md_number_to_chars (p + addr_size, 0, addr_size);
1689 symbol_set_value_now (aranges_end);
1692 /* Emit data for .debug_abbrev. Note that this must be kept in
1693 sync with out_debug_info below. */
1696 out_debug_abbrev (segT abbrev_seg,
1697 segT info_seg ATTRIBUTE_UNUSED,
1698 segT line_seg ATTRIBUTE_UNUSED)
1700 subseg_set (abbrev_seg, 0);
1703 out_uleb128 (DW_TAG_compile_unit);
1704 out_byte (DW_CHILDREN_no);
1705 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1706 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1708 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1709 if (all_segs->next == NULL)
1711 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1712 if (DWARF2_VERSION < 4)
1713 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1715 out_abbrev (DW_AT_high_pc, (sizeof_address == 4
1716 ? DW_FORM_data4 : DW_FORM_data8));
1720 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1721 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1723 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1725 out_abbrev (DW_AT_name, DW_FORM_string);
1726 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1727 out_abbrev (DW_AT_producer, DW_FORM_string);
1728 out_abbrev (DW_AT_language, DW_FORM_data2);
1731 /* Terminate the abbreviations for this compilation unit. */
1735 /* Emit a description of this compilation unit for .debug_info. */
1738 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1741 const char *comp_dir;
1742 const char *dirname;
1749 sizeof_offset = out_header (info_seg, &exp);
1750 info_end = exp.X_add_symbol;
1752 /* DWARF version. */
1753 out_two (DWARF2_VERSION);
1755 /* .debug_abbrev offset */
1756 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1758 /* Target address size. */
1759 out_byte (sizeof_address);
1761 /* DW_TAG_compile_unit DIE abbrev */
1764 /* DW_AT_stmt_list */
1765 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
1766 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
1769 /* These two attributes are emitted if all of the code is contiguous. */
1770 if (all_segs->next == NULL)
1773 exp.X_op = O_symbol;
1774 exp.X_add_symbol = all_segs->text_start;
1775 exp.X_add_number = 0;
1776 emit_expr (&exp, sizeof_address);
1779 if (DWARF2_VERSION < 4)
1780 exp.X_op = O_symbol;
1783 exp.X_op = O_subtract;
1784 exp.X_op_symbol = all_segs->text_start;
1786 exp.X_add_symbol = all_segs->text_end;
1787 exp.X_add_number = 0;
1788 emit_expr (&exp, sizeof_address);
1792 /* This attribute is emitted if the code is disjoint. */
1794 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1797 /* DW_AT_name. We don't have the actual file name that was present
1798 on the command line, so assume files[1] is the main input file.
1799 We're not supposed to get called unless at least one line number
1800 entry was emitted, so this should always be defined. */
1801 if (files_in_use == 0)
1805 dirname = remap_debug_filename (dirs[files[1].dir]);
1806 len = strlen (dirname);
1808 /* Already has trailing slash. */
1809 p = frag_more (len);
1810 memcpy (p, dirname, len);
1812 p = frag_more (len + 1);
1813 memcpy (p, dirname, len);
1814 INSERT_DIR_SEPARATOR (p, len);
1817 len = strlen (files[1].filename) + 1;
1818 p = frag_more (len);
1819 memcpy (p, files[1].filename, len);
1821 /* DW_AT_comp_dir */
1822 comp_dir = remap_debug_filename (getpwd ());
1823 len = strlen (comp_dir) + 1;
1824 p = frag_more (len);
1825 memcpy (p, comp_dir, len);
1827 /* DW_AT_producer */
1828 sprintf (producer, "GNU AS %s", VERSION);
1829 len = strlen (producer) + 1;
1830 p = frag_more (len);
1831 memcpy (p, producer, len);
1833 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1834 dwarf2 draft has no standard code for assembler. */
1835 out_two (DW_LANG_Mips_Assembler);
1837 symbol_set_value_now (info_end);
1843 all_segs_hash = hash_new ();
1844 last_seg_ptr = &all_segs;
1848 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1849 were any .file/.loc directives, or --gdwarf2 was given, or if the
1850 file has a non-empty .debug_info section and an empty .debug_line
1851 section. If we emit .debug_line, and the .debug_info section is
1852 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1853 ALL_SEGS will be non-null if there were any .file/.loc directives,
1854 or --gdwarf2 was given and there were any located instructions
1858 dwarf2_finish (void)
1863 int emit_other_sections = 0;
1864 int empty_debug_line = 0;
1866 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1867 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1869 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
1870 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
1872 /* We can't construct a new debug_line section if we already have one.
1874 if (all_segs && !empty_debug_line)
1875 as_fatal ("duplicate .debug_line sections");
1877 if ((!all_segs && emit_other_sections)
1878 || (!emit_other_sections && !empty_debug_line))
1879 /* If there is no line information and no non-empty .debug_info
1880 section, or if there is both a non-empty .debug_info and a non-empty
1881 .debug_line, then we do nothing. */
1884 /* Calculate the size of an address for the target machine. */
1885 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1887 /* Create and switch to the line number section. */
1888 line_seg = subseg_new (".debug_line", 0);
1889 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1891 /* For each subsection, chain the debug entries together. */
1892 for (s = all_segs; s; s = s->next)
1894 struct line_subseg *lss = s->head;
1895 struct line_entry **ptail = lss->ptail;
1897 while ((lss = lss->next) != NULL)
1904 out_debug_line (line_seg);
1906 /* If this is assembler generated line info, and there is no
1907 debug_info already, we need .debug_info and .debug_abbrev
1908 sections as well. */
1909 if (emit_other_sections)
1915 gas_assert (all_segs);
1917 info_seg = subseg_new (".debug_info", 0);
1918 abbrev_seg = subseg_new (".debug_abbrev", 0);
1919 aranges_seg = subseg_new (".debug_aranges", 0);
1921 bfd_set_section_flags (stdoutput, info_seg,
1922 SEC_READONLY | SEC_DEBUGGING);
1923 bfd_set_section_flags (stdoutput, abbrev_seg,
1924 SEC_READONLY | SEC_DEBUGGING);
1925 bfd_set_section_flags (stdoutput, aranges_seg,
1926 SEC_READONLY | SEC_DEBUGGING);
1928 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1930 if (all_segs->next == NULL)
1934 ranges_seg = subseg_new (".debug_ranges", 0);
1935 bfd_set_section_flags (stdoutput, ranges_seg,
1936 SEC_READONLY | SEC_DEBUGGING);
1937 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1938 out_debug_ranges (ranges_seg);
1941 out_debug_aranges (aranges_seg, info_seg);
1942 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
1943 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);