diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c
index c6303ba..1250fce 100644
--- a/gas/dwarf2dbg.c
+++ b/gas/dwarf2dbg.c
@@ -782,6 +782,32 @@
   while (e);
 }
 
+/* Remove any generated line entries.  These don't live comfortably
+   with compiler generated line info.  */
+
+static void
+purge_generated_debug (void)
+{
+  struct line_seg *s;
+
+  for (s = all_segs; s; s = s->next)
+    {
+      struct line_subseg *lss = s->head;
+      struct line_entry *e, *next;
+
+      for (e = lss->head; e; e = next)
+	{
+	  know (e->loc.filenum == -1u);
+	  next = e->next;
+	  free (e);
+	}
+
+      lss->head = NULL;
+      lss->ptail = &lss->head;
+      lss->pmove_tail = &lss->head;
+    }
+}
+
 /* Allocate slot NUM in the .debug_line file table to FILENAME.
    If DIRNAME is not NULL or there is a directory component to FILENAME
    then this will be stored in the directory table, if not already present.
@@ -1146,6 +1172,8 @@
 
   /* A .file directive implies compiler generated debug information is
      being supplied.  Turn off gas generated debug info.  */
+  if (debug_type == DEBUG_DWARF2)
+    purge_generated_debug ();
   debug_type = DEBUG_NONE;
 
   if (num != (unsigned int) num
@@ -2414,7 +2442,7 @@
   for (s = all_segs; s; s = s->next)
     /* Paranoia - this check should have already have
        been handled in dwarf2_gen_line_info_1().  */
-    if (SEG_NORMAL (s->seg))
+    if (s->head->head && SEG_NORMAL (s->seg))
       process_entries (s->seg, s->head->head);
 
   if (flag_dwarf_sections)
diff --git a/gas/testsuite/gas/i386/dwarf2-line-4.d b/gas/testsuite/gas/i386/dwarf2-line-4.d
index a01fd05..0403c3e 100644
--- a/gas/testsuite/gas/i386/dwarf2-line-4.d
+++ b/gas/testsuite/gas/i386/dwarf2-line-4.d
@@ -28,21 +28,15 @@
   Opcode 11 has 0 args
   Opcode 12 has 1 arg
 
- The Directory Table \(offset 0x.*\):
-  .*
+ The Directory Table is empty\.
 
  The File Name Table \(offset 0x.*\):
   Entry	Dir	Time	Size	Name
   1	0	0	0	dwarf2-test.c
-  2	1	0	0	dwarf2-line-4.s
 
  Line Number Statements:
-  \[0x.*\]  Set File Name to entry 2 in the File Name Table
-  \[0x.*\]  Extended opcode 2: set Address to 0x0
-  \[0x.*\]  Special opcode 13: advance Address by 0 to 0x0 and Line by 8 to 9
-  \[0x.*\]  Set File Name to entry 1 in the File Name Table
-  \[0x.*\]  Advance Line by -8 to 1
-  \[0x.*\]  Special opcode 19: advance Address by 1 to 0x1 and Line by 0 to 1
+  \[0x.*\]  Extended opcode 2: set Address to 0x1
+  \[0x.*\]  Copy
   \[0x.*\]  Advance PC by 1 to 0x2
   \[0x.*\]  Extended opcode 1: End of Sequence
 
diff --git a/gas/testsuite/gas/i386/dwarf4-line-1.d b/gas/testsuite/gas/i386/dwarf4-line-1.d
index 8199efb..762bdce 100644
--- a/gas/testsuite/gas/i386/dwarf4-line-1.d
+++ b/gas/testsuite/gas/i386/dwarf4-line-1.d
@@ -29,24 +29,11 @@
   Opcode 11 has 0 args
   Opcode 12 has 1 arg
 
- The Directory Table \(offset 0x.*\):
-  1	.*/gas/testsuite/gas/i386
+ The Directory Table is empty\.
 
  The File Name Table \(offset 0x.*\):
   Entry	Dir	Time	Size	Name
   1	0	0	0	foo.c
   2	0	0	0	foo.h
-  3	1	0	0	dwarf4-line-1.s
 
- Line Number Statements:
-  \[0x.*\]  Set File Name to entry 2 in the File Name Table
-  \[0x.*\]  Extended opcode 2: set Address to 0x0
-  \[0x.*\]  Advance Line by 81 to 82
-  \[0x.*\]  Copy
-  \[0x.*\]  Set File Name to entry 3 in the File Name Table
-  \[0x.*\]  Advance Line by -73 to 9
-  \[0x.*\]  Special opcode 19: advance Address by 1 to 0x1 and Line by 0 to 9
-  \[0x.*\]  Advance PC by 3 to 0x4
-  \[0x.*\]  Extended opcode 1: End of Sequence
-
-
+ No Line Number Statements\.
diff --git a/gas/testsuite/gas/i386/dwarf5-line-1.d b/gas/testsuite/gas/i386/dwarf5-line-1.d
index 2c2cf56..6ec5191 100644
--- a/gas/testsuite/gas/i386/dwarf5-line-1.d
+++ b/gas/testsuite/gas/i386/dwarf5-line-1.d
@@ -31,22 +31,13 @@
   Opcode 11 has 0 args
   Opcode 12 has 1 arg
 
- The Directory Table \(offset 0x.*, lines 2, columns 1\):
+ The Directory Table \(offset 0x.*, lines 1, columns 1\):
   Entry	Name
   0	\(indirect line string, offset: 0x.*\): .*/gas/testsuite
-  1	\(indirect line string, offset: 0x.*\): .*/gas/testsuite/gas/i386
 
- The File Name Table \(offset 0x.*, lines 3, columns 3\):
+ The File Name Table \(offset 0x.*, lines 2, columns 3\):
   Entry	Dir	MD5				Name
   0	0 0xbbd69fc03ce253b2dbaab2522dd519ae	\(indirect line string, offset: 0x.*\): core.c
   1	0 0x0	\(indirect line string, offset: 0x.*\): types.h
-  2	1 0x0	\(indirect line string, offset: 0x.*\): dwarf5-line-1.s
 
- Line Number Statements:
-  \[0x.*\]  Set File Name to entry 2 in the File Name Table
-  \[0x.*\]  Extended opcode 2: set Address to 0x0
-  \[0x.*\]  Special opcode 8: advance Address by 0 to 0x0 and Line by 3 to 4
-  \[0x.*\]  Advance PC by 1 to 0x1
-  \[0x.*\]  Extended opcode 1: End of Sequence
-
-
+ No Line Number Statements\.
diff --git a/gas/testsuite/gas/i386/dwarf5-line-2.d b/gas/testsuite/gas/i386/dwarf5-line-2.d
index 85f98c8..4bb849b 100644
--- a/gas/testsuite/gas/i386/dwarf5-line-2.d
+++ b/gas/testsuite/gas/i386/dwarf5-line-2.d
@@ -31,20 +31,12 @@
   Opcode 11 has 0 args
   Opcode 12 has 1 arg
 
- The Directory Table \(offset 0x.*, lines 2, columns 1\):
+ The Directory Table \(offset 0x.*, lines 1, columns 1\):
   Entry	Name
   0	\(indirect line string, offset: 0x.*\): .*/gas/testsuite
-  1	\(indirect line string, offset: 0x.*\): .*/gas/testsuite/gas/i386
 
- The File Name Table \(offset 0x.*, lines 2, columns 3\):
+ The File Name Table \(offset 0x.*, lines 1, columns 3\):
   Entry	Dir	MD5				Name
   0	0 0xbbd69fc03ce253b2dbaab2522dd519ae	\(indirect line string, offset: 0x.*\): core.c
-  1	1 0x0	\(indirect line string, offset: .*\): dwarf5-line-2.s
 
- Line Number Statements:
-  \[0x.*\]  Extended opcode 2: set Address to 0x0
-  \[0x.*\]  Special opcode 8: advance Address by 0 to 0x0 and Line by 3 to 4
-  \[0x.*\]  Advance PC by 1 to 0x1
-  \[0x.*\]  Extended opcode 1: End of Sequence
-
-
+ No Line Number Statements\.
