diff --git a/libdw/dwarf_ranges.c b/libdw/dwarf_ranges.c
new file mode 100644
index 0000000..4b6853d
--- /dev/null
+++ b/libdw/dwarf_ranges.c
@@ -0,0 +1,193 @@
+/* Enumerate the PC ranges covered by a DIE.
+   Copyright (C) 2005, 2007, 2009 Red Hat, Inc.
+   This file is part of elfutils.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of either
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at
+       your option) any later version
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at
+       your option) any later version
+
+   or both in parallel, as here.
+
+   elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see <http://www.gnu.org/licenses/>.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "libdwP.h"
+#include <dwarf.h>
+#include <assert.h>
+
+/* Read up begin/end pair and increment read pointer.
+    - If it's normal range record, set up `*beginp' and `*endp' and return 0.
+    - If it's base address selection record, set up `*basep' and return 1.
+    - If it's end of rangelist, don't set anything and return 2
+    - If an error occurs, don't set anything and return -1.  */
+internal_function int
+__libdw_read_begin_end_pair_inc (Dwarf *dbg, int sec_index,
+				 unsigned char **addrp, int width,
+				 Dwarf_Addr *beginp, Dwarf_Addr *endp,
+				 Dwarf_Addr *basep)
+{
+  Dwarf_Addr escape = (width == 8 ? (Elf64_Addr) -1
+		       : (Elf64_Addr) (Elf32_Addr) -1);
+  Dwarf_Addr begin;
+  Dwarf_Addr end;
+
+  unsigned char *addr = *addrp;
+  bool begin_relocated = READ_AND_RELOCATE (__libdw_relocate_address, begin);
+  bool end_relocated = READ_AND_RELOCATE (__libdw_relocate_address, end);
+  *addrp = addr;
+
+  /* Unrelocated escape for begin means base address selection.  */
+  if (begin == escape && !begin_relocated)
+    {
+      if (unlikely (end == escape))
+	{
+	  __libdw_seterrno (DWARF_E_INVALID_DWARF);
+	  return -1;
+	}
+
+      if (basep != NULL)
+	*basep = end;
+      return 1;
+    }
+
+  /* Unrelocated pair of zeroes means end of range list.  */
+  if (begin == 0 && end == 0 && !begin_relocated && !end_relocated)
+    return 2;
+
+  /* Don't check for begin_relocated == end_relocated.  Serve the data
+     to the client even though it may be buggy.  */
+  *beginp = begin;
+  *endp = end;
+
+  return 0;
+}
+
+ptrdiff_t
+dwarf_ranges (Dwarf_Die *die, ptrdiff_t offset, Dwarf_Addr *basep,
+	      Dwarf_Addr *startp, Dwarf_Addr *endp)
+{
+  if (die == NULL)
+    return -1;
+
+  if (offset == 0
+      /* Usually there is a single contiguous range.  */
+      && INTUSE(dwarf_highpc) (die, endp) == 0
+      && INTUSE(dwarf_lowpc) (die, startp) == 0)
+    /* A offset into .debug_ranges will never be 1, it must be at least a
+       multiple of 4.  So we can return 1 as a special case value to mark
+       there are no ranges to look for on the next call.  */
+    return 1;
+
+  if (offset == 1)
+    return 0;
+
+  /* We have to look for a noncontiguous range.  */
+
+  const Elf_Data *d = die->cu->dbg->sectiondata[IDX_debug_ranges];
+  if (d == NULL && offset != 0)
+    {
+      __libdw_seterrno (DWARF_E_NO_DEBUG_RANGES);
+      return -1;
+    }
+
+  unsigned char *readp;
+  unsigned char *readendp;
+  if (offset == 0)
+    {
+      Dwarf_Attribute attr_mem;
+      Dwarf_Attribute *attr = INTUSE(dwarf_attr) (die, DW_AT_ranges,
+						  &attr_mem);
+      if (attr == NULL)
+	/* No PC attributes in this DIE at all, so an empty range list.  */
+	return 0;
+
+      Dwarf_Word start_offset;
+      if ((readp = __libdw_formptr (attr, IDX_debug_ranges,
+				    DWARF_E_NO_DEBUG_RANGES,
+				    &readendp, &start_offset)) == NULL)
+	return -1;
+
+      offset = start_offset;
+      assert ((Dwarf_Word) offset == start_offset);
+
+      /* Fetch the CU's base address.  */
+      Dwarf_Die cudie = CUDIE (attr->cu);
+
+      /* Find the base address of the compilation unit.  It will
+	 normally be specified by DW_AT_low_pc.  In DWARF-3 draft 4,
+	 the base address could be overridden by DW_AT_entry_pc.  It's
+	 been removed, but GCC emits DW_AT_entry_pc and not DW_AT_lowpc
+	 for compilation units with discontinuous ranges.  */
+      if (unlikely (INTUSE(dwarf_lowpc) (&cudie, basep) != 0)
+	  && INTUSE(dwarf_formaddr) (INTUSE(dwarf_attr) (&cudie,
+							 DW_AT_entry_pc,
+							 &attr_mem),
+				     basep) != 0)
+	*basep = (Dwarf_Addr) -1;
+    }
+  else
+    {
+      if (__libdw_offset_in_section (die->cu->dbg,
+				     IDX_debug_ranges, offset, 1))
+	return -1l;
+
+      readp = d->d_buf + offset;
+      readendp = d->d_buf + d->d_size;
+    }
+
+ next:
+  if (readendp - readp < die->cu->address_size * 2)
+    goto invalid;
+
+  Dwarf_Addr begin;
+  Dwarf_Addr end;
+
+  switch (__libdw_read_begin_end_pair_inc (die->cu->dbg, IDX_debug_ranges,
+					   &readp, die->cu->address_size,
+					   &begin, &end, basep))
+    {
+    case 0:
+      break;
+    case 1:
+      goto next;
+    case 2:
+      return 0;
+    default:
+      return -1l;
+    }
+
+  /* We have an address range entry.  Check that we have a base.  */
+  if (*basep == (Dwarf_Addr) -1)
+    {
+      if (INTUSE(dwarf_errno) () == 0)
+	{
+	invalid:
+	  __libdw_seterrno (DWARF_E_INVALID_DWARF);
+	}
+      return -1;
+    }
+
+  *startp = *basep + begin;
+  *endp = *basep + end;
+  return readp - (unsigned char *) d->d_buf;
+}
+INTDEF (dwarf_ranges)