* po/bfd.pot: Updated by the Translation project.
[deliverable/binutils-gdb.git] / gas / dwarf2dbg.c
index ba920d409747ab5a257c956cafa5f594726e8883..42d7267ffdfe2242fdbf8bf5c2c3cefdee851d78 100644 (file)
@@ -1,5 +1,5 @@
 /* dwarf2dbg.c - DWARF2 debug support
 /* dwarf2dbg.c - DWARF2 debug support
-   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
+   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
    Free Software Foundation, Inc.
    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
 
    Free Software Foundation, Inc.
    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
 
@@ -7,7 +7,7 @@
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    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>
 #include "dwarf2dbg.h"
 #include <filenames.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
 #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
 
 #endif
 
 #ifndef DWARF2_ADDR_SIZE
 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
 #endif
 
-#ifdef BFD_ASSEMBLER
+#ifndef DWARF2_FILE_NAME
+#define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
+#endif
+
+#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
 
 #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   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
 /* 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.  */
 
 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;
 };
 
@@ -131,6 +168,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;
+/* Hash used to quickly lookup a segment by name, avoiding the need to search
+   through the all_segs list.  */
+static struct hash_control *all_segs_hash;
+static struct line_seg **last_seg_ptr;
 
 struct file_entry {
   const char *filename;
 
 struct file_entry {
   const char *filename;
@@ -149,41 +190,26 @@ 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;
+
+/* 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.  */
 
 /* Current location as indicated by the most recent .loc directive.  */
-static struct dwarf2_line_info current;
+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 (segT, subsegT);
 static unsigned int get_filenum (const char *, unsigned int);
 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 offsetT get_frag_fix (fragS *);
-static void out_set_addr (segT, fragS *, addressT);
-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 relax_inc_line_addr (int, segT, fragS *, addressT,
-                                fragS *, addressT);
-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);
-static void out_debug_info (segT, segT, segT);
-\f
+
 #ifndef TC_DWARF2_EMIT_OFFSET
 #ifndef TC_DWARF2_EMIT_OFFSET
-# define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
-static void generic_dwarf2_emit_offset (symbolS *, unsigned int);
+#define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
 
 /* Create an offset to .dwarf2_*.  */
 
 
 /* Create an offset to .dwarf2_*.  */
 
@@ -214,17 +240,19 @@ get_line_subseg (segT seg, subsegT subseg)
   if (seg == last_seg && subseg == last_subseg)
     return last_line_subseg;
 
   if (seg == last_seg && subseg == last_subseg)
     return last_line_subseg;
 
-  for (s = all_segs; s; s = s->next)
-    if (s->seg == seg)
-      goto found_seg;
-
-  s = (struct line_seg *) xmalloc (sizeof (*s));
-  s->next = all_segs;
-  s->seg = seg;
-  s->head = NULL;
-  all_segs = s;
+  s = (struct line_seg *) hash_find (all_segs_hash, seg->name);
+  if (s == NULL)
+    {
+      s = (struct line_seg *) xmalloc (sizeof (*s));
+      s->next = NULL;
+      s->seg = seg;
+      s->head = NULL;
+      *last_seg_ptr = s;
+      last_seg_ptr = &s->next;
+      hash_insert (all_segs_hash, seg->name, s);
+    }
+  gas_assert (seg == s->seg);
 
 
- found_seg:
   for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
     {
       if (ss->subseg == subseg)
   for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
     {
       if (ss->subseg == subseg)
@@ -248,16 +276,34 @@ get_line_subseg (segT seg, subsegT subseg)
   return ss;
 }
 
   return ss;
 }
 
+/* Record an entry for LOC occurring at LABEL.  */
+
+static void
+dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
+{
+  struct line_subseg *ss;
+  struct line_entry *e;
+
+  e = (struct line_entry *) xmalloc (sizeof (*e));
+  e->next = NULL;
+  e->label = label;
+  e->loc = *loc;
+
+  ss = get_line_subseg (now_seg, now_subseg);
+  *ss->ptail = e;
+  ss->ptail = &e->next;
+}
+
 /* Record an entry for LOC occurring at OFS within the current fragment.  */
 
 void
 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
 {
 /* Record an entry for LOC occurring at OFS within the current fragment.  */
 
 void
 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;
@@ -273,17 +319,15 @@ dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *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;
-
-  ss = get_line_subseg (now_seg, now_subseg);
-  *ss->ptail = e;
-  ss->ptail = &e->next;
+  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
 dwarf2_where (struct dwarf2_line_info *line)
 {
 void
 dwarf2_where (struct dwarf2_line_info *line)
 {
@@ -293,12 +337,23 @@ dwarf2_where (struct dwarf2_line_info *line)
       as_where (&filename, &line->line);
       line->filenum = get_filenum (filename, 0);
       line->column = 0;
       as_where (&filename, &line->line);
       line->filenum = get_filenum (filename, 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
 /* 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
@@ -309,26 +364,56 @@ dwarf2_emit_insn (int size)
 {
   struct dwarf2_line_info loc;
 
 {
   struct dwarf2_line_info loc;
 
-  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)
+  if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
     return;
     return;
-  else
-    dwarf2_where (& loc);
+
+  dwarf2_where (&loc);
 
   dwarf2_gen_line_info (frag_now_fix () - size, &loc);
 
   dwarf2_gen_line_info (frag_now_fix () - size, &loc);
+  dwarf2_consume_line_info ();
+}
+
+/* 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;
+
+  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.  If NUM is nonzero,
 }
 
 /* Get a .debug_line file number for FILENAME.  If NUM is nonzero,
@@ -371,7 +456,9 @@ get_filenum (const char *filename, unsigned int num)
   dir = 0;
   if (dir_len)
     {
   dir = 0;
   if (dir_len)
     {
+#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
       --dir_len;
       --dir_len;
+#endif
       for (dir = 1; dir < dirs_in_use; ++dir)
        if (strncmp (filename, dirs[dir], dir_len) == 0
            && dirs[dir][dir_len] == '\0')
       for (dir = 1; dir < dirs_in_use; ++dir)
        if (strncmp (filename, dirs[dir], dir_len) == 0
            && dirs[dir][dir_len] == '\0')
@@ -386,7 +473,7 @@ get_filenum (const char *filename, unsigned int num)
                     xrealloc (dirs, (dir + 32) * sizeof (const char *));
            }
 
                     xrealloc (dirs, (dir + 32) * sizeof (const char *));
            }
 
-         dirs[dir] = xmalloc (dir_len + 1);
+         dirs[dir] = (char *) xmalloc (dir_len + 1);
          memcpy (dirs[dir], filename, dir_len);
          dirs[dir][dir_len] = '\0';
          dirs_in_use = dir + 1;
          memcpy (dirs[dir], filename, dir_len);
          dirs[dir][dir_len] = '\0';
          dirs_in_use = dir + 1;
@@ -421,7 +508,8 @@ get_filenum (const char *filename, unsigned int num)
 
   files[i].filename = num ? file : xstrdup (file);
   files[i].dir = dir;
 
   files[i].filename = num ? file : xstrdup (file);
   files[i].dir = dir;
-  files_in_use = i + 1;
+  if (files_in_use < i + 1)
+    files_in_use = i + 1;
   last_used = i;
   last_used_dir_len = dir_len;
 
   last_used = i;
   last_used_dir_len = dir_len;
 
@@ -451,6 +539,8 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
 
   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)
@@ -459,6 +549,10 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
       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);
   if (num < (int) files_in_use && files[num].filename != 0)
     {
       as_bad (_("file number %ld already allocated"), (long) num);
@@ -473,14 +567,16 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
 void
 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
 {
 void
 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)
     {
@@ -495,10 +591,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
 
   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)
@@ -510,7 +603,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
          char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
 
          memcpy (cp, dirs[files[filenum].dir], dir_len);
          char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
 
          memcpy (cp, dirs[files[filenum].dir], dir_len);
-         cp[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);
          memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
          cp[dir_len + file_len + 1] = '\0';
          listing_source_file (cp);
@@ -520,32 +613,122 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
       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;
+
+      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 if (strcmp (p, "discriminator") == 0)
+       {
+         *input_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);
+         *input_line_pointer = c;
+         return;
+       }
+
+      SKIP_WHITESPACE ();
+    }
+
+  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 *
 first_frag_for_seg (segT seg)
 {
 }
 \f
 static struct frag *
 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 *
 last_frag_for_seg (segT seg)
 {
 }
 
 static struct frag *
 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.  */
 }
 \f
 /* Emit a single byte into the current segment.  */
@@ -588,6 +771,14 @@ 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 signed "little-endian base 128" number.  */
+
+static void
+out_leb128 (addressT value)
+{
+  output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
+}
+
 /* Emit a tuple for .debug_abbrev.  */
 
 static inline void
 /* Emit a tuple for .debug_abbrev.  */
 
 static inline void
@@ -600,7 +791,7 @@ out_abbrev (int name, int form)
 /* Get the size of a fragment.  */
 
 static offsetT
 /* Get the size of a fragment.  */
 
 static offsetT
-get_frag_fix (fragS *frag)
+get_frag_fix (fragS *frag, segT seg)
 {
   frchainS *fr;
 
 {
   frchainS *fr;
 
@@ -610,7 +801,7 @@ get_frag_fix (fragS *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)
       return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
 
     if (fr->frch_last == frag)
       return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
 
@@ -620,12 +811,9 @@ get_frag_fix (fragS *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 (segT seg, fragS *frag, addressT ofs)
+out_set_addr (symbolS *sym)
 {
   expressionS expr;
 {
   expressionS expr;
-  symbolS *sym;
-
-  sym = symbol_temp_new (seg, ofs, frag);
 
   out_opcode (DW_LNS_extended_op);
   out_uleb128 (sizeof_address + 1);
 
   out_opcode (DW_LNS_extended_op);
   out_uleb128 (sizeof_address + 1);
@@ -729,6 +917,10 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
   int need_copy = 0;
   char *end = p + len;
 
   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);
 
@@ -761,19 +953,19 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int 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;
 
@@ -808,7 +1000,7 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
     *p++ = tmp;
 
  done:
     *p++ = tmp;
 
  done:
-  assert (p == end);
+  gas_assert (p == end);
 }
 
 /* Handy routine to combine calls to the above two routines.  */
 }
 
 /* Handy routine to combine calls to the above two routines.  */
@@ -820,21 +1012,116 @@ out_inc_line_addr (int line_delta, addressT addr_delta)
   emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
 }
 
   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.  */
+
+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 > 50000)
+    {
+      /* 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 *exp;
+  segT line_seg;
+  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);
+
+  /* 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);
+    }
+
+  exp = symbol_get_value_expression (frag->fr_symbol);
+  line_seg = subseg_get (".debug_line", 0);
+
+  /* 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 > 50000)
+    {
+      symbolS *to_sym;
+      expressionS expr;
+
+      gas_assert (exp->X_op = O_subtract);
+      to_sym = exp->X_add_symbol;
+
+      *p++ = DW_LNS_extended_op;
+      p += output_leb128 (p, sizeof_address + 1, 0);
+      *p++ = DW_LNE_set_address;
+      expr.X_op = O_symbol;
+      expr.X_add_symbol = to_sym;
+      expr.X_add_number = 0;
+      subseg_change (line_seg, 0);
+      emit_expr_fix (&expr, sizeof_address, frag, p);
+      p += sizeof_address;
+    }
+  else
+    {
+      *p++ = DW_LNS_fixed_advance_pc;
+      subseg_change (line_seg, 0);
+      emit_expr_fix (exp, 2, frag, p);
+      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 (int line_delta, segT seg,
-                    fragS *to_frag, addressT to_ofs,
-                    fragS *from_frag, addressT from_ofs)
+relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
 {
 {
-  symbolS *to_sym, *from_sym;
   expressionS expr;
   int max_chars;
 
   expressionS expr;
   int max_chars;
 
-  to_sym = symbol_temp_new (seg, to_ofs, to_frag);
-  from_sym = symbol_temp_new (seg, from_ofs, from_frag);
-
   expr.X_op = O_subtract;
   expr.X_add_symbol = to_sym;
   expr.X_op_symbol = from_sym;
   expr.X_op = O_subtract;
   expr.X_add_symbol = to_sym;
   expr.X_op_symbol = from_sym;
@@ -842,7 +1129,11 @@ relax_inc_line_addr (int line_delta, segT seg,
 
   /* 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,
            make_expr_symbol (&expr), line_delta, NULL);
 
   frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
            make_expr_symbol (&expr), line_delta, NULL);
@@ -859,7 +1150,10 @@ dwarf2dbg_estimate_size_before_relax (fragS *frag)
   int size;
 
   addr_delta = resolve_symbol_value (frag->fr_symbol);
   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;
 
@@ -895,10 +1189,15 @@ dwarf2dbg_convert_frag (fragS *frag)
   /* 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;
@@ -915,23 +1214,22 @@ 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)
+  do
     {
     {
-      int changed = 0;
+      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)
@@ -939,64 +1237,78 @@ process_entries (segT seg, struct line_entry *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 (isa != e->loc.isa)
+       {
+         isa = e->loc.isa;
+         out_opcode (DW_LNS_set_isa);
+         out_uleb128 (isa);
        }
 
        }
 
-      if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
+      if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
        {
        {
-         out_opcode (DW_LNS_set_basic_block);
-         changed = 1;
+         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.  */
 }
 
 /* Emit the directory and file tables for .debug_line.  */
@@ -1005,21 +1317,25 @@ static void
 out_file_list (void)
 {
   size_t size;
 out_file_list (void)
 {
   size_t size;
+  const char *dir;
   char *cp;
   unsigned int i;
 
   /* Emit directory list.  */
   for (i = 1; i < dirs_in_use; ++i)
     {
   char *cp;
   unsigned int i;
 
   /* Emit directory list.  */
   for (i = 1; i < dirs_in_use; ++i)
     {
-      size = strlen (dirs[i]) + 1;
+      dir = remap_debug_filename (dirs[i]);
+      size = strlen (dir) + 1;
       cp = frag_more (size);
       cp = frag_more (size);
-      memcpy (cp, dirs[i], size);
+      memcpy (cp, dir, size);
     }
   /* Terminate it.  */
   out_byte ('\0');
 
   for (i = 1; i < files_in_use; ++i)
     {
     }
   /* Terminate it.  */
   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);
@@ -1028,75 +1344,87 @@ out_file_list (void)
          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);
 }
 
+/* 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.  */
+
+static int
+out_header (asection *sec, expressionS *expr)
+{
+  symbolS *start_sym;
+  symbolS *end_sym;
+
+  subseg_set (sec, 0);
+  start_sym = symbol_temp_new_now ();;
+  end_sym = symbol_temp_make ();
+
+  /* Total length of the information.  */
+  expr->X_op = O_subtract;
+  expr->X_add_symbol = end_sym;
+  expr->X_op_symbol = start_sym;
+
+  switch (DWARF2_FORMAT (sec))
+    {
+    case dwarf2_format_32bit:
+      expr->X_add_number = -4;
+      emit_expr (expr, 4);
+      return 4;
+
+    case dwarf2_format_64bit:
+      expr->X_add_number = -12;
+      out_four (-1);
+      emit_expr (expr, 8);
+      return 8;
+
+    case dwarf2_format_64bit_irix:
+      expr->X_add_number = -8;
+      emit_expr (expr, 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 expr;
 /* Emit the collected .debug_line data.  */
 
 static void
 out_debug_line (segT line_seg)
 {
   expressionS expr;
-  symbolS *line_start;
   symbolS *prologue_end;
   symbolS *line_end;
   struct line_seg *s;
   symbolS *prologue_end;
   symbolS *line_end;
   struct line_seg *s;
-  enum dwarf2_format d2f;
   int sizeof_offset;
 
   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)
-    {
-      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 (line_seg, &expr);
+  line_end = expr.X_add_symbol;
 
   /* Version.  */
   out_two (2);
 
   /* Length of the prologue following this length.  */
 
   /* Version.  */
   out_two (2);
 
   /* Length of the prologue following this length.  */
-  expr.X_op = O_subtract;
+  prologue_end = symbol_temp_make ();
   expr.X_add_symbol = prologue_end;
   expr.X_add_symbol = prologue_end;
-  expr.X_op_symbol = line_start;
   expr.X_add_number = - (4 + 2 + 4);
   emit_expr (&expr, sizeof_offset);
 
   expr.X_add_number = - (4 + 2 + 4);
   emit_expr (&expr, sizeof_offset);
 
@@ -1117,6 +1445,9 @@ out_debug_line (segT 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 ();
 
@@ -1129,40 +1460,74 @@ out_debug_line (segT line_seg)
   symbol_set_value_now (line_end);
 }
 
   symbol_set_value_now (line_end);
 }
 
-/* Emit data for .debug_aranges.  */
-
 static void
 static void
-out_debug_aranges (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;
   expressionS expr;
   struct line_seg *s;
   expressionS expr;
-  char *p;
+  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;
 
 
-  /* Length of the compilation unit.  */
-  out_four (size - 4);
+      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);
+    }
+
+  /* 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;
+  struct line_seg *s;
+  expressionS expr;
+  symbolS *aranges_end;
+  char *p;
+  int sizeof_offset;
+
+  sizeof_offset = out_header (aranges_seg, &expr);
+  aranges_end = expr.X_add_symbol;
 
   /* Version.  */
   out_two (2);
 
   /* Offset to .debug_info.  */
 
   /* Version.  */
   out_two (2);
 
   /* Offset to .debug_info.  */
-  /* ??? sizeof_offset */
-  TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
+  TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
 
   /* Size of an address (offset portion).  */
   out_byte (addr_size);
 
   /* Size of an address (offset portion).  */
   out_byte (addr_size);
@@ -1171,8 +1536,7 @@ out_debug_aranges (segT aranges_seg, segT info_seg)
   out_byte (0);
 
   /* Align the header.  */
   out_byte (0);
 
   /* Align the header.  */
-  if (skip)
-    frag_align (ffs (2 * addr_size) - 1, 0, 0);
+  frag_align (ffs (2 * addr_size) - 1, 0, 0);
 
   for (s = all_segs; s; s = s->next)
     {
 
   for (s = all_segs; s; s = s->next)
     {
@@ -1184,7 +1548,7 @@ out_debug_aranges (segT aranges_seg, segT info_seg)
       s->text_start = beg;
 
       frag = last_frag_for_seg (s->seg);
       s->text_start = beg;
 
       frag = last_frag_for_seg (s->seg);
-      end = symbol_temp_new (s->seg, get_frag_fix (frag), frag);
+      end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
       s->text_end = end;
 
       expr.X_op = O_symbol;
       s->text_end = end;
 
       expr.X_op = O_symbol;
@@ -1202,25 +1566,39 @@ out_debug_aranges (segT aranges_seg, segT info_seg)
   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 (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);
       out_abbrev (DW_AT_high_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);
     }
+  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_producer, DW_FORM_string);
   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);
@@ -1234,52 +1612,19 @@ out_debug_abbrev (segT 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 (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;
+  const char *comp_dir;
+  const char *dirname;
   expressionS expr;
   expressionS expr;
-  symbolS *info_start;
   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_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)
-    {
-      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, &expr);
+  info_end = expr.X_add_symbol;
 
   /* DWARF version.  */
   out_two (2);
 
   /* DWARF version.  */
   out_two (2);
@@ -1294,11 +1639,11 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg)
   out_uleb128 (1);
 
   /* DW_AT_stmt_list */
   out_uleb128 (1);
 
   /* DW_AT_stmt_list */
-  /* ??? sizeof_offset */
-  TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 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 */
@@ -1313,26 +1658,39 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg)
       expr.X_add_number = 0;
       emit_expr (&expr, sizeof_address);
     }
       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.  */
 
   /* 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 ();
   if (files[1].dir)
     {
     abort ();
   if (files[1].dir)
     {
-      len = strlen (dirs[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);
       p = frag_more (len + 1);
-      memcpy (p, dirs[files[1].dir], len);
-      p[len] = '/';
+      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);
@@ -1350,6 +1708,14 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg)
   symbol_set_value_now (info_end);
 }
 
   symbol_set_value_now (info_end);
 }
 
+void
+dwarf2_init (void)
+{
+  all_segs_hash = hash_new ();
+  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.  If we emit .debug_line,
 /* 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,
@@ -1403,9 +1769,10 @@ dwarf2_finish (void)
     {
       segT abbrev_seg;
       segT aranges_seg;
     {
       segT abbrev_seg;
       segT aranges_seg;
+      segT ranges_seg;
+
+      gas_assert (all_segs);
 
 
-      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);
@@ -1419,59 +1786,19 @@ dwarf2_finish (void)
 
       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.041808 seconds and 4 git commands to generate.