+++ /dev/null
-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
projects / packages / binutils.git / commitdiff