gas: avoid spurious failures in non-ELF targets in the SPARC testsuite.
[deliverable/binutils-gdb.git] / gas / dwarf2dbg.c
index 846213cbb9ecd32695c867dabae68f9b111448d5..61268a8cd1e3f43982b3ff212f47ec396713d388 100644 (file)
@@ -1,12 +1,12 @@
 /* dwarf2dbg.c - DWARF2 debug support
 /* dwarf2dbg.c - DWARF2 debug support
-   Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1999-2016 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
    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,
    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
 
    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
 
 /* Logical line numbers can be controlled by the compiler via the
-   following two directives:
+   following directives:
 
        .file FILENO "file.c"
 
        .file FILENO "file.c"
-       .loc  FILENO LINENO [COLUMN]
+       .loc  FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
+             [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
+             [discriminator VALUE]
+*/
 
 
-   FILENO is the filenumber.  */
-
-#include "ansidecl.h"
 #include "as.h"
 #include "as.h"
+#include "safe-ctype.h"
 
 #ifdef HAVE_LIMITS_H
 #include <limits.h>
 
 #ifdef HAVE_LIMITS_H
 #include <limits.h>
 #endif
 
 #include "dwarf2dbg.h"
 #endif
 
 #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
 
 #ifndef DWARF2_FORMAT
-#define DWARF2_FORMAT() dwarf2_format_32bit
+# define DWARF2_FORMAT(SEC) dwarf2_format_32bit
+#endif
+
+#ifndef DWARF2_ADDR_SIZE
+# define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
+#endif
+
+#ifndef DWARF2_FILE_NAME
+#define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
 #endif
 
 #endif
 
-#ifdef BFD_ASSEMBLER
+#ifndef DWARF2_FILE_TIME_NAME
+#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
+#endif
+
+#ifndef DWARF2_FILE_SIZE_NAME
+#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
+#endif
+
+#ifndef DWARF2_VERSION
+#define DWARF2_VERSION 2
+#endif
+
+/* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
+#ifndef DWARF2_ARANGES_VERSION
+#define DWARF2_ARANGES_VERSION 2
+#endif
+
+/* This implementation output version 2 .debug_line information. */
+#ifndef DWARF2_LINE_VERSION
+#define DWARF2_LINE_VERSION 2
+#endif
 
 #include "subsegs.h"
 
 
 #include "subsegs.h"
 
-#include "elf/dwarf2.h"
+#include "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
 
 /* 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
 
 #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   linkrelax
+#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
 /* 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_BASE
   /* Minimum line offset in a special line info. opcode.  This value
 # define DWARF2_LINE_MIN_INSN_LENGTH   1
 #endif
 
 # 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
 
 /* Given a special op, return the line skip amount.  */
 #define        DWARF2_LINE_DEFAULT_IS_STMT     1
 
 /* Given a special op, return the line skip amount.  */
 /* The maximum address skip amount that can be encoded with a special op.  */
 #define MAX_SPECIAL_ADDR_DELTA         SPECIAL_ADDR(255)
 
 /* The maximum address skip amount that can be encoded with a special op.  */
 #define MAX_SPECIAL_ADDR_DELTA         SPECIAL_ADDR(255)
 
+#ifndef TC_PARSE_CONS_RETURN_NONE
+#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
+#endif
+
 struct line_entry {
   struct line_entry *next;
 struct line_entry {
   struct line_entry *next;
-  fragS *frag;
-  addressT frag_ofs;
+  symbolS *label;
   struct dwarf2_line_info loc;
 };
 
   struct dwarf2_line_info loc;
 };
 
@@ -113,6 +173,7 @@ struct line_subseg {
   subsegT subseg;
   struct line_entry *head;
   struct line_entry **ptail;
   subsegT subseg;
   struct line_entry *head;
   struct line_entry **ptail;
+  struct line_entry **pmove_tail;
 };
 
 struct line_seg {
 };
 
 struct line_seg {
@@ -125,9 +186,10 @@ struct line_seg {
 
 /* Collects data for all line table entries during assembly.  */
 static struct line_seg *all_segs;
 
 /* Collects data for all line table entries during assembly.  */
 static struct line_seg *all_segs;
+static struct line_seg **last_seg_ptr;
 
 struct file_entry {
 
 struct file_entry {
-  char *filename;
+  const char *filename;
   unsigned int dir;
 };
 
   unsigned int dir;
 };
 
@@ -136,109 +198,119 @@ static struct file_entry *files;
 static unsigned int files_in_use;
 static unsigned int files_allocated;
 
 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.  */
 /* 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;
+bfd_boolean dwarf2_loc_directive_seen;
 
 
-/* Current location as indicated by the most recent .loc directive.  */
-static struct dwarf2_line_info current;
+/* TRUE when we're supposed to set the basic block mark whenever a
+   label is seen.  */
+bfd_boolean dwarf2_loc_mark_labels;
 
 
-/* Fake label name.  */
-static char const fake_label_name[] = ".L0\001";
+/* 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,
+  0
+};
 
 /* The size of an address on the target.  */
 static unsigned int sizeof_address;
 \f
 
 /* The size of an address on the target.  */
 static unsigned int sizeof_address;
 \f
-static struct line_subseg *get_line_subseg PARAMS ((segT, subsegT));
-static unsigned int get_filenum PARAMS ((const char *));
-static struct frag *first_frag_for_seg PARAMS ((segT));
-static struct frag *last_frag_for_seg PARAMS ((segT));
-static void out_byte PARAMS ((int));
-static void out_opcode PARAMS ((int));
-static void out_two PARAMS ((int));
-static void out_four PARAMS ((int));
-static void out_abbrev PARAMS ((int, int));
-static void out_uleb128 PARAMS ((addressT));
-static symbolS *symbol_new_now PARAMS ((void));
-static void set_symbol_value_now PARAMS ((symbolS *));
-static offsetT get_frag_fix PARAMS ((fragS *));
-static void out_set_addr PARAMS ((segT, fragS *, addressT));
-static int size_inc_line_addr PARAMS ((int, addressT));
-static void emit_inc_line_addr PARAMS ((int, addressT, char *, int));
-static void out_inc_line_addr PARAMS ((int, addressT));
-static void relax_inc_line_addr PARAMS ((int, segT, fragS *, addressT,
-                                        fragS *, addressT));
-static void process_entries PARAMS ((segT, struct line_entry *));
-static void out_file_list PARAMS ((void));
-static void out_debug_line PARAMS ((segT));
-static void out_debug_aranges PARAMS ((segT, segT));
-static void out_debug_abbrev PARAMS ((segT));
-static void out_debug_info PARAMS ((segT, segT, segT));
-static void scale_addr_delta PARAMS ((int *));
-\f
-/* Find or create an entry for SEG+SUBSEG in ALL_SEGS.  */
+static unsigned int get_filenum (const char *, unsigned int);
 
 
-static struct line_subseg *
-get_line_subseg (seg, subseg)
-     segT seg;
-     subsegT subseg;
+#ifndef TC_DWARF2_EMIT_OFFSET
+#define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
+
+/* Create an offset to .dwarf2_*.  */
+
+static void
+generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
 {
 {
-  static segT last_seg;
-  static subsegT last_subseg;
-  static struct line_subseg *last_line_subseg;
+  expressionS exp;
 
 
-  struct line_seg *s;
-  struct line_subseg **pss, *ss;
+  exp.X_op = O_symbol;
+  exp.X_add_symbol = symbol;
+  exp.X_add_number = 0;
+  emit_expr (&exp, size);
+}
+#endif
 
 
-  if (seg == last_seg && subseg == last_subseg)
-    return last_line_subseg;
+/* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS.  */
 
 
-  for (s = all_segs; s; s = s->next)
-    if (s->seg == seg)
-      goto found_seg;
+static struct line_subseg *
+get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p)
+{
+  struct line_seg *s = seg_info (seg)->dwarf2_line_seg;
+  struct line_subseg **pss, *lss;
 
 
-  s = (struct line_seg *) xmalloc (sizeof (*s));
-  s->next = all_segs;
-  s->seg = seg;
-  s->head = NULL;
-  all_segs = s;
+  if (s == NULL)
+    {
+      if (!create_p)
+       return NULL;
+
+      s = XNEW (struct line_seg);
+      s->next = NULL;
+      s->seg = seg;
+      s->head = NULL;
+      *last_seg_ptr = s;
+      last_seg_ptr = &s->next;
+      seg_info (seg)->dwarf2_line_seg = s;
+    }
+  gas_assert (seg == s->seg);
 
 
- found_seg:
-  for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
+  for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
     {
     {
-      if (ss->subseg == subseg)
+      if (lss->subseg == subseg)
        goto found_subseg;
        goto found_subseg;
-      if (ss->subseg > subseg)
+      if (lss->subseg > subseg)
        break;
     }
 
        break;
     }
 
-  ss = (struct line_subseg *) xmalloc (sizeof (*ss));
-  ss->next = *pss;
-  ss->subseg = subseg;
-  ss->head = NULL;
-  ss->ptail = &ss->head;
-  *pss = ss;
+  lss = XNEW (struct line_subseg);
+  lss->next = *pss;
+  lss->subseg = subseg;
+  lss->head = NULL;
+  lss->ptail = &lss->head;
+  lss->pmove_tail = &lss->head;
+  *pss = lss;
 
  found_subseg:
 
  found_subseg:
-  last_seg = seg;
-  last_subseg = subseg;
-  last_line_subseg = ss;
+  return lss;
+}
+
+/* Record an entry for LOC occurring at LABEL.  */
 
 
-  return ss;
+static void
+dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
+{
+  struct line_subseg *lss;
+  struct line_entry *e;
+
+  e = XNEW (struct line_entry);
+  e->next = NULL;
+  e->label = label;
+  e->loc = *loc;
+
+  lss = get_line_subseg (now_seg, now_subseg, TRUE);
+  *lss->ptail = e;
+  lss->ptail = &e->next;
 }
 
 }
 
-/* Record an entry for LOC ocurring at OFS within the current fragment.  */
+/* Record an entry for LOC occurring at OFS within the current fragment.  */
 
 void
 
 void
-dwarf2_gen_line_info (ofs, loc)
-     addressT ofs;
-     struct dwarf2_line_info *loc;
+dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
 {
 {
-  struct line_subseg *ss;
-  struct line_entry *e;
   static unsigned int line = -1;
   static unsigned int filenum = -1;
 
   static unsigned int line = -1;
   static unsigned int filenum = -1;
 
+  symbolS *sym;
+
   /* Early out for as-yet incomplete location information.  */
   if (loc->filenum == 0 || loc->line == 0)
     return;
   /* Early out for as-yet incomplete location information.  */
   if (loc->filenum == 0 || loc->line == 0)
     return;
@@ -254,98 +326,231 @@ dwarf2_gen_line_info (ofs, loc)
   line = loc->line;
   filenum = loc->filenum;
 
   line = loc->line;
   filenum = loc->filenum;
 
-  e = (struct line_entry *) xmalloc (sizeof (*e));
-  e->next = NULL;
-  e->frag = frag_now;
-  e->frag_ofs = ofs;
-  e->loc = *loc;
+  if (linkrelax)
+    {
+      char name[120];
 
 
-  ss = get_line_subseg (now_seg, now_subseg);
-  *ss->ptail = e;
-  ss->ptail = &e->next;
+      /* Use a non-fake name for the line number location,
+        so that it can be referred to by relocations.  */
+      sprintf (name, ".Loc.%u.%u", line, filenum);
+      sym = symbol_new (name, now_seg, ofs, frag_now);
+    }
+  else
+    sym = symbol_temp_new (now_seg, ofs, frag_now);
+  dwarf2_gen_line_info_1 (sym, loc);
 }
 
 }
 
+/* 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
 void
-dwarf2_where (line)
-     struct dwarf2_line_info *line;
+dwarf2_where (struct dwarf2_line_info *line)
 {
   if (debug_type == DEBUG_DWARF2)
     {
 {
   if (debug_type == DEBUG_DWARF2)
     {
-      char *filename;
-      as_where (&filename, &line->line);
-      line->filenum = get_filenum (filename);
+      const char *filename = as_where (&line->line);
+      line->filenum = get_filenum (filename, 0);
       line->column = 0;
       line->column = 0;
-      line->flags = DWARF2_FLAG_BEGIN_STMT;
+      line->flags = DWARF2_FLAG_IS_STMT;
+      line->isa = current.isa;
+      line->discriminator = current.discriminator;
     }
   else
     *line = current;
 }
 
     }
   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.  */
+
+void
+dwarf2_set_isa (unsigned int isa)
+{
+  current.isa = isa;
+}
+
 /* 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
 /* 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 (size)
-     int size;
+dwarf2_emit_insn (int size)
 {
   struct dwarf2_line_info loc;
 
 {
   struct dwarf2_line_info loc;
 
-  if (loc_directive_seen)
+  if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
+    return;
+
+  dwarf2_where (&loc);
+
+  dwarf2_gen_line_info (frag_now_fix () - size, &loc);
+  dwarf2_consume_line_info ();
+}
+
+/* Move all previously-emitted line entries for the current position by
+   DELTA bytes.  This function cannot be used to move the same entries
+   twice.  */
+
+void
+dwarf2_move_insn (int delta)
+{
+  struct line_subseg *lss;
+  struct line_entry *e;
+  valueT now;
+
+  if (delta == 0)
+    return;
+
+  lss = get_line_subseg (now_seg, now_subseg, FALSE);
+  if (!lss)
+    return;
+
+  now = frag_now_fix ();
+  while ((e = *lss->pmove_tail))
     {
     {
-      /* 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;
+      if (S_GET_VALUE (e->label) == now)
+       S_SET_VALUE (e->label, now + delta);
+      lss->pmove_tail = &e->next;
     }
     }
-  else if (debug_type != DEBUG_DWARF2)
+}
+
+/* Called after the current line information has been either used with
+   dwarf2_gen_line_info or saved with a machine instruction for later use.
+   This resets the state of the line number information to reflect that
+   it has been used.  */
+
+void
+dwarf2_consume_line_info (void)
+{
+  /* Unless we generate DWARF2 debugging information for each
+     assembler line, we only emit one line symbol for one LOC.  */
+  dwarf2_loc_directive_seen = FALSE;
+
+  current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
+                    | DWARF2_FLAG_PROLOGUE_END
+                    | DWARF2_FLAG_EPILOGUE_BEGIN);
+  current.discriminator = 0;
+}
+
+/* Called for each (preferably code) label.  If dwarf2_loc_mark_labels
+   is enabled, emit a basic block marker.  */
+
+void
+dwarf2_emit_label (symbolS *label)
+{
+  struct dwarf2_line_info loc;
+
+  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 (files_in_use == 0 && debug_type != DEBUG_DWARF2)
     return;
     return;
-  else
-    dwarf2_where (& loc);
 
 
-  dwarf2_gen_line_info (frag_now_fix () - size, &loc);
+  dwarf2_where (&loc);
+
+  loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
+
+  dwarf2_gen_line_info_1 (label, &loc);
+  dwarf2_consume_line_info ();
 }
 
 }
 
-/* Get a .debug_line file number for FILENAME.  */
+/* 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
 
 static unsigned int
-get_filenum (filename)
-     const char *filename;
+get_filenum (const char *filename, unsigned int num)
 {
 {
-  static unsigned int last_used;
-  unsigned int i;
+  static unsigned int last_used, last_used_dir_len;
+  const char *file;
+  size_t dir_len;
+  unsigned int i, dir;
 
 
-  if (last_used)
-    if (strcmp (filename, files[last_used].filename) == 0)
-      return last_used;
+  if (num == 0 && last_used)
+    {
+      if (! files[last_used].dir
+         && filename_cmp (filename, files[last_used].filename) == 0)
+       return last_used;
+      if (files[last_used].dir
+         && filename_ncmp (filename, dirs[files[last_used].dir],
+                           last_used_dir_len) == 0
+         && IS_DIR_SEPARATOR (filename [last_used_dir_len])
+         && filename_cmp (filename + last_used_dir_len + 1,
+                          files[last_used].filename) == 0)
+       return last_used;
+    }
 
 
-  for (i = 1; i < files_in_use; ++i)
-    if (strcmp (filename, files[i].filename) == 0)
-      return i;
+  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
+  if (file == filename + 1)
+    file = filename;
+#endif
+  dir_len = file - filename;
+
+  dir = 0;
+  if (dir_len)
+    {
+#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
+      --dir_len;
+#endif
+      for (dir = 1; dir < dirs_in_use; ++dir)
+       if (filename_ncmp (filename, dirs[dir], dir_len) == 0
+           && dirs[dir][dir_len] == '\0')
+         break;
+
+      if (dir >= dirs_in_use)
+       {
+         if (dir >= dirs_allocated)
+           {
+             dirs_allocated = dir + 32;
+             dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
+           }
+
+         dirs[dir] = xmemdup0 (filename, dir_len);
+         dirs_in_use = dir + 1;
+       }
+    }
+
+  if (num == 0)
+    {
+      for (i = 1; i < files_in_use; ++i)
+       if (files[i].dir == dir
+           && files[i].filename
+           && filename_cmp (file, files[i].filename) == 0)
+         {
+           last_used = i;
+           last_used_dir_len = dir_len;
+           return i;
+         }
+    }
+  else
+    i = num;
 
   if (i >= files_allocated)
     {
       unsigned int old = files_allocated;
 
       files_allocated = i + 32;
 
   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));
+      files = XRESIZEVEC (struct file_entry, files, files_allocated);
 
       memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
     }
 
 
       memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
     }
 
-  files[i].filename = xstrdup (filename);
-  files[i].dir = 0;
-  files_in_use = i + 1;
+  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 = i;
+  last_used_dir_len = dir_len;
 
   return i;
 }
 
   return i;
 }
@@ -357,8 +562,7 @@ get_filenum (filename)
    If an entry is added to the file table, return a pointer to the filename. */
 
 char *
    If an entry is added to the file table, return a pointer to the filename. */
 
 char *
-dwarf2_directive_file (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
 {
   offsetT num;
   char *filename;
 {
   offsetT num;
   char *filename;
@@ -374,6 +578,8 @@ dwarf2_directive_file (dummy)
 
   num = get_absolute_expression ();
   filename = demand_copy_C_string (&filename_len);
 
   num = get_absolute_expression ();
   filename = demand_copy_C_string (&filename_len);
+  if (filename == NULL)
+    return NULL;
   demand_empty_rest_of_line ();
 
   if (num < 1)
   demand_empty_rest_of_line ();
 
   if (num < 1)
@@ -382,43 +588,34 @@ dwarf2_directive_file (dummy)
       return NULL;
     }
 
       return NULL;
     }
 
+  /* A .file directive implies compiler generated debug information is
+     being supplied.  Turn off gas generated debug info.  */
+  debug_type = DEBUG_NONE;
+
   if (num < (int) files_in_use && files[num].filename != 0)
     {
       as_bad (_("file number %ld already allocated"), (long) num);
       return NULL;
     }
 
   if (num < (int) files_in_use && files[num].filename != 0)
     {
       as_bad (_("file number %ld already allocated"), (long) num);
       return NULL;
     }
 
-  if (num >= (int) files_allocated)
-    {
-      unsigned int old = files_allocated;
-
-      files_allocated = num + 16;
-      files = (struct file_entry *)
-       xrealloc (files, (num + 16) * sizeof (struct file_entry));
-
-      /* Zero the new memory.  */
-      memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
-    }
-
-  files[num].filename = filename;
-  files[num].dir = 0;
-  files_in_use = num + 1;
+  get_filenum (filename, num);
 
   return filename;
 }
 
 void
 
   return filename;
 }
 
 void
-dwarf2_directive_loc (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
 {
 {
-  offsetT filenum, line, column;
+  offsetT filenum, line;
+
+  /* If we see two .loc directives in a row, force the first one to be
+     output now.  */
+  if (dwarf2_loc_directive_seen)
+    dwarf2_emit_insn (0);
 
   filenum = get_absolute_expression ();
   SKIP_WHITESPACE ();
   line = get_absolute_expression ();
 
   filenum = get_absolute_expression ();
   SKIP_WHITESPACE ();
   line = get_absolute_expression ();
-  SKIP_WHITESPACE ();
-  column = get_absolute_expression ();
-  demand_empty_rest_of_line ();
 
   if (filenum < 1)
     {
 
   if (filenum < 1)
     {
@@ -433,53 +630,150 @@ dwarf2_directive_loc (dummy)
 
   current.filenum = filenum;
   current.line = line;
 
   current.filenum = filenum;
   current.line = line;
-  current.column = column;
-  current.flags = DWARF2_FLAG_BEGIN_STMT;
-
-  loc_directive_seen = TRUE;
+  current.discriminator = 0;
 
 #ifndef NO_LISTING
   if (listing)
     {
 
 #ifndef NO_LISTING
   if (listing)
     {
-      listing_source_file (files[filenum].filename);
+      if (files[filenum].dir)
+       {
+         size_t dir_len = strlen (dirs[files[filenum].dir]);
+         size_t file_len = strlen (files[filenum].filename);
+         char *cp = XNEWVEC (char, 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);
+         free (cp);
+       }
+      else
+       listing_source_file (files[filenum].filename);
       listing_source_line (line);
     }
 #endif
       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;
+
+      c = get_symbol_name (& p);
+
+      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)
+       {
+         (void) restore_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)
+       {
+         (void) restore_line_pointer (c);
+         value = get_absolute_expression ();
+         if (value >= 0)
+           current.isa = value;
+         else
+           {
+             as_bad (_("isa number less than zero"));
+             return;
+           }
+       }
+      else if (strcmp (p, "discriminator") == 0)
+       {
+         (void) restore_line_pointer (c);
+         value = get_absolute_expression ();
+         if (value >= 0)
+           current.discriminator = value;
+         else
+           {
+             as_bad (_("discriminator less than zero"));
+             return;
+           }
+       }
+      else
+       {
+         as_bad (_("unknown .loc sub-directive `%s'"), p);
+         (void) restore_line_pointer (c);
+         return;
+       }
+
+      SKIP_WHITESPACE_AFTER_NAME ();
+    }
+
+  demand_empty_rest_of_line ();
+  dwarf2_loc_directive_seen = TRUE;
+  debug_type = DEBUG_NONE;
+}
+
+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
+    {
+      dwarf2_loc_mark_labels = value != 0;
+      demand_empty_rest_of_line ();
+    }
 }
 \f
 static struct frag *
 }
 \f
 static struct frag *
-first_frag_for_seg (seg)
-     segT seg;
+first_frag_for_seg (segT seg)
 {
 {
-  frchainS *f, *first = NULL;
-
-  for (f = frchain_root; f; f = f->frch_next)
-    if (f->frch_seg == seg
-       && (! first || first->frch_subseg > f->frch_subseg))
-      first = f;
-
-  return first ? first->frch_root : NULL;
+  return seg_info (seg)->frchainP->frch_root;
 }
 
 static struct frag *
 }
 
 static struct frag *
-last_frag_for_seg (seg)
-     segT seg;
+last_frag_for_seg (segT seg)
 {
 {
-  frchainS *f, *last = NULL;
+  frchainS *f = seg_info (seg)->frchainP;
 
 
-  for (f = frchain_root; f; f = f->frch_next)
-    if (f->frch_seg == seg
-       && (! last || last->frch_subseg < f->frch_subseg))
-      last= f;
+  while (f->frch_next != NULL)
+    f = f->frch_next;
 
 
-  return last ? last->frch_last : NULL;
+  return f->frch_last;
 }
 \f
 /* Emit a single byte into the current segment.  */
 
 static inline void
 }
 \f
 /* Emit a single byte into the current segment.  */
 
 static inline void
-out_byte (byte)
-     int byte;
+out_byte (int byte)
 {
   FRAG_APPEND_1_CHAR (byte);
 }
 {
   FRAG_APPEND_1_CHAR (byte);
 }
@@ -487,8 +781,7 @@ out_byte (byte)
 /* Emit a statement program opcode into the current segment.  */
 
 static inline void
 /* Emit a statement program opcode into the current segment.  */
 
 static inline void
-out_opcode (opc)
-     int opc;
+out_opcode (int opc)
 {
   out_byte (opc);
 }
 {
   out_byte (opc);
 }
@@ -496,8 +789,7 @@ out_opcode (opc)
 /* Emit a two-byte word into the current segment.  */
 
 static inline void
 /* Emit a two-byte word into the current segment.  */
 
 static inline void
-out_two (data)
-     int data;
+out_two (int data)
 {
   md_number_to_chars (frag_more (2), data, 2);
 }
 {
   md_number_to_chars (frag_more (2), data, 2);
 }
@@ -505,8 +797,7 @@ out_two (data)
 /* Emit a four byte word into the current segment.  */
 
 static inline void
 /* Emit a four byte word into the current segment.  */
 
 static inline void
-out_four (data)
-     int data;
+out_four (int data)
 {
   md_number_to_chars (frag_more (4), data, 4);
 }
 {
   md_number_to_chars (frag_more (4), data, 4);
 }
@@ -514,46 +805,32 @@ out_four (data)
 /* Emit an unsigned "little-endian base 128" number.  */
 
 static void
 /* Emit an unsigned "little-endian base 128" number.  */
 
 static void
-out_uleb128 (value)
-     addressT value;
+out_uleb128 (addressT value)
 {
   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
 }
 
 {
   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
 }
 
-/* Emit a tuple for .debug_abbrev.  */
-
-static inline void
-out_abbrev (name, form)
-     int name, form;
-{
-  out_uleb128 (name);
-  out_uleb128 (form);
-}
-
-/* Create a new fake symbol whose value is the current position.  */
+/* Emit a signed "little-endian base 128" number.  */
 
 
-static symbolS *
-symbol_new_now ()
+static void
+out_leb128 (addressT value)
 {
 {
-  return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
+  output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
 }
 
 }
 
-/* Set the value of SYM to the current position in the current segment.  */
+/* Emit a tuple for .debug_abbrev.  */
 
 
-static void
-set_symbol_value_now (sym)
-     symbolS *sym;
+static inline void
+out_abbrev (int name, int form)
 {
 {
-  S_SET_SEGMENT (sym, now_seg);
-  S_SET_VALUE (sym, frag_now_fix ());
-  symbol_set_frag (sym, frag_now);
+  out_uleb128 (name);
+  out_uleb128 (form);
 }
 
 /* Get the size of a fragment.  */
 
 static offsetT
 }
 
 /* Get the size of a fragment.  */
 
 static offsetT
-get_frag_fix (frag)
-     fragS *frag;
+get_frag_fix (fragS *frag, segT seg)
 {
   frchainS *fr;
 
 {
   frchainS *fr;
 
@@ -563,13 +840,9 @@ get_frag_fix (frag)
   /* 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.  */
   /* 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 = frchain_root; fr; fr = fr->frch_next)
+  for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
     if (fr->frch_last == frag)
     if (fr->frch_last == frag)
-      {
-       long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
-       return (((char *) obstack_next_free (&fr->frch_obstack)
-                - frag->fr_literal) + ~align_mask) & align_mask;
-      }
+      return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
 
   abort ();
 }
 
   abort ();
 }
@@ -577,43 +850,36 @@ get_frag_fix (frag)
 /* Set an absolute address (may result in a relocation entry).  */
 
 static void
 /* Set an absolute address (may result in a relocation entry).  */
 
 static void
-out_set_addr (seg, frag, ofs)
-     segT seg;
-     fragS *frag;
-     addressT ofs;
+out_set_addr (symbolS *sym)
 {
 {
-  expressionS expr;
-  symbolS *sym;
-
-  sym = symbol_new (fake_label_name, seg, ofs, frag);
+  expressionS exp;
 
   out_opcode (DW_LNS_extended_op);
   out_uleb128 (sizeof_address + 1);
 
   out_opcode (DW_LNE_set_address);
 
   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);
+  exp.X_op = O_symbol;
+  exp.X_add_symbol = sym;
+  exp.X_add_number = 0;
+  emit_expr (&exp, sizeof_address);
 }
 
 }
 
-#if DWARF2_LINE_MIN_INSN_LENGTH > 1
+static void scale_addr_delta (addressT *);
+
 static void
 static void
-scale_addr_delta (addr_delta)
-     int *addr_delta;
+scale_addr_delta (addressT *addr_delta)
 {
   static int printed_this = 0;
 {
   static int printed_this = 0;
-  if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
+  if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
     {
     {
-      if (!printed_this)
-       as_bad("unaligned opcodes detected in executable segment");
-      printed_this = 1;
+      if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0  && !printed_this)
+        {
+         as_bad("unaligned opcodes detected in executable segment");
+          printed_this = 1;
+        }
+      *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
     }
     }
-  *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
 }
 }
-#else
-#define scale_addr_delta(A)
-#endif
 
 /* 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.
 
 /* 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.
@@ -623,9 +889,7 @@ scale_addr_delta (addr_delta)
    exactly the expected number of bytes.  */
 
 static int
    exactly the expected number of bytes.  */
 
 static int
-size_inc_line_addr (line_delta, addr_delta)
-     int line_delta;
-     addressT addr_delta;
+size_inc_line_addr (int line_delta, addressT addr_delta)
 {
   unsigned int tmp, opcode;
   int len = 0;
 {
   unsigned int tmp, opcode;
   int len = 0;
@@ -684,16 +948,16 @@ size_inc_line_addr (line_delta, addr_delta)
 }
 
 static void
 }
 
 static void
-emit_inc_line_addr (line_delta, addr_delta, p, len)
-     int line_delta;
-     addressT addr_delta;
-     char *p;
-     int len;
+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;
 
 {
   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.  */
+  gas_assert ((offsetT) addr_delta >= 0);
+
   /* Scale the address delta by the minimum instruction length.  */
   scale_addr_delta (&addr_delta);
 
   /* Scale the address delta by the minimum instruction length.  */
   scale_addr_delta (&addr_delta);
 
@@ -726,19 +990,19 @@ emit_inc_line_addr (line_delta, addr_delta, p, len)
       *p++ = DW_LNS_advance_line;
       p += output_leb128 (p, line_delta, 1);
 
       *p++ = DW_LNS_advance_line;
       p += output_leb128 (p, line_delta, 1);
 
-      /* Prettier, I think, to use DW_LNS_copy instead of a
-        "line +0, addr +0" special opcode.  */
-      if (addr_delta == 0)
-       {
-         *p++ = DW_LNS_copy;
-         goto done;
-       }
-
       line_delta = 0;
       tmp = 0 - DWARF2_LINE_BASE;
       need_copy = 1;
     }
 
       line_delta = 0;
       tmp = 0 - DWARF2_LINE_BASE;
       need_copy = 1;
     }
 
+  /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
+     special opcode.  */
+  if (line_delta == 0 && addr_delta == 0)
+    {
+      *p++ = DW_LNS_copy;
+      goto done;
+    }
+
   /* Bias the opcode by the special opcode base.  */
   tmp += DWARF2_LINE_OPCODE_BASE;
 
   /* Bias the opcode by the special opcode base.  */
   tmp += DWARF2_LINE_OPCODE_BASE;
 
@@ -773,48 +1037,143 @@ emit_inc_line_addr (line_delta, addr_delta, p, len)
     *p++ = tmp;
 
  done:
     *p++ = tmp;
 
  done:
-  assert (p == end);
+  gas_assert (p == end);
 }
 
 /* Handy routine to combine calls to the above two routines.  */
 
 static void
 }
 
 /* Handy routine to combine calls to the above two routines.  */
 
 static void
-out_inc_line_addr (line_delta, addr_delta)
-     int line_delta;
-     addressT addr_delta;
+out_inc_line_addr (int line_delta, addressT addr_delta)
 {
   int len = size_inc_line_addr (line_delta, addr_delta);
   emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
 }
 
 {
   int len = size_inc_line_addr (line_delta, addr_delta);
   emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
 }
 
+/* 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 is required if linker relaxation
+   could change the code offsets.  The following two routines *must* be
+   kept in sync.  */
+#define ADDR_DELTA_LIMIT 50000
+
+static int
+size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
+{
+  int len = 0;
+
+  /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.  */
+  if (line_delta != INT_MAX)
+    len = 1 + sizeof_leb128 (line_delta, 1);
+
+  if (addr_delta > ADDR_DELTA_LIMIT)
+    {
+      /* DW_LNS_extended_op */
+      len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
+      /* DW_LNE_set_address */
+      len += 1 + sizeof_address;
+    }
+  else
+    /* DW_LNS_fixed_advance_pc */
+    len += 3;
+
+  if (line_delta == INT_MAX)
+    /* DW_LNS_extended_op + DW_LNE_end_sequence */
+    len += 3;
+  else
+    /* DW_LNS_copy */
+    len += 1;
+
+  return len;
+}
+
+static void
+emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
+                         char *p, int len)
+{
+  expressionS *pexp;
+  char *end = p + len;
+
+  /* Line number sequences cannot go backward in addresses.  This means
+     we've incorrectly ordered the statements in the sequence.  */
+  gas_assert ((offsetT) addr_delta >= 0);
+
+  /* Verify that we have kept in sync with size_fixed_inc_line_addr.  */
+  gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
+
+  /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.  */
+  if (line_delta != INT_MAX)
+    {
+      *p++ = DW_LNS_advance_line;
+      p += output_leb128 (p, line_delta, 1);
+    }
+
+  pexp = symbol_get_value_expression (frag->fr_symbol);
+
+  /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
+     advance the address by at most 64K.  Linker relaxation (without
+     which this function would not be used) could change the operand by
+     an unknown amount.  If the address increment is getting close to
+     the limit, just reset the address.  */
+  if (addr_delta > ADDR_DELTA_LIMIT)
+    {
+      symbolS *to_sym;
+      expressionS exp;
+
+      gas_assert (pexp->X_op == O_subtract);
+      to_sym = pexp->X_add_symbol;
+
+      *p++ = DW_LNS_extended_op;
+      p += output_leb128 (p, sizeof_address + 1, 0);
+      *p++ = DW_LNE_set_address;
+      exp.X_op = O_symbol;
+      exp.X_add_symbol = to_sym;
+      exp.X_add_number = 0;
+      emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE);
+      p += sizeof_address;
+    }
+  else
+    {
+      *p++ = DW_LNS_fixed_advance_pc;
+      emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE);
+      p += 2;
+    }
+
+  if (line_delta == INT_MAX)
+    {
+      *p++ = DW_LNS_extended_op;
+      *p++ = 1;
+      *p++ = DW_LNE_end_sequence;
+    }
+  else
+    *p++ = DW_LNS_copy;
+
+  gas_assert (p == end);
+}
+
 /* Generate a variant frag that we can use to relax address/line
    increments between fragments of the target segment.  */
 
 static void
 /* 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 (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
-     int line_delta;
-     segT seg;
-     fragS *to_frag, *from_frag;
-     addressT to_ofs, from_ofs;
+relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
 {
 {
-  symbolS *to_sym, *from_sym;
-  expressionS expr;
+  expressionS exp;
   int max_chars;
 
   int max_chars;
 
-  to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
-  from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
-
-  expr.X_op = O_subtract;
-  expr.X_add_symbol = to_sym;
-  expr.X_op_symbol = from_sym;
-  expr.X_add_number = 0;
+  exp.X_op = O_subtract;
+  exp.X_add_symbol = to_sym;
+  exp.X_op_symbol = from_sym;
+  exp.X_add_number = 0;
 
   /* The maximum size of the frag is the line delta with a maximum
      sized address delta.  */
 
   /* 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);
+  if (DWARF2_USE_FIXED_ADVANCE_PC)
+    max_chars = size_fixed_inc_line_addr (line_delta,
+                                         -DWARF2_LINE_MIN_INSN_LENGTH);
+  else
+    max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
 
   frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
 
   frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
-           make_expr_symbol (&expr), line_delta, NULL);
+           make_expr_symbol (&exp), line_delta, NULL);
 }
 
 /* The function estimates the size of a rs_dwarf2dbg variant frag
 }
 
 /* The function estimates the size of a rs_dwarf2dbg variant frag
@@ -822,14 +1181,16 @@ relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
    the relaxation loop.  We set fr_subtype to the expected length.  */
 
 int
    the relaxation loop.  We set fr_subtype to the expected length.  */
 
 int
-dwarf2dbg_estimate_size_before_relax (frag)
-     fragS *frag;
+dwarf2dbg_estimate_size_before_relax (fragS *frag)
 {
   offsetT addr_delta;
   int size;
 
   addr_delta = resolve_symbol_value (frag->fr_symbol);
 {
   offsetT addr_delta;
   int size;
 
   addr_delta = resolve_symbol_value (frag->fr_symbol);
-  size = size_inc_line_addr (frag->fr_offset, addr_delta);
+  if (DWARF2_USE_FIXED_ADVANCE_PC)
+    size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
+  else
+    size = size_inc_line_addr (frag->fr_offset, addr_delta);
 
   frag->fr_subtype = size;
 
 
   frag->fr_subtype = size;
 
@@ -841,8 +1202,7 @@ dwarf2dbg_estimate_size_before_relax (frag)
    of the frag.  This returns the change in frag length.  */
 
 int
    of the frag.  This returns the change in frag length.  */
 
 int
-dwarf2dbg_relax_frag (frag)
-     fragS *frag;
+dwarf2dbg_relax_frag (fragS *frag)
 {
   int old_size, new_size;
 
 {
   int old_size, new_size;
 
@@ -857,20 +1217,41 @@ dwarf2dbg_relax_frag (frag)
    fr_subtype will be the desired length of the frag.  */
 
 void
    fr_subtype will be the desired length of the frag.  */
 
 void
-dwarf2dbg_convert_frag (frag)
-     fragS *frag;
+dwarf2dbg_convert_frag (fragS *frag)
 {
   offsetT addr_diff;
 
 {
   offsetT addr_diff;
 
-  addr_diff = resolve_symbol_value (frag->fr_symbol);
+  if (DWARF2_USE_FIXED_ADVANCE_PC)
+    {
+      /* If linker relaxation is enabled then the distance bewteen the two
+        symbols in the frag->fr_symbol expression might change.  Hence we
+        cannot rely upon the value computed by resolve_symbol_value.
+        Instead we leave the expression unfinalized and allow
+        emit_fixed_inc_line_addr to create a fixup (which later becomes a
+        relocation) that will allow the linker to correctly compute the
+        actual address difference.  We have to use a fixed line advance for
+        this as we cannot (easily) relocate leb128 encoded values.  */
+      int saved_finalize_syms = finalize_syms;
+
+      finalize_syms = 0;
+      addr_diff = resolve_symbol_value (frag->fr_symbol);
+      finalize_syms = saved_finalize_syms;
+    }
+  else
+    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.  */
 
   /* 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);
+  gas_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);
+  if (DWARF2_USE_FIXED_ADVANCE_PC)
+    emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
+                             frag->fr_literal + frag->fr_fix,
+                             frag->fr_subtype);
+  else
+    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_fix += frag->fr_subtype;
   frag->fr_type = rs_fill;
@@ -882,30 +1263,57 @@ dwarf2dbg_convert_frag (frag)
    beginning at E, for segment SEG.  */
 
 static void
    beginning at E, for segment SEG.  */
 
 static void
-process_entries (seg, e)
-     segT seg;
-     struct line_entry *e;
+process_entries (segT seg, struct line_entry *e)
 {
   unsigned filenum = 1;
   unsigned line = 1;
   unsigned column = 0;
 {
   unsigned filenum = 1;
   unsigned line = 1;
   unsigned column = 0;
-  unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
-  fragS *frag = NULL;
-  fragS *last_frag;
-  addressT frag_ofs = 0;
-  addressT last_frag_ofs;
+  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;
 
   struct line_entry *next;
 
-  while (e)
+  if (flag_dwarf_sections)
     {
     {
-      int changed = 0;
+      char * name;
+      const char * sec_name;
+
+      /* Switch to the relevent sub-section before we start to emit
+        the line number table.
+
+        FIXME: These sub-sections do not have a normal Line Number
+        Program Header, thus strictly speaking they are not valid
+        DWARF sections.  Unfortunately the DWARF standard assumes
+        a one-to-one relationship between compilation units and
+        line number tables.  Thus we have to have a .debug_line
+        section, as well as our sub-sections, and we have to ensure
+        that all of the sub-sections are merged into a proper
+        .debug_line section before a debugger sees them.  */
+
+      sec_name = bfd_get_section_name (stdoutput, seg);
+      if (strcmp (sec_name, ".text") != 0)
+       {
+         name = concat (".debug_line", sec_name, (char *) NULL);
+         subseg_set (subseg_get (name, FALSE), 0);
+       }
+      else
+       /* Don't create a .debug_line.text section -
+          that is redundant.  Instead just switch back to the
+          normal .debug_line section.  */
+       subseg_set (subseg_get (".debug_line", FALSE), 0);
+    }
+
+  do
+    {
+      int line_delta;
 
       if (filenum != e->loc.filenum)
        {
          filenum = e->loc.filenum;
          out_opcode (DW_LNS_set_file);
          out_uleb128 (filenum);
 
       if (filenum != e->loc.filenum)
        {
          filenum = e->loc.filenum;
          out_opcode (DW_LNS_set_file);
          out_uleb128 (filenum);
-         changed = 1;
        }
 
       if (column != e->loc.column)
        }
 
       if (column != e->loc.column)
@@ -913,158 +1321,214 @@ process_entries (seg, e)
          column = e->loc.column;
          out_opcode (DW_LNS_set_column);
          out_uleb128 (column);
          column = e->loc.column;
          out_opcode (DW_LNS_set_column);
          out_uleb128 (column);
-         changed = 1;
        }
 
        }
 
-      if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
+      if (e->loc.discriminator != 0)
        {
        {
-         flags = e->loc.flags;
-         out_opcode (DW_LNS_negate_stmt);
-         changed = 1;
+         out_opcode (DW_LNS_extended_op);
+         out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
+         out_opcode (DW_LNE_set_discriminator);
+         out_uleb128 (e->loc.discriminator);
        }
 
        }
 
-      if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
+      if (isa != e->loc.isa)
        {
        {
-         out_opcode (DW_LNS_set_basic_block);
-         changed = 1;
+         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.  */
       /* 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.  */
-      if (1 /* line != e->loc.line || changed */)
-       {
-         int line_delta = e->loc.line - line;
-         if (frag == NULL)
-           {
-             out_set_addr (seg, e->frag, e->frag_ofs);
-             out_inc_line_addr (line_delta, 0);
-           }
-         else if (frag == e->frag)
-           out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
-         else
-           relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
-                                frag, frag_ofs);
+      line_delta = e->loc.line - line;
+      lab = e->label;
+      frag = symbol_get_frag (lab);
+      frag_ofs = S_GET_VALUE (lab);
 
 
-         frag = e->frag;
-         frag_ofs = e->frag_ofs;
-         line = e->loc.line;
-       }
-      else if (frag == NULL)
+      if (last_frag == NULL)
        {
        {
-         out_set_addr (seg, e->frag, e->frag_ofs);
-         frag = e->frag;
-         frag_ofs = e->frag_ofs;
+         out_set_addr (lab);
+         out_inc_line_addr (line_delta, 0);
        }
        }
+      else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
+       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;
     }
 
       next = e->next;
       free (e);
       e = next;
     }
+  while (e);
 
   /* Emit a DW_LNE_end_sequence for the end of the section.  */
 
   /* Emit a DW_LNE_end_sequence for the end of the section.  */
-  last_frag = last_frag_for_seg (seg);
-  last_frag_ofs = get_frag_fix (last_frag);
-  if (frag == last_frag)
-    out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
+  frag = last_frag_for_seg (seg);
+  frag_ofs = get_frag_fix (frag, seg);
+  if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
+    out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
   else
   else
-    relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
-                        frag, frag_ofs);
+    {
+      lab = symbol_temp_new (seg, frag_ofs, frag);
+      relax_inc_line_addr (INT_MAX, lab, last_lab);
+    }
 }
 
 /* Emit the directory and file tables for .debug_line.  */
 
 static void
 }
 
 /* Emit the directory and file tables for .debug_line.  */
 
 static void
-out_file_list ()
+out_file_list (void)
 {
   size_t size;
 {
   size_t size;
+  const char *dir;
   char *cp;
   unsigned int i;
 
   char *cp;
   unsigned int i;
 
-  /* Terminate directory list.  */
+  /* Emit directory list.  */
+  for (i = 1; i < dirs_in_use; ++i)
+    {
+      dir = remap_debug_filename (dirs[i]);
+      size = strlen (dir) + 1;
+      cp = frag_more (size);
+      memcpy (cp, dir, size);
+    }
+  /* Terminate it.  */
   out_byte ('\0');
 
   for (i = 1; i < files_in_use; ++i)
     {
   out_byte ('\0');
 
   for (i = 1; i < files_in_use; ++i)
     {
+      const char *fullfilename;
+
       if (files[i].filename == NULL)
        {
          as_bad (_("unassigned file number %ld"), (long) 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;
        }
 
          continue;
        }
 
-      size = strlen (files[i].filename) + 1;
+      fullfilename = DWARF2_FILE_NAME (files[i].filename,
+                                      files[i].dir ? dirs [files [i].dir] : "");
+      size = strlen (fullfilename) + 1;
       cp = frag_more (size);
       cp = frag_more (size);
-      memcpy (cp, files[i].filename, size);
+      memcpy (cp, fullfilename, size);
 
       out_uleb128 (files[i].dir);      /* directory number */
 
       out_uleb128 (files[i].dir);      /* directory number */
-      out_uleb128 (0);                 /* last modification timestamp */
-      out_uleb128 (0);                 /* filesize */
+      /* Output the last modification timestamp.  */
+      out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
+                                         files[i].dir ? dirs [files [i].dir] : ""));
+      /* Output the filesize.  */
+      out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
+                                         files[i].dir ? dirs [files [i].dir] : ""));
     }
 
   /* Terminate filename list.  */
   out_byte (0);
 }
 
     }
 
   /* Terminate filename list.  */
   out_byte (0);
 }
 
-/* Emit the collected .debug_line data.  */
+/* Switch to SEC and output a header length field.  Return the size of
+   offsets used in SEC.  The caller must set EXPR->X_add_symbol value
+   to the end of the section.  EXPR->X_add_number will be set to the
+   negative size of the header.  */
 
 
-static void
-out_debug_line (line_seg)
-     segT line_seg;
+static int
+out_header (asection *sec, expressionS *exp)
 {
 {
-  expressionS expr;
-  symbolS *line_start;
-  symbolS *prologue_end;
-  symbolS *line_end;
-  struct line_seg *s;
-  enum dwarf2_format d2f;
-  int sizeof_offset;
+  symbolS *start_sym;
+  symbolS *end_sym;
 
 
-  subseg_set (line_seg, 0);
+  subseg_set (sec, 0);
 
 
-  line_start = symbol_new_now ();
-  prologue_end = symbol_make (fake_label_name);
-  line_end = symbol_make (fake_label_name);
-
-  /* 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)
-    {
-      expr.X_add_number = -4;
-      emit_expr (&expr, 4);
-      sizeof_offset = 4;
-    }
-  else if (d2f == dwarf2_format_64bit)
+  if (flag_dwarf_sections)
     {
     {
-      expr.X_add_number = -12;
-      out_four (-1);
-      emit_expr (&expr, 8);
-      sizeof_offset = 8;
+      /* If we are going to put the start and end symbols in different
+        sections, then we need real symbols, not just fake, local ones.  */
+      frag_now_fix ();
+      start_sym = symbol_make (".Ldebug_line_start");
+      end_sym = symbol_make (".Ldebug_line_end");
+      symbol_set_value_now (start_sym);
     }
     }
-  else if (d2f == dwarf2_format_64bit_irix)
+  else
     {
     {
-      expr.X_add_number = -8;
-      emit_expr (&expr, 8);
-      sizeof_offset = 8;
+      start_sym = symbol_temp_new_now ();
+      end_sym = symbol_temp_make ();
     }
     }
-  else
+
+  /* Total length of the information.  */
+  exp->X_op = O_subtract;
+  exp->X_add_symbol = end_sym;
+  exp->X_op_symbol = start_sym;
+
+  switch (DWARF2_FORMAT (sec))
     {
     {
-      as_fatal (_("internal error: unknown dwarf2 format"));
+    case dwarf2_format_32bit:
+      exp->X_add_number = -4;
+      emit_expr (exp, 4);
+      return 4;
+
+    case dwarf2_format_64bit:
+      exp->X_add_number = -12;
+      out_four (-1);
+      emit_expr (exp, 8);
+      return 8;
+
+    case dwarf2_format_64bit_irix:
+      exp->X_add_number = -8;
+      emit_expr (exp, 8);
+      return 8;
     }
 
     }
 
+  as_fatal (_("internal error: unknown dwarf2 format"));
+  return 0;
+}
+
+/* Emit the collected .debug_line data.  */
+
+static void
+out_debug_line (segT line_seg)
+{
+  expressionS exp;
+  symbolS *prologue_start, *prologue_end;
+  symbolS *line_end;
+  struct line_seg *s;
+  int sizeof_offset;
+
+  sizeof_offset = out_header (line_seg, &exp);
+  line_end = exp.X_add_symbol;
+
   /* Version.  */
   /* Version.  */
-  out_two (2);
+  out_two (DWARF2_LINE_VERSION);
 
   /* Length of the prologue following this length.  */
 
   /* 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);
+  prologue_start = symbol_temp_make ();
+  prologue_end = symbol_temp_make ();
+  exp.X_op = O_subtract;
+  exp.X_add_symbol = prologue_end;
+  exp.X_op_symbol = prologue_start;
+  exp.X_add_number = 0;
+  emit_expr (&exp, sizeof_offset);
+  symbol_set_value_now (prologue_start);
 
   /* Parameters of the state machine.  */
   out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
 
   /* Parameters of the state machine.  */
   out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
@@ -1083,66 +1547,119 @@ out_debug_line (line_seg)
   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_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 ();
 
 
   out_file_list ();
 
-  set_symbol_value_now (prologue_end);
+  symbol_set_value_now (prologue_end);
 
   /* For each section, emit a statement program.  */
   for (s = all_segs; s; s = s->next)
 
   /* For each section, emit a statement program.  */
   for (s = all_segs; s; s = s->next)
-    process_entries (s->seg, s->head->head);
-
-  set_symbol_value_now (line_end);
+    if (SEG_NORMAL (s->seg))
+      process_entries (s->seg, s->head->head);
+    else
+      as_warn ("dwarf line number information for %s ignored",
+              segment_name (s->seg));
+
+  if (flag_dwarf_sections)
+    /* We have to switch to the special .debug_line_end section
+       before emitting the end-of-debug_line symbol.  The linker
+       script arranges for this section to be placed after all the
+       (potentially garbage collected) .debug_line.<foo> sections.
+       This section contains the line_end symbol which is used to
+       compute the size of the linked .debug_line section, as seen
+       in the DWARF Line Number header.  */
+    subseg_set (subseg_get (".debug_line_end", FALSE), 0);
+
+  symbol_set_value_now (line_end);
 }
 
 }
 
-/* Emit data for .debug_aranges.  */
-
 static void
 static void
-out_debug_aranges (aranges_seg, info_seg)
-     segT aranges_seg;
-     segT info_seg;
+out_debug_ranges (segT ranges_seg)
 {
   unsigned int addr_size = sizeof_address;
 {
   unsigned int addr_size = sizeof_address;
-  addressT size, skip;
   struct line_seg *s;
   struct line_seg *s;
-  expressionS expr;
-  char *p;
+  expressionS exp;
+  unsigned int i;
 
 
-  size = 4 + 2 + 4 + 1 + 1;
+  subseg_set (ranges_seg, 0);
 
 
-  skip = 2 * addr_size - (size & (2 * addr_size - 1));
-  if (skip == 2 * addr_size)
-    skip = 0;
-  size += skip;
+  /* 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)
   for (s = all_segs; s; s = s->next)
-    size += 2 * addr_size;
+    {
+      fragS *frag;
+      symbolS *beg, *end;
 
 
-  size += 2 * addr_size;
+      frag = first_frag_for_seg (s->seg);
+      beg = symbol_temp_new (s->seg, 0, frag);
+      s->text_start = beg;
 
 
-  subseg_set (aranges_seg, 0);
+      frag = last_frag_for_seg (s->seg);
+      end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
+      s->text_end = end;
+
+      exp.X_op = O_symbol;
+      exp.X_add_symbol = beg;
+      exp.X_add_number = 0;
+      emit_expr (&exp, addr_size);
+
+      exp.X_op = O_symbol;
+      exp.X_add_symbol = end;
+      exp.X_add_number = 0;
+      emit_expr (&exp, addr_size);
+    }
+
+  /* End of Range Entry.   */
+  for (i = 0; i < addr_size; i++)
+    out_byte (0);
+  for (i = 0; i < addr_size; i++)
+    out_byte (0);
+}
+
+/* Emit data for .debug_aranges.  */
+
+static void
+out_debug_aranges (segT aranges_seg, segT info_seg)
+{
+  unsigned int addr_size = sizeof_address;
+  offsetT size;
+  struct line_seg *s;
+  expressionS exp;
+  symbolS *aranges_end;
+  char *p;
+  int sizeof_offset;
 
 
-  /* Length of the compilation unit.  */
-  out_four (size - 4);
+  sizeof_offset = out_header (aranges_seg, &exp);
+  aranges_end = exp.X_add_symbol;
+  size = -exp.X_add_number;
 
   /* Version.  */
 
   /* Version.  */
-  out_two (2);
+  out_two (DWARF2_ARANGES_VERSION);
+  size += 2;
 
   /* Offset to .debug_info.  */
 
   /* Offset to .debug_info.  */
-  expr.X_op = O_symbol;
-  expr.X_add_symbol = section_symbol (info_seg);
-  expr.X_add_number = 0;
-  emit_expr (&expr, 4);
+  TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
+  size += sizeof_offset;
 
   /* Size of an address (offset portion).  */
   out_byte (addr_size);
 
   /* Size of an address (offset portion).  */
   out_byte (addr_size);
+  size++;
 
   /* Size of a segment descriptor.  */
   out_byte (0);
 
   /* Size of a segment descriptor.  */
   out_byte (0);
+  size++;
 
   /* Align the header.  */
 
   /* Align the header.  */
-  if (skip)
-    frag_align (ffs (2 * addr_size) - 1, 0, 0);
+  while ((size++ % (2 * addr_size)) > 0)
+    out_byte (0);
 
   for (s = all_segs; s; s = s->next)
     {
 
   for (s = all_segs; s; s = s->next)
     {
@@ -1150,47 +1667,64 @@ out_debug_aranges (aranges_seg, info_seg)
       symbolS *beg, *end;
 
       frag = first_frag_for_seg (s->seg);
       symbolS *beg, *end;
 
       frag = first_frag_for_seg (s->seg);
-      beg = symbol_new (fake_label_name, s->seg, 0, frag);
+      beg = symbol_temp_new (s->seg, 0, frag);
       s->text_start = beg;
 
       frag = last_frag_for_seg (s->seg);
       s->text_start = beg;
 
       frag = last_frag_for_seg (s->seg);
-      end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
+      end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
       s->text_end = end;
 
       s->text_end = end;
 
-      expr.X_op = O_symbol;
-      expr.X_add_symbol = beg;
-      expr.X_add_number = 0;
-      emit_expr (&expr, addr_size);
+      exp.X_op = O_symbol;
+      exp.X_add_symbol = beg;
+      exp.X_add_number = 0;
+      emit_expr (&exp, 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);
+      exp.X_op = O_subtract;
+      exp.X_add_symbol = end;
+      exp.X_op_symbol = beg;
+      exp.X_add_number = 0;
+      emit_expr (&exp, addr_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);
     }
 
   p = frag_more (2 * addr_size);
   md_number_to_chars (p, 0, addr_size);
   md_number_to_chars (p + addr_size, 0, addr_size);
+
+  symbol_set_value_now (aranges_end);
 }
 
 /* Emit data for .debug_abbrev.  Note that this must be kept in
    sync with out_debug_info below.  */
 
 static void
 }
 
 /* Emit data for .debug_abbrev.  Note that this must be kept in
    sync with out_debug_info below.  */
 
 static void
-out_debug_abbrev (abbrev_seg)
-     segT abbrev_seg;
+out_debug_abbrev (segT abbrev_seg,
+                 segT info_seg ATTRIBUTE_UNUSED,
+                 segT line_seg ATTRIBUTE_UNUSED)
 {
   subseg_set (abbrev_seg, 0);
 
   out_uleb128 (1);
   out_uleb128 (DW_TAG_compile_unit);
   out_byte (DW_CHILDREN_no);
 {
   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 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
+    out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
+  else
+    out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
   if (all_segs->next == NULL)
     {
       out_abbrev (DW_AT_low_pc, DW_FORM_addr);
   if (all_segs->next == NULL)
     {
       out_abbrev (DW_AT_low_pc, DW_FORM_addr);
-      out_abbrev (DW_AT_high_pc, DW_FORM_addr);
+      if (DWARF2_VERSION < 4)
+       out_abbrev (DW_AT_high_pc, DW_FORM_addr);
+      else
+       out_abbrev (DW_AT_high_pc, (sizeof_address == 4
+                                   ? DW_FORM_data4 : DW_FORM_data8));
+    }
+  else
+    {
+      if (DWARF2_FORMAT (info_seg) == 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_name, DW_FORM_string);
   out_abbrev (DW_AT_comp_dir, DW_FORM_string);
@@ -1205,64 +1739,25 @@ out_debug_abbrev (abbrev_seg)
 /* Emit a description of this compilation unit for .debug_info.  */
 
 static void
 /* Emit a description of this compilation unit for .debug_info.  */
 
 static void
-out_debug_info (info_seg, abbrev_seg, line_seg)
-     segT info_seg;
-     segT abbrev_seg;
-     segT line_seg;
+out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
 {
   char producer[128];
 {
   char producer[128];
-  char *comp_dir;
-  expressionS expr;
-  symbolS *info_start;
+  const char *comp_dir;
+  const char *dirname;
+  expressionS exp;
   symbolS *info_end;
   char *p;
   int len;
   symbolS *info_end;
   char *p;
   int len;
-  enum dwarf2_format d2f;
   int sizeof_offset;
 
   int sizeof_offset;
 
-  subseg_set (info_seg, 0);
-
-  info_start = symbol_new_now ();
-  info_end = symbol_make (fake_label_name);
-
-  /* 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)
-    {
-      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"));
-    }
+  sizeof_offset = out_header (info_seg, &exp);
+  info_end = exp.X_add_symbol;
 
   /* DWARF version.  */
 
   /* DWARF version.  */
-  out_two (2);
+  out_two (DWARF2_VERSION);
 
   /* .debug_abbrev offset */
 
   /* .debug_abbrev offset */
-  expr.X_op = O_symbol;
-  expr.X_add_symbol = section_symbol (abbrev_seg);
-  expr.X_add_number = 0;
-  emit_expr (&expr, sizeof_offset);
+  TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
 
   /* Target address size.  */
   out_byte (sizeof_address);
 
   /* Target address size.  */
   out_byte (sizeof_address);
@@ -1271,40 +1766,64 @@ out_debug_info (info_seg, abbrev_seg, line_seg)
   out_uleb128 (1);
 
   /* DW_AT_stmt_list */
   out_uleb128 (1);
 
   /* DW_AT_stmt_list */
-  expr.X_op = O_symbol;
-  expr.X_add_symbol = section_symbol (line_seg);
-  expr.X_add_number = 0;
-  emit_expr (&expr, 4);
+  TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
+                        (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
+                         ? 4 : 8));
 
 
-  /* These two attributes may only be emitted if all of the code is
-     contiguous.  Multiple sections are not that.  */
+  /* These two attributes are emitted if all of the code is contiguous.  */
   if (all_segs->next == NULL)
     {
       /* DW_AT_low_pc */
   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);
+      exp.X_op = O_symbol;
+      exp.X_add_symbol = all_segs->text_start;
+      exp.X_add_number = 0;
+      emit_expr (&exp, sizeof_address);
 
       /* DW_AT_high_pc */
 
       /* 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);
+      if (DWARF2_VERSION < 4)
+       exp.X_op = O_symbol;
+      else
+       {
+         exp.X_op = O_subtract;
+         exp.X_op_symbol = all_segs->text_start;
+       }
+      exp.X_add_symbol = all_segs->text_end;
+      exp.X_add_number = 0;
+      emit_expr (&exp, 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.  */
     }
 
   /* 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)
+  if (files_in_use == 0)
     abort ();
     abort ();
+  if (files[1].dir)
+    {
+      dirname = remap_debug_filename (dirs[files[1].dir]);
+      len = strlen (dirname);
+#ifdef TE_VMS
+      /* Already has trailing slash.  */
+      p = frag_more (len);
+      memcpy (p, dirname, len);
+#else
+      p = frag_more (len + 1);
+      memcpy (p, dirname, len);
+      INSERT_DIR_SEPARATOR (p, len);
+#endif
+    }
   len = strlen (files[1].filename) + 1;
   p = frag_more (len);
   memcpy (p, files[1].filename, len);
 
   /* DW_AT_comp_dir */
   len = strlen (files[1].filename) + 1;
   p = frag_more (len);
   memcpy (p, files[1].filename, len);
 
   /* DW_AT_comp_dir */
-  comp_dir = getpwd ();
+  comp_dir = remap_debug_filename (getpwd ());
   len = strlen (comp_dir) + 1;
   p = frag_more (len);
   memcpy (p, comp_dir, len);
   len = strlen (comp_dir) + 1;
   p = frag_more (len);
   memcpy (p, comp_dir, len);
@@ -1319,119 +1838,111 @@ out_debug_info (info_seg, abbrev_seg, line_seg)
      dwarf2 draft has no standard code for assembler.  */
   out_two (DW_LANG_Mips_Assembler);
 
      dwarf2 draft has no standard code for assembler.  */
   out_two (DW_LANG_Mips_Assembler);
 
-  set_symbol_value_now (info_end);
+  symbol_set_value_now (info_end);
+}
+
+void
+dwarf2_init (void)
+{
+  last_seg_ptr = &all_segs;
 }
 
 }
 
+
+/* 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 and an empty .debug_line
+   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
 void
-dwarf2_finish ()
+dwarf2_finish (void)
 {
   segT line_seg;
   struct line_seg *s;
 {
   segT line_seg;
   struct line_seg *s;
-
-  /* We don't need to do anything unless:
-     - Some debug information was recorded via .file/.loc
-     - or, we are generating DWARF2 information ourself (--gdwarf2)
-     - or, there is a user-provided .debug_info section which could
-       reference the file table in the .debug_line section we generate
-       below.  */
-  if (all_segs == NULL
-      && debug_type != DEBUG_DWARF2
-      && bfd_get_section_by_name (stdoutput, ".debug_info") == NULL)
+  segT info_seg;
+  int emit_other_sections = 0;
+  int empty_debug_line = 0;
+
+  info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
+  emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
+
+  line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
+  empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
+
+  /* We can't construct a new debug_line section if we already have one.
+     Give an error.  */
+  if (all_segs && !empty_debug_line)
+    as_fatal ("duplicate .debug_line sections");
+
+  if ((!all_segs && emit_other_sections)
+      || (!emit_other_sections && !empty_debug_line))
+    /* If there is no line information and no non-empty .debug_info
+       section, or if there is both a non-empty .debug_info and a non-empty
+       .debug_line, then we do nothing.  */
     return;
 
   /* Calculate the size of an address for the target machine.  */
     return;
 
   /* Calculate the size of an address for the target machine.  */
-  sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
+  sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
 
   /* Create and switch to the line number section.  */
   line_seg = subseg_new (".debug_line", 0);
 
   /* Create and switch to the line number section.  */
   line_seg = subseg_new (".debug_line", 0);
-  bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
+  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)
     {
 
   /* For each subsection, chain the debug entries together.  */
   for (s = all_segs; s; s = s->next)
     {
-      struct line_subseg *ss = s->head;
-      struct line_entry **ptail = ss->ptail;
+      struct line_subseg *lss = s->head;
+      struct line_entry **ptail = lss->ptail;
 
 
-      while ((ss = ss->next) != NULL)
+      while ((lss = lss->next) != NULL)
        {
        {
-         *ptail = ss->head;
-         ptail = ss->ptail;
+         *ptail = lss->head;
+         ptail = lss->ptail;
        }
     }
 
   out_debug_line (line_seg);
 
        }
     }
 
   out_debug_line (line_seg);
 
-  /* If this is assembler generated line info, we need .debug_info
-     and .debug_abbrev sections as well.  */
-  if (all_segs != NULL && debug_type == DEBUG_DWARF2)
+  /* 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 abbrev_seg;
-      segT info_seg;
       segT aranges_seg;
       segT aranges_seg;
+      segT ranges_seg;
+
+      gas_assert (all_segs);
 
       info_seg = subseg_new (".debug_info", 0);
       abbrev_seg = subseg_new (".debug_abbrev", 0);
       aranges_seg = subseg_new (".debug_aranges", 0);
 
 
       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);
-      bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
-      bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
+      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);
 
 
       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_aranges (aranges_seg, info_seg);
-      out_debug_abbrev (abbrev_seg);
-      out_debug_info (info_seg, abbrev_seg, line_seg);
+      out_debug_abbrev (abbrev_seg, info_seg, line_seg);
+      out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);
     }
 }
     }
 }
-
-#else
-void
-dwarf2_finish ()
-{
-}
-
-int
-dwarf2dbg_estimate_size_before_relax (frag)
-     fragS *frag ATTRIBUTE_UNUSED;
-{
-  as_fatal (_("dwarf2 is not supported for this object file format"));
-  return 0;
-}
-
-int
-dwarf2dbg_relax_frag (frag)
-     fragS *frag ATTRIBUTE_UNUSED;
-{
-  as_fatal (_("dwarf2 is not supported for this object file format"));
-  return 0;
-}
-
-void
-dwarf2dbg_convert_frag (frag)
-     fragS *frag ATTRIBUTE_UNUSED;
-{
-  as_fatal (_("dwarf2 is not supported for this object file format"));
-}
-
-void
-dwarf2_emit_insn (size)
-     int size ATTRIBUTE_UNUSED;
-{
-}
-
-char *
-dwarf2_directive_file (dummy)
-     int dummy ATTRIBUTE_UNUSED;
-{
-  s_app_file (0);
-  return NULL;
-}
-
-void
-dwarf2_directive_loc (dummy)
-     int dummy ATTRIBUTE_UNUSED;
-{
-  as_fatal (_("dwarf2 is not supported for this object file format"));
-}
-#endif /* BFD_ASSEMBLER */
This page took 0.053889 seconds and 4 git commands to generate.