/* dwarf2dbg.c - DWARF2 debug support
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ the Free Software Foundation; either version 3, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING. If not, write to the Free
- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
/* Logical line numbers can be controlled by the compiler via the
- following two directives:
+ following directives:
.file FILENO "file.c"
- .loc FILENO LINENO [COLUMN]
+ .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
+ [epilogue_begin] [is_stmt VALUE] [isa VALUE]
+*/
- FILENO is the filenumber. */
+#include "as.h"
+#include "safe-ctype.h"
-#include "ansidecl.h"
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#else
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#ifndef INT_MAX
+#define INT_MAX (int) (((unsigned) (-1)) >> 1)
+#endif
+#endif
-#include "as.h"
#include "dwarf2dbg.h"
+#include <filenames.h>
+
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+/* We need to decide which character to use as a directory separator.
+ Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
+ necessarily mean that the backslash character is the one to use.
+ Some environments, eg Cygwin, can support both naming conventions.
+ So we use the heuristic that we only need to use the backslash if
+ the path is an absolute path starting with a DOS style drive
+ selector. eg C: or D: */
+# define INSERT_DIR_SEPARATOR(string, offset) \
+ do \
+ { \
+ if (offset > 1 \
+ && string[0] != 0 \
+ && string[1] == ':') \
+ string [offset] = '\\'; \
+ else \
+ string [offset] = '/'; \
+ } \
+ while (0)
+#else
+# define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
+#endif
+
+#ifndef DWARF2_FORMAT
+# define DWARF2_FORMAT() dwarf2_format_32bit
+#endif
+
+#ifndef DWARF2_ADDR_SIZE
+# define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
+#endif
+
#include "subsegs.h"
-#include <elf/dwarf2.h>
+#include "elf/dwarf2.h"
/* Since we can't generate the prolog until the body is complete, we
use three different subsegments for .debug_line: one holding the
#define DL_FILES 1
#define DL_BODY 2
+/* If linker relaxation might change offsets in the code, the DWARF special
+ opcodes and variable-length operands cannot be used. If this macro is
+ nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
+#ifndef DWARF2_USE_FIXED_ADVANCE_PC
+# define DWARF2_USE_FIXED_ADVANCE_PC 0
+#endif
+
/* First special line opcde - leave room for the standard opcodes.
Note: If you want to change this, you'll have to update the
"standard_opcode_lengths" table that is emitted below in
- dwarf2_finish(). */
-#define DWARF2_LINE_OPCODE_BASE 10
+ out_debug_line(). */
+#define DWARF2_LINE_OPCODE_BASE 13
#ifndef DWARF2_LINE_BASE
/* Minimum line offset in a special line info. opcode. This value
#ifndef DWARF2_LINE_MIN_INSN_LENGTH
/* Define the architecture-dependent minimum instruction length (in
bytes). This value should be rather too small than too big. */
-# define DWARF2_LINE_MIN_INSN_LENGTH 4
+# define DWARF2_LINE_MIN_INSN_LENGTH 1
#endif
-/* Flag that indicates the initial value of the is_stmt_start flag.
- In the present implementation, we do not mark any lines as
- the beginning of a source statement, because that information
- is not made available by the GCC front-end. */
+/* Flag that indicates the initial value of the is_stmt_start flag. */
#define DWARF2_LINE_DEFAULT_IS_STMT 1
-/* Flag that indicates the initial value of the is_stmt_start flag.
- In the present implementation, we do not mark any lines as
- the beginning of a source statement, because that information
- is not made available by the GCC front-end. */
-#define DWARF2_LINE_DEFAULT_IS_STMT 1
-
-/* Given a special op, return the line skip amount: */
+/* Given a special op, return the line skip amount. */
#define SPECIAL_LINE(op) \
(((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
DWARF2_LINE_MIN_INSN_LENGTH. */
#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
-/* The maximum address skip amont that can be encoded with a special op: */
+/* The maximum address skip amount that can be encoded with a special op. */
#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
-#define INITIAL_STATE \
- /* initialize as per DWARF2.0 standard: */ \
- 0, /* address */ \
- 1, /* file */ \
- 1, /* line */ \
- 0, /* column */ \
- DWARF2_LINE_DEFAULT_IS_STMT, /* is_stmt */ \
- 0, /* basic_block */ \
- 1 /* empty_sequence */
-
-static struct
- {
- /* state machine state as per DWARF2 manual: */
- struct dwarf2_sm
- {
- addressT addr;
- unsigned int filenum;
- unsigned int line;
- unsigned int column;
- unsigned int
- is_stmt : 1,
- basic_block : 1,
- empty_sequence : 1; /* current code sequence has no DWARF2 directives? */
- }
- sm;
-
- unsigned int
- any_dwarf2_directives : 1; /* did we emit any DWARF2 line debug directives? */
-
- segT text_seg; /* text segment "addr" is relative to */
- subsegT text_subseg;
- segT line_seg; /* ".debug_line" segment */
- int last_filename; /* index of last filename that was used */
- int num_filenames; /* index of last filename in use */
- int filename_len; /* length of the filename array */
- struct
- {
- int dir; /* valid after gen_dir_list() only */
- char *name; /* full path before gen_dir_list(), filename afterwards */
- }
- *file;
-
- struct dwarf2_line_info current; /* current source info: */
-
- /* counters for statistical purposes: */
- unsigned int num_line_entries;
- unsigned int opcode_hist[256]; /* histogram of opcode frequencies */
- }
-ls =
- {
- {
- INITIAL_STATE
- },
- };
-
-
-/* Function prototypes: */
-static void out_uleb128 PARAMS ((addressT));
-static void out_sleb128 PARAMS ((offsetT));
-static void gen_addr_line PARAMS ((int, addressT));
-static void reset_state_machine PARAMS ((void));
-static void out_set_addr PARAMS ((addressT));
-static void out_end_sequence PARAMS ((void));
-static int get_filenum PARAMS ((int, char *));
-static void gen_dir_list PARAMS ((void));
-static void gen_file_list PARAMS ((void));
-static void print_stats PARAMS ((unsigned long));
-
-
-#define out_byte(byte) FRAG_APPEND_1_CHAR(byte)
-#define out_opcode(opc) (out_byte ((opc)), ++ls.opcode_hist[(opc) & 0xff])
-
-/* Output an unsigned "little-endian base 128" number. */
+struct line_entry {
+ struct line_entry *next;
+ symbolS *label;
+ struct dwarf2_line_info loc;
+};
+
+struct line_subseg {
+ struct line_subseg *next;
+ subsegT subseg;
+ struct line_entry *head;
+ struct line_entry **ptail;
+};
+
+struct line_seg {
+ struct line_seg *next;
+ segT seg;
+ struct line_subseg *head;
+ symbolS *text_start;
+ symbolS *text_end;
+};
+
+/* Collects data for all line table entries during assembly. */
+static struct line_seg *all_segs;
+
+struct file_entry {
+ const char *filename;
+ unsigned int dir;
+};
+
+/* Table of files used by .debug_line. */
+static struct file_entry *files;
+static unsigned int files_in_use;
+static unsigned int files_allocated;
+
+/* Table of directories used by .debug_line. */
+static char **dirs;
+static unsigned int dirs_in_use;
+static unsigned int dirs_allocated;
+
+/* TRUE when we've seen a .loc directive recently. Used to avoid
+ doing work when there's nothing to do. */
+static bfd_boolean loc_directive_seen;
+
+/* TRUE when we're supposed to set the basic block mark whenever a
+ label is seen. */
+bfd_boolean dwarf2_loc_mark_labels;
+
+/* Current location as indicated by the most recent .loc directive. */
+static struct dwarf2_line_info current = {
+ 1, 1, 0, 0,
+ DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0
+};
+
+/* The size of an address on the target. */
+static unsigned int sizeof_address;
+\f
+static struct line_subseg *get_line_subseg (segT, subsegT);
+static unsigned int get_filenum (const char *, unsigned int);
+static struct frag *first_frag_for_seg (segT);
+static struct frag *last_frag_for_seg (segT);
+static void out_byte (int);
+static void out_opcode (int);
+static void out_two (int);
+static void out_four (int);
+static void out_abbrev (int, int);
+static void out_uleb128 (addressT);
+static void out_sleb128 (addressT);
+static offsetT get_frag_fix (fragS *, segT);
+static void out_set_addr (symbolS *);
+static int size_inc_line_addr (int, addressT);
+static void emit_inc_line_addr (int, addressT, char *, int);
+static void out_inc_line_addr (int, addressT);
+static void out_fixed_inc_line_addr (int, symbolS *, symbolS *);
+static void relax_inc_line_addr (int, symbolS *, symbolS *);
+static void process_entries (segT, struct line_entry *);
+static void out_file_list (void);
+static void out_debug_line (segT);
+static void out_debug_aranges (segT, segT);
+static void out_debug_abbrev (segT);
+\f
+#ifndef TC_DWARF2_EMIT_OFFSET
+#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
+
+/* Create an offset to .dwarf2_*. */
+
static void
-out_uleb128 (value)
- addressT value;
+generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
{
- unsigned char byte, more = 0x80;
+ expressionS expr;
- do
- {
- byte = value & 0x7f;
- value >>= 7;
- if (value == 0)
- more = 0;
- out_byte (more | byte);
- }
- while (more);
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = symbol;
+ expr.X_add_number = 0;
+ emit_expr (&expr, size);
}
+#endif
-/* Output a signed "little-endian base 128" number. */
-static void
-out_sleb128 (value)
- offsetT value;
+/* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
+
+static struct line_subseg *
+get_line_subseg (segT seg, subsegT subseg)
{
- unsigned char byte, more = 0x80;
+ static segT last_seg;
+ static subsegT last_subseg;
+ static struct line_subseg *last_line_subseg;
- do
+ struct line_seg **ps, *s;
+ struct line_subseg **pss, *ss;
+
+ if (seg == last_seg && subseg == last_subseg)
+ return last_line_subseg;
+
+ for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next)
+ if (s->seg == seg)
+ goto found_seg;
+
+ s = (struct line_seg *) xmalloc (sizeof (*s));
+ s->next = NULL;
+ s->seg = seg;
+ s->head = NULL;
+ *ps = s;
+
+ found_seg:
+ for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
{
- byte = value & 0x7f;
- value >>= 7;
- if (((value == 0) && ((byte & 0x40) == 0))
- || ((value == -1) && ((byte & 0x40) != 0)))
- more = 0;
- out_byte (more | byte);
+ if (ss->subseg == subseg)
+ goto found_subseg;
+ if (ss->subseg > subseg)
+ break;
}
- while (more);
+
+ ss = (struct line_subseg *) xmalloc (sizeof (*ss));
+ ss->next = *pss;
+ ss->subseg = subseg;
+ ss->head = NULL;
+ ss->ptail = &ss->head;
+ *pss = ss;
+
+ found_subseg:
+ last_seg = seg;
+ last_subseg = subseg;
+ last_line_subseg = ss;
+
+ return ss;
}
-/* Encode a pair of line and address skips as efficiently as possible.
- Note that the line skip is signed, whereas the address skip is
- unsigned. */
+/* Record an entry for LOC occurring at LABEL. */
+
static void
-gen_addr_line (line_delta, addr_delta)
- int line_delta;
- addressT addr_delta;
+dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
{
- unsigned int tmp, opcode;
+ struct line_subseg *ss;
+ struct line_entry *e;
- tmp = line_delta - DWARF2_LINE_BASE;
+ e = (struct line_entry *) xmalloc (sizeof (*e));
+ e->next = NULL;
+ e->label = label;
+ e->loc = *loc;
- if (tmp >= DWARF2_LINE_RANGE)
- {
- out_opcode (DW_LNS_advance_line);
- out_sleb128 (line_delta);
- tmp = 0 - DWARF2_LINE_BASE;
- line_delta = 0;
- }
+ ss = get_line_subseg (now_seg, now_subseg);
+ *ss->ptail = e;
+ ss->ptail = &e->next;
+}
- tmp += DWARF2_LINE_OPCODE_BASE;
+/* Record an entry for LOC occurring at OFS within the current fragment. */
- /* try using a special opcode: */
- opcode = tmp + addr_delta*DWARF2_LINE_RANGE;
- if (opcode <= 255)
- {
- out_opcode (opcode);
- return;
- }
+void
+dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
+{
+ static unsigned int line = -1;
+ static unsigned int filenum = -1;
- /* try using DW_LNS_const_add_pc followed by special op: */
- opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA)*DWARF2_LINE_RANGE;
- if (opcode <= 255)
- {
- out_opcode (DW_LNS_const_add_pc);
- out_opcode (opcode);
- return;
- }
+ symbolS *sym;
- out_opcode (DW_LNS_advance_pc);
- out_uleb128 (addr_delta);
+ /* Early out for as-yet incomplete location information. */
+ if (loc->filenum == 0 || loc->line == 0)
+ return;
- if (line_delta)
- out_opcode (tmp); /* output line-delta */
- else
- out_opcode (DW_LNS_copy); /* append new row with current info */
+ /* Don't emit sequences of line symbols for the same line when the
+ symbols apply to assembler code. It is necessary to emit
+ duplicate line symbols when a compiler asks for them, because GDB
+ uses them to determine the end of the prologue. */
+ if (debug_type == DEBUG_DWARF2
+ && line == loc->line && filenum == loc->filenum)
+ return;
+
+ line = loc->line;
+ filenum = loc->filenum;
+
+ sym = symbol_temp_new (now_seg, ofs, frag_now);
+ dwarf2_gen_line_info_1 (sym, loc);
}
-static void
-reset_state_machine ()
+/* Returns the current source information. If .file directives have
+ been encountered, the info for the corresponding source file is
+ returned. Otherwise, the info for the assembly source file is
+ returned. */
+
+void
+dwarf2_where (struct dwarf2_line_info *line)
{
- static const struct dwarf2_sm initial_state = { INITIAL_STATE };
+ if (debug_type == DEBUG_DWARF2)
+ {
+ char *filename;
+ as_where (&filename, &line->line);
+ line->filenum = get_filenum (filename, 0);
+ line->column = 0;
+ line->flags = DWARF2_FLAG_IS_STMT;
+ line->isa = current.isa;
+ }
+ else
+ *line = current;
+}
+
+/* A hook to allow the target backend to inform the line number state
+ machine of isa changes when assembler debug info is enabled. */
- ls.sm = initial_state;
+void
+dwarf2_set_isa (unsigned int isa)
+{
+ current.isa = isa;
}
-/* Set an absolute address (may results in a relocation entry): */
-static void
-out_set_addr (addr)
- addressT addr;
+/* Called for each machine instruction, or relatively atomic group of
+ machine instructions (ie built-in macro). The instruction or group
+ is SIZE bytes in length. If dwarf2 line number generation is called
+ for, emit a line statement appropriately. */
+
+void
+dwarf2_emit_insn (int size)
{
- subsegT saved_subseg;
- segT saved_seg;
- expressionS expr;
- symbolS *sym;
- int bytes_per_address;
+ struct dwarf2_line_info loc;
- saved_seg = now_seg;
- saved_subseg = now_subseg;
+ if (loc_directive_seen)
+ {
+ /* Use the last location established by a .loc directive, not
+ the value returned by dwarf2_where(). That calls as_where()
+ which will return either the logical input file name (foo.c)
+ or the physical input file name (foo.s) and not the file name
+ specified in the most recent .loc directive (eg foo.h). */
+ loc = current;
+
+ /* Unless we generate DWARF2 debugging information for each
+ assembler line, we only emit one line symbol for one LOC. */
+ if (debug_type != DEBUG_DWARF2)
+ loc_directive_seen = FALSE;
+ }
+ else if (debug_type != DEBUG_DWARF2)
+ return;
+ else
+ dwarf2_where (&loc);
- subseg_set (ls.text_seg, ls.text_subseg);
- sym = symbol_new (".L0\001", now_seg, addr, frag_now);
+ dwarf2_gen_line_info (frag_now_fix () - size, &loc);
- subseg_set (saved_seg, saved_subseg);
+ current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
+ | DWARF2_FLAG_PROLOGUE_END
+ | DWARF2_FLAG_EPILOGUE_BEGIN);
+}
-#ifdef BFD_ASSEMBLER
- bytes_per_address = bfd_arch_bits_per_address (stdoutput) / 8;
-#else
- /* FIXME. */
- bytes_per_address = 4;
-#endif
+/* Called for each (preferably code) label. If dwarf2_loc_mark_labels
+ is enabled, emit a basic block marker. */
- out_opcode (DW_LNS_extended_op);
- out_uleb128 (bytes_per_address + 1);
+void
+dwarf2_emit_label (symbolS *label)
+{
+ struct dwarf2_line_info loc;
- out_opcode (DW_LNE_set_address);
- expr.X_op = O_symbol;
- expr.X_add_symbol = sym;
- expr.X_add_number = 0;
- emit_expr (&expr, bytes_per_address);
+ if (!dwarf2_loc_mark_labels)
+ return;
+ if (S_GET_SEGMENT (label) != now_seg)
+ return;
+ if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
+ return;
+
+ if (debug_type == DEBUG_DWARF2)
+ dwarf2_where (&loc);
+ else
+ {
+ loc = current;
+ loc_directive_seen = FALSE;
+ }
+
+ loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
+
+ current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
+ | DWARF2_FLAG_PROLOGUE_END
+ | DWARF2_FLAG_EPILOGUE_BEGIN);
+
+ dwarf2_gen_line_info_1 (label, &loc);
}
-/* Emit DW_LNS_end_sequence and reset state machine. Does not
- preserve the current segment/sub-segment! */
-static void
-out_end_sequence ()
+/* Get a .debug_line file number for FILENAME. If NUM is nonzero,
+ allocate it on that file table slot, otherwise return the first
+ empty one. */
+
+static unsigned int
+get_filenum (const char *filename, unsigned int num)
{
- addressT addr, delta;
+ static unsigned int last_used, last_used_dir_len;
+ const char *file;
+ size_t dir_len;
+ unsigned int i, dir;
- if (ls.text_seg)
+ if (num == 0 && last_used)
{
- subseg_set (ls.text_seg, ls.text_subseg);
-#ifdef md_current_text_addr
- addr = md_current_text_addr ();
+ if (! files[last_used].dir
+ && strcmp (filename, files[last_used].filename) == 0)
+ return last_used;
+ if (files[last_used].dir
+ && strncmp (filename, dirs[files[last_used].dir],
+ last_used_dir_len) == 0
+ && IS_DIR_SEPARATOR (filename [last_used_dir_len])
+ && strcmp (filename + last_used_dir_len + 1,
+ files[last_used].filename) == 0)
+ return last_used;
+ }
+
+ file = lbasename (filename);
+ /* Don't make empty string from / or A: from A:/ . */
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ if (file <= filename + 3)
+ file = filename;
#else
- addr = frag_now_fix ();
+ if (file == filename + 1)
+ file = filename;
#endif
- subseg_set (ls.line_seg, DL_BODY);
- if (addr < ls.sm.addr)
- {
- out_set_addr (addr);
- ls.sm.addr = addr;
- }
- else
+ dir_len = file - filename;
+
+ dir = 0;
+ if (dir_len)
+ {
+ --dir_len;
+ for (dir = 1; dir < dirs_in_use; ++dir)
+ if (strncmp (filename, dirs[dir], dir_len) == 0
+ && dirs[dir][dir_len] == '\0')
+ break;
+
+ if (dir >= dirs_in_use)
{
- delta = addr - ls.sm.addr;
- if (delta > 0)
- gen_addr_line (0, delta / DWARF2_LINE_MIN_INSN_LENGTH);
+ if (dir >= dirs_allocated)
+ {
+ dirs_allocated = dir + 32;
+ dirs = (char **)
+ xrealloc (dirs, (dir + 32) * sizeof (const char *));
+ }
+
+ dirs[dir] = xmalloc (dir_len + 1);
+ memcpy (dirs[dir], filename, dir_len);
+ dirs[dir][dir_len] = '\0';
+ dirs_in_use = dir + 1;
}
}
+
+ if (num == 0)
+ {
+ for (i = 1; i < files_in_use; ++i)
+ if (files[i].dir == dir
+ && files[i].filename
+ && strcmp (file, files[i].filename) == 0)
+ {
+ last_used = i;
+ last_used_dir_len = dir_len;
+ return i;
+ }
+ }
else
- subseg_set (ls.line_seg, DL_BODY);
+ i = num;
- out_opcode (DW_LNS_extended_op);
- out_uleb128 (1);
- out_byte (DW_LNE_end_sequence);
+ if (i >= files_allocated)
+ {
+ unsigned int old = files_allocated;
+
+ files_allocated = i + 32;
+ files = (struct file_entry *)
+ xrealloc (files, (i + 32) * sizeof (struct file_entry));
+
+ memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
+ }
- reset_state_machine ();
+ files[i].filename = num ? file : xstrdup (file);
+ files[i].dir = dir;
+ if (files_in_use < i + 1)
+ files_in_use = i + 1;
+ last_used = i;
+ last_used_dir_len = dir_len;
+
+ return i;
}
-/* Look up a filenumber either by filename or by filenumber. If both
- a filenumber and a filename are specified, lookup by filename takes
- precedence. If the filename cannot be found, it is added to the
- filetable the filenumber for the new entry is returned. */
-static int
-get_filenum (filenum, file)
- int filenum;
- char *file;
+/* Handle two forms of .file directive:
+ - Pass .file "source.c" to s_app_file
+ - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
+
+ If an entry is added to the file table, return a pointer to the filename. */
+
+char *
+dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
{
- int i, last = filenum - 1;
- char char0 = file[0];
+ offsetT num;
+ char *filename;
+ int filename_len;
- if ((unsigned) last >= ls.num_filenames)
- last = ls.last_filename;
+ /* Continue to accept a bare string and pass it off. */
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer == '"')
+ {
+ s_app_file (0);
+ return NULL;
+ }
- /* do a quick check against the previously used filename: */
- if (ls.num_filenames > 0 && ls.file[last].name[0] == char0
- && strcmp (ls.file[last].name + 1, file + 1) == 0)
- return last + 1;
+ num = get_absolute_expression ();
+ filename = demand_copy_C_string (&filename_len);
+ if (filename == NULL)
+ return NULL;
+ demand_empty_rest_of_line ();
- /* no match, fall back to simple linear scan: */
- for (i = 0; i < ls.num_filenames; ++i)
+ if (num < 1)
{
- if (ls.file[i].name[0] == char0
- && strcmp (ls.file[i].name + 1, file + 1) == 0)
- {
- ls.last_filename = i;
- return i + 1;
- }
+ as_bad (_("file number less than one"));
+ return NULL;
}
- /* no match: enter new filename */
- if (ls.num_filenames >= ls.filename_len)
+ if (num < (int) files_in_use && files[num].filename != 0)
{
- ls.filename_len += 13;
- ls.file = xrealloc (ls.file, ls.filename_len * sizeof (ls.file[0]));
+ as_bad (_("file number %ld already allocated"), (long) num);
+ return NULL;
}
- ls.file[ls.num_filenames].dir = 0;
- ls.file[ls.num_filenames].name = file;
- return ++ls.num_filenames;
+
+ get_filenum (filename, num);
+
+ return filename;
}
void
-dwarf2_gen_line_info (addr, l)
- addressT addr;
- struct dwarf2_line_info *l;
+dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
{
- unsigned int filenum = l->filenum;
- unsigned int any_output = 0;
- subsegT saved_subseg;
- segT saved_seg;
+ offsetT filenum, line;
- if (flag_debug)
- fprintf (stderr, "line: addr %llx file `%s' line %u col %u flags %x\n",
- (long long) addr, l->filename, l->line, l->column, l->flags);
+ filenum = get_absolute_expression ();
+ SKIP_WHITESPACE ();
+ line = get_absolute_expression ();
- if (filenum > 0 && !l->filename)
+ if (filenum < 1)
{
- if (filenum >= ls.num_filenames)
+ as_bad (_("file number less than one"));
+ return;
+ }
+ if (filenum >= (int) files_in_use || files[filenum].filename == 0)
+ {
+ as_bad (_("unassigned file number %ld"), (long) filenum);
+ return;
+ }
+
+ current.filenum = filenum;
+ current.line = line;
+
+#ifndef NO_LISTING
+ if (listing)
+ {
+ if (files[filenum].dir)
{
- as_warn ("Encountered bad file number in line number debug info!");
+ size_t dir_len = strlen (dirs[files[filenum].dir]);
+ size_t file_len = strlen (files[filenum].filename);
+ char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
+
+ memcpy (cp, dirs[files[filenum].dir], dir_len);
+ INSERT_DIR_SEPARATOR (cp, dir_len);
+ memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
+ cp[dir_len + file_len + 1] = '\0';
+ listing_source_file (cp);
+ }
+ else
+ listing_source_file (files[filenum].filename);
+ listing_source_line (line);
+ }
+#endif
+
+ SKIP_WHITESPACE ();
+ if (ISDIGIT (*input_line_pointer))
+ {
+ current.column = get_absolute_expression ();
+ SKIP_WHITESPACE ();
+ }
+
+ while (ISALPHA (*input_line_pointer))
+ {
+ char *p, c;
+ offsetT value;
+
+ p = input_line_pointer;
+ c = get_symbol_end ();
+
+ if (strcmp (p, "basic_block") == 0)
+ {
+ current.flags |= DWARF2_FLAG_BASIC_BLOCK;
+ *input_line_pointer = c;
+ }
+ else if (strcmp (p, "prologue_end") == 0)
+ {
+ current.flags |= DWARF2_FLAG_PROLOGUE_END;
+ *input_line_pointer = c;
+ }
+ else if (strcmp (p, "epilogue_begin") == 0)
+ {
+ current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
+ *input_line_pointer = c;
+ }
+ else if (strcmp (p, "is_stmt") == 0)
+ {
+ *input_line_pointer = c;
+ value = get_absolute_expression ();
+ if (value == 0)
+ current.flags &= ~DWARF2_FLAG_IS_STMT;
+ else if (value == 1)
+ current.flags |= DWARF2_FLAG_IS_STMT;
+ else
+ {
+ as_bad (_("is_stmt value not 0 or 1"));
+ return;
+ }
+ }
+ else if (strcmp (p, "isa") == 0)
+ {
+ *input_line_pointer = c;
+ value = get_absolute_expression ();
+ if (value >= 0)
+ current.isa = value;
+ else
+ {
+ as_bad (_("isa number less than zero"));
+ return;
+ }
+ }
+ else
+ {
+ as_bad (_("unknown .loc sub-directive `%s'"), p);
+ *input_line_pointer = c;
return;
}
+
+ SKIP_WHITESPACE ();
+ }
+
+ demand_empty_rest_of_line ();
+ loc_directive_seen = TRUE;
+}
+
+void
+dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
+{
+ offsetT value = get_absolute_expression ();
+
+ if (value != 0 && value != 1)
+ {
+ as_bad (_("expected 0 or 1"));
+ ignore_rest_of_line ();
}
- else if (l->filename)
- filenum = get_filenum (filenum, l->filename);
else
- return; /* no filename, no filnum => no play */
+ {
+ dwarf2_loc_mark_labels = value != 0;
+ demand_empty_rest_of_line ();
+ }
+}
+\f
+static struct frag *
+first_frag_for_seg (segT seg)
+{
+ return seg_info (seg)->frchainP->frch_root;
+}
+
+static struct frag *
+last_frag_for_seg (segT seg)
+{
+ frchainS *f = seg_info (seg)->frchainP;
+
+ while (f->frch_next != NULL)
+ f = f->frch_next;
+
+ return f->frch_last;
+}
+\f
+/* Emit a single byte into the current segment. */
+
+static inline void
+out_byte (int byte)
+{
+ FRAG_APPEND_1_CHAR (byte);
+}
+
+/* Emit a statement program opcode into the current segment. */
+
+static inline void
+out_opcode (int opc)
+{
+ out_byte (opc);
+}
+
+/* Emit a two-byte word into the current segment. */
+
+static inline void
+out_two (int data)
+{
+ md_number_to_chars (frag_more (2), data, 2);
+}
+
+/* Emit a four byte word into the current segment. */
+
+static inline void
+out_four (int data)
+{
+ md_number_to_chars (frag_more (4), data, 4);
+}
+
+/* Emit an unsigned "little-endian base 128" number. */
+
+static void
+out_uleb128 (addressT value)
+{
+ output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
+}
+
+/* Emit a signed "little-endian base 128" number. */
+
+static void
+out_sleb128 (addressT value)
+{
+ output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
+}
+
+/* Emit a tuple for .debug_abbrev. */
+
+static inline void
+out_abbrev (int name, int form)
+{
+ out_uleb128 (name);
+ out_uleb128 (form);
+}
+
+/* Get the size of a fragment. */
+
+static offsetT
+get_frag_fix (fragS *frag, segT seg)
+{
+ frchainS *fr;
- if (!ls.line_seg)
+ if (frag->fr_next)
+ return frag->fr_fix;
+
+ /* If a fragment is the last in the chain, special measures must be
+ taken to find its size before relaxation, since it may be pending
+ on some subsegment chain. */
+ for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
+ if (fr->frch_last == frag)
+ return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
+
+ abort ();
+}
+
+/* Set an absolute address (may result in a relocation entry). */
+
+static void
+out_set_addr (symbolS *sym)
+{
+ expressionS expr;
+
+ out_opcode (DW_LNS_extended_op);
+ out_uleb128 (sizeof_address + 1);
+
+ out_opcode (DW_LNE_set_address);
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = sym;
+ expr.X_add_number = 0;
+ emit_expr (&expr, sizeof_address);
+}
+
+#if DWARF2_LINE_MIN_INSN_LENGTH > 1
+static void scale_addr_delta (addressT *);
+
+static void
+scale_addr_delta (addressT *addr_delta)
+{
+ static int printed_this = 0;
+ if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
{
-#ifdef BFD_ASSEMBLER
- symbolS *secsym;
+ if (!printed_this)
+ as_bad("unaligned opcodes detected in executable segment");
+ printed_this = 1;
+ }
+ *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
+}
+#else
+#define scale_addr_delta(A)
#endif
- ls.line_seg = subseg_new (".debug_line", 0);
+/* Encode a pair of line and address skips as efficiently as possible.
+ Note that the line skip is signed, whereas the address skip is unsigned.
+
+ The following two routines *must* be kept in sync. This is
+ enforced by making emit_inc_line_addr abort if we do not emit
+ exactly the expected number of bytes. */
+
+static int
+size_inc_line_addr (int line_delta, addressT addr_delta)
+{
+ unsigned int tmp, opcode;
+ int len = 0;
-#ifdef BFD_ASSEMBLER
- bfd_set_section_flags (stdoutput, ls.line_seg, SEC_READONLY);
+ /* Scale the address delta by the minimum instruction length. */
+ scale_addr_delta (&addr_delta);
- /* We're going to need this symbol. */
- secsym = symbol_find (".debug_line");
- if (secsym != NULL)
- symbol_set_bfdsym (secsym, ls.line_seg->symbol);
+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
+ We cannot use special opcodes here, since we want the end_sequence
+ to emit the matrix entry. */
+ if (line_delta == INT_MAX)
+ {
+ if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
+ len = 1;
else
- symbol_table_insert (section_symbol (ls.line_seg));
-#endif
+ len = 1 + sizeof_leb128 (addr_delta, 0);
+ return len + 3;
}
- saved_seg = now_seg;
- saved_subseg = now_subseg;
- subseg_set (ls.line_seg, DL_BODY);
+ /* Bias the line delta by the base. */
+ tmp = line_delta - DWARF2_LINE_BASE;
- if (ls.text_seg != saved_seg || ls.text_subseg != saved_subseg)
+ /* If the line increment is out of range of a special opcode, we
+ must encode it with DW_LNS_advance_line. */
+ if (tmp >= DWARF2_LINE_RANGE)
{
- if (!ls.sm.empty_sequence)
- {
- out_end_sequence (); /* terminate previous sequence */
- ls.sm.empty_sequence = 1;
- }
- any_output = 1;
- ls.text_seg = saved_seg;
- ls.text_subseg = saved_subseg;
- out_set_addr (addr);
- ls.sm.addr = addr;
+ len = 1 + sizeof_leb128 (line_delta, 1);
+ line_delta = 0;
+ tmp = 0 - DWARF2_LINE_BASE;
}
- if (ls.sm.filenum != filenum)
+ /* Bias the opcode by the special opcode base. */
+ tmp += DWARF2_LINE_OPCODE_BASE;
+
+ /* Avoid overflow when addr_delta is large. */
+ if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
{
- any_output = 1;
- out_opcode (DW_LNS_set_file);
- out_uleb128 (filenum);
- ls.sm.filenum = filenum;
+ /* Try using a special opcode. */
+ opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
+ if (opcode <= 255)
+ return len + 1;
+
+ /* Try using DW_LNS_const_add_pc followed by special op. */
+ opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
+ if (opcode <= 255)
+ return len + 2;
}
- if (ls.sm.column != l->column)
+ /* Otherwise use DW_LNS_advance_pc. */
+ len += 1 + sizeof_leb128 (addr_delta, 0);
+
+ /* DW_LNS_copy or special opcode. */
+ len += 1;
+
+ return len;
+}
+
+static void
+emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
+{
+ unsigned int tmp, opcode;
+ int need_copy = 0;
+ char *end = p + len;
+
+ /* Line number sequences cannot go backward in addresses. This means
+ we've incorrectly ordered the statements in the sequence. */
+ assert ((offsetT) addr_delta >= 0);
+
+ /* Scale the address delta by the minimum instruction length. */
+ scale_addr_delta (&addr_delta);
+
+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
+ We cannot use special opcodes here, since we want the end_sequence
+ to emit the matrix entry. */
+ if (line_delta == INT_MAX)
{
- any_output = 1;
- out_opcode (DW_LNS_set_column);
- out_uleb128 (l->column);
- ls.sm.column = l->column;
+ if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
+ *p++ = DW_LNS_const_add_pc;
+ else
+ {
+ *p++ = DW_LNS_advance_pc;
+ p += output_leb128 (p, addr_delta, 0);
+ }
+
+ *p++ = DW_LNS_extended_op;
+ *p++ = 1;
+ *p++ = DW_LNE_end_sequence;
+ goto done;
}
- if (((l->flags & DWARF2_FLAG_BEGIN_STMT) != 0) != ls.sm.is_stmt)
+ /* Bias the line delta by the base. */
+ tmp = line_delta - DWARF2_LINE_BASE;
+
+ /* If the line increment is out of range of a special opcode, we
+ must encode it with DW_LNS_advance_line. */
+ if (tmp >= DWARF2_LINE_RANGE)
{
- any_output = 1;
- out_opcode (DW_LNS_negate_stmt);
+ *p++ = DW_LNS_advance_line;
+ p += output_leb128 (p, line_delta, 1);
+
+ line_delta = 0;
+ tmp = 0 - DWARF2_LINE_BASE;
+ need_copy = 1;
}
- if (l->flags & DWARF2_FLAG_BEGIN_BLOCK)
+ /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
+ special opcode. */
+ if (line_delta == 0 && addr_delta == 0)
{
- any_output = 1;
- out_opcode (DW_LNS_set_basic_block);
+ *p++ = DW_LNS_copy;
+ goto done;
}
- if (ls.sm.line != l->line)
+ /* Bias the opcode by the special opcode base. */
+ tmp += DWARF2_LINE_OPCODE_BASE;
+
+ /* Avoid overflow when addr_delta is large. */
+ if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
{
- any_output = 1;
- if (addr < ls.sm.addr)
+ /* Try using a special opcode. */
+ opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
+ if (opcode <= 255)
{
- if (!ls.sm.empty_sequence)
- {
- out_end_sequence ();
- ls.sm.empty_sequence = 1;
- }
- out_set_addr (addr);
- ls.sm.addr = addr;
+ *p++ = opcode;
+ goto done;
+ }
+
+ /* Try using DW_LNS_const_add_pc followed by special op. */
+ opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
+ if (opcode <= 255)
+ {
+ *p++ = DW_LNS_const_add_pc;
+ *p++ = opcode;
+ goto done;
}
- gen_addr_line (l->line - ls.sm.line,
- (addr - ls.sm.addr) / DWARF2_LINE_MIN_INSN_LENGTH);
- ls.sm.basic_block = 0;
- ls.sm.line = l->line;
- ls.sm.addr = addr;
}
- subseg_set (saved_seg, saved_subseg);
+ /* Otherwise use DW_LNS_advance_pc. */
+ *p++ = DW_LNS_advance_pc;
+ p += output_leb128 (p, addr_delta, 0);
+
+ if (need_copy)
+ *p++ = DW_LNS_copy;
+ else
+ *p++ = tmp;
- ls.num_line_entries += any_output;
- if (any_output)
- ls.sm.empty_sequence = 0;
+ done:
+ assert (p == end);
}
+/* Handy routine to combine calls to the above two routines. */
+
static void
-gen_dir_list ()
+out_inc_line_addr (int line_delta, addressT addr_delta)
{
- char *str, *slash, *dir_list, *dp, *cp;
- int i, j, num_dirs;
+ int len = size_inc_line_addr (line_delta, addr_delta);
+ emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
+}
- dir_list = frag_more (0);
- num_dirs = 0;
+/* Write out an alternative form of line and address skips using
+ DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
+ line and address information, but it helps support linker relaxation that
+ changes the code offsets. */
- for (i = 0; i < ls.num_filenames; ++i)
+static void
+out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
+{
+ expressionS expr;
+
+ /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
+ if (line_delta == INT_MAX)
{
- str = ls.file[i].name;
- slash = strrchr (str, '/');
- if (slash)
+ out_opcode (DW_LNS_fixed_advance_pc);
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = to_sym;
+ expr.X_op_symbol = from_sym;
+ expr.X_add_number = 0;
+ emit_expr (&expr, 2);
+
+ out_opcode (DW_LNS_extended_op);
+ out_byte (1);
+ out_opcode (DW_LNE_end_sequence);
+ return;
+ }
+
+ out_opcode (DW_LNS_advance_line);
+ out_sleb128 (line_delta);
+
+ out_opcode (DW_LNS_fixed_advance_pc);
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = to_sym;
+ expr.X_op_symbol = from_sym;
+ expr.X_add_number = 0;
+ emit_expr (&expr, 2);
+
+ out_opcode (DW_LNS_copy);
+}
+
+/* Generate a variant frag that we can use to relax address/line
+ increments between fragments of the target segment. */
+
+static void
+relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
+{
+ expressionS expr;
+ int max_chars;
+
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = to_sym;
+ expr.X_op_symbol = from_sym;
+ expr.X_add_number = 0;
+
+ /* The maximum size of the frag is the line delta with a maximum
+ sized address delta. */
+ max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
+
+ frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
+ make_expr_symbol (&expr), line_delta, NULL);
+}
+
+/* The function estimates the size of a rs_dwarf2dbg variant frag
+ based on the current values of the symbols. It is called before
+ the relaxation loop. We set fr_subtype to the expected length. */
+
+int
+dwarf2dbg_estimate_size_before_relax (fragS *frag)
+{
+ offsetT addr_delta;
+ int size;
+
+ addr_delta = resolve_symbol_value (frag->fr_symbol);
+ size = size_inc_line_addr (frag->fr_offset, addr_delta);
+
+ frag->fr_subtype = size;
+
+ return size;
+}
+
+/* This function relaxes a rs_dwarf2dbg variant frag based on the
+ current values of the symbols. fr_subtype is the current length
+ of the frag. This returns the change in frag length. */
+
+int
+dwarf2dbg_relax_frag (fragS *frag)
+{
+ int old_size, new_size;
+
+ old_size = frag->fr_subtype;
+ new_size = dwarf2dbg_estimate_size_before_relax (frag);
+
+ return new_size - old_size;
+}
+
+/* This function converts a rs_dwarf2dbg variant frag into a normal
+ fill frag. This is called after all relaxation has been done.
+ fr_subtype will be the desired length of the frag. */
+
+void
+dwarf2dbg_convert_frag (fragS *frag)
+{
+ offsetT addr_diff;
+
+ addr_diff = resolve_symbol_value (frag->fr_symbol);
+
+ /* fr_var carries the max_chars that we created the fragment with.
+ fr_subtype carries the current expected length. We must, of
+ course, have allocated enough memory earlier. */
+ assert (frag->fr_var >= (int) frag->fr_subtype);
+
+ emit_inc_line_addr (frag->fr_offset, addr_diff,
+ frag->fr_literal + frag->fr_fix, frag->fr_subtype);
+
+ frag->fr_fix += frag->fr_subtype;
+ frag->fr_type = rs_fill;
+ frag->fr_var = 0;
+ frag->fr_offset = 0;
+}
+
+/* Generate .debug_line content for the chain of line number entries
+ beginning at E, for segment SEG. */
+
+static void
+process_entries (segT seg, struct line_entry *e)
+{
+ unsigned filenum = 1;
+ unsigned line = 1;
+ unsigned column = 0;
+ unsigned isa = 0;
+ unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
+ fragS *last_frag = NULL, *frag;
+ addressT last_frag_ofs = 0, frag_ofs;
+ symbolS *last_lab = NULL, *lab;
+ struct line_entry *next;
+
+ do
+ {
+ int line_delta;
+
+ if (filenum != e->loc.filenum)
{
- *slash = '\0';
- for (j = 0, dp = dir_list; j < num_dirs; ++j)
- {
- if (strcmp (str, dp) == 0)
- {
- ls.file[i].dir = j;
- break;
- }
- dp += strlen (dp);
- }
- if (j >= num_dirs)
- {
- /* didn't find this directory: append it to the list */
- size_t size = strlen (str) + 1;
- cp = frag_more (size);
- memcpy (cp, str, size);
- ls.file[i].dir = ++num_dirs;
- }
- *slash = '/';
- ls.file[i].name = slash + 1;
+ filenum = e->loc.filenum;
+ out_opcode (DW_LNS_set_file);
+ out_uleb128 (filenum);
}
+
+ if (column != e->loc.column)
+ {
+ column = e->loc.column;
+ out_opcode (DW_LNS_set_column);
+ out_uleb128 (column);
+ }
+
+ if (isa != e->loc.isa)
+ {
+ isa = e->loc.isa;
+ out_opcode (DW_LNS_set_isa);
+ out_uleb128 (isa);
+ }
+
+ if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
+ {
+ flags = e->loc.flags;
+ out_opcode (DW_LNS_negate_stmt);
+ }
+
+ if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
+ out_opcode (DW_LNS_set_basic_block);
+
+ if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
+ out_opcode (DW_LNS_set_prologue_end);
+
+ if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
+ out_opcode (DW_LNS_set_epilogue_begin);
+
+ /* Don't try to optimize away redundant entries; gdb wants two
+ entries for a function where the code starts on the same line as
+ the {, and there's no way to identify that case here. Trust gcc
+ to optimize appropriately. */
+ line_delta = e->loc.line - line;
+ lab = e->label;
+ frag = symbol_get_frag (lab);
+ frag_ofs = S_GET_VALUE (lab);
+
+ if (last_frag == NULL)
+ {
+ out_set_addr (lab);
+ out_inc_line_addr (line_delta, 0);
+ }
+ else if (DWARF2_USE_FIXED_ADVANCE_PC)
+ out_fixed_inc_line_addr (line_delta, lab, last_lab);
+ else if (frag == last_frag)
+ out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
+ else
+ relax_inc_line_addr (line_delta, lab, last_lab);
+
+ line = e->loc.line;
+ last_lab = lab;
+ last_frag = frag;
+ last_frag_ofs = frag_ofs;
+
+ next = e->next;
+ free (e);
+ e = next;
+ }
+ while (e);
+
+ /* Emit a DW_LNE_end_sequence for the end of the section. */
+ frag = last_frag_for_seg (seg);
+ frag_ofs = get_frag_fix (frag, seg);
+ if (DWARF2_USE_FIXED_ADVANCE_PC)
+ {
+ lab = symbol_temp_new (seg, frag_ofs, frag);
+ out_fixed_inc_line_addr (INT_MAX, lab, last_lab);
+ }
+ else if (frag == last_frag)
+ out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
+ else
+ {
+ lab = symbol_temp_new (seg, frag_ofs, frag);
+ relax_inc_line_addr (INT_MAX, lab, last_lab);
}
- out_byte ('\0'); /* terminate directory list */
}
+/* Emit the directory and file tables for .debug_line. */
+
static void
-gen_file_list ()
+out_file_list (void)
{
size_t size;
char *cp;
- int i;
+ unsigned int i;
- for (i = 0; i < ls.num_filenames; ++i)
+ /* Emit directory list. */
+ for (i = 1; i < dirs_in_use; ++i)
{
- size = strlen (ls.file[i].name) + 1;
+ size = strlen (dirs[i]) + 1;
cp = frag_more (size);
- memcpy (cp, ls.file[i].name, size);
+ memcpy (cp, dirs[i], size);
+ }
+ /* Terminate it. */
+ out_byte ('\0');
+
+ for (i = 1; i < files_in_use; ++i)
+ {
+ if (files[i].filename == NULL)
+ {
+ as_bad (_("unassigned file number %ld"), (long) i);
+ /* Prevent a crash later, particularly for file 1. */
+ files[i].filename = "";
+ continue;
+ }
+
+ size = strlen (files[i].filename) + 1;
+ cp = frag_more (size);
+ memcpy (cp, files[i].filename, size);
- out_uleb128 (ls.file[i].dir); /* directory number */
+ out_uleb128 (files[i].dir); /* directory number */
out_uleb128 (0); /* last modification timestamp */
out_uleb128 (0); /* filesize */
}
- out_byte (0); /* terminate filename list */
+
+ /* Terminate filename list. */
+ out_byte (0);
}
+/* Emit the collected .debug_line data. */
+
static void
-print_stats (total_size)
- unsigned long total_size;
+out_debug_line (segT line_seg)
{
- static const char *opc_name[] =
+ expressionS expr;
+ symbolS *line_start;
+ symbolS *prologue_end;
+ symbolS *line_end;
+ struct line_seg *s;
+ enum dwarf2_format d2f;
+ int sizeof_offset;
+
+ subseg_set (line_seg, 0);
+
+ line_start = symbol_temp_new_now ();
+ prologue_end = symbol_temp_make ();
+ line_end = symbol_temp_make ();
+
+ /* Total length of the information for this compilation unit. */
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = line_end;
+ expr.X_op_symbol = line_start;
+
+ d2f = DWARF2_FORMAT ();
+ if (d2f == dwarf2_format_32bit)
{
- "extended", "copy", "advance_pc", "advance_line", "set_file",
- "set_column", "negate_stmt", "set_basic_block", "const_add_pc",
- "fixed_advance_pc"
- };
- int i, j;
-
- fprintf (stderr, "Average size: %g bytes/line\n",
- total_size / (double) ls.num_line_entries);
-
- fprintf (stderr, "\nStandard opcode histogram:\n");
-
- for (i = 0; i < sizeof (opc_name)/sizeof (opc_name[0]); ++i)
+ expr.X_add_number = -4;
+ emit_expr (&expr, 4);
+ sizeof_offset = 4;
+ }
+ else if (d2f == dwarf2_format_64bit)
+ {
+ expr.X_add_number = -12;
+ out_four (-1);
+ emit_expr (&expr, 8);
+ sizeof_offset = 8;
+ }
+ else if (d2f == dwarf2_format_64bit_irix)
+ {
+ expr.X_add_number = -8;
+ emit_expr (&expr, 8);
+ sizeof_offset = 8;
+ }
+ else
{
- fprintf (stderr, "%s", opc_name[i]);
- for (j = strlen (opc_name[i]); j < 16; ++j)
- fprintf (stderr, " ");
- fprintf (stderr, ": %u\n", ls.opcode_hist[i]);
+ as_fatal (_("internal error: unknown dwarf2 format"));
}
- fprintf (stderr, "\nSpecial opcodes:\naddr\t\t\t\tline skip\n");
+ /* Version. */
+ out_two (2);
+
+ /* Length of the prologue following this length. */
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = prologue_end;
+ expr.X_op_symbol = line_start;
+ expr.X_add_number = - (4 + 2 + 4);
+ emit_expr (&expr, sizeof_offset);
+
+ /* Parameters of the state machine. */
+ out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
+ out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
+ out_byte (DWARF2_LINE_BASE);
+ out_byte (DWARF2_LINE_RANGE);
+ out_byte (DWARF2_LINE_OPCODE_BASE);
+
+ /* Standard opcode lengths. */
+ out_byte (0); /* DW_LNS_copy */
+ out_byte (1); /* DW_LNS_advance_pc */
+ out_byte (1); /* DW_LNS_advance_line */
+ out_byte (1); /* DW_LNS_set_file */
+ out_byte (1); /* DW_LNS_set_column */
+ out_byte (0); /* DW_LNS_negate_stmt */
+ out_byte (0); /* DW_LNS_set_basic_block */
+ out_byte (0); /* DW_LNS_const_add_pc */
+ out_byte (1); /* DW_LNS_fixed_advance_pc */
+ out_byte (0); /* DW_LNS_set_prologue_end */
+ out_byte (0); /* DW_LNS_set_epilogue_begin */
+ out_byte (1); /* DW_LNS_set_isa */
+
+ out_file_list ();
+
+ symbol_set_value_now (prologue_end);
+
+ /* For each section, emit a statement program. */
+ for (s = all_segs; s; s = s->next)
+ process_entries (s->seg, s->head->head);
+
+ symbol_set_value_now (line_end);
+}
- fprintf (stderr, "skip: ");
- for (j = DWARF2_LINE_BASE; j < DWARF2_LINE_BASE + DWARF2_LINE_RANGE; ++j)
- fprintf (stderr, "%3d", j);
- fprintf (stderr, "\n-----");
+static void
+out_debug_ranges (segT ranges_seg)
+{
+ unsigned int addr_size = sizeof_address;
+ struct line_seg *s;
+ expressionS expr;
+ unsigned int i;
- for (; i < 256; ++i)
+ subseg_set (ranges_seg, 0);
+
+ /* Base Address Entry. */
+ for (i = 0; i < addr_size; i++)
+ out_byte (0xff);
+ for (i = 0; i < addr_size; i++)
+ out_byte (0);
+
+ /* Range List Entry. */
+ for (s = all_segs; s; s = s->next)
{
- j = SPECIAL_LINE (i);
- if (j == DWARF2_LINE_BASE)
- fprintf (stderr, "\n%4u: ",
- DWARF2_LINE_MIN_INSN_LENGTH*SPECIAL_ADDR (i));
- fprintf (stderr, " %2u", ls.opcode_hist[i]);
+ fragS *frag;
+ symbolS *beg, *end;
+
+ frag = first_frag_for_seg (s->seg);
+ beg = symbol_temp_new (s->seg, 0, frag);
+ s->text_start = beg;
+
+ frag = last_frag_for_seg (s->seg);
+ end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
+ s->text_end = end;
+
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = beg;
+ expr.X_add_number = 0;
+ emit_expr (&expr, addr_size);
+
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = end;
+ expr.X_add_number = 0;
+ emit_expr (&expr, addr_size);
}
- fprintf (stderr, "\n");
+
+ /* End of Range Entry. */
+ for (i = 0; i < addr_size; i++)
+ out_byte (0);
+ for (i = 0; i < addr_size; i++)
+ out_byte (0);
}
-void
-dwarf2_finish ()
+/* Emit data for .debug_aranges. */
+
+static void
+out_debug_aranges (segT aranges_seg, segT info_seg)
{
- addressT body_size, total_size, prolog_size;
- subsegT saved_subseg;
- segT saved_seg;
- char *cp;
+ unsigned int addr_size = sizeof_address;
+ addressT size, skip;
+ struct line_seg *s;
+ expressionS expr;
+ char *p;
- if (!ls.line_seg)
- /* no .debug_line segment, no work to do... */
- return;
+ size = 4 + 2 + 4 + 1 + 1;
+
+ skip = 2 * addr_size - (size & (2 * addr_size - 1));
+ if (skip == 2 * addr_size)
+ skip = 0;
+ size += skip;
+
+ for (s = all_segs; s; s = s->next)
+ size += 2 * addr_size;
- saved_seg = now_seg;
- saved_subseg = now_subseg;
+ size += 2 * addr_size;
- if (!ls.sm.empty_sequence)
- out_end_sequence ();
- total_size = body_size = frag_now_fix ();
+ subseg_set (aranges_seg, 0);
- /* now generate the directory and file lists: */
- subseg_set (ls.line_seg, DL_FILES);
- gen_dir_list ();
- gen_file_list ();
- total_size += frag_now_fix ();
+ /* Length of the compilation unit. */
+ out_four (size - 4);
- /* and now the header ("statement program prolog", in DWARF2 lingo...) */
- subseg_set (ls.line_seg, DL_PROLOG);
+ /* Version. */
+ out_two (2);
- cp = frag_more (15 + DWARF2_LINE_OPCODE_BASE - 1);
+ /* Offset to .debug_info. */
+ /* ??? sizeof_offset */
+ TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
- total_size += frag_now_fix ();
- prolog_size = total_size - body_size - 10;
+ /* Size of an address (offset portion). */
+ out_byte (addr_size);
-# define STUFF(val,size) md_number_to_chars (cp, val, size); cp += size;
- STUFF (total_size - 4, 4); /* length */
- STUFF (2, 2); /* version */
- STUFF (prolog_size, 4); /* prologue_length */
- STUFF (DWARF2_LINE_MIN_INSN_LENGTH, 1);
- STUFF (DWARF2_LINE_DEFAULT_IS_STMT, 1);
- STUFF (DWARF2_LINE_BASE, 1);
- STUFF (DWARF2_LINE_RANGE, 1);
- STUFF (DWARF2_LINE_OPCODE_BASE, 1);
+ /* Size of a segment descriptor. */
+ out_byte (0);
- /* standard_opcode_lengths: */
- STUFF (0, 1); /* DW_LNS_copy */
- STUFF (1, 1); /* DW_LNS_advance_pc */
- STUFF (1, 1); /* DW_LNS_advance_line */
- STUFF (1, 1); /* DW_LNS_set_file */
- STUFF (1, 1); /* DW_LNS_set_column */
- STUFF (0, 1); /* DW_LNS_negate_stmt */
- STUFF (0, 1); /* DW_LNS_set_basic_block */
- STUFF (0, 1); /* DW_LNS_const_add_pc */
- STUFF (1, 1); /* DW_LNS_fixed_advance_pc */
+ /* Align the header. */
+ if (skip)
+ frag_align (ffs (2 * addr_size) - 1, 0, 0);
- subseg_set (saved_seg, saved_subseg);
+ for (s = all_segs; s; s = s->next)
+ {
+ fragS *frag;
+ symbolS *beg, *end;
+
+ frag = first_frag_for_seg (s->seg);
+ beg = symbol_temp_new (s->seg, 0, frag);
+ s->text_start = beg;
+
+ frag = last_frag_for_seg (s->seg);
+ end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
+ s->text_end = end;
+
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = beg;
+ expr.X_add_number = 0;
+ emit_expr (&expr, addr_size);
+
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = end;
+ expr.X_op_symbol = beg;
+ expr.X_add_number = 0;
+ emit_expr (&expr, addr_size);
+ }
- if (flag_debug)
- print_stats (total_size);
+ p = frag_more (2 * addr_size);
+ md_number_to_chars (p, 0, addr_size);
+ md_number_to_chars (p + addr_size, 0, addr_size);
}
-void
-dwarf2_directive_file (dummy)
- int dummy;
+/* Emit data for .debug_abbrev. Note that this must be kept in
+ sync with out_debug_info below. */
+
+static void
+out_debug_abbrev (segT abbrev_seg)
+{
+ subseg_set (abbrev_seg, 0);
+
+ out_uleb128 (1);
+ out_uleb128 (DW_TAG_compile_unit);
+ out_byte (DW_CHILDREN_no);
+ out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
+ if (all_segs->next == NULL)
+ {
+ out_abbrev (DW_AT_low_pc, DW_FORM_addr);
+ out_abbrev (DW_AT_high_pc, DW_FORM_addr);
+ }
+ else
+ {
+ if (DWARF2_FORMAT () == dwarf2_format_32bit)
+ out_abbrev (DW_AT_ranges, DW_FORM_data4);
+ else
+ out_abbrev (DW_AT_ranges, DW_FORM_data8);
+ }
+ out_abbrev (DW_AT_name, DW_FORM_string);
+ out_abbrev (DW_AT_comp_dir, DW_FORM_string);
+ out_abbrev (DW_AT_producer, DW_FORM_string);
+ out_abbrev (DW_AT_language, DW_FORM_data2);
+ out_abbrev (0, 0);
+
+ /* Terminate the abbreviations for this compilation unit. */
+ out_byte (0);
+}
+
+/* Emit a description of this compilation unit for .debug_info. */
+
+static void
+out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
{
+ char producer[128];
+ char *comp_dir;
+ expressionS expr;
+ symbolS *info_start;
+ symbolS *info_end;
+ char *p;
int len;
+ enum dwarf2_format d2f;
+ int sizeof_offset;
- /* Continue to accept a bare string and pass it off. */
- SKIP_WHITESPACE ();
- if (*input_line_pointer == '"')
+ subseg_set (info_seg, 0);
+
+ info_start = symbol_temp_new_now ();
+ info_end = symbol_temp_make ();
+
+ /* Compilation Unit length. */
+ expr.X_op = O_subtract;
+ expr.X_add_symbol = info_end;
+ expr.X_op_symbol = info_start;
+
+ d2f = DWARF2_FORMAT ();
+ if (d2f == dwarf2_format_32bit)
{
- s_app_file (0);
- return;
+ expr.X_add_number = -4;
+ emit_expr (&expr, 4);
+ sizeof_offset = 4;
+ }
+ else if (d2f == dwarf2_format_64bit)
+ {
+ expr.X_add_number = -12;
+ out_four (-1);
+ emit_expr (&expr, 8);
+ sizeof_offset = 8;
+ }
+ else if (d2f == dwarf2_format_64bit_irix)
+ {
+ expr.X_add_number = -8;
+ emit_expr (&expr, 8);
+ sizeof_offset = 8;
+ }
+ else
+ {
+ as_fatal (_("internal error: unknown dwarf2 format"));
}
- ls.any_dwarf2_directives = 1;
+ /* DWARF version. */
+ out_two (2);
- if (debug_type == DEBUG_NONE)
- /* Automatically turn on DWARF2 debug info unless something else
- has been selected. */
- debug_type = DEBUG_DWARF2;
+ /* .debug_abbrev offset */
+ TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
- ls.current.filenum = get_absolute_expression ();
- ls.current.filename = demand_copy_C_string (&len);
+ /* Target address size. */
+ out_byte (sizeof_address);
- demand_empty_rest_of_line ();
+ /* DW_TAG_compile_unit DIE abbrev */
+ out_uleb128 (1);
+
+ /* DW_AT_stmt_list */
+ /* ??? sizeof_offset */
+ TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
+
+ /* These two attributes are emitted if all of the code is contiguous. */
+ if (all_segs->next == NULL)
+ {
+ /* DW_AT_low_pc */
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = all_segs->text_start;
+ expr.X_add_number = 0;
+ emit_expr (&expr, sizeof_address);
+
+ /* DW_AT_high_pc */
+ expr.X_op = O_symbol;
+ expr.X_add_symbol = all_segs->text_end;
+ expr.X_add_number = 0;
+ emit_expr (&expr, sizeof_address);
+ }
+ else
+ {
+ /* This attribute is emitted if the code is disjoint. */
+ /* DW_AT_ranges. */
+ TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
+ }
+
+ /* DW_AT_name. We don't have the actual file name that was present
+ on the command line, so assume files[1] is the main input file.
+ We're not supposed to get called unless at least one line number
+ entry was emitted, so this should always be defined. */
+ if (!files || files_in_use < 1)
+ abort ();
+ if (files[1].dir)
+ {
+ len = strlen (dirs[files[1].dir]);
+ p = frag_more (len + 1);
+ memcpy (p, dirs[files[1].dir], len);
+ INSERT_DIR_SEPARATOR (p, len);
+ }
+ len = strlen (files[1].filename) + 1;
+ p = frag_more (len);
+ memcpy (p, files[1].filename, len);
+
+ /* DW_AT_comp_dir */
+ comp_dir = getpwd ();
+ len = strlen (comp_dir) + 1;
+ p = frag_more (len);
+ memcpy (p, comp_dir, len);
+
+ /* DW_AT_producer */
+ sprintf (producer, "GNU AS %s", VERSION);
+ len = strlen (producer) + 1;
+ p = frag_more (len);
+ memcpy (p, producer, len);
+
+ /* DW_AT_language. Yes, this is probably not really MIPS, but the
+ dwarf2 draft has no standard code for assembler. */
+ out_two (DW_LANG_Mips_Assembler);
+
+ symbol_set_value_now (info_end);
}
+/* Finish the dwarf2 debug sections. We emit .debug.line if there
+ were any .file/.loc directives, or --gdwarf2 was given, or if the
+ file has a non-empty .debug_info section. If we emit .debug_line,
+ and the .debug_info section is empty, we also emit .debug_info,
+ .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
+ there were any .file/.loc directives, or --gdwarf2 was given and
+ there were any located instructions emitted. */
+
void
-dwarf2_directive_loc (dummy)
- int dummy;
+dwarf2_finish (void)
{
- ls.any_dwarf2_directives = 1;
+ segT line_seg;
+ struct line_seg *s;
+ segT info_seg;
+ int emit_other_sections = 0;
- ls.current.filenum = get_absolute_expression ();
- SKIP_WHITESPACE ();
- ls.current.line = get_absolute_expression ();
- SKIP_WHITESPACE ();
- ls.current.column = get_absolute_expression ();
- demand_empty_rest_of_line ();
+ info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
+ emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
- ls.current.flags = DWARF2_FLAG_BEGIN_STMT;
+ if (!all_segs && emit_other_sections)
+ /* There is no line information and no non-empty .debug_info
+ section. */
+ return;
-#ifndef NO_LISTING
- if (listing)
- listing_source_line (ls.current.line);
-#endif
-}
+ /* Calculate the size of an address for the target machine. */
+ sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
-void
-dwarf2_where (line)
- struct dwarf2_line_info *line;
-{
- if (ls.any_dwarf2_directives)
- *line = ls.current;
- else
+ /* Create and switch to the line number section. */
+ line_seg = subseg_new (".debug_line", 0);
+ bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
+
+ /* For each subsection, chain the debug entries together. */
+ for (s = all_segs; s; s = s->next)
{
- as_where (&line->filename, &line->line);
- line->filenum = 0;
- line->column = 0;
- line->flags = DWARF2_FLAG_BEGIN_STMT;
+ struct line_subseg *ss = s->head;
+ struct line_entry **ptail = ss->ptail;
+
+ while ((ss = ss->next) != NULL)
+ {
+ *ptail = ss->head;
+ ptail = ss->ptail;
+ }
+ }
+
+ out_debug_line (line_seg);
+
+ /* If this is assembler generated line info, and there is no
+ debug_info already, we need .debug_info and .debug_abbrev
+ sections as well. */
+ if (emit_other_sections)
+ {
+ segT abbrev_seg;
+ segT aranges_seg;
+ segT ranges_seg;
+
+ assert (all_segs);
+
+ info_seg = subseg_new (".debug_info", 0);
+ abbrev_seg = subseg_new (".debug_abbrev", 0);
+ aranges_seg = subseg_new (".debug_aranges", 0);
+
+ bfd_set_section_flags (stdoutput, info_seg,
+ SEC_READONLY | SEC_DEBUGGING);
+ bfd_set_section_flags (stdoutput, abbrev_seg,
+ SEC_READONLY | SEC_DEBUGGING);
+ bfd_set_section_flags (stdoutput, aranges_seg,
+ SEC_READONLY | SEC_DEBUGGING);
+
+ record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
+
+ if (all_segs->next == NULL)
+ ranges_seg = NULL;
+ else
+ {
+ ranges_seg = subseg_new (".debug_ranges", 0);
+ bfd_set_section_flags (stdoutput, ranges_seg,
+ SEC_READONLY | SEC_DEBUGGING);
+ record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
+ out_debug_ranges (ranges_seg);
+ }
+
+ out_debug_aranges (aranges_seg, info_seg);
+ out_debug_abbrev (abbrev_seg);
+ out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);
}
}