[packages/binutils.git] / binutils-pr-5755.patch

diff -urN binutils-2.18.50.0.4.org/bfd/arange-set.c binutils-2.18.50.0.4/bfd/arange-set.c
--- binutils-2.18.50.0.4.org/bfd/arange-set.c	2008-02-08 17:44:56.000000000 +0100
+++ binutils-2.18.50.0.4/bfd/arange-set.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,737 +0,0 @@
-/* DWARF 2 Arange-Set.
-   Copyright 2007 Free Software Foundation, Inc.
-   Contributed by Doug Kwan, Google Inc.
- 
-   This file is part of BFD.
-
-   This program 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 3 of the License, or (at
-   your option) any later version.
-
-   This program 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 a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
-   MA 02110-1301, USA.  */
-
-#include "sysdep.h"
-#include "bfd.h"
-#include "libiberty.h"
-#include "libbfd.h"
-#include "arange-set.h"
-#include "splay-tree.h"
-
-/* Implementation of an arange-set.  The set is implemented using the
-   splay tree support in libiberty.  The advantage of using this is
-   that it has been well tested and is relatively simple to use.  The
-   disadvantage is that it is too general and it does not fit our design
-   exactly.  So we waste a bit of memory for unneeded generality and work
-   around for mis-match between the splay tree API and the arange-set
-   internals.  A specialized implentation of a balanced tree type for
-   arange-set exclusively may speed up things a little and reduce memory
-   consumption.  Until there is a pressing need, we stick to the splay
-   tree in libiberty.  */
-
-struct arange_set_s
-{
-  /* Splay tree containing aranges.  */
-  splay_tree ranges;
-
-  /* Lowest address in set.  If set is empty, it is ~0.  */
-  bfd_vma lower_bound;
-
-  /* Highest address in set.  If set is empty, it is 0.  */
-  bfd_vma upper_bound;
-
-  /* TRUE if aranges in this set have values.  */
-  bfd_boolean value_p;
-
-  /* Function to compare arange values.  */
-  arange_value_equal_fn value_equal_fn;
-
-  /* Function to copy an arange value.  */
-  arange_value_copy_fn value_copy_fn;
-
-  /* Function to combine arange values.  */
-  arange_value_combine_fn value_combine_fn;
-
-  /* Function to delete an arange value.  */
-  arange_value_delete_fn value_delete_fn;
-
-  /* Function to allocate a piece of memory.  */
-  arange_set_allocate_fn allocate_fn;
-
-  /* Function to deallocate a piece of memory.  */
-  arange_set_deallocate_fn deallocate_fn;
-
-  /* Call back data shared by all callbacks.  */
-  void *data;
-};
-
-/* Structure for aranges with a value attached.  Since a splay tree
-   node can only hold one value,  we need to use the container struct
-   to store data associated with an arange and have the splay tree value
-   to be a pointer to this struct. */
-
-typedef struct
-{
-  /* High-pc of an arange.  This is different from the DWARF2 semantics that
-     the high-pc is really the last location in an arange.  */
-  bfd_vma high;
-
-  /* We need to store a pointer to the set because splay_tree_value_delete
-     only takes a pointer to the value deleted.  If we use a deallocator
-     that need extra information like a pointer to the memory pool, we need to
-     look up via the set pointer.  This adds one extra pointer per arange. */
-  arange_set set;
-
-  /* Value associated with this arange.  */
-  arange_value_type value;
-
-} arange_value_container_t;
-
-
-
-static void
-arange_set_delete_value (arange_set set, arange_value_type value)
-{
-  if (set->value_delete_fn)
-    (set->value_delete_fn) (value, set->data);
-}
-
-/* Compare two VMAs as keys of splay tree nodes.  */
-
-static int
-splay_tree_compare_bfd_vmas (splay_tree_key k1, splay_tree_key k2)
-{
-  if ((bfd_vma) k1 < (bfd_vma) k2)
-    return -1;
-  else if ((bfd_vma) k1 > (bfd_vma) k2)
-    return 1;
-
-  return 0;
-}
-
-/* Default memory allocator and deallocator.  */
-
-void *
-arange_set_allocate (arange_set set, int size)
-{
-  if (set->allocate_fn)
-    return (set->allocate_fn) (size, set->data); 
-
-  return xmalloc (size);
-}
-
-void
-arange_set_deallocate (arange_set set, void *object)
-{
-  if (set->deallocate_fn)
-    (set->deallocate_fn) (object, set->data); 
-  else
-    free (object);
-}
-
-static void
-arange_set_delete_value_container (splay_tree_value value)
-{
-  arange_value_container_t *container;
-
-  container = (arange_value_container_t*) value;
-  arange_set_delete_value (container->set, container->value);
-  arange_set_deallocate (container->set, container);
-}
-
-/* Create an arange set.  Return the new set of NULL if there is any
-   error.  
-
-   allocate_fn is the memory allocator function of this arange set. If
-   it is NULL, the default allocator will be used.
-
-   deallocate_fn is the memory deallocator function of this arange set. If
-   it is NULL, the default allocator will be used.
-
-   value_p specifies whether an arange set supports values.  If it is
-   TURE.  Each arange can be associated with a value of type arange_value_type.
-   If it is FALSE, the following parameters value_equal_fn, value_copy_fn,
-   value_combine_fn and value_delete_fn will be ignored.
-
-   value_equal_fn is the value equality function.  An arange uses it to
-   check if two values are the same.  If it is NULL, the default bit-wise
-   equality function will be used.
-
-   value_copy_fn is the value copy function.  An arange uses it to copy
-   values of type arange_value_type.  If it is NULL, the default bit-wise
-   copy function will be used.
-
-   value_combine_fn is the value combine function. An arange uses it to
-   combine values of two identical arange.  If it is NULL, the default
-   constant zero function will be used.
-
-   value_delete_fn is the value deletion function. If it is not NULL,
-   it will be called when an arange deletes a value.
-
-   data is pointer to an object, which will be passed to all allocate_fn,
-   deallocate_fn, value_equal_fn, value_copy_fn, value_combine_fn and
-   value_delete_fn.  */
-
-arange_set
-arange_set_new (arange_set_allocate_fn allocate_fn,
-		arange_set_deallocate_fn deallocate_fn,
-		bfd_boolean value_p,
-		arange_value_equal_fn value_equal_fn,
-		arange_value_copy_fn value_copy_fn,
-		arange_value_combine_fn value_combine_fn,
-		arange_value_delete_fn value_delete_fn,
-		void *data)
-{
-  arange_set set;
-  splay_tree sp;
-  splay_tree_delete_value_fn fn;
-
-  if (sizeof (bfd_vma) > sizeof (splay_tree_key)
-      || sizeof (bfd_vma) > sizeof (splay_tree_value))
-    {
-      (*_bfd_error_handler)
-	(_("size of bfd_vma > size of splay_tree types"));
-      abort ();
-    }
-
-  /* Allocate space for arange structure.  */
-  set = (arange_set)
-    (*allocate_fn) (sizeof (struct arange_set_s), data);
-  if (!set)
-    return set;
-  
-  fn = value_p ? arange_set_delete_value_container : NULL;
-  sp = splay_tree_new_with_allocator (splay_tree_compare_bfd_vmas, NULL,
-				      fn, allocate_fn, deallocate_fn,
-				      data);
-  if (!sp)
-    {
-      (deallocate_fn) (set, data);
-      return NULL;
-    }
-
-  set->ranges = sp;
-  set->lower_bound = ~0;
-  set->upper_bound = 0;
-  set->value_p = value_p;
-  set->allocate_fn = allocate_fn;
-  set->deallocate_fn = deallocate_fn;
-  set->value_equal_fn = value_equal_fn;
-  set->value_copy_fn = value_copy_fn;
-  set->value_combine_fn = value_combine_fn;
-  set->value_delete_fn = value_delete_fn;
-  set->data = data;
-  return set;
-}
-
-/*  Delete an arange set.  */
-
-void
-arange_set_delete (arange_set set)
-{
-  splay_tree_delete (set->ranges);
-  (*set->deallocate_fn) (set, set->data);
-}
-
-/* Return TRUE if and only if arange set is empty.  */
-
-bfd_boolean
-arange_set_empty_p (arange_set set)
-{
-  return set->lower_bound > set->upper_bound;
-}
-
-/* Accessors for low and high of an arange.
- 
-   There is no arange_set_node_set_low since the low address is the
-   key of the splay tree node.  */
-
-/* Get the high VMA address of a node.  */
-
-static bfd_vma
-arange_set_node_high (arange_set set, splay_tree_node node)
-{
-  arange_value_container_t *container;
-
-  if (set->value_p)
-    {
-      container = (arange_value_container_t*) node->value;
-      return container->high;
-    }
-
-  return (bfd_vma) node->value;
-}
-
-/* Set the high VMA address of a node.  */
-
-static void
-arange_set_node_set_high (arange_set set, splay_tree_node node, bfd_vma address)
-{
-  arange_value_container_t *container;
-
-  if (set->value_p)
-    {
-      container = (arange_value_container_t*) node->value;
-      container->high = address;
-    }
-  else
-    node->value = (splay_tree_value) address;
-}
-
-/* Get the low VMA address of a node.  */
-
-static bfd_vma
-arange_set_node_low (splay_tree_node node)
-{
-  return (bfd_vma) node->key;
-}
-
-/* If arange set supports values, return value of an arange; otheriwse
-   always return 0 so that it appears that all aranges have the same value.  */
-
-static arange_value_type
-arange_set_node_value (arange_set set, splay_tree_node node)
-{
-  arange_value_container_t *container;
-
-  if (set->value_p)
-    {
-      container = (arange_value_container_t*) node->value;
-      return container->value;
-    }
-
-  return 0;
-}
-
-/* If arange set supports values, return value of an arange; otheriwse
-   always return 0 so that it appears that all aranges have the same value.  */
-
-static void
-arange_set_node_set_value (arange_set set,
-			   splay_tree_node node,
-			   arange_value_type value)
-{
-  arange_value_container_t *container;
-
-  if (set->value_p)
-    {
-      container = (arange_value_container_t*) node->value;
-      container->value = value;
-    }
-}
-
-/* Return TRUE if and only if arange set supports values.  */
-
-bfd_boolean
-arange_set_has_values_p (arange_set set)
-{
-  return set->value_p;
-}
-
-/* Copy a value using the value copying function of an arange set.  If
-   the set does not support values or if there is not value copying
-   function specified, it simply returns the input value.  */
-
-arange_value_type
-arange_set_copy_value (arange_set set, arange_value_type value)
-{
-  /* If no copy function is specified or set does not support values,
-     default is bit-wise copy.  */
-  if (set->value_p && set->value_copy_fn)
-    return (set->value_copy_fn) (value, set->data);
-
-  return value;
-}
-
-static arange_value_type
-arange_set_combine_value (arange_set set,
-			  arange_value_type value1,
-			  arange_value_type value2)
-{
-  /* If no combine function is specified or set does not support values,
-     default is returning 0.  */
-  if (set->value_p && set->value_combine_fn)
-    return (set->value_combine_fn) (value1, value2, set->data);
-
-  return (arange_value_type) 0;
-}
-
-/* Compares two values for equality.  If the arange set does not support values
-   or if no value equality function is specified, this function simply does
-   a bit-wise comparison.  */
-
-bfd_boolean
-arange_set_value_equal_p (arange_set set,
-			  arange_value_type value1,
-			  arange_value_type value2)
-{
-  /* If no equality function is specified or set does not support values,
-     default is bit-wise comparison.  */
-  if (set->value_p && set->value_equal_fn)
-    return (set->value_equal_fn) (value1, value2, set->data);
-
-  return value1 == value2;
-}
-
-/* Check to see if a given address is in an arange set.  Return TRUE if the
-   address is inside one of the aranges. If low_ptr, high_ptr and value_ptr are
-   used to return lower address, upper address and value associated with a
-   found arounge.  If anyone of them is NULL, the corresponding information
-   is not returned.  For arange set without values, no information is returned
-   through the pointer value_ptr.  */
-
-bfd_boolean
-arange_set_lookup_address (arange_set set, bfd_vma address,
-			   bfd_vma *low_ptr, bfd_vma *high_ptr,
-			   arange_value_type *value_ptr)
-{
-  splay_tree_node pred, node;
-
-  if (address < set->lower_bound || address > set->upper_bound)
-    return FALSE;
-
-  /* Find immediate predecessor.  */
-  pred = splay_tree_predecessor (set->ranges, (splay_tree_key) address);
-  if (pred
-      && arange_set_node_high (set, pred) >= address)
-    node = pred;
-  else
-    /* If the predecessor range does not cover this address, the address
-       is in the arange set only if itself starts an arange.  */
-    node = splay_tree_lookup (set->ranges, (splay_tree_key) address);
-
-  if (node)
-    {
-      /* Also return arange boundaries if caller supplies pointers.  */
-      if (low_ptr)
-	*low_ptr = arange_set_node_low (node);
-      if (high_ptr)
-	*high_ptr = arange_set_node_high (set, node);
-      if (set->value_p && value_ptr)
-	*value_ptr = arange_set_node_value (set, node);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-/* Insert an arange [low, high] into a set's splay tree.  If the set supports
-   value, also insert with the given value.  Return the inserted node if there
-   is no error or NULL otherwise.  */
-
-static splay_tree_node
-arange_set_splay_tree_insert (arange_set set,
-			      bfd_vma low,
-			      bfd_vma high,
-			      arange_value_type value)
-{
-  splay_tree_value sp_value;
-  arange_value_container_t *container;
-   
-  if (set->value_p)
-    {
-      int size = sizeof (arange_value_container_t);
-      void *data = set->ranges->allocate_data;
-
-      container =
-	(arange_value_container_t*) (*set->ranges->allocate) (size, data);
-      if (!container)
-	return NULL;
-      container->high = high;
-
-      /* Due to the design of splay tree API, there is no way of passing
-	 callback data to the splay tree value delete function.  Hence we need
-	 to store a pointer to set in every containier!  */
-      container->set = set;
-
-      container->value = value;
-      sp_value = (splay_tree_value) container;
-    }
-  else
-    sp_value = (splay_tree_value) high;	
-
-  /* Currently splay_tree_insert does not return any status to tell if there
-     is an error.  */
-  return splay_tree_insert (set->ranges, (splay_tree_key) low, sp_value);
-}
-
-/* Split [low, high] to [low, address) & [address, high].  */
-
-static bfd_boolean
-arange_set_split_node (arange_set set, splay_tree_node node, bfd_vma address)
-{
-  splay_tree_node node2;
-  arange_value_type value;
-  bfd_vma low, high;
-
-  low = arange_set_node_low (node);
-  high = arange_set_node_high (set, node);
-
-  BFD_ASSERT (low < address && address <= high);
-  
-  value = arange_set_copy_value (set, arange_set_node_value (set, node));
-  node2 = arange_set_splay_tree_insert (set, address, high, value);
-  if (!node2)
-    return FALSE;
-
-  arange_set_node_set_high (set, node, address - 1);
-  return TRUE;
-}
-
-static splay_tree_node
-arange_set_maybe_merge_with_predecessor (arange_set set, splay_tree_node node)
-{
-  splay_tree_node pred;
-  bfd_vma low, high;
-
-  low = arange_set_node_low (node);
-  high = arange_set_node_high (set, node);
-
-  pred = splay_tree_predecessor (set->ranges, low);
-  if (! pred)
-    return node;
-
-  if (arange_set_node_high (set, pred) + 1 == low
-      && arange_set_value_equal_p (set,
-				   arange_set_node_value (set, pred),
-				   arange_set_node_value (set, node)))
-    {
-      splay_tree_remove (set->ranges, arange_set_node_low (node));
-      arange_set_node_set_high (set, pred, high);
-      return arange_set_maybe_merge_with_predecessor (set, pred);	
-    }
-
-  return node;
-}
-
-/* Insert an arange [low,high] into a set. Return TRUE if and only if there
-   is no error.  Note that the address high is also included where as in
-   DWARF2 an address range between low & high means [low,high).
-
-   This only handles sets with values. For the simpler case of sets without
-   value, it is handled in arange_set_insert().  This function is
-   tail-recurive.  It is guaranteed to terminate because it only recurses
-   with a smaller range than it is given.  */
-
-static bfd_boolean
-arange_set_insert_value (arange_set set,
-			 bfd_vma low,
-			 bfd_vma high,
-			 arange_value_type value)
-{
-  splay_tree_node succ, pred, node;
-  bfd_vma succ_high, succ_low;
-  arange_value_type combined, old_value;
-
-  if (low > high)
-    {
-      arange_set_delete_value (set, value);
-      return FALSE;
-    }
-
-  pred = splay_tree_predecessor (set->ranges, low);
-  if (pred && arange_set_node_high (set, pred) >= low)
-    arange_set_split_node (set, pred, low);
-
-  node = splay_tree_lookup (set->ranges, low);
-  if (node)
-    {
-      /* Split node if its arange is larger than inserted arange. */
-      if (arange_set_node_high (set, node) > high)
-	arange_set_split_node (set, node, high + 1);
-
-      old_value = arange_set_node_value (set, node);
-      combined = arange_set_combine_value (set, old_value, value); 
-      arange_set_node_set_value (set, node, combined);
-      node = arange_set_maybe_merge_with_predecessor (set, node);
-      arange_set_delete_value (set, old_value);
-
-      /* Insert remaining arange by tail-recursion.  */
-      if (high > arange_set_node_high (set, node))
-	return arange_set_insert_value (set,
-					arange_set_node_high (set, node) + 1,
-					high, value);
-      else
-	{
-	  /* Node must cover exactly the range. */
-	  BFD_ASSERT (high == arange_set_node_high (set, node));
-	  arange_set_delete_value (set, value);
-	  succ = splay_tree_successor (set->ranges, arange_set_node_low (node));
-	  if (succ)
-	    succ = arange_set_maybe_merge_with_predecessor (set, succ);	
-	  return TRUE;
-	}
-    }
-  
-  succ = splay_tree_successor (set->ranges, low);
-  if (succ)
-    {
-      succ_low = arange_set_node_low (succ);	
-      succ_high = arange_set_node_high (set, succ);
-
-      if (succ_low <= high)
-	{
-	  node = arange_set_splay_tree_insert (set, low, succ_low - 1, value); 
-	  if (!node)
-	    return FALSE;
-
-	  /* Update set lower bound only after insertion is successful.  */
-	  if (low < set->lower_bound)
-	    set->lower_bound = low;
-
-	  node = arange_set_maybe_merge_with_predecessor (set, node);
-
-	  /* Recurse to handle rest of insertion.  Note that we have to copy
-	     value here since it has already been used in the node above.  */
-	  return arange_set_insert_value (set, succ_low, high,
-					  arange_set_copy_value (set, value));
-	}
-     }
-  
-  node = arange_set_splay_tree_insert (set, low, high, value);
-  if (!node)
-    return FALSE;
-
-  /* Update set boundaries only after insertion is successful.  */
-  if (low < set->lower_bound)
-    set->lower_bound = low;
-  if (high > set->upper_bound)
-    set->upper_bound = high;
-
-  node = arange_set_maybe_merge_with_predecessor (set, node);
-
-  succ = splay_tree_successor (set->ranges, arange_set_node_low (node));
-  if (succ)
-    succ = arange_set_maybe_merge_with_predecessor (set, succ);	
-
-  return TRUE;
-}
-
-bfd_boolean
-arange_set_insert (arange_set set,
-		   bfd_vma low,
-		   bfd_vma high,
-		   arange_value_type value)
-{
-  splay_tree tree = set->ranges;
-  splay_tree_node pred, succ, node = NULL;
-  bfd_vma pred_high, node_low;
-
-  if (set->value_p)
-    return arange_set_insert_value (set, low, high, value);
-
-  if (low > high)
-    return FALSE;
-
-  pred = splay_tree_predecessor (tree, low);
-  if (pred)
-    {
-      pred_high = arange_set_node_high (set, pred);
-
-      /* Nothing to be done if predecessor contains new aranges.  */ 
-      if (pred_high >= high)
-	return TRUE;
-
-      /* If we can expand predecessor, do so.  Test for the case in which
-	 predecessor does not contain new arange but touches it.  */
-      if (pred_high >= low || pred_high + 1 == low)
-	{
-	  node = pred;
-	  arange_set_node_set_high (set, node, high);
-	}
-    }
-
-  /* Try to see if [low,something] is already in splay tree.  */ 
-  if (node == NULL)
-    {
-      node = splay_tree_lookup (tree, low); 	
-      if (node)
-	{
-	  /* Nothing to be done if node contains new aranges.  */ 
-	  if (arange_set_node_high (set, node) >= high)
-	    return TRUE;
-
-	  arange_set_node_set_high (set, node, high);
-	}
-    }
-
-  if (node == NULL)
-    {
-      node = arange_set_splay_tree_insert (set, low, high, 0);
-      if (!node)
-	return FALSE;
-    }
-
-  BFD_ASSERT (node
-	      && arange_set_node_low (node) <= low
-	      && arange_set_node_high (set, node) >= high);
-
-  /* Update set upper and lower bounds.  */
-  if (low < set->lower_bound)
-    set->lower_bound = low;
-  if (high > set->upper_bound)
-    set->upper_bound = high;
-
-  /* Merge successor if it overlaps or touches node.  */
-  node_low = arange_set_node_low (node);
-  while ((succ = splay_tree_successor (tree, node_low)) != NULL
-	 && ((arange_set_node_high (set, node) >= arange_set_node_low (succ))
-	     || (arange_set_node_high (set, node) + 1
-		 == arange_set_node_low (succ))))
-    {
-      if (arange_set_node_high (set, succ) > high)
-        arange_set_node_set_high (set, node, arange_set_node_high (set, succ));
-      splay_tree_remove (tree, arange_set_node_low (succ));
-    }
-  return TRUE;
-}
-
-struct arange_set_foreach_adapter_data
-{
-  void *data;
-  arange_set set;
-  arange_set_foreach_fn foreach_fn;
-};
-
-/* Adaptor to make arange_set_foreach works with splay_tree_foreach.  */
-
-static int
-arange_set_foreach_adapter (splay_tree_node node, void *data)
-{
-  struct arange_set_foreach_adapter_data *adapter_data;
-  arange_set set;
-
-  adapter_data = data;
-  set = adapter_data->set;
-  return (adapter_data->foreach_fn) (arange_set_node_low (node),
-				     arange_set_node_high (set, node),
-				     arange_set_node_value (set, node),
-				     adapter_data->data);
-}
-
-/* Traverse aranges in a set.  For each arange in ascending order of
-   low addresses, call foreach_fn with arange boundaries and data.
-   If any invocation of foreach_fn returns a non-zero value, stop traversal
-   and return that value. Otherwise, return 0.  */
-
-int
-arange_set_foreach (arange_set set,
-		    arange_set_foreach_fn foreach_fn,
-		    void *data)
-{
-  struct arange_set_foreach_adapter_data adapter_data;
-
-  adapter_data.data = data;
-  adapter_data.foreach_fn = foreach_fn;
-  adapter_data.set = set;
-  return splay_tree_foreach (set->ranges, arange_set_foreach_adapter,
-			     (void *) &adapter_data);
-}
diff -urN binutils-2.18.50.0.4.org/bfd/arange-set.h binutils-2.18.50.0.4/bfd/arange-set.h
--- binutils-2.18.50.0.4.org/bfd/arange-set.h	2007-10-03 17:52:57.000000000 +0200
+++ binutils-2.18.50.0.4/bfd/arange-set.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,187 +0,0 @@
-/* DWARF 2 Arange-Set.
-   Copyright 2007 Free Software Foundation, Inc.
-   Contributed by Doug Kwan, Google Inc.
- 
-   This file is part of BFD.
-
-   This program 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 3 of the License, or (at
-   your option) any later version.
-
-   This program 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 a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
-   MA 02110-1301, USA.  */
-
-/* Scalable DWARF2 Arange Set.
- 
-   The original code in dwarf2.c uses an unsorted singly-linked list to
-   represent aranges in a compilation unit.  Looking up for an address
-   became very in-efficient for extremely large binaries with many
-   compilation units, each of which having long list of aranges.
-
-   The arange-set implemented here supports insertion and address
-   containment queries for an arbitrary large collection of aranges in
-   an efficient manner.  In addition, it also supports aranges with
-   values.
-
-     Arange insertion with value.
-
-   For valued arange-set, we need to specify 4 operations during set
-   creation.  If unspecified, reasonable default behaviours are assumed.
-   The operations define how arange insertion merges two identical aranges
-   with different values. The 4 operations are:
-
-	Equality
-	Copy
-	Combination
-	Deletion
-
-   When arange_set_insert () inserts an arange. It breaks the to-be-inserted
-   arange into smaller aranges using the boundaries of any overlapping
-   aranges as cutting point.  In addition, arange_set_insert () may also
-   splilt any existing arange that overlap the ends of the to-be-inserted
-   arange.  After such splitting of the new and existing aranges, the
-   to-be-inserted arange becomes a collection of smaller aranges, each of
-   which either does not overlapping with any existing arange or overlapping
-   completely with one existing arange.  While splitting aranges, values
-   are copied using the Copy operation specified in the set.
-
-   The for each smaller new arange, arange_set_insert () inserts the new
-   arange according to these rules:
-
-   1. If there is no overlapping existing arange, insert new arange.
-
-   2. If there is an overlapping existing arange and its value equals
-      to the inserted value according to the value equality operation
-      of the set, do nothing.
-
-   3. If there is an overlapping existing arange and its value is not
-      the inserted value according to the value equality operation,
-      combine the inserted value with that of the existing arange using
-      the value combination operation of set.
- 
-   If as a result of insertion, there are adjacent aranges with equal values,
-   the adjacent aranges will be merge.  */
-
-#ifndef ARANGE_SET_H
-#define ARANGE_SET_H
-
-#include "sysdep.h"
-#include "bfd.h"
-
-/* An arange_set is a pointer to an arange_set_s struct, whose implementation
-   is opaque to clients using the arange set.  */
-typedef struct arange_set_s *arange_set;
-
-#ifndef _WIN64
-  typedef unsigned long int arange_set_uhostptr_t;
-#else
-  typedef unsigned long long arange_set_uhostptr_t;
-#endif
-
-/* Type of value attached to an arange.  This should be wide enough to be
-   converted from and back to any type without loss.  */
-typedef arange_set_uhostptr_t arange_value_type;
-
-/* Type of function that is used to allocate memory for an arange-set.  */
-typedef void* (*arange_set_allocate_fn)(int, void*);
-
-/* Type of function that is used to deallocate memory of an arange-set.  */
-typedef void (*arange_set_deallocate_fn)(void*, void*);
-
-/* Type of function that is called for each arange during a traversal of
-   the set containing that arange.  */
-typedef int (*arange_set_foreach_fn)(bfd_vma, bfd_vma, arange_value_type,
-				     void *);
-
-/* Type of function that is called to test equality of range values. */
-typedef bfd_boolean (*arange_value_equal_fn)(arange_value_type,
-					     arange_value_type, void *);
-
-/* Type of function that is called to copy a range value. */
-typedef arange_value_type (*arange_value_copy_fn)(arange_value_type, void *);
-
-/* Type of function that is called to combine two range values. */
-typedef arange_value_type (*arange_value_combine_fn)(arange_value_type,
-						     arange_value_type,
-						     void *);
-
-/* Type of function that is called to delete a range value. */
-typedef void (*arange_value_delete_fn)(arange_value_type, void *);
-
-/* Create an arange set.  Return the new set of NULL if there is any
-   error.  */
-extern arange_set arange_set_new (arange_set_allocate_fn,
-				  arange_set_deallocate_fn,
-				  bfd_boolean,
-				  arange_value_equal_fn,
-				  arange_value_copy_fn,
-				  arange_value_combine_fn,
-				  arange_value_delete_fn,
-				  void *);
-
-/*  Delete an arange set.  */
-extern void arange_set_delete (arange_set);
-
-/* Return TRUE if an only if arange set is empty.  */
-extern bfd_boolean arange_set_empty_p (arange_set);
-
-/* Check to see if a given address is in an arange set.  Return TRUE if the
-   address is inside one of the aranges and if also low_ptr and high_ptr are
-   not NULL, return the boundaries of the arange.
-
-   If the address is not in any arange in set, return FALSE. */
-extern bfd_boolean arange_set_lookup_address (arange_set, bfd_vma, bfd_vma *,
-					      bfd_vma *, arange_value_type *);
-
-/* Insert an arange [low,high] into a set.  Note that the address high is
-   also included where as in DWARF2 an address range between low & high means
-   [low,high).
-
-   If the set is created with no capability of storing values, the value
-   argument is ignored.  Otherwise, the value is stored in the inserted range.
-   If there are overlapping ranges, values are combined according to
-   value_combine_fn.
-
-   If value is an object, arange_set_insert () takes ownership of that objec.
-   Caller should not deallocate objects that are passed to arange_set_insert().
-
-   Return TRUE if and only if there is no error.  */
-extern bfd_boolean arange_set_insert (arange_set, bfd_vma, bfd_vma,
-				      arange_value_type);
-
-/* Return TRUE if and only if arange set supports arang evalues.  */
-extern bfd_boolean arange_set_has_values_p (arange_set);
-
-/* Traverse aranges in a set.  For each arange in ascending order of
-   low addresses, call foreach_fn with arange boundaries and data.
-   If any invocation of foreach_fn returns a non-zero value, stop traversal
-   and return that value. Otherwise, return 0.  */
-extern int arange_set_foreach (arange_set, arange_set_foreach_fn, void *);
-
-/* Return TRUE if two values are considered equal by the value comparison
-   function of an arange_set.  If the arange set does not support values or
-   if it has no value equality function specified, this function performs
-   a bit-wise comparison of its input.  */
-extern bfd_boolean arange_set_value_equal_p (arange_set, arange_value_type,
-					     arange_value_type);
-
-/* Duplicate a value. If the arange set does not support values or if it
-   has no value copying function specified, this function returns the input
-   value.  */
-extern arange_value_type arange_set_copy_value (arange_set, arange_value_type);
-
-/* Allocate memory using the allocator of an arange set.  */
-extern void * arange_set_allocate (arange_set, int);
-
-/* Deallocate memory allocated from arange_set_allocate ().  */
-extern void arange_set_deallocate (arange_set, void *);
-
-#endif /* ARANGE_SET_H */
diff -urN binutils-2.18.50.0.4.org/bfd/dwarf2.c binutils-2.18.50.0.4/bfd/dwarf2.c
--- binutils-2.18.50.0.4.org/bfd/dwarf2.c	2008-02-08 17:44:55.000000000 +0100
+++ binutils-2.18.50.0.4/bfd/dwarf2.c	2008-02-16 21:39:52.643275415 +0100
@@ -1,6 +1,6 @@
 /* DWARF 2 support.
    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-   2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
 
    Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
    (gavin@cygnus.com).
@@ -36,7 +36,6 @@
 #include "libbfd.h"
 #include "elf-bfd.h"
 #include "elf/dwarf2.h"
-#include "arange-set.h"
 
 /* The data in the .debug_line statement prologue looks like this.  */
 
@@ -90,9 +89,6 @@
   /* Last comp unit in list above.  */
   struct comp_unit *last_comp_unit;
 
-  /* Number of comp units. */
-  int comp_unit_count;
-
   /* The next unread compilation unit within the .debug_info section.
      Zero indicates that the .debug_info section has not been loaded
      into a buffer yet.  */
@@ -167,33 +163,11 @@
 #define STASH_INFO_HASH_OFF        0
 #define STASH_INFO_HASH_ON         1
 #define STASH_INFO_HASH_DISABLED   2
-
-  /* Arange-set for fast lookup.  The aranges in this set have pointers
-     to compilation units containing them.  In the unlikely case that there
-     are multiple compilation units associated with an arange, the arange-set
-     is a NULL pointer and we need to fall back to sequential search.  */
-  arange_set comp_unit_arange_set;
-
-  /* Status of global arange set.  */
-  int arange_set_status;
-#define STASH_ARANGE_SET_OFF		0
-#define STASH_ARANGE_SET_ON		1
-#define STASH_ARANGE_SET_DISABLED	2
-
-  /* Build a whole binary arange-set for compilation unit look-up
-     if there are at least this many compilation units.  */
-#define STASH_ARANGE_SET_TRIGGER	500
 };
 
-/* Simple singly linked list for aranges.  We now use a more scalable
-   arange-set for aranges in compilation units.  For functions, we still
-   use this since it is more efficient for simple cases.  */
-
 struct arange
 {
   struct arange *next;
-  /* The lowest and highest addresses contained a compilation
-     unit as specified in the compilation unit's header.  */
   bfd_vma low;
   bfd_vma high;
 };
@@ -213,8 +187,9 @@
   /* Keep the bfd convenient (for memory allocation).  */
   bfd *abfd;
 
-  /* The set of aranges in a compilation unit.  */
-  arange_set arange_set;
+  /* The lowest and highest addresses contained in this compilation
+     unit as specified in the compilation unit header.  */
+  struct arange arange;
 
   /* The DW_AT_name attribute (for error messages).  */
   char *name;
@@ -895,8 +870,8 @@
   char *comp_dir;
   char **dirs;
   struct fileinfo* files;
-  struct line_info* last_line;  /* Largest VMA.  */
-  struct line_info* lcl_head;   /* Local head; used in 'add_line_info'.  */
+  struct line_info* last_line;  /* largest VMA */
+  struct line_info* lcl_head;   /* local head; used in 'add_line_info' */
 };
 
 /* Remember some information about each function.  If the function is
@@ -906,121 +881,35 @@
 
 struct funcinfo
 {
-  struct funcinfo *prev_func;		/* Pointer to previous function in list of all functions.  */
-  struct funcinfo *caller_func;		/* Pointer to function one scope higher.  */
-  char *caller_file;			/* Source location file name where caller_func inlines this func.  */
-  int caller_line;			/* Source location line number where caller_func inlines this func.  */
-  char *file;				/* Source location file name.  */
-  int line;				/* Source location line number.  */
+  struct funcinfo *prev_func;		/* Pointer to previous function in list of all functions */
+  struct funcinfo *caller_func;		/* Pointer to function one scope higher */
+  char *caller_file;			/* Source location file name where caller_func inlines this func */
+  int caller_line;			/* Source location line number where caller_func inlines this func */
+  char *file;				/* Source location file name */
+  int line;				/* Source location line number */
   int tag;
   char *name;
   struct arange arange;
-  asection *sec;			/* Where the symbol is defined.  */
+  asection *sec;			/* Where the symbol is defined */
 };
 
 struct varinfo
 {
-  /* Pointer to previous variable in list of all variables.  */
+  /* Pointer to previous variable in list of all variables */
   struct varinfo *prev_var;
-  /* Source location file name.  */
+  /* Source location file name */
   char *file;
-  /* Source location line number.  */
+  /* Source location line number */
   int line;
   int tag;
   char *name;
   bfd_vma addr;
-  /* Where the symbol is defined.  */
+  /* Where the symbol is defined */
   asection *sec;
-  /* Is this a stack variable?  */
+  /* Is this a stack variable? */
   unsigned int stack: 1;
 };
 
-/* Arange-sets:
- 
-   To handle extremely large binaries, we want to use a more efficient data
-   structure than a singly-linked list to represent aranges.  So instead we
-   use an arange-set, which supports efficient insertions and queries.  We
-   use a simple arange-set with no values attached to represent the aranges
-   in a compilation unit and we also use a global arange-set to store all
-   the aranges in all the compilation units.  The global arange-set stores
-   values which are pointers to the compilation units.
-
-   Normally aranges in the global set do not overlap, but this can happen.
-   To simplify things and to prevent excessive memory usage, an arange in
-   the global set can only point to at most one compilation unit.  In case
-   of an overlap, the pointer is set to NULL, meaning that there are more
-   than one compilation units containing that arange.  Code that looks up
-   the global set should fall back to searching all compilation units if
-   that happens.  */
- 
-/* Allocate memory for an arange set.  */ 
-
-static void *
-dwarf2_arange_set_allocate (int size, void *data)
-{
-  return bfd_alloc ((bfd *) data, size);
-}
-
-/* Deallocate memory of an arange set.  */ 
-
-static void
-dwarf2_arange_set_deallocate (void *object ATTRIBUTE_UNUSED,
-			      void *data ATTRIBUTE_UNUSED)
-{
-  /* Do nothing. Let BFD clean up when it's done.  */
-}
-
-/* Combine two comp unit pointers.  If they are the same,
-   return either one, otherwise return NULL.  */
-
-static arange_value_type
-dwarf2_combine_arange_value (arange_value_type value1,
-			     arange_value_type value2,
-			     void *data ATTRIBUTE_UNUSED)
-{
-  return ((value1 == value2) ? value1 : 0); 
-}
-
-/* Create a simple arange set that does not store values.  */
-
-static arange_set
-dwarf2_arange_set_new (bfd *abfd)
-{
-  return arange_set_new (dwarf2_arange_set_allocate,
-			 dwarf2_arange_set_deallocate,
-			 FALSE, NULL, NULL, NULL, NULL, (void *) abfd);
-}
-
-/* Create an arange set that stores pointers to compilation units.  */
-
-static arange_set
-dwarf2_arange_set_with_value_new (bfd *abfd)
-{
-  return arange_set_new (dwarf2_arange_set_allocate,
-			 dwarf2_arange_set_deallocate,
-			 TRUE, NULL, NULL, dwarf2_combine_arange_value,
-			 NULL, (void *) abfd);
-}
-
-/* Add an arange to a compilation unit.  Add the arange to both the
-   unit's valueless arange set and the global arange set.  */
-
-static void
-dwarf2_comp_unit_arange_add (struct comp_unit *unit,
-			     bfd_vma low, 
-			     bfd_vma high)
-{
-  /* Add arange to unit's local arange set.  */
-  arange_set_insert (unit->arange_set, low, high - 1, 0);
-
-  if (unit->stash->arange_set_status == STASH_ARANGE_SET_ON)
-    {
-      BFD_ASSERT (unit->stash->comp_unit_arange_set);
-      arange_set_insert (unit->stash->comp_unit_arange_set, low, high - 1,
-			 (arange_value_type) unit);
-    }
-}
-
 /* Return TRUE if NEW_LINE should sort after LINE.  */
 
 static inline bfd_boolean
@@ -1046,7 +935,7 @@
 	       int end_sequence)
 {
   bfd_size_type amt = sizeof (struct line_info);
-  struct line_info * info = bfd_alloc (table->abfd, amt);
+  struct line_info* info = bfd_alloc (table->abfd, amt);
 
   /* Set member data of 'info'.  */
   info->address = address;
@@ -1090,9 +979,9 @@
       table->last_line = info;
     }
   else if (!table->last_line
-	   || new_line_sorts_after (info, table->last_line))
+      || new_line_sorts_after (info, table->last_line))
     {
-      /* Normal case: add 'info' to the beginning of the list.  */
+      /* Normal case: add 'info' to the beginning of the list */
       info->prev_line = table->last_line;
       table->last_line = info;
 
@@ -1112,7 +1001,7 @@
     {
       /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
 	 heads for 'info'.  Reset 'lcl_head'.  */
-      struct line_info* li2 = table->last_line; /* Always non-NULL.  */
+      struct line_info* li2 = table->last_line; /* always non-NULL */
       struct line_info* li1 = li2->prev_line;
 
       while (li1)
@@ -1121,7 +1010,7 @@
 	      && new_line_sorts_after (info, li1))
 	    break;
 
-	  li2 = li1; /* Always non-NULL.  */
+	  li2 = li1; /* always non-NULL */
 	  li1 = li1->prev_line;
 	}
       table->lcl_head = li2;
@@ -1195,12 +1084,11 @@
 }
 
 static void
-arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc,
-	    bfd_vma high_pc)
+arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
 {
   struct arange *arange;
 
-  /* If the first arange is empty, use it.  */
+  /* If the first arange is empty, use it. */
   if (first_arange->high == 0)
     {
       first_arange->low = low_pc;
@@ -1227,7 +1115,7 @@
   while (arange);
 
   /* Need to allocate a new arange and insert it into the arange list.
-     Order isn't significant, so just insert after the first arange.  */
+     Order isn't significant, so just insert after the first arange. */
   arange = bfd_zalloc (abfd, sizeof (*arange));
   arange->low = low_pc;
   arange->high = high_pc;
@@ -1462,7 +1350,7 @@
 		    low_pc = address;
 		  if (address > high_pc)
 		    high_pc = address;
-		  dwarf2_comp_unit_arange_add (unit, low_pc, high_pc);
+		  arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
 		  break;
 		case DW_LNE_set_address:
 		  address = read_address (unit, line_ptr);
@@ -1893,44 +1781,11 @@
 	    }
 	}
     }
-  return name;
-}
-
-/* Type of callback function used in read_rangelist below.  */
-
-typedef void (*read_rangelist_callback_t)(struct comp_unit*, bfd_vma,
-					  bfd_vma, void*);
-
-/* Call back to add an arange to the old-style arange list.  */
-
-static void
-read_rangelist_insert_arange_list (struct comp_unit *unit,
-				   bfd_vma low,
-				   bfd_vma high,
-				   void *data)
-{
-  arange_add (unit->abfd, (struct arange*) data, low, high);
+  return (name);
 }
 
-/* Callback to add an arange in the arange set of a compilation unit.  */
-
-static void
-read_rangelist_comp_unit_arange_add (struct comp_unit *unit,
-				     bfd_vma low,
-				     bfd_vma high,
-				     void *data ATTRIBUTE_UNUSED)
-{
-  dwarf2_comp_unit_arange_add (unit, low, high);
-}
-
-/* Read ARANGE list of a compilation unit.  For each read arange,
-   call the supplied callback function for further processing.  */
-
 static void
-read_rangelist (struct comp_unit *unit,
-	        bfd_uint64_t offset,
-		read_rangelist_callback_t callback,
-		void *callback_data)
+read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
 {
   bfd_byte *ranges_ptr;
   bfd_vma base_address = unit->base_address;
@@ -1966,9 +1821,7 @@
       if (low_pc == -1UL && high_pc != -1UL)
 	base_address = high_pc;
       else
-	/* Call callback to process new arange.  */
-	(callback) (unit, base_address + low_pc, base_address + high_pc,
-		    callback_data);
+	arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
     }
 }
 
@@ -2101,9 +1954,7 @@
 		  break;
 
 		case DW_AT_ranges:
-		  read_rangelist (unit, attr.u.val,
-				  read_rangelist_insert_arange_list,
-				  & func->arange);
+		  read_rangelist (unit, &func->arange, attr.u.val);
 		  break;
 
 		case DW_AT_decl_file:
@@ -2305,7 +2156,6 @@
   unit->end_ptr = end_ptr;
   unit->stash = stash;
   unit->info_ptr_unit = info_ptr_unit;
-  unit->arange_set = dwarf2_arange_set_new (abfd);
 
   for (i = 0; i < abbrev->num_attrs; ++i)
     {
@@ -2337,14 +2187,12 @@
 	  break;
 
 	case DW_AT_ranges:
-	  read_rangelist (unit, attr.u.val,
-			  read_rangelist_comp_unit_arange_add, NULL);
+	  read_rangelist (unit, &unit->arange, attr.u.val);
 	  break;
 
 	case DW_AT_comp_dir:
 	  {
 	    char *comp_dir = attr.u.str;
-
 	    if (comp_dir)
 	      {
 		/* Irix 6.2 native cc prepends <machine>.: to the compilation
@@ -2362,9 +2210,10 @@
 	  break;
 	}
     }
-
   if (high_pc != 0)
-    dwarf2_comp_unit_arange_add (unit, low_pc, high_pc);
+    {
+      arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
+    }
 
   unit->first_child_die_ptr = info_ptr;
   return unit;
@@ -2379,7 +2228,21 @@
 static bfd_boolean
 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
 {
-  return arange_set_lookup_address (unit->arange_set, addr, NULL, NULL, NULL);
+  struct arange *arange;
+
+  if (unit->error)
+    return FALSE;
+
+  arange = &unit->arange;
+  do
+    {
+      if (addr >= arange->low && addr < arange->high)
+	return TRUE;
+      arange = arange->next;
+    }
+  while (arange);
+
+  return FALSE;
 }
 
 /* If UNIT contains ADDR, set the output parameters to the values for
@@ -2951,107 +2814,6 @@
 				   filename_ptr, linenumber_ptr);
 }
 
-typedef struct
-{
-  struct dwarf2_debug * stash;
-  arange_set            set;
-  struct comp_unit *    unit;
-} stash_copy_local_aranges_data_t;
-
-static int
-stash_copy_local_aranges (bfd_vma low,
-			  bfd_vma high,
-			  arange_value_type data ATTRIBUTE_UNUSED,
-			  void *info)
-{
-  bfd_boolean status;
-
-  stash_copy_local_aranges_data_t *copy_data = info;
-  status = arange_set_insert (copy_data->set, low, high,
-			      (arange_value_type) copy_data->unit);
-
-  return status ? 0 : 1;
-}
-
-static bfd_boolean
-stash_maybe_enable_arange_set (bfd *abfd, struct dwarf2_debug *stash)
-{
-  struct comp_unit *unit;
-  stash_copy_local_aranges_data_t copy_data;
-
-  if (stash->arange_set_status != STASH_ARANGE_SET_OFF)
-    return TRUE;
-
-  if (stash->comp_unit_count < STASH_ARANGE_SET_TRIGGER)
-    return TRUE;
-
-  if (stash->comp_unit_arange_set == NULL)
-    {
-      stash->comp_unit_arange_set =
-	dwarf2_arange_set_with_value_new (abfd);
-      if (!stash->comp_unit_arange_set)
-	{
-	  stash->arange_set_status = STASH_ARANGE_SET_DISABLED;
-	  return FALSE;
-	}
-    }
-
-  copy_data.stash = stash;
-  copy_data.set = stash->comp_unit_arange_set;
-  for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
-    {
-      copy_data.unit = unit;
-      if (arange_set_foreach (unit->arange_set, stash_copy_local_aranges, 
-			      & copy_data))
-	{
-	  stash->arange_set_status = STASH_ARANGE_SET_DISABLED;
-	  return FALSE;
-	}
-    }
-  stash->arange_set_status = STASH_ARANGE_SET_ON;
-  return TRUE;
-}
-
-/* Find the nearest line to a given address and record filename,
-   function name and line number if found.  Return TRUE if a line is
-   found or FALSE otherwise.  */
-
-static bfd_boolean ATTRIBUTE_UNUSED
-stash_find_nearest_line_fast (struct dwarf2_debug *stash,
-			      bfd_vma addr,
-			      const char **filename_ptr,
-			      const char **functionname_ptr,
-			      unsigned int *linenumber_ptr)
-{
-  arange_value_type value;
-  struct comp_unit *unit;
-
-  /* Try looking up global arange set first.  */
-  if (stash->arange_set_status == STASH_ARANGE_SET_ON
-      && arange_set_lookup_address (stash->comp_unit_arange_set, addr, NULL,
-				    NULL, &value))
-    {
-      if ((unit = (struct comp_unit *) value) != NULL)
-	/* There is only one compilation unit containing this address.  */
-	return comp_unit_find_nearest_line (unit, addr, filename_ptr,
-					    functionname_ptr, linenumber_ptr,
-					    stash);
-    }
-
-  /* The arange set is not available or there are multiple compilation
-     units containing this address.  Search all compilation units.  */
-  for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
-    {
-      if (comp_unit_contains_address (unit, addr)
-	  && comp_unit_find_nearest_line (unit, addr, filename_ptr,
-					  functionname_ptr,
-					  linenumber_ptr, stash))
-	  return TRUE;
-    }
-
-  return FALSE;
-}
-
 /* Find the source code location of SYMBOL.  If SYMBOL is NULL
    then find the nearest source code location corresponding to
    the address SECTION + OFFSET.
@@ -3306,13 +3068,17 @@
     }
   else
     {
-      if (stash->arange_set_status == STASH_ARANGE_SET_OFF)
-	stash_maybe_enable_arange_set (abfd, stash);
-
-      found = stash_find_nearest_line_fast (stash, addr, filename_ptr,
-					    functionname_ptr, linenumber_ptr);
-      if (found)
-	goto done;
+      for (each = stash->all_comp_units; each; each = each->next_unit)
+	{
+	  found = (comp_unit_contains_address (each, addr)
+		   && comp_unit_find_nearest_line (each, addr,
+						   filename_ptr,
+						   functionname_ptr,
+						   linenumber_ptr,
+						   stash));
+	  if (found)
+	    goto done;
+	}
     }
 
   /* The DWARF2 spec says that the initial length field, and the
@@ -3386,22 +3152,22 @@
 
 	      each->next_unit = stash->all_comp_units;
 	      stash->all_comp_units = each;
-	      stash->comp_unit_count++;
 
 	      /* DW_AT_low_pc and DW_AT_high_pc are optional for
-		 compilation units.  If we don't have them, we need to
-		 consult the line info table to see if a compilation unit
-		 contains the given address.  */
+		 compilation units.  If we don't have them (i.e.,
+		 unit->high == 0), we need to consult the line info
+		 table to see if a compilation unit contains the given
+		 address.  */
 	      if (do_line)
 		found = (((symbol->flags & BSF_FUNCTION) == 0
-			  || arange_set_empty_p (each->arange_set)
+			  || each->arange.high == 0
 			  || comp_unit_contains_address (each, addr))
 			 && comp_unit_find_line (each, symbol, addr,
 						 filename_ptr,
 						 linenumber_ptr,
 						 stash));
 	      else
-		found = ((arange_set_empty_p (each->arange_set)
+		found = ((each->arange.high == 0
 			  || comp_unit_contains_address (each, addr))
 			 && comp_unit_find_nearest_line (each, addr,
 							 filename_ptr,
diff -urN binutils-2.18.50.0.4.org/bfd/Makefile.am binutils-2.18.50.0.4/bfd/Makefile.am
--- binutils-2.18.50.0.4.org/bfd/Makefile.am	2008-02-08 17:44:09.000000000 +0100
+++ binutils-2.18.50.0.4/bfd/Makefile.am	2008-02-16 21:39:52.643275415 +0100
@@ -42,7 +42,7 @@
 	format.lo init.lo libbfd.lo opncls.lo reloc.lo \
 	section.lo syms.lo targets.lo hash.lo linker.lo \
 	srec.lo binary.lo tekhex.lo ihex.lo stabs.lo stab-syms.lo \
-	merge.lo dwarf2.lo simple.lo arange-set.lo
+	merge.lo dwarf2.lo simple.lo
 
 BFD64_LIBS = archive64.lo
 
@@ -52,7 +52,7 @@
 	format.c init.c libbfd.c opncls.c reloc.c \
 	section.c syms.c targets.c hash.c linker.c \
 	srec.c binary.c tekhex.c ihex.c stabs.c stab-syms.c \
-	merge.c dwarf2.c simple.c arange-set.c
+	merge.c dwarf2.c simple.c
 
 BFD64_LIBS_CFILES = archive64.c
 
@@ -665,8 +665,8 @@
 
 ## This is a list of all .h files which are in the source tree.
 SOURCE_HFILES = \
-	arange-set.h aout-target.h aoutf1.h aoutx.h coffcode.h coffswap.h \
-	ecoffswap.h elf-bfd.h elf-hppa.h elf32-hppa.h \
+	aout-target.h aoutf1.h aoutx.h coffcode.h coffswap.h ecoffswap.h \
+	elf-bfd.h elf-hppa.h elf32-hppa.h \
 	elf64-hppa.h elfcode.h elfcore.h \
 	freebsd.h genlink.h go32stub.h \
 	libaout.h libbfd.h libcoff.h libecoff.h libhppa.h libieee.h \
@@ -1049,11 +1049,9 @@
 dwarf2.lo: dwarf2.c $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
   $(INCDIR)/hashtab.h elf-bfd.h $(INCDIR)/elf/common.h \
   $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h \
-  $(INCDIR)/elf/dwarf2.h arange-set.h
+  $(INCDIR)/elf/dwarf2.h
 simple.lo: simple.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h \
   $(INCDIR)/bfdlink.h
-arange-set.lo: arange-set.c $(INCDIR)/filenames.h $(INCDIR)/libiberty.h \
-  $(INCDIR)/hashtab.h arange-set.h $(INCDIR)/splay-tree.h
 archive64.lo: archive64.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h \
   $(INCDIR)/aout/ar.h
 cpu-alpha.lo: cpu-alpha.c $(INCDIR)/filenames.h $(INCDIR)/hashtab.h
diff -urN binutils-2.18.50.0.4.org/bfd/po/SRC-POTFILES.in binutils-2.18.50.0.4/bfd/po/SRC-POTFILES.in
--- binutils-2.18.50.0.4.org/bfd/po/SRC-POTFILES.in	2007-11-03 21:40:36.000000000 +0100
+++ binutils-2.18.50.0.4/bfd/po/SRC-POTFILES.in	2008-02-16 21:39:52.643275415 +0100
@@ -12,8 +12,6 @@
 aout-target.h
 aout-tic30.c
 aoutx.h
-arange-set.c
-arange-set.h
 archive64.c
 archive.c
 archures.c