blob: a741c56b242bda55a1e0cc79858a5f8d29299145 [file] [log] [blame]
// Splay tree utilities -*- C++ -*-
// Copyright (C) 2020-2022 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC 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, or (at your option) any later
// version.
//
// GCC 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 GCC; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// INDEX is either 0 or 1. If it is 0, return NODE's left child,
// otherwise return NODE's right child.
template<typename Accessors>
inline typename base_splay_tree<Accessors>::node_type
base_splay_tree<Accessors>::get_child (node_type node, unsigned int index)
{
return Accessors::child (node, index);
}
// INDEX is either 0 or 1. If it is 0, change NODE's left child to CHILD,
// otherwise change NODE's right child to CHILD. If CHILD has a parent
// field, record that its parent is now NODE.
template<typename Accessors>
inline void
base_splay_tree<Accessors>::set_child (node_type node, unsigned int index,
node_type child)
{
Accessors::child (node, index) = child;
if (child)
set_parent (child, node);
}
// Rotate the tree to promote child number INDEX of NODE, so that that
// child becomes a parent of NODE. Return the promoted node.
//
// The caller has the responsibility of assigning a correct parent
// to the returned node.
template<typename Accessors>
inline typename base_splay_tree<Accessors>::node_type
base_splay_tree<Accessors>::promote_child (node_type node, unsigned int index)
{
node_type promoted = get_child (node, index);
set_child (node, index, get_child (promoted, 1 - index));
set_child (promoted, 1 - index, node);
return promoted;
}
// Treat child number INDEX of NODE as being CHILD and rotate the tree
// so that CHILD becomes a parent of NODE.
//
// The caller has the responsibility of assigning a correct parent to CHILD.
template<typename Accessors>
inline void
base_splay_tree<Accessors>::promote_child (node_type node, unsigned int index,
node_type child)
{
set_child (node, index, get_child (child, 1 - index));
set_child (child, 1 - index, node);
}
// Print NODE to PP, using PRINTER (PP, N) to print the contents of node N.
// Prefix each new line with INDENT_STRING. CODE is 'T' if NODE is the root
// node, 'L' if NODE is the left child of its parent, or 'R' if NODE is the
// right child of its parent.
template<typename Accessors>
template<typename Printer>
void
base_splay_tree<Accessors>::print (pretty_printer *pp, node_type node,
Printer printer, char code,
vec<char> &indent_string)
{
// In the comments below, PREFIX refers to the incoming contents
// of INDENT_STRING.
node_type left = get_child (node, 0);
node_type right = get_child (node, 1);
auto orig_indent_len = indent_string.length ();
indent_string.safe_grow (orig_indent_len + 3);
char *extra_indent = indent_string.address () + orig_indent_len;
// Print [T], [L], or [R].
extra_indent[0] = '[';
extra_indent[1] = code;
extra_indent[2] = ']';
pp_append_text (pp, extra_indent, indent_string.end ());
pp_space (pp);
// Print the node itself, using PREFIX + " | " or PREFIX + " " to indent
// new lines under the "[_]" that we just printed.
extra_indent[0] = ' ';
extra_indent[1] = (left || right ? '|' : ' ');
extra_indent[2] = ' ';
{
pretty_printer sub_pp;
printer (&sub_pp, node);
const char *text = pp_formatted_text (&sub_pp);
while (const char *end = strchr (text, '\n'))
{
pp_append_text (pp, text, end);
pp_newline_and_indent (pp, 0);
pp_append_text (pp, indent_string.begin (), indent_string.end ());
text = end + 1;
}
pp_string (pp, text);
}
if (left)
{
// Print PREFIX + " +-" for the first line of the left subtree,
// to be followed by "[L]".
extra_indent[1] = '+';
extra_indent[2] = '-';
pp_newline_and_indent (pp, 0);
pp_append_text (pp, indent_string.begin (), indent_string.end ());
// Print the left subtree, using PREFIX + " | " or PREFIX + " "
// to indent under the PREFIX + " +-" that we just printed.
extra_indent[1] = right ? '|' : ' ';
extra_indent[2] = ' ';
print (pp, left, printer, 'L', indent_string);
extra_indent = indent_string.address () + orig_indent_len;
// If LEFT is not a leaf and we also have a right subtree, use a
// PREFIX + " |" line to separate them.
if (right && (get_child (left, 0) || get_child (left, 1)))
{
pp_newline_and_indent (pp, 0);
pp_append_text (pp, indent_string.begin (), &extra_indent[2]);
}
}
if (right)
{
// Print PREFIX + " +-" for the first line of the right subtree,
// to be followed by "[R]".
extra_indent[1] = '+';
extra_indent[2] = '-';
pp_newline_and_indent (pp, 0);
pp_append_text (pp, indent_string.begin (), indent_string.end ());
// Print the right subtree, using PREFIX + " " to indent under the
// PREFIX + " +-" that we just printed.
extra_indent[1] = ' ';
extra_indent[2] = ' ';
print (pp, right, printer, 'R', indent_string);
}
indent_string.truncate (orig_indent_len);
}
// See the comment above the declaration.
template<typename Accessors>
template<typename Printer>
void
base_splay_tree<Accessors>::print (pretty_printer *pp, node_type node,
Printer printer)
{
if (!node)
{
pp_string (pp, "null");
return;
}
auto_vec<char, 64> indent_string;
print (pp, node, printer, 'T', indent_string);
}
// If N is 1, splay the last (rightmost) node reachable from START
// to the position that START current holds and return the splayed node.
// START is not itself the last node.
//
// If N is 0, splay the first (leftmost) node reachable from START
// to the position that START current holds and return the splayed node.
// START is not itself the first node.
//
// The caller has the responsibility of updating the parent of the
// returned node.
template<typename Accessors>
template<unsigned int N>
typename base_splay_tree<Accessors>::node_type
base_splay_tree<Accessors>::splay_limit (node_type start)
{
// This essentially follows the simpilfied top-down method described
// in Sleator and Tarjan's "Self-adjusting Binary Search Trees", but
// specialized for the case in which the comparison result is fixed.
// The first iteration is peeled to avoid the need for stack temporaries.
//
// The comments and names reflect the behavior for N == 1, but the
// N == 0 case behaves analogously.
// Rotate the tree to promote the right child of START to the root.
node_type node = promote_child (start, N);
if (node_type right = get_child (node, N))
{
// Perform the link left step, which for this first iteration
// means making NODE the root of the left tree.
//
// NODE will become left child of the final node. For a right
// spine starting at NODE of the form:
//
// 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> ... -> N
// | | | | | | | |
// V V V V V V V V
// A B C D E F G NL
//
// the next step is to create a subtree of N whose right spine contains
// the odd-numbered nodes, as follows:
//
// N
// |
// V
// 1 ------> 3 ------> 5 ------> 7 -> .... -> NL
// | | | |
// V V V V
// A 2 -> C 4 -> E 6 -> G
// | | |
// V V V
// B D F
//
// First record 1 as the left child of the final root (N) and move
// on to node 2.
node_type final_child = node;
node_type new_spine_end = node;
node = right;
while (node_type right = get_child (node, N))
{
// Perform another rotate left step.
//
// We've built the tree rooted at 1 in the diagram above up to,
// but not including, an even-numbered node NODE on the original
// right spine. Rotate the tree at NODE to promote the following
// odd-numbered node.
promote_child (node, N, right);
node = right;
if (node_type right = get_child (node, N))
{
// Perform another link left step.
//
// Add the promoted odd-numbered node to the right spine of the
// tree rooted at 1 and move on to the next even-numbered node.
set_child (new_spine_end, N, node);
new_spine_end = node;
node = right;
}
}
// Perform the assembly step.
//
// Add NL to the new spine and make N the new root.
set_child (new_spine_end, N, get_child (node, 1 - N));
set_child (node, 1 - N, final_child);
}
return node;
}
// Remove NODE from its position in the splay tree. If NODE has at least
// one child node, return the node that should now hold NODE's position in
// the splay tree. If NODE has no children, return null.
//
// The caller has the responsibility of updating the parent of the
// returned node.
template<typename Accessors>
inline typename base_splay_tree<Accessors>::node_type
base_splay_tree<Accessors>::remove_node_internal (node_type node)
{
node_type left = get_child (node, 0);
node_type right = get_child (node, 1);
if (!left)
return right;
if (!right)
return left;
if (get_child (left, 1))
{
left = splay_limit<1> (left);
gcc_checking_assert (!get_child (left, 1));
}
set_child (left, 1, right);
return left;
}
// See the comment above the declaration.
template<typename Accessors>
inline void
base_splay_tree<Accessors>::insert_child (node_type node, unsigned int index,
node_type child)
{
gcc_checking_assert (!get_child (child, 0) && !get_child (child, 1));
set_child (child, index, get_child (node, index));
set_child (node, index, child);
}
// Implement splay_next_node if N == 1 and splay_prev_node if N == 0.
template<typename Accessors>
template<unsigned int N>
bool
rooted_splay_tree<Accessors>::splay_neighbor ()
{
node_type node = m_root;
node_type new_root = get_child (node, N);
if (!new_root)
return false;
if (get_child (new_root, 1 - N))
{
// NEW_ROOT is not itself the required node, so splay the required
// node into its place.
new_root = parent::template splay_limit<1 - N> (new_root);
gcc_checking_assert (!get_child (new_root, 1 - N));
set_child (node, N, node_type ());
set_child (new_root, 1 - N, node);
}
else
promote_child (node, N, new_root);
set_parent (new_root, node_type ());
m_root = new_root;
return true;
}
// See the comment above the declaration.
template<typename Accessors>
template<typename Comparator>
bool
rooted_splay_tree<Accessors>::insert (node_type new_node, Comparator compare)
{
gcc_checking_assert (!get_child (new_node, 0) && !get_child (new_node, 1));
if (!m_root)
{
m_root = new_node;
return true;
}
int comparison = lookup (compare);
if (comparison == 0)
return false;
// Insert NEW_NODE before M_ROOT if COMPARISON < 0 and after M_ROOT
// otherwise.
set_child (new_node, comparison < 0, m_root);
set_child (new_node, comparison > 0, get_child (m_root, comparison > 0));
set_child (m_root, comparison > 0, nullptr);
m_root = new_node;
return true;
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::insert_max_node (node_type new_node)
{
gcc_checking_assert (!get_child (new_node, 0) && !get_child (new_node, 1));
set_child (new_node, 0, m_root);
m_root = new_node;
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::splice_next_tree (rooted_splay_tree next_tree)
{
splay_max_node ();
set_child (m_root, 1, next_tree.m_root);
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::replace_max_node_at_root (node_type new_node)
{
node_type old_node = m_root;
gcc_checking_assert (!get_child (new_node, 0)
&& !get_child (new_node, 1)
&& !get_child (old_node, 1));
set_child (new_node, 0, get_child (old_node, 0));
// Clear the links from OLD_NODE. Its parent and right child are
// already node_type ().
set_child (old_node, 0, node_type ());
m_root = new_node;
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::remove_root ()
{
node_type node = m_root;
m_root = parent::remove_node_internal (node);
if (m_root)
set_parent (m_root, node_type ());
// Clear the links from NODE. Its parent is already node_type ().
set_child (node, 0, node_type ());
set_child (node, 1, node_type ());
}
// See the comment above the declaration.
template<typename Accessors>
inline rooted_splay_tree<Accessors>
rooted_splay_tree<Accessors>::split_before_root ()
{
node_type new_root = get_child (m_root, 0);
set_child (m_root, 0, node_type ());
set_parent (new_root, node_type ());
return new_root;
}
// See the comment above the declaration.
template<typename Accessors>
inline rooted_splay_tree<Accessors>
rooted_splay_tree<Accessors>::split_after_root ()
{
node_type new_root = get_child (m_root, 1);
set_child (m_root, 1, node_type ());
set_parent (new_root, node_type ());
return new_root;
}
// See the comment above the declaration.
template<typename Accessors>
inline bool
rooted_splay_tree<Accessors>::splay_prev_node ()
{
return splay_neighbor<0> ();
}
// See the comment above the declaration.
template<typename Accessors>
inline bool
rooted_splay_tree<Accessors>::splay_next_node ()
{
return splay_neighbor<1> ();
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::splay_min_node ()
{
if (m_root && get_child (m_root, 0))
{
m_root = parent::template splay_limit<0> (m_root);
set_parent (m_root, node_type ());
}
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rooted_splay_tree<Accessors>::splay_max_node ()
{
if (m_root && get_child (m_root, 1))
{
m_root = parent::template splay_limit<1> (m_root);
set_parent (m_root, node_type ());
}
}
// See the comment above the declaration.
template<typename Accessors>
inline typename rooted_splay_tree<Accessors>::node_type
rooted_splay_tree<Accessors>::min_node ()
{
splay_min_node ();
return m_root;
}
// See the comment above the declaration.
template<typename Accessors>
inline typename rooted_splay_tree<Accessors>::node_type
rooted_splay_tree<Accessors>::max_node ()
{
splay_max_node ();
return m_root;
}
// See the comment above the declaration.
template<typename Accessors>
template<typename Comparator>
auto
rooted_splay_tree<Accessors>::lookup (Comparator compare)
-> decltype (compare (m_root))
{
// This essentially follows the simpilfied top-down method described
// in Sleator and Tarjan's "Self-adjusting Binary Search Trees", but
// with the complication that the comparisons are done only once.
using result_type = decltype (compare (m_root));
// The roots of the left and right trees.
node_type link_left_root = node_type ();
node_type link_right_root = node_type ();
// Where to add new nodes to the left and right trees.
node_type *link_left_ptr = &link_left_root;
node_type *link_right_ptr = &link_right_root;
// The nodes that contain *LINK_LEFT_PTR and *LINK_RIGHT_PTR,
// once they no longer point to the roots above.
node_type link_left_parent = node_type ();
node_type link_right_parent = node_type ();
auto link_left = [&](node_type node)
{
*link_left_ptr = node;
link_left_ptr = &Accessors::child (node, 1);
set_parent (node, link_left_parent);
link_left_parent = node;
};
auto link_right = [&](node_type node)
{
*link_right_ptr = node;
link_right_ptr = &Accessors::child (node, 0);
set_parent (node, link_right_parent);
link_right_parent = node;
};
node_type node = m_root;
node_type parent = node_type ();
result_type result;
result_type old_result = 0;
while (1)
{
// OLD_RESULT is 0 if NODE is the root of the middle tree.
// Otherwise, PARENT is the root of the middle tree and OLD_RESULT
// is how it compared.
//
// Results are:
// < 0 if we want something smaller.
// = 0 if we found the right node.
// > 0 if we want something bigger.
result = compare (node);
if (old_result < 0)
{
if (result < 0)
{
// SEARCH < NODE < PARENT
//
// Promote NODE (rotate right).
promote_child (parent, 0, node);
node_type next = get_child (node, 0);
if (!next)
break;
link_right (node);
// NEXT is now the root of the middle tree.
node = next;
old_result = 0;
continue;
}
// SEARCH >= NODE, NODE < PARENT
link_right (parent);
}
else if (old_result > 0)
{
if (result > 0)
{
// SEARCH > NODE > PARENT
//
// Promote NODE (rotate left).
promote_child (parent, 1, node);
node_type next = get_child (node, 1);
if (!next)
break;
link_left (node);
// NEXT is now the root of the middle tree.
node = next;
old_result = 0;
continue;
}
// SEARCH <= NODE, NODE > PARENT
link_left (parent);
}
// Microoptimization to allow NODE to be read even if RESULT == 0.
node_type next = get_child (node, result >= 0);
if (result == 0 || !next)
break;
// NODE is now the root of the tree.
parent = node;
node = next;
old_result = result;
}
node_type new_left = link_left_root;
node_type new_right = link_right_root;
if (new_left)
{
node_type old_left = get_child (node, 0);
*link_left_ptr = old_left;
if (old_left)
set_parent (old_left, link_left_parent);
set_child (node, 0, new_left);
}
if (new_right)
{
node_type old_right = get_child (node, 1);
*link_right_ptr = old_right;
if (old_right)
set_parent (old_right, link_right_parent);
set_child (node, 1, new_right);
}
set_parent (node, node_type ());
m_root = node;
return result;
}
// See the comment above the declaration.
template<typename Accessors>
template<typename LeftPredicate, typename RightPredicate>
int
rooted_splay_tree<Accessors>::lookup (LeftPredicate want_something_smaller,
RightPredicate want_something_bigger)
{
// This essentially follows the simpilfied top-down method described
// in Sleator and Tarjan's "Self-adjusting Binary Search Trees"
// (and follows it more closely than the single-comparator version above).
// The roots of the left and right trees.
node_type link_left_root = node_type ();
node_type link_right_root = node_type ();
// Where to add new nodes to the left and right trees.
node_type *link_left_ptr = &link_left_root;
node_type *link_right_ptr = &link_right_root;
// The nodes that contain *LINK_LEFT_PTR and *LINK_RIGHT_PTR,
// once they no longer point to the roots above.
node_type link_left_parent = node_type ();
node_type link_right_parent = node_type ();
node_type node = m_root;
int result;
for (;;)
{
// NODE is the root of the middle tree.
if (want_something_smaller (node))
{
result = -1;
node_type next = get_child (node, 0);
if (!next)
break;
if (want_something_smaller (next))
{
// Promote NODE (rotate right).
promote_child (node, 0, next);
node = next;
next = get_child (node, 0);
if (!next)
break;
}
// Add NODE to the right tree (link right).
*link_right_ptr = node;
link_right_ptr = &Accessors::child (node, 0);
set_parent (node, link_right_parent);
link_right_parent = node;
node = next;
}
else if (want_something_bigger (node))
{
result = 1;
node_type next = get_child (node, 1);
if (!next)
break;
if (want_something_bigger (next))
{
// Promote NODE (rotate left).
promote_child (node, 1, next);
node = next;
next = get_child (node, 1);
if (!next)
break;
}
// Add NODE to the left tree (link left).
*link_left_ptr = node;
link_left_ptr = &Accessors::child (node, 1);
set_parent (node, link_left_parent);
link_left_parent = node;
node = next;
}
else
{
result = 0;
break;
}
}
node_type new_left = link_left_root;
node_type new_right = link_right_root;
if (new_left)
{
node_type old_left = get_child (node, 0);
*link_left_ptr = old_left;
if (old_left)
set_parent (old_left, link_left_parent);
set_child (node, 0, new_left);
}
if (new_right)
{
node_type old_right = get_child (node, 1);
*link_right_ptr = old_right;
if (old_right)
set_parent (old_right, link_right_parent);
set_child (node, 1, new_right);
}
set_parent (node, node_type ());
m_root = node;
return result;
}
// See the comment above the declaration.
template<typename Accessors>
template<typename Printer>
inline void
rooted_splay_tree<Accessors>::print (pretty_printer *pp, Printer printer) const
{
print (pp, m_root, printer);
}
// Return NODE's current parent.
template<typename Accessors>
inline typename rootless_splay_tree<Accessors>::node_type
rootless_splay_tree<Accessors>::get_parent (node_type node)
{
return Accessors::parent (node);
}
// CHILD is known to be a child of PARENT. Return which index it has.
template<typename Accessors>
inline unsigned int
rootless_splay_tree<Accessors>::child_index (node_type parent, node_type child)
{
return get_child (parent, 1) == child;
}
// If N == 1, implement splay_known_max_node, otherwise implement
// splay_known_min_node.
template<typename Accessors>
template<unsigned int N>
inline void
rootless_splay_tree<Accessors>::splay_known_limit (node_type node)
{
node_type child = node;
node_type parent = get_parent (child);
if (!parent)
return;
do
// At this point, NODE conceptually replaces CHILD as a child of
// PARENT, but we haven't yet updated PARENT accordingly.
if (node_type grandparent = get_parent (parent))
{
node_type greatgrandparent = get_parent (grandparent);
promote_child (grandparent, N, parent);
promote_child (parent, N, node);
child = grandparent;
parent = greatgrandparent;
}
else
{
promote_child (parent, N, node);
break;
}
while (parent);
set_parent (node, node_type ());
}
// See the comment above the declaration.
template<typename Accessors>
typename rootless_splay_tree<Accessors>::node_type
rootless_splay_tree<Accessors>::remove_node (node_type node)
{
node_type replacement = parent::remove_node_internal (node);
if (node_type parent = get_parent (node))
set_child (parent, child_index (parent, node), replacement);
else if (replacement)
set_parent (replacement, node_type ());
// Clear the links from NODE.
set_parent (node, node_type ());
set_child (node, 0, node_type ());
set_child (node, 1, node_type ());
return replacement;
}
// See the comment above the declaration.
template<typename Accessors>
void
rootless_splay_tree<Accessors>::splay (node_type node)
{
node_type child = node;
node_type parent = get_parent (child);
if (!parent)
return;
do
{
// At this point, NODE conceptually replaces CHILD as a child of
// PARENT, but we haven't yet updated PARENT accordingly.
unsigned int index = child_index (parent, child);
if (node_type grandparent = get_parent (parent))
{
node_type greatgrandparent = get_parent (grandparent);
unsigned int parent_index = child_index (grandparent, parent);
if (index == parent_index)
{
promote_child (grandparent, parent_index, parent);
promote_child (parent, index, node);
}
else
{
promote_child (parent, index, node);
promote_child (grandparent, parent_index, node);
}
child = grandparent;
parent = greatgrandparent;
}
else
{
promote_child (parent, index, node);
break;
}
}
while (parent);
set_parent (node, node_type ());
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rootless_splay_tree<Accessors>::splay_known_min_node (node_type node)
{
splay_known_limit<0> (node);
}
// See the comment above the declaration.
template<typename Accessors>
inline void
rootless_splay_tree<Accessors>::splay_known_max_node (node_type node)
{
splay_known_limit<1> (node);
}
// See the comment above the declaration.
template<typename Accessors>
template<typename DefaultResult, typename Predicate>
auto
rootless_splay_tree<Accessors>::
splay_and_search (node_type node, DefaultResult default_result,
Predicate predicate)
-> decltype (predicate (node, 0))
{
using Result = decltype (predicate (node, 0));
node_type child = node;
node_type parent = get_parent (child);
if (!parent)
return default_result;
do
{
// At this point, NODE conceptually replaces CHILD as a child of
// PARENT, but we haven't yet updated PARENT accordingly.
unsigned int index = child_index (parent, child);
if (Result result = predicate (parent, index))
{
set_child (parent, index, node);
return result;
}
if (node_type grandparent = get_parent (parent))
{
node_type greatgrandparent = get_parent (grandparent);
unsigned int parent_index = child_index (grandparent, parent);
if (Result result = predicate (grandparent, parent_index))
{
set_child (parent, index, node);
return result;
}
if (index == parent_index)
{
promote_child (grandparent, parent_index, parent);
promote_child (parent, index, node);
}
else
{
promote_child (parent, index, node);
promote_child (grandparent, parent_index, node);
}
child = grandparent;
parent = greatgrandparent;
}
else
{
promote_child (parent, index, node);
break;
}
}
while (parent);
set_parent (node, node_type ());
return default_result;
}
// Splay NODE1 looking to see if one of its ancestors is NODE2. If it is,
// return -1 if NODE1 comes before NODE2 or 1 if NODE1 comes after NODE2.
// Return 0 if NODE2 is not an ancestor of NODE1.
template<typename Accessors>
int
rootless_splay_tree<Accessors>::compare_nodes_one_way (node_type node1,
node_type node2)
{
auto compare = [&](node_type parent, unsigned int index) -> int
{
if (parent == node2)
return index ? 1 : -1;
return 0;
};
return splay_and_search (node1, 0, compare);
}
// See the comment above the declaration.
template<typename Accessors>
int
rootless_splay_tree<Accessors>::compare_nodes (node_type node1,
node_type node2)
{
if (node1 == node2)
return 0;
// Splay NODE1 looking for NODE2.
int cmp = compare_nodes_one_way (node1, node2);
if (cmp)
return cmp;
// That failed, but NODE1 is now the root of the tree. Splay NODE2
// to see on which side of NODE1 it falls.
cmp = compare_nodes_one_way (node2, node1);
gcc_checking_assert (cmp);
return -cmp;
}