1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2018 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 opcode - 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)
161 #ifndef TC_PARSE_CONS_RETURN_NONE
162 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
167 struct line_entry *next;
169 struct dwarf2_line_info loc;
172 /* Don't change the offset of next in line_entry. set_or_check_view
173 calls in dwarf2_gen_line_info_1 depend on it. */
174 static char unused[offsetof(struct line_entry, next) ? -1 : 1]
179 struct line_subseg *next;
181 struct line_entry *head;
182 struct line_entry **ptail;
183 struct line_entry **pmove_tail;
188 struct line_seg *next;
190 struct line_subseg *head;
195 /* Collects data for all line table entries during assembly. */
196 static struct line_seg *all_segs;
197 static struct line_seg **last_seg_ptr;
201 const char *filename;
205 /* Table of files used by .debug_line. */
206 static struct file_entry *files;
207 static unsigned int files_in_use;
208 static unsigned int files_allocated;
210 /* Table of directories used by .debug_line. */
212 static unsigned int dirs_in_use;
213 static unsigned int dirs_allocated;
215 /* TRUE when we've seen a .loc directive recently. Used to avoid
216 doing work when there's nothing to do. */
217 bfd_boolean dwarf2_loc_directive_seen;
219 /* TRUE when we're supposed to set the basic block mark whenever a
221 bfd_boolean dwarf2_loc_mark_labels;
223 /* Current location as indicated by the most recent .loc directive. */
224 static struct dwarf2_line_info current =
227 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
231 /* This symbol is used to recognize view number forced resets in loc
233 static symbolS *force_reset_view;
235 /* This symbol evaluates to an expression that, if nonzero, indicates
236 some view assert check failed. */
237 static symbolS *view_assert_failed;
239 /* The size of an address on the target. */
240 static unsigned int sizeof_address;
242 static unsigned int get_filenum (const char *, unsigned int);
244 #ifndef TC_DWARF2_EMIT_OFFSET
245 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
247 /* Create an offset to .dwarf2_*. */
250 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
254 memset (&exp, 0, sizeof exp);
256 exp.X_add_symbol = symbol;
257 exp.X_add_number = 0;
258 emit_expr (&exp, size);
262 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
264 static struct line_subseg *
265 get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p)
267 struct line_seg *s = seg_info (seg)->dwarf2_line_seg;
268 struct line_subseg **pss, *lss;
275 s = XNEW (struct line_seg);
280 last_seg_ptr = &s->next;
281 seg_info (seg)->dwarf2_line_seg = s;
283 gas_assert (seg == s->seg);
285 for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
287 if (lss->subseg == subseg)
289 if (lss->subseg > subseg)
293 lss = XNEW (struct line_subseg);
295 lss->subseg = subseg;
297 lss->ptail = &lss->head;
298 lss->pmove_tail = &lss->head;
305 /* (Un)reverse the line_entry list starting from H. */
307 static struct line_entry *
308 reverse_line_entry_list (struct line_entry *h)
310 struct line_entry *p = NULL, *e, *n;
312 for (e = h; e; e = n)
321 /* Compute the view for E based on the previous entry P. If we
322 introduce an (undefined) view symbol for P, and H is given (P must
323 be the tail in this case), introduce view symbols for earlier list
324 entries as well, until one of them is constant. */
327 set_or_check_view (struct line_entry *e, struct line_entry *p,
328 struct line_entry *h)
332 memset (&viewx, 0, sizeof (viewx));
333 viewx.X_unsigned = 1;
335 /* First, compute !(E->label > P->label), to tell whether or not
336 we're to reset the view number. If we can't resolve it to a
337 constant, keep it symbolic. */
338 if (!p || (e->loc.view == force_reset_view && force_reset_view))
340 viewx.X_op = O_constant;
341 viewx.X_add_number = 0;
342 viewx.X_add_symbol = NULL;
343 viewx.X_op_symbol = NULL;
348 viewx.X_add_number = 0;
349 viewx.X_add_symbol = e->label;
350 viewx.X_op_symbol = p->label;
351 resolve_expression (&viewx);
352 if (viewx.X_op == O_constant)
353 viewx.X_add_number = !viewx.X_add_number;
356 viewx.X_add_symbol = make_expr_symbol (&viewx);
357 viewx.X_add_number = 0;
358 viewx.X_op_symbol = NULL;
359 viewx.X_op = O_logical_not;
363 if (S_IS_DEFINED (e->loc.view) && symbol_constant_p (e->loc.view))
365 expressionS *value = symbol_get_value_expression (e->loc.view);
366 /* We can't compare the view numbers at this point, because in
367 VIEWX we've only determined whether we're to reset it so
369 if (viewx.X_op == O_constant)
371 if (!value->X_add_number != !viewx.X_add_number)
372 as_bad (_("view number mismatch"));
374 /* Record the expression to check it later. It is the result of
375 a logical not, thus 0 or 1. We just add up all such deferred
376 expressions, and resolve it at the end. */
377 else if (!value->X_add_number)
379 symbolS *deferred = make_expr_symbol (&viewx);
380 if (view_assert_failed)
384 memset (&chk, 0, sizeof (chk));
387 chk.X_add_number = 0;
388 chk.X_add_symbol = view_assert_failed;
389 chk.X_op_symbol = deferred;
390 deferred = make_expr_symbol (&chk);
392 view_assert_failed = deferred;
396 if (viewx.X_op != O_constant || viewx.X_add_number)
402 p->loc.view = symbol_temp_make ();
403 gas_assert (!S_IS_DEFINED (p->loc.view));
406 memset (&incv, 0, sizeof (incv));
408 incv.X_op = O_symbol;
409 incv.X_add_symbol = p->loc.view;
410 incv.X_add_number = 1;
412 if (viewx.X_op == O_constant)
414 gas_assert (viewx.X_add_number == 1);
419 viewx.X_add_symbol = make_expr_symbol (&viewx);
420 viewx.X_add_number = 0;
421 viewx.X_op_symbol = make_expr_symbol (&incv);
422 viewx.X_op = O_multiply;
426 if (!S_IS_DEFINED (e->loc.view))
428 symbol_set_value_expression (e->loc.view, &viewx);
429 S_SET_SEGMENT (e->loc.view, absolute_section);
430 symbol_set_frag (e->loc.view, &zero_address_frag);
433 /* Define and attempt to simplify any earlier views needed to
435 if (h && p && p->loc.view && !S_IS_DEFINED (p->loc.view))
437 struct line_entry *h2;
438 /* Reverse the list to avoid quadratic behavior going backwards
439 in a single-linked list. */
440 struct line_entry *r = reverse_line_entry_list (h);
443 /* Set or check views until we find a defined or absent view. */
445 set_or_check_view (r, r->next, NULL);
446 while (r->next && r->next->loc.view && !S_IS_DEFINED (r->next->loc.view)
449 /* Unreverse the list, so that we can go forward again. */
450 h2 = reverse_line_entry_list (p);
451 gas_assert (h2 == h);
453 /* Starting from the last view we just defined, attempt to
454 simplify the view expressions, until we do so to P. */
457 gas_assert (S_IS_DEFINED (r->loc.view));
458 resolve_expression (symbol_get_value_expression (r->loc.view));
460 while (r != p && (r = r->next));
462 /* Now that we've defined and computed all earlier views that might
463 be needed to compute E's, attempt to simplify it. */
464 resolve_expression (symbol_get_value_expression (e->loc.view));
468 /* Record an entry for LOC occurring at LABEL. */
471 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
473 struct line_subseg *lss;
474 struct line_entry *e;
476 e = XNEW (struct line_entry);
481 lss = get_line_subseg (now_seg, now_subseg, TRUE);
484 set_or_check_view (e,
485 !lss->head ? NULL : (struct line_entry *)lss->ptail,
489 lss->ptail = &e->next;
492 /* Record an entry for LOC occurring at OFS within the current fragment. */
495 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
497 static unsigned int line = -1;
498 static unsigned int filenum = -1;
502 /* Early out for as-yet incomplete location information. */
503 if (loc->filenum == 0 || loc->line == 0)
506 /* Don't emit sequences of line symbols for the same line when the
507 symbols apply to assembler code. It is necessary to emit
508 duplicate line symbols when a compiler asks for them, because GDB
509 uses them to determine the end of the prologue. */
510 if (debug_type == DEBUG_DWARF2
511 && line == loc->line && filenum == loc->filenum)
515 filenum = loc->filenum;
521 /* Use a non-fake name for the line number location,
522 so that it can be referred to by relocations. */
523 sprintf (name, ".Loc.%u.%u", line, filenum);
524 sym = symbol_new (name, now_seg, ofs, frag_now);
527 sym = symbol_temp_new (now_seg, ofs, frag_now);
528 dwarf2_gen_line_info_1 (sym, loc);
531 /* Returns the current source information. If .file directives have
532 been encountered, the info for the corresponding source file is
533 returned. Otherwise, the info for the assembly source file is
537 dwarf2_where (struct dwarf2_line_info *line)
539 if (debug_type == DEBUG_DWARF2)
541 const char *filename;
543 memset (line, 0, sizeof (*line));
544 filename = as_where (&line->line);
545 line->filenum = get_filenum (filename, 0);
547 line->flags = DWARF2_FLAG_IS_STMT;
548 line->isa = current.isa;
549 line->discriminator = current.discriminator;
556 /* A hook to allow the target backend to inform the line number state
557 machine of isa changes when assembler debug info is enabled. */
560 dwarf2_set_isa (unsigned int isa)
565 /* Called for each machine instruction, or relatively atomic group of
566 machine instructions (ie built-in macro). The instruction or group
567 is SIZE bytes in length. If dwarf2 line number generation is called
568 for, emit a line statement appropriately. */
571 dwarf2_emit_insn (int size)
573 struct dwarf2_line_info loc;
575 if (debug_type != DEBUG_DWARF2
576 ? !dwarf2_loc_directive_seen
577 : !seen_at_least_1_file ())
582 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
583 dwarf2_consume_line_info ();
586 /* Move all previously-emitted line entries for the current position by
587 DELTA bytes. This function cannot be used to move the same entries
591 dwarf2_move_insn (int delta)
593 struct line_subseg *lss;
594 struct line_entry *e;
600 lss = get_line_subseg (now_seg, now_subseg, FALSE);
604 now = frag_now_fix ();
605 while ((e = *lss->pmove_tail))
607 if (S_GET_VALUE (e->label) == now)
608 S_SET_VALUE (e->label, now + delta);
609 lss->pmove_tail = &e->next;
613 /* Called after the current line information has been either used with
614 dwarf2_gen_line_info or saved with a machine instruction for later use.
615 This resets the state of the line number information to reflect that
619 dwarf2_consume_line_info (void)
621 /* Unless we generate DWARF2 debugging information for each
622 assembler line, we only emit one line symbol for one LOC. */
623 dwarf2_loc_directive_seen = FALSE;
625 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
626 | DWARF2_FLAG_PROLOGUE_END
627 | DWARF2_FLAG_EPILOGUE_BEGIN);
628 current.discriminator = 0;
632 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
633 is enabled, emit a basic block marker. */
636 dwarf2_emit_label (symbolS *label)
638 struct dwarf2_line_info loc;
640 if (!dwarf2_loc_mark_labels)
642 if (S_GET_SEGMENT (label) != now_seg)
644 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
646 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
651 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
653 dwarf2_gen_line_info_1 (label, &loc);
654 dwarf2_consume_line_info ();
657 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
658 allocate it on that file table slot, otherwise return the first
662 get_filenum (const char *filename, unsigned int num)
664 static unsigned int last_used, last_used_dir_len;
669 if (num == 0 && last_used)
671 if (! files[last_used].dir
672 && filename_cmp (filename, files[last_used].filename) == 0)
674 if (files[last_used].dir
675 && filename_ncmp (filename, dirs[files[last_used].dir],
676 last_used_dir_len) == 0
677 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
678 && filename_cmp (filename + last_used_dir_len + 1,
679 files[last_used].filename) == 0)
683 file = lbasename (filename);
684 /* Don't make empty string from / or A: from A:/ . */
685 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
686 if (file <= filename + 3)
689 if (file == filename + 1)
692 dir_len = file - filename;
697 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
700 for (dir = 1; dir < dirs_in_use; ++dir)
701 if (filename_ncmp (filename, dirs[dir], dir_len) == 0
702 && dirs[dir][dir_len] == '\0')
705 if (dir >= dirs_in_use)
707 if (dir >= dirs_allocated)
709 dirs_allocated = dir + 32;
710 dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
713 dirs[dir] = xmemdup0 (filename, dir_len);
714 dirs_in_use = dir + 1;
720 for (i = 1; i < files_in_use; ++i)
721 if (files[i].dir == dir
723 && filename_cmp (file, files[i].filename) == 0)
726 last_used_dir_len = dir_len;
733 if (i >= files_allocated)
735 unsigned int old = files_allocated;
737 files_allocated = i + 32;
738 files = XRESIZEVEC (struct file_entry, files, files_allocated);
740 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
743 files[i].filename = num ? file : xstrdup (file);
745 if (files_in_use < i + 1)
746 files_in_use = i + 1;
748 last_used_dir_len = dir_len;
753 /* Handle two forms of .file directive:
754 - Pass .file "source.c" to s_app_file
755 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
757 If an entry is added to the file table, return a pointer to the filename. */
760 dwarf2_directive_filename (void)
766 /* Continue to accept a bare string and pass it off. */
768 if (*input_line_pointer == '"')
774 num = get_absolute_expression ();
775 filename = demand_copy_C_string (&filename_len);
776 if (filename == NULL)
778 demand_empty_rest_of_line ();
782 as_bad (_("file number less than one"));
786 /* A .file directive implies compiler generated debug information is
787 being supplied. Turn off gas generated debug info. */
788 debug_type = DEBUG_NONE;
790 if (num < (int) files_in_use && files[num].filename != 0)
792 as_bad (_("file number %ld already allocated"), (long) num);
796 get_filenum (filename, num);
801 /* Calls dwarf2_directive_filename, but discards its result.
802 Used in pseudo-op tables where the function result is ignored. */
805 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
807 (void) dwarf2_directive_filename ();
811 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
813 offsetT filenum, line;
815 /* If we see two .loc directives in a row, force the first one to be
817 if (dwarf2_loc_directive_seen)
818 dwarf2_emit_insn (0);
820 filenum = get_absolute_expression ();
822 line = get_absolute_expression ();
826 as_bad (_("file number less than one"));
829 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
831 as_bad (_("unassigned file number %ld"), (long) filenum);
835 current.filenum = filenum;
837 current.discriminator = 0;
842 if (files[filenum].dir)
844 size_t dir_len = strlen (dirs[files[filenum].dir]);
845 size_t file_len = strlen (files[filenum].filename);
846 char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1);
848 memcpy (cp, dirs[files[filenum].dir], dir_len);
849 INSERT_DIR_SEPARATOR (cp, dir_len);
850 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
851 cp[dir_len + file_len + 1] = '\0';
852 listing_source_file (cp);
856 listing_source_file (files[filenum].filename);
857 listing_source_line (line);
862 if (ISDIGIT (*input_line_pointer))
864 current.column = get_absolute_expression ();
868 while (ISALPHA (*input_line_pointer))
873 c = get_symbol_name (& p);
875 if (strcmp (p, "basic_block") == 0)
877 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
878 *input_line_pointer = c;
880 else if (strcmp (p, "prologue_end") == 0)
882 current.flags |= DWARF2_FLAG_PROLOGUE_END;
883 *input_line_pointer = c;
885 else if (strcmp (p, "epilogue_begin") == 0)
887 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
888 *input_line_pointer = c;
890 else if (strcmp (p, "is_stmt") == 0)
892 (void) restore_line_pointer (c);
893 value = get_absolute_expression ();
895 current.flags &= ~DWARF2_FLAG_IS_STMT;
897 current.flags |= DWARF2_FLAG_IS_STMT;
900 as_bad (_("is_stmt value not 0 or 1"));
904 else if (strcmp (p, "isa") == 0)
906 (void) restore_line_pointer (c);
907 value = get_absolute_expression ();
912 as_bad (_("isa number less than zero"));
916 else if (strcmp (p, "discriminator") == 0)
918 (void) restore_line_pointer (c);
919 value = get_absolute_expression ();
921 current.discriminator = value;
924 as_bad (_("discriminator less than zero"));
928 else if (strcmp (p, "view") == 0)
932 (void) restore_line_pointer (c);
935 if (ISDIGIT (*input_line_pointer)
936 || *input_line_pointer == '-')
938 bfd_boolean force_reset = *input_line_pointer == '-';
940 value = get_absolute_expression ();
943 as_bad (_("numeric view can only be asserted to zero"));
946 if (force_reset && force_reset_view)
947 sym = force_reset_view;
950 sym = symbol_temp_new (absolute_section, value,
953 force_reset_view = sym;
958 char *name = read_symbol_name ();
962 sym = symbol_find_or_make (name);
963 if (S_IS_DEFINED (sym))
965 if (!S_CAN_BE_REDEFINED (sym))
966 as_bad (_("symbol `%s' is already defined"), name);
968 sym = symbol_clone (sym, 1);
969 S_SET_SEGMENT (sym, undefined_section);
970 S_SET_VALUE (sym, 0);
971 symbol_set_frag (sym, &zero_address_frag);
978 as_bad (_("unknown .loc sub-directive `%s'"), p);
979 (void) restore_line_pointer (c);
983 SKIP_WHITESPACE_AFTER_NAME ();
986 demand_empty_rest_of_line ();
987 dwarf2_loc_directive_seen = TRUE;
988 debug_type = DEBUG_NONE;
990 /* If we were given a view id, emit the row right away. */
992 dwarf2_emit_insn (0);
996 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
998 offsetT value = get_absolute_expression ();
1000 if (value != 0 && value != 1)
1002 as_bad (_("expected 0 or 1"));
1003 ignore_rest_of_line ();
1007 dwarf2_loc_mark_labels = value != 0;
1008 demand_empty_rest_of_line ();
1012 static struct frag *
1013 first_frag_for_seg (segT seg)
1015 return seg_info (seg)->frchainP->frch_root;
1018 static struct frag *
1019 last_frag_for_seg (segT seg)
1021 frchainS *f = seg_info (seg)->frchainP;
1023 while (f->frch_next != NULL)
1026 return f->frch_last;
1029 /* Emit a single byte into the current segment. */
1034 FRAG_APPEND_1_CHAR (byte);
1037 /* Emit a statement program opcode into the current segment. */
1040 out_opcode (int opc)
1045 /* Emit a two-byte word into the current segment. */
1050 md_number_to_chars (frag_more (2), data, 2);
1053 /* Emit a four byte word into the current segment. */
1058 md_number_to_chars (frag_more (4), data, 4);
1061 /* Emit an unsigned "little-endian base 128" number. */
1064 out_uleb128 (addressT value)
1066 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1069 /* Emit a signed "little-endian base 128" number. */
1072 out_leb128 (addressT value)
1074 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1077 /* Emit a tuple for .debug_abbrev. */
1080 out_abbrev (int name, int form)
1086 /* Get the size of a fragment. */
1089 get_frag_fix (fragS *frag, segT seg)
1094 return frag->fr_fix;
1096 /* If a fragment is the last in the chain, special measures must be
1097 taken to find its size before relaxation, since it may be pending
1098 on some subsegment chain. */
1099 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
1100 if (fr->frch_last == frag)
1101 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
1106 /* Set an absolute address (may result in a relocation entry). */
1109 out_set_addr (symbolS *sym)
1113 memset (&exp, 0, sizeof exp);
1114 out_opcode (DW_LNS_extended_op);
1115 out_uleb128 (sizeof_address + 1);
1117 out_opcode (DW_LNE_set_address);
1118 exp.X_op = O_symbol;
1119 exp.X_add_symbol = sym;
1120 exp.X_add_number = 0;
1121 emit_expr (&exp, sizeof_address);
1124 static void scale_addr_delta (addressT *);
1127 scale_addr_delta (addressT *addr_delta)
1129 static int printed_this = 0;
1130 if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
1132 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
1134 as_bad("unaligned opcodes detected in executable segment");
1137 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
1141 /* Encode a pair of line and address skips as efficiently as possible.
1142 Note that the line skip is signed, whereas the address skip is unsigned.
1144 The following two routines *must* be kept in sync. This is
1145 enforced by making emit_inc_line_addr abort if we do not emit
1146 exactly the expected number of bytes. */
1149 size_inc_line_addr (int line_delta, addressT addr_delta)
1151 unsigned int tmp, opcode;
1154 /* Scale the address delta by the minimum instruction length. */
1155 scale_addr_delta (&addr_delta);
1157 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1158 We cannot use special opcodes here, since we want the end_sequence
1159 to emit the matrix entry. */
1160 if (line_delta == INT_MAX)
1162 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1165 len = 1 + sizeof_leb128 (addr_delta, 0);
1169 /* Bias the line delta by the base. */
1170 tmp = line_delta - DWARF2_LINE_BASE;
1172 /* If the line increment is out of range of a special opcode, we
1173 must encode it with DW_LNS_advance_line. */
1174 if (tmp >= DWARF2_LINE_RANGE)
1176 len = 1 + sizeof_leb128 (line_delta, 1);
1178 tmp = 0 - DWARF2_LINE_BASE;
1181 /* Bias the opcode by the special opcode base. */
1182 tmp += DWARF2_LINE_OPCODE_BASE;
1184 /* Avoid overflow when addr_delta is large. */
1185 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1187 /* Try using a special opcode. */
1188 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1192 /* Try using DW_LNS_const_add_pc followed by special op. */
1193 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1198 /* Otherwise use DW_LNS_advance_pc. */
1199 len += 1 + sizeof_leb128 (addr_delta, 0);
1201 /* DW_LNS_copy or special opcode. */
1208 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
1210 unsigned int tmp, opcode;
1212 char *end = p + len;
1214 /* Line number sequences cannot go backward in addresses. This means
1215 we've incorrectly ordered the statements in the sequence. */
1216 gas_assert ((offsetT) addr_delta >= 0);
1218 /* Scale the address delta by the minimum instruction length. */
1219 scale_addr_delta (&addr_delta);
1221 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1222 We cannot use special opcodes here, since we want the end_sequence
1223 to emit the matrix entry. */
1224 if (line_delta == INT_MAX)
1226 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1227 *p++ = DW_LNS_const_add_pc;
1230 *p++ = DW_LNS_advance_pc;
1231 p += output_leb128 (p, addr_delta, 0);
1234 *p++ = DW_LNS_extended_op;
1236 *p++ = DW_LNE_end_sequence;
1240 /* Bias the line delta by the base. */
1241 tmp = line_delta - DWARF2_LINE_BASE;
1243 /* If the line increment is out of range of a special opcode, we
1244 must encode it with DW_LNS_advance_line. */
1245 if (tmp >= DWARF2_LINE_RANGE)
1247 *p++ = DW_LNS_advance_line;
1248 p += output_leb128 (p, line_delta, 1);
1251 tmp = 0 - DWARF2_LINE_BASE;
1255 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1257 if (line_delta == 0 && addr_delta == 0)
1263 /* Bias the opcode by the special opcode base. */
1264 tmp += DWARF2_LINE_OPCODE_BASE;
1266 /* Avoid overflow when addr_delta is large. */
1267 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1269 /* Try using a special opcode. */
1270 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1277 /* Try using DW_LNS_const_add_pc followed by special op. */
1278 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1281 *p++ = DW_LNS_const_add_pc;
1287 /* Otherwise use DW_LNS_advance_pc. */
1288 *p++ = DW_LNS_advance_pc;
1289 p += output_leb128 (p, addr_delta, 0);
1297 gas_assert (p == end);
1300 /* Handy routine to combine calls to the above two routines. */
1303 out_inc_line_addr (int line_delta, addressT addr_delta)
1305 int len = size_inc_line_addr (line_delta, addr_delta);
1306 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1309 /* Write out an alternative form of line and address skips using
1310 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1311 line and address information, but it is required if linker relaxation
1312 could change the code offsets. The following two routines *must* be
1314 #define ADDR_DELTA_LIMIT 50000
1317 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1321 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1322 if (line_delta != INT_MAX)
1323 len = 1 + sizeof_leb128 (line_delta, 1);
1325 if (addr_delta > ADDR_DELTA_LIMIT)
1327 /* DW_LNS_extended_op */
1328 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1329 /* DW_LNE_set_address */
1330 len += 1 + sizeof_address;
1333 /* DW_LNS_fixed_advance_pc */
1336 if (line_delta == INT_MAX)
1337 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1347 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1351 char *end = p + len;
1353 /* Line number sequences cannot go backward in addresses. This means
1354 we've incorrectly ordered the statements in the sequence. */
1355 gas_assert ((offsetT) addr_delta >= 0);
1357 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1358 gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
1360 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1361 if (line_delta != INT_MAX)
1363 *p++ = DW_LNS_advance_line;
1364 p += output_leb128 (p, line_delta, 1);
1367 pexp = symbol_get_value_expression (frag->fr_symbol);
1369 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1370 advance the address by at most 64K. Linker relaxation (without
1371 which this function would not be used) could change the operand by
1372 an unknown amount. If the address increment is getting close to
1373 the limit, just reset the address. */
1374 if (addr_delta > ADDR_DELTA_LIMIT)
1379 memset (&exp, 0, sizeof exp);
1380 gas_assert (pexp->X_op == O_subtract);
1381 to_sym = pexp->X_add_symbol;
1383 *p++ = DW_LNS_extended_op;
1384 p += output_leb128 (p, sizeof_address + 1, 0);
1385 *p++ = DW_LNE_set_address;
1386 exp.X_op = O_symbol;
1387 exp.X_add_symbol = to_sym;
1388 exp.X_add_number = 0;
1389 emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE);
1390 p += sizeof_address;
1394 *p++ = DW_LNS_fixed_advance_pc;
1395 emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE);
1399 if (line_delta == INT_MAX)
1401 *p++ = DW_LNS_extended_op;
1403 *p++ = DW_LNE_end_sequence;
1408 gas_assert (p == end);
1411 /* Generate a variant frag that we can use to relax address/line
1412 increments between fragments of the target segment. */
1415 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1420 memset (&exp, 0, sizeof exp);
1421 exp.X_op = O_subtract;
1422 exp.X_add_symbol = to_sym;
1423 exp.X_op_symbol = from_sym;
1424 exp.X_add_number = 0;
1426 /* The maximum size of the frag is the line delta with a maximum
1427 sized address delta. */
1428 if (DWARF2_USE_FIXED_ADVANCE_PC)
1429 max_chars = size_fixed_inc_line_addr (line_delta,
1430 -DWARF2_LINE_MIN_INSN_LENGTH);
1432 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1434 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1435 make_expr_symbol (&exp), line_delta, NULL);
1438 /* The function estimates the size of a rs_dwarf2dbg variant frag
1439 based on the current values of the symbols. It is called before
1440 the relaxation loop. We set fr_subtype to the expected length. */
1443 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1448 addr_delta = resolve_symbol_value (frag->fr_symbol);
1449 if (DWARF2_USE_FIXED_ADVANCE_PC)
1450 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1452 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1454 frag->fr_subtype = size;
1459 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1460 current values of the symbols. fr_subtype is the current length
1461 of the frag. This returns the change in frag length. */
1464 dwarf2dbg_relax_frag (fragS *frag)
1466 int old_size, new_size;
1468 old_size = frag->fr_subtype;
1469 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1471 return new_size - old_size;
1474 /* This function converts a rs_dwarf2dbg variant frag into a normal
1475 fill frag. This is called after all relaxation has been done.
1476 fr_subtype will be the desired length of the frag. */
1479 dwarf2dbg_convert_frag (fragS *frag)
1483 if (DWARF2_USE_FIXED_ADVANCE_PC)
1485 /* If linker relaxation is enabled then the distance between the two
1486 symbols in the frag->fr_symbol expression might change. Hence we
1487 cannot rely upon the value computed by resolve_symbol_value.
1488 Instead we leave the expression unfinalized and allow
1489 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1490 relocation) that will allow the linker to correctly compute the
1491 actual address difference. We have to use a fixed line advance for
1492 this as we cannot (easily) relocate leb128 encoded values. */
1493 int saved_finalize_syms = finalize_syms;
1496 addr_diff = resolve_symbol_value (frag->fr_symbol);
1497 finalize_syms = saved_finalize_syms;
1500 addr_diff = resolve_symbol_value (frag->fr_symbol);
1502 /* fr_var carries the max_chars that we created the fragment with.
1503 fr_subtype carries the current expected length. We must, of
1504 course, have allocated enough memory earlier. */
1505 gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1507 if (DWARF2_USE_FIXED_ADVANCE_PC)
1508 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1509 frag->fr_literal + frag->fr_fix,
1512 emit_inc_line_addr (frag->fr_offset, addr_diff,
1513 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1515 frag->fr_fix += frag->fr_subtype;
1516 frag->fr_type = rs_fill;
1518 frag->fr_offset = 0;
1521 /* Generate .debug_line content for the chain of line number entries
1522 beginning at E, for segment SEG. */
1525 process_entries (segT seg, struct line_entry *e)
1527 unsigned filenum = 1;
1529 unsigned column = 0;
1531 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1532 fragS *last_frag = NULL, *frag;
1533 addressT last_frag_ofs = 0, frag_ofs;
1534 symbolS *last_lab = NULL, *lab;
1535 struct line_entry *next;
1537 if (flag_dwarf_sections)
1540 const char * sec_name;
1542 /* Switch to the relevant sub-section before we start to emit
1543 the line number table.
1545 FIXME: These sub-sections do not have a normal Line Number
1546 Program Header, thus strictly speaking they are not valid
1547 DWARF sections. Unfortunately the DWARF standard assumes
1548 a one-to-one relationship between compilation units and
1549 line number tables. Thus we have to have a .debug_line
1550 section, as well as our sub-sections, and we have to ensure
1551 that all of the sub-sections are merged into a proper
1552 .debug_line section before a debugger sees them. */
1554 sec_name = bfd_get_section_name (stdoutput, seg);
1555 if (strcmp (sec_name, ".text") != 0)
1557 name = concat (".debug_line", sec_name, (char *) NULL);
1558 subseg_set (subseg_get (name, FALSE), 0);
1561 /* Don't create a .debug_line.text section -
1562 that is redundant. Instead just switch back to the
1563 normal .debug_line section. */
1564 subseg_set (subseg_get (".debug_line", FALSE), 0);
1571 if (filenum != e->loc.filenum)
1573 filenum = e->loc.filenum;
1574 out_opcode (DW_LNS_set_file);
1575 out_uleb128 (filenum);
1578 if (column != e->loc.column)
1580 column = e->loc.column;
1581 out_opcode (DW_LNS_set_column);
1582 out_uleb128 (column);
1585 if (e->loc.discriminator != 0)
1587 out_opcode (DW_LNS_extended_op);
1588 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1589 out_opcode (DW_LNE_set_discriminator);
1590 out_uleb128 (e->loc.discriminator);
1593 if (isa != e->loc.isa)
1596 out_opcode (DW_LNS_set_isa);
1600 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1602 flags = e->loc.flags;
1603 out_opcode (DW_LNS_negate_stmt);
1606 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1607 out_opcode (DW_LNS_set_basic_block);
1609 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1610 out_opcode (DW_LNS_set_prologue_end);
1612 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1613 out_opcode (DW_LNS_set_epilogue_begin);
1615 /* Don't try to optimize away redundant entries; gdb wants two
1616 entries for a function where the code starts on the same line as
1617 the {, and there's no way to identify that case here. Trust gcc
1618 to optimize appropriately. */
1619 line_delta = e->loc.line - line;
1621 frag = symbol_get_frag (lab);
1622 frag_ofs = S_GET_VALUE (lab);
1624 if (last_frag == NULL
1625 || (e->loc.view == force_reset_view && force_reset_view
1626 /* If we're going to reset the view, but we know we're
1627 advancing the PC, we don't have to force with
1628 set_address. We know we do when we're at the same
1629 address of the same frag, and we know we might when
1630 we're in the beginning of a frag, and we were at the
1631 end of the previous frag. */
1632 && (frag == last_frag
1633 ? (last_frag_ofs == frag_ofs)
1635 && ((offsetT)last_frag_ofs
1636 >= get_frag_fix (last_frag, seg))))))
1639 out_inc_line_addr (line_delta, 0);
1641 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1642 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1644 relax_inc_line_addr (line_delta, lab, last_lab);
1649 last_frag_ofs = frag_ofs;
1657 /* Emit a DW_LNE_end_sequence for the end of the section. */
1658 frag = last_frag_for_seg (seg);
1659 frag_ofs = get_frag_fix (frag, seg);
1660 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1661 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1664 lab = symbol_temp_new (seg, frag_ofs, frag);
1665 relax_inc_line_addr (INT_MAX, lab, last_lab);
1669 /* Emit the directory and file tables for .debug_line. */
1672 out_file_list (void)
1679 /* Emit directory list. */
1680 for (i = 1; i < dirs_in_use; ++i)
1682 dir = remap_debug_filename (dirs[i]);
1683 size = strlen (dir) + 1;
1684 cp = frag_more (size);
1685 memcpy (cp, dir, size);
1690 for (i = 1; i < files_in_use; ++i)
1692 const char *fullfilename;
1694 if (files[i].filename == NULL)
1696 as_bad (_("unassigned file number %ld"), (long) i);
1697 /* Prevent a crash later, particularly for file 1. */
1698 files[i].filename = "";
1702 fullfilename = DWARF2_FILE_NAME (files[i].filename,
1703 files[i].dir ? dirs [files [i].dir] : "");
1704 size = strlen (fullfilename) + 1;
1705 cp = frag_more (size);
1706 memcpy (cp, fullfilename, size);
1708 out_uleb128 (files[i].dir); /* directory number */
1709 /* Output the last modification timestamp. */
1710 out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1711 files[i].dir ? dirs [files [i].dir] : ""));
1712 /* Output the filesize. */
1713 out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1714 files[i].dir ? dirs [files [i].dir] : ""));
1717 /* Terminate filename list. */
1721 /* Switch to SEC and output a header length field. Return the size of
1722 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1723 to the end of the section. EXPR->X_add_number will be set to the
1724 negative size of the header. */
1727 out_header (asection *sec, expressionS *exp)
1732 subseg_set (sec, 0);
1734 if (flag_dwarf_sections)
1736 /* If we are going to put the start and end symbols in different
1737 sections, then we need real symbols, not just fake, local ones. */
1739 start_sym = symbol_make (".Ldebug_line_start");
1740 end_sym = symbol_make (".Ldebug_line_end");
1741 symbol_set_value_now (start_sym);
1745 start_sym = symbol_temp_new_now ();
1746 end_sym = symbol_temp_make ();
1749 /* Total length of the information. */
1750 exp->X_op = O_subtract;
1751 exp->X_add_symbol = end_sym;
1752 exp->X_op_symbol = start_sym;
1754 switch (DWARF2_FORMAT (sec))
1756 case dwarf2_format_32bit:
1757 exp->X_add_number = -4;
1761 case dwarf2_format_64bit:
1762 exp->X_add_number = -12;
1767 case dwarf2_format_64bit_irix:
1768 exp->X_add_number = -8;
1773 as_fatal (_("internal error: unknown dwarf2 format"));
1777 /* Emit the collected .debug_line data. */
1780 out_debug_line (segT line_seg)
1783 symbolS *prologue_start, *prologue_end;
1788 memset (&exp, 0, sizeof exp);
1789 sizeof_offset = out_header (line_seg, &exp);
1790 line_end = exp.X_add_symbol;
1793 out_two (DWARF2_LINE_VERSION);
1795 /* Length of the prologue following this length. */
1796 prologue_start = symbol_temp_make ();
1797 prologue_end = symbol_temp_make ();
1798 exp.X_op = O_subtract;
1799 exp.X_add_symbol = prologue_end;
1800 exp.X_op_symbol = prologue_start;
1801 exp.X_add_number = 0;
1802 emit_expr (&exp, sizeof_offset);
1803 symbol_set_value_now (prologue_start);
1805 /* Parameters of the state machine. */
1806 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1807 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1808 out_byte (DWARF2_LINE_BASE);
1809 out_byte (DWARF2_LINE_RANGE);
1810 out_byte (DWARF2_LINE_OPCODE_BASE);
1812 /* Standard opcode lengths. */
1813 out_byte (0); /* DW_LNS_copy */
1814 out_byte (1); /* DW_LNS_advance_pc */
1815 out_byte (1); /* DW_LNS_advance_line */
1816 out_byte (1); /* DW_LNS_set_file */
1817 out_byte (1); /* DW_LNS_set_column */
1818 out_byte (0); /* DW_LNS_negate_stmt */
1819 out_byte (0); /* DW_LNS_set_basic_block */
1820 out_byte (0); /* DW_LNS_const_add_pc */
1821 out_byte (1); /* DW_LNS_fixed_advance_pc */
1822 out_byte (0); /* DW_LNS_set_prologue_end */
1823 out_byte (0); /* DW_LNS_set_epilogue_begin */
1824 out_byte (1); /* DW_LNS_set_isa */
1828 symbol_set_value_now (prologue_end);
1830 /* For each section, emit a statement program. */
1831 for (s = all_segs; s; s = s->next)
1832 if (SEG_NORMAL (s->seg))
1833 process_entries (s->seg, s->head->head);
1835 as_warn ("dwarf line number information for %s ignored",
1836 segment_name (s->seg));
1838 if (flag_dwarf_sections)
1839 /* We have to switch to the special .debug_line_end section
1840 before emitting the end-of-debug_line symbol. The linker
1841 script arranges for this section to be placed after all the
1842 (potentially garbage collected) .debug_line.<foo> sections.
1843 This section contains the line_end symbol which is used to
1844 compute the size of the linked .debug_line section, as seen
1845 in the DWARF Line Number header. */
1846 subseg_set (subseg_get (".debug_line_end", FALSE), 0);
1848 symbol_set_value_now (line_end);
1852 out_debug_ranges (segT ranges_seg)
1854 unsigned int addr_size = sizeof_address;
1859 memset (&exp, 0, sizeof exp);
1860 subseg_set (ranges_seg, 0);
1862 /* Base Address Entry. */
1863 for (i = 0; i < addr_size; i++)
1865 for (i = 0; i < addr_size; i++)
1868 /* Range List Entry. */
1869 for (s = all_segs; s; s = s->next)
1874 frag = first_frag_for_seg (s->seg);
1875 beg = symbol_temp_new (s->seg, 0, frag);
1876 s->text_start = beg;
1878 frag = last_frag_for_seg (s->seg);
1879 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1882 exp.X_op = O_symbol;
1883 exp.X_add_symbol = beg;
1884 exp.X_add_number = 0;
1885 emit_expr (&exp, addr_size);
1887 exp.X_op = O_symbol;
1888 exp.X_add_symbol = end;
1889 exp.X_add_number = 0;
1890 emit_expr (&exp, addr_size);
1893 /* End of Range Entry. */
1894 for (i = 0; i < addr_size; i++)
1896 for (i = 0; i < addr_size; i++)
1900 /* Emit data for .debug_aranges. */
1903 out_debug_aranges (segT aranges_seg, segT info_seg)
1905 unsigned int addr_size = sizeof_address;
1909 symbolS *aranges_end;
1913 memset (&exp, 0, sizeof exp);
1914 sizeof_offset = out_header (aranges_seg, &exp);
1915 aranges_end = exp.X_add_symbol;
1916 size = -exp.X_add_number;
1919 out_two (DWARF2_ARANGES_VERSION);
1922 /* Offset to .debug_info. */
1923 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1924 size += sizeof_offset;
1926 /* Size of an address (offset portion). */
1927 out_byte (addr_size);
1930 /* Size of a segment descriptor. */
1934 /* Align the header. */
1935 while ((size++ % (2 * addr_size)) > 0)
1938 for (s = all_segs; s; s = s->next)
1943 frag = first_frag_for_seg (s->seg);
1944 beg = symbol_temp_new (s->seg, 0, frag);
1945 s->text_start = beg;
1947 frag = last_frag_for_seg (s->seg);
1948 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1951 exp.X_op = O_symbol;
1952 exp.X_add_symbol = beg;
1953 exp.X_add_number = 0;
1954 emit_expr (&exp, addr_size);
1956 exp.X_op = O_subtract;
1957 exp.X_add_symbol = end;
1958 exp.X_op_symbol = beg;
1959 exp.X_add_number = 0;
1960 emit_expr (&exp, addr_size);
1963 p = frag_more (2 * addr_size);
1964 md_number_to_chars (p, 0, addr_size);
1965 md_number_to_chars (p + addr_size, 0, addr_size);
1967 symbol_set_value_now (aranges_end);
1970 /* Emit data for .debug_abbrev. Note that this must be kept in
1971 sync with out_debug_info below. */
1974 out_debug_abbrev (segT abbrev_seg,
1975 segT info_seg ATTRIBUTE_UNUSED,
1976 segT line_seg ATTRIBUTE_UNUSED)
1978 subseg_set (abbrev_seg, 0);
1981 out_uleb128 (DW_TAG_compile_unit);
1982 out_byte (DW_CHILDREN_no);
1983 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1984 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1986 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1987 if (all_segs->next == NULL)
1989 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1990 if (DWARF2_VERSION < 4)
1991 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1993 out_abbrev (DW_AT_high_pc, (sizeof_address == 4
1994 ? DW_FORM_data4 : DW_FORM_data8));
1998 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1999 out_abbrev (DW_AT_ranges, DW_FORM_data4);
2001 out_abbrev (DW_AT_ranges, DW_FORM_data8);
2003 out_abbrev (DW_AT_name, DW_FORM_strp);
2004 out_abbrev (DW_AT_comp_dir, DW_FORM_strp);
2005 out_abbrev (DW_AT_producer, DW_FORM_strp);
2006 out_abbrev (DW_AT_language, DW_FORM_data2);
2009 /* Terminate the abbreviations for this compilation unit. */
2013 /* Emit a description of this compilation unit for .debug_info. */
2016 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg,
2017 symbolS *name_sym, symbolS *comp_dir_sym, symbolS *producer_sym)
2023 memset (&exp, 0, sizeof exp);
2024 sizeof_offset = out_header (info_seg, &exp);
2025 info_end = exp.X_add_symbol;
2027 /* DWARF version. */
2028 out_two (DWARF2_VERSION);
2030 /* .debug_abbrev offset */
2031 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
2033 /* Target address size. */
2034 out_byte (sizeof_address);
2036 /* DW_TAG_compile_unit DIE abbrev */
2039 /* DW_AT_stmt_list */
2040 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
2041 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
2044 /* These two attributes are emitted if all of the code is contiguous. */
2045 if (all_segs->next == NULL)
2048 exp.X_op = O_symbol;
2049 exp.X_add_symbol = all_segs->text_start;
2050 exp.X_add_number = 0;
2051 emit_expr (&exp, sizeof_address);
2054 if (DWARF2_VERSION < 4)
2055 exp.X_op = O_symbol;
2058 exp.X_op = O_subtract;
2059 exp.X_op_symbol = all_segs->text_start;
2061 exp.X_add_symbol = all_segs->text_end;
2062 exp.X_add_number = 0;
2063 emit_expr (&exp, sizeof_address);
2067 /* This attribute is emitted if the code is disjoint. */
2069 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
2072 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2073 setup in out_debug_str below. */
2074 TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset);
2075 TC_DWARF2_EMIT_OFFSET (comp_dir_sym, sizeof_offset);
2076 TC_DWARF2_EMIT_OFFSET (producer_sym, sizeof_offset);
2078 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2079 dwarf2 draft has no standard code for assembler. */
2080 out_two (DW_LANG_Mips_Assembler);
2082 symbol_set_value_now (info_end);
2085 /* Emit the three debug strings needed in .debug_str and setup symbols
2086 to them for use in out_debug_info. */
2088 out_debug_str (segT str_seg, symbolS **name_sym, symbolS **comp_dir_sym,
2089 symbolS **producer_sym)
2092 const char *comp_dir;
2093 const char *dirname;
2097 subseg_set (str_seg, 0);
2099 /* DW_AT_name. We don't have the actual file name that was present
2100 on the command line, so assume files[1] is the main input file.
2101 We're not supposed to get called unless at least one line number
2102 entry was emitted, so this should always be defined. */
2103 *name_sym = symbol_temp_new_now ();
2104 if (files_in_use == 0)
2108 dirname = remap_debug_filename (dirs[files[1].dir]);
2109 len = strlen (dirname);
2111 /* Already has trailing slash. */
2112 p = frag_more (len);
2113 memcpy (p, dirname, len);
2115 p = frag_more (len + 1);
2116 memcpy (p, dirname, len);
2117 INSERT_DIR_SEPARATOR (p, len);
2120 len = strlen (files[1].filename) + 1;
2121 p = frag_more (len);
2122 memcpy (p, files[1].filename, len);
2124 /* DW_AT_comp_dir */
2125 *comp_dir_sym = symbol_temp_new_now ();
2126 comp_dir = remap_debug_filename (getpwd ());
2127 len = strlen (comp_dir) + 1;
2128 p = frag_more (len);
2129 memcpy (p, comp_dir, len);
2131 /* DW_AT_producer */
2132 *producer_sym = symbol_temp_new_now ();
2133 sprintf (producer, "GNU AS %s", VERSION);
2134 len = strlen (producer) + 1;
2135 p = frag_more (len);
2136 memcpy (p, producer, len);
2142 last_seg_ptr = &all_segs;
2146 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2147 were any .file/.loc directives, or --gdwarf2 was given, or if the
2148 file has a non-empty .debug_info section and an empty .debug_line
2149 section. If we emit .debug_line, and the .debug_info section is
2150 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2151 ALL_SEGS will be non-null if there were any .file/.loc directives,
2152 or --gdwarf2 was given and there were any located instructions
2156 dwarf2_finish (void)
2161 int emit_other_sections = 0;
2162 int empty_debug_line = 0;
2164 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
2165 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
2167 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
2168 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
2170 /* We can't construct a new debug_line section if we already have one.
2172 if (all_segs && !empty_debug_line)
2173 as_fatal ("duplicate .debug_line sections");
2175 if ((!all_segs && emit_other_sections)
2176 || (!emit_other_sections && !empty_debug_line))
2177 /* If there is no line information and no non-empty .debug_info
2178 section, or if there is both a non-empty .debug_info and a non-empty
2179 .debug_line, then we do nothing. */
2182 /* Calculate the size of an address for the target machine. */
2183 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
2185 /* Create and switch to the line number section. */
2186 line_seg = subseg_new (".debug_line", 0);
2187 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
2189 /* For each subsection, chain the debug entries together. */
2190 for (s = all_segs; s; s = s->next)
2192 struct line_subseg *lss = s->head;
2193 struct line_entry **ptail = lss->ptail;
2195 while ((lss = lss->next) != NULL)
2202 out_debug_line (line_seg);
2204 /* If this is assembler generated line info, and there is no
2205 debug_info already, we need .debug_info, .debug_abbrev and
2206 .debug_str sections as well. */
2207 if (emit_other_sections)
2213 symbolS *name_sym, *comp_dir_sym, *producer_sym;
2215 gas_assert (all_segs);
2217 info_seg = subseg_new (".debug_info", 0);
2218 abbrev_seg = subseg_new (".debug_abbrev", 0);
2219 aranges_seg = subseg_new (".debug_aranges", 0);
2220 str_seg = subseg_new (".debug_str", 0);
2222 bfd_set_section_flags (stdoutput, info_seg,
2223 SEC_READONLY | SEC_DEBUGGING);
2224 bfd_set_section_flags (stdoutput, abbrev_seg,
2225 SEC_READONLY | SEC_DEBUGGING);
2226 bfd_set_section_flags (stdoutput, aranges_seg,
2227 SEC_READONLY | SEC_DEBUGGING);
2228 bfd_set_section_flags (stdoutput, str_seg,
2229 (SEC_READONLY | SEC_DEBUGGING
2230 | SEC_MERGE | SEC_STRINGS));
2231 str_seg->entsize = 1;
2233 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
2235 if (all_segs->next == NULL)
2239 ranges_seg = subseg_new (".debug_ranges", 0);
2240 bfd_set_section_flags (stdoutput, ranges_seg,
2241 SEC_READONLY | SEC_DEBUGGING);
2242 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
2243 out_debug_ranges (ranges_seg);
2246 out_debug_aranges (aranges_seg, info_seg);
2247 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
2248 out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym);
2249 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg,
2250 name_sym, comp_dir_sym, producer_sym);
2254 /* Perform any deferred checks pertaining to debug information. */
2257 dwarf2dbg_final_check (void)
2259 /* Perform reset-view checks. Don't evaluate view_assert_failed
2260 recursively: it could be very deep. It's a chain of adds, with
2261 each chain element pointing to the next in X_add_symbol, and
2262 holding the check value in X_op_symbol. */
2263 while (view_assert_failed)
2269 gas_assert (!symbol_resolved_p (view_assert_failed));
2271 exp = symbol_get_value_expression (view_assert_failed);
2272 sym = view_assert_failed;
2274 /* If view_assert_failed looks like a compound check in the
2275 chain, break it up. */
2276 if (exp->X_op == O_add && exp->X_add_number == 0 && exp->X_unsigned)
2278 view_assert_failed = exp->X_add_symbol;
2279 sym = exp->X_op_symbol;
2282 view_assert_failed = NULL;
2284 failed = resolve_symbol_value (sym);
2285 if (!symbol_resolved_p (sym) || failed)
2287 as_bad (_("view number mismatch"));