OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [et-forest.c] - Diff between revs 154 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 154 Rev 816
/* ET-trees data structure implementation.
/* ET-trees data structure implementation.
   Contributed by Pavel Nejedly
   Contributed by Pavel Nejedly
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
 
 
This file is part of the libiberty library.
This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.
version 3 of the License, or (at your option) any later version.
 
 
Libiberty is distributed in the hope that it will be useful,
Libiberty is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.
Library General Public License for more details.
 
 
You should have received a copy of the GNU Library General Public
You should have received a copy of the GNU Library General Public
License along with libiberty; see the file COPYING3.  If not see
License along with libiberty; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.
<http://www.gnu.org/licenses/>.
 
 
  The ET-forest structure is described in:
  The ET-forest structure is described in:
    D. D. Sleator and R. E. Tarjan. A data structure for dynamic trees.
    D. D. Sleator and R. E. Tarjan. A data structure for dynamic trees.
    J.  G'omput. System Sci., 26(3):362 381, 1983.
    J.  G'omput. System Sci., 26(3):362 381, 1983.
*/
*/
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "tm.h"
#include "tm.h"
#include "et-forest.h"
#include "et-forest.h"
#include "alloc-pool.h"
#include "alloc-pool.h"
 
 
/* We do not enable this with ENABLE_CHECKING, since it is awfully slow.  */
/* We do not enable this with ENABLE_CHECKING, since it is awfully slow.  */
#undef DEBUG_ET
#undef DEBUG_ET
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
#include "basic-block.h"
#include "basic-block.h"
#endif
#endif
 
 
/* The occurrence of a node in the et tree.  */
/* The occurrence of a node in the et tree.  */
struct et_occ
struct et_occ
{
{
  struct et_node *of;           /* The node.  */
  struct et_node *of;           /* The node.  */
 
 
  struct et_occ *parent;        /* Parent in the splay-tree.  */
  struct et_occ *parent;        /* Parent in the splay-tree.  */
  struct et_occ *prev;          /* Left son in the splay-tree.  */
  struct et_occ *prev;          /* Left son in the splay-tree.  */
  struct et_occ *next;          /* Right son in the splay-tree.  */
  struct et_occ *next;          /* Right son in the splay-tree.  */
 
 
  int depth;                    /* The depth of the node is the sum of depth
  int depth;                    /* The depth of the node is the sum of depth
                                   fields on the path to the root.  */
                                   fields on the path to the root.  */
  int min;                      /* The minimum value of the depth in the subtree
  int min;                      /* The minimum value of the depth in the subtree
                                   is obtained by adding sum of depth fields
                                   is obtained by adding sum of depth fields
                                   on the path to the root.  */
                                   on the path to the root.  */
  struct et_occ *min_occ;       /* The occurrence in the subtree with the minimal
  struct et_occ *min_occ;       /* The occurrence in the subtree with the minimal
                                   depth.  */
                                   depth.  */
};
};
 
 
static alloc_pool et_nodes;
static alloc_pool et_nodes;
static alloc_pool et_occurrences;
static alloc_pool et_occurrences;
 
 
/* Changes depth of OCC to D.  */
/* Changes depth of OCC to D.  */
 
 
static inline void
static inline void
set_depth (struct et_occ *occ, int d)
set_depth (struct et_occ *occ, int d)
{
{
  if (!occ)
  if (!occ)
    return;
    return;
 
 
  occ->min += d - occ->depth;
  occ->min += d - occ->depth;
  occ->depth = d;
  occ->depth = d;
}
}
 
 
/* Adds D to the depth of OCC.  */
/* Adds D to the depth of OCC.  */
 
 
static inline void
static inline void
set_depth_add (struct et_occ *occ, int d)
set_depth_add (struct et_occ *occ, int d)
{
{
  if (!occ)
  if (!occ)
    return;
    return;
 
 
  occ->min += d;
  occ->min += d;
  occ->depth += d;
  occ->depth += d;
}
}
 
 
/* Sets prev field of OCC to P.  */
/* Sets prev field of OCC to P.  */
 
 
static inline void
static inline void
set_prev (struct et_occ *occ, struct et_occ *t)
set_prev (struct et_occ *occ, struct et_occ *t)
{
{
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  gcc_assert (occ != t);
  gcc_assert (occ != t);
#endif
#endif
 
 
  occ->prev = t;
  occ->prev = t;
  if (t)
  if (t)
    t->parent = occ;
    t->parent = occ;
}
}
 
 
/* Sets next field of OCC to P.  */
/* Sets next field of OCC to P.  */
 
 
static inline void
static inline void
set_next (struct et_occ *occ, struct et_occ *t)
set_next (struct et_occ *occ, struct et_occ *t)
{
{
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  gcc_assert (occ != t);
  gcc_assert (occ != t);
#endif
#endif
 
 
  occ->next = t;
  occ->next = t;
  if (t)
  if (t)
    t->parent = occ;
    t->parent = occ;
}
}
 
 
/* Recompute minimum for occurrence OCC.  */
/* Recompute minimum for occurrence OCC.  */
 
 
static inline void
static inline void
et_recomp_min (struct et_occ *occ)
et_recomp_min (struct et_occ *occ)
{
{
  struct et_occ *mson = occ->prev;
  struct et_occ *mson = occ->prev;
 
 
  if (!mson
  if (!mson
      || (occ->next
      || (occ->next
          && mson->min > occ->next->min))
          && mson->min > occ->next->min))
      mson = occ->next;
      mson = occ->next;
 
 
  if (mson && mson->min < 0)
  if (mson && mson->min < 0)
    {
    {
      occ->min = mson->min + occ->depth;
      occ->min = mson->min + occ->depth;
      occ->min_occ = mson->min_occ;
      occ->min_occ = mson->min_occ;
    }
    }
  else
  else
    {
    {
      occ->min = occ->depth;
      occ->min = occ->depth;
      occ->min_occ = occ;
      occ->min_occ = occ;
    }
    }
}
}
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
/* Checks whether neighborhood of OCC seems sane.  */
/* Checks whether neighborhood of OCC seems sane.  */
 
 
static void
static void
et_check_occ_sanity (struct et_occ *occ)
et_check_occ_sanity (struct et_occ *occ)
{
{
  if (!occ)
  if (!occ)
    return;
    return;
 
 
  gcc_assert (occ->parent != occ);
  gcc_assert (occ->parent != occ);
  gcc_assert (occ->prev != occ);
  gcc_assert (occ->prev != occ);
  gcc_assert (occ->next != occ);
  gcc_assert (occ->next != occ);
  gcc_assert (!occ->next || occ->next != occ->prev);
  gcc_assert (!occ->next || occ->next != occ->prev);
 
 
  if (occ->next)
  if (occ->next)
    {
    {
      gcc_assert (occ->next != occ->parent);
      gcc_assert (occ->next != occ->parent);
      gcc_assert (occ->next->parent == occ);
      gcc_assert (occ->next->parent == occ);
    }
    }
 
 
  if (occ->prev)
  if (occ->prev)
    {
    {
      gcc_assert (occ->prev != occ->parent);
      gcc_assert (occ->prev != occ->parent);
      gcc_assert (occ->prev->parent == occ);
      gcc_assert (occ->prev->parent == occ);
    }
    }
 
 
  gcc_assert (!occ->parent
  gcc_assert (!occ->parent
              || occ->parent->prev == occ
              || occ->parent->prev == occ
              || occ->parent->next == occ);
              || occ->parent->next == occ);
}
}
 
 
/* Checks whether tree rooted at OCC is sane.  */
/* Checks whether tree rooted at OCC is sane.  */
 
 
static void
static void
et_check_sanity (struct et_occ *occ)
et_check_sanity (struct et_occ *occ)
{
{
  et_check_occ_sanity (occ);
  et_check_occ_sanity (occ);
  if (occ->prev)
  if (occ->prev)
    et_check_sanity (occ->prev);
    et_check_sanity (occ->prev);
  if (occ->next)
  if (occ->next)
    et_check_sanity (occ->next);
    et_check_sanity (occ->next);
}
}
 
 
/* Checks whether tree containing OCC is sane.  */
/* Checks whether tree containing OCC is sane.  */
 
 
static void
static void
et_check_tree_sanity (struct et_occ *occ)
et_check_tree_sanity (struct et_occ *occ)
{
{
  while (occ->parent)
  while (occ->parent)
    occ = occ->parent;
    occ = occ->parent;
 
 
  et_check_sanity (occ);
  et_check_sanity (occ);
}
}
 
 
/* For recording the paths.  */
/* For recording the paths.  */
 
 
/* An ad-hoc constant; if the function has more blocks, this won't work,
/* An ad-hoc constant; if the function has more blocks, this won't work,
   but since it is used for debugging only, it does not matter.  */
   but since it is used for debugging only, it does not matter.  */
#define MAX_NODES 100000
#define MAX_NODES 100000
 
 
static int len;
static int len;
static void *datas[MAX_NODES];
static void *datas[MAX_NODES];
static int depths[MAX_NODES];
static int depths[MAX_NODES];
 
 
/* Records the path represented by OCC, with depth incremented by DEPTH.  */
/* Records the path represented by OCC, with depth incremented by DEPTH.  */
 
 
static int
static int
record_path_before_1 (struct et_occ *occ, int depth)
record_path_before_1 (struct et_occ *occ, int depth)
{
{
  int mn, m;
  int mn, m;
 
 
  depth += occ->depth;
  depth += occ->depth;
  mn = depth;
  mn = depth;
 
 
  if (occ->prev)
  if (occ->prev)
    {
    {
      m = record_path_before_1 (occ->prev, depth);
      m = record_path_before_1 (occ->prev, depth);
      if (m < mn)
      if (m < mn)
        mn = m;
        mn = m;
    }
    }
 
 
  fprintf (stderr, "%d (%d); ", ((basic_block) occ->of->data)->index, depth);
  fprintf (stderr, "%d (%d); ", ((basic_block) occ->of->data)->index, depth);
 
 
  gcc_assert (len < MAX_NODES);
  gcc_assert (len < MAX_NODES);
 
 
  depths[len] = depth;
  depths[len] = depth;
  datas[len] = occ->of;
  datas[len] = occ->of;
  len++;
  len++;
 
 
  if (occ->next)
  if (occ->next)
    {
    {
      m = record_path_before_1 (occ->next, depth);
      m = record_path_before_1 (occ->next, depth);
      if (m < mn)
      if (m < mn)
        mn = m;
        mn = m;
    }
    }
 
 
  gcc_assert (mn == occ->min + depth - occ->depth);
  gcc_assert (mn == occ->min + depth - occ->depth);
 
 
  return mn;
  return mn;
}
}
 
 
/* Records the path represented by a tree containing OCC.  */
/* Records the path represented by a tree containing OCC.  */
 
 
static void
static void
record_path_before (struct et_occ *occ)
record_path_before (struct et_occ *occ)
{
{
  while (occ->parent)
  while (occ->parent)
    occ = occ->parent;
    occ = occ->parent;
 
 
  len = 0;
  len = 0;
  record_path_before_1 (occ, 0);
  record_path_before_1 (occ, 0);
  fprintf (stderr, "\n");
  fprintf (stderr, "\n");
}
}
 
 
/* Checks whether the path represented by OCC, with depth incremented by DEPTH,
/* Checks whether the path represented by OCC, with depth incremented by DEPTH,
   was not changed since the last recording.  */
   was not changed since the last recording.  */
 
 
static int
static int
check_path_after_1 (struct et_occ *occ, int depth)
check_path_after_1 (struct et_occ *occ, int depth)
{
{
  int mn, m;
  int mn, m;
 
 
  depth += occ->depth;
  depth += occ->depth;
  mn = depth;
  mn = depth;
 
 
  if (occ->next)
  if (occ->next)
    {
    {
      m = check_path_after_1 (occ->next, depth);
      m = check_path_after_1 (occ->next, depth);
      if (m < mn)
      if (m < mn)
        mn =  m;
        mn =  m;
    }
    }
 
 
  len--;
  len--;
  gcc_assert (depths[len] == depth && datas[len] == occ->of);
  gcc_assert (depths[len] == depth && datas[len] == occ->of);
 
 
  if (occ->prev)
  if (occ->prev)
    {
    {
      m = check_path_after_1 (occ->prev, depth);
      m = check_path_after_1 (occ->prev, depth);
      if (m < mn)
      if (m < mn)
        mn =  m;
        mn =  m;
    }
    }
 
 
  gcc_assert (mn == occ->min + depth - occ->depth);
  gcc_assert (mn == occ->min + depth - occ->depth);
 
 
  return mn;
  return mn;
}
}
 
 
/* Checks whether the path represented by a tree containing OCC was
/* Checks whether the path represented by a tree containing OCC was
   not changed since the last recording.  */
   not changed since the last recording.  */
 
 
static void
static void
check_path_after (struct et_occ *occ)
check_path_after (struct et_occ *occ)
{
{
  while (occ->parent)
  while (occ->parent)
    occ = occ->parent;
    occ = occ->parent;
 
 
  check_path_after_1 (occ, 0);
  check_path_after_1 (occ, 0);
  gcc_assert (!len);
  gcc_assert (!len);
}
}
 
 
#endif
#endif
 
 
/* Splay the occurrence OCC to the root of the tree.  */
/* Splay the occurrence OCC to the root of the tree.  */
 
 
static void
static void
et_splay (struct et_occ *occ)
et_splay (struct et_occ *occ)
{
{
  struct et_occ *f, *gf, *ggf;
  struct et_occ *f, *gf, *ggf;
  int occ_depth, f_depth, gf_depth;
  int occ_depth, f_depth, gf_depth;
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  record_path_before (occ);
  record_path_before (occ);
  et_check_tree_sanity (occ);
  et_check_tree_sanity (occ);
#endif
#endif
 
 
  while (occ->parent)
  while (occ->parent)
    {
    {
      occ_depth = occ->depth;
      occ_depth = occ->depth;
 
 
      f = occ->parent;
      f = occ->parent;
      f_depth = f->depth;
      f_depth = f->depth;
 
 
      gf = f->parent;
      gf = f->parent;
 
 
      if (!gf)
      if (!gf)
        {
        {
          set_depth_add (occ, f_depth);
          set_depth_add (occ, f_depth);
          occ->min_occ = f->min_occ;
          occ->min_occ = f->min_occ;
          occ->min = f->min;
          occ->min = f->min;
 
 
          if (f->prev == occ)
          if (f->prev == occ)
            {
            {
              /* zig */
              /* zig */
              set_prev (f, occ->next);
              set_prev (f, occ->next);
              set_next (occ, f);
              set_next (occ, f);
              set_depth_add (f->prev, occ_depth);
              set_depth_add (f->prev, occ_depth);
            }
            }
          else
          else
            {
            {
              /* zag */
              /* zag */
              set_next (f, occ->prev);
              set_next (f, occ->prev);
              set_prev (occ, f);
              set_prev (occ, f);
              set_depth_add (f->next, occ_depth);
              set_depth_add (f->next, occ_depth);
            }
            }
          set_depth (f, -occ_depth);
          set_depth (f, -occ_depth);
          occ->parent = NULL;
          occ->parent = NULL;
 
 
          et_recomp_min (f);
          et_recomp_min (f);
#ifdef DEBUG_ET
#ifdef DEBUG_ET
          et_check_tree_sanity (occ);
          et_check_tree_sanity (occ);
          check_path_after (occ);
          check_path_after (occ);
#endif
#endif
          return;
          return;
        }
        }
 
 
      gf_depth = gf->depth;
      gf_depth = gf->depth;
 
 
      set_depth_add (occ, f_depth + gf_depth);
      set_depth_add (occ, f_depth + gf_depth);
      occ->min_occ = gf->min_occ;
      occ->min_occ = gf->min_occ;
      occ->min = gf->min;
      occ->min = gf->min;
 
 
      ggf = gf->parent;
      ggf = gf->parent;
 
 
      if (gf->prev == f)
      if (gf->prev == f)
        {
        {
          if (f->prev == occ)
          if (f->prev == occ)
            {
            {
              /* zig zig */
              /* zig zig */
              set_prev (gf, f->next);
              set_prev (gf, f->next);
              set_prev (f, occ->next);
              set_prev (f, occ->next);
              set_next (occ, f);
              set_next (occ, f);
              set_next (f, gf);
              set_next (f, gf);
 
 
              set_depth (f, -occ_depth);
              set_depth (f, -occ_depth);
              set_depth_add (f->prev, occ_depth);
              set_depth_add (f->prev, occ_depth);
              set_depth (gf, -f_depth);
              set_depth (gf, -f_depth);
              set_depth_add (gf->prev, f_depth);
              set_depth_add (gf->prev, f_depth);
            }
            }
          else
          else
            {
            {
              /* zag zig */
              /* zag zig */
              set_prev (gf, occ->next);
              set_prev (gf, occ->next);
              set_next (f, occ->prev);
              set_next (f, occ->prev);
              set_prev (occ, f);
              set_prev (occ, f);
              set_next (occ, gf);
              set_next (occ, gf);
 
 
              set_depth (f, -occ_depth);
              set_depth (f, -occ_depth);
              set_depth_add (f->next, occ_depth);
              set_depth_add (f->next, occ_depth);
              set_depth (gf, -occ_depth - f_depth);
              set_depth (gf, -occ_depth - f_depth);
              set_depth_add (gf->prev, occ_depth + f_depth);
              set_depth_add (gf->prev, occ_depth + f_depth);
            }
            }
        }
        }
      else
      else
        {
        {
          if (f->prev == occ)
          if (f->prev == occ)
            {
            {
              /* zig zag */
              /* zig zag */
              set_next (gf, occ->prev);
              set_next (gf, occ->prev);
              set_prev (f, occ->next);
              set_prev (f, occ->next);
              set_prev (occ, gf);
              set_prev (occ, gf);
              set_next (occ, f);
              set_next (occ, f);
 
 
              set_depth (f, -occ_depth);
              set_depth (f, -occ_depth);
              set_depth_add (f->prev, occ_depth);
              set_depth_add (f->prev, occ_depth);
              set_depth (gf, -occ_depth - f_depth);
              set_depth (gf, -occ_depth - f_depth);
              set_depth_add (gf->next, occ_depth + f_depth);
              set_depth_add (gf->next, occ_depth + f_depth);
            }
            }
          else
          else
            {
            {
              /* zag zag */
              /* zag zag */
              set_next (gf, f->prev);
              set_next (gf, f->prev);
              set_next (f, occ->prev);
              set_next (f, occ->prev);
              set_prev (occ, f);
              set_prev (occ, f);
              set_prev (f, gf);
              set_prev (f, gf);
 
 
              set_depth (f, -occ_depth);
              set_depth (f, -occ_depth);
              set_depth_add (f->next, occ_depth);
              set_depth_add (f->next, occ_depth);
              set_depth (gf, -f_depth);
              set_depth (gf, -f_depth);
              set_depth_add (gf->next, f_depth);
              set_depth_add (gf->next, f_depth);
            }
            }
        }
        }
 
 
      occ->parent = ggf;
      occ->parent = ggf;
      if (ggf)
      if (ggf)
        {
        {
          if (ggf->prev == gf)
          if (ggf->prev == gf)
            ggf->prev = occ;
            ggf->prev = occ;
          else
          else
            ggf->next = occ;
            ggf->next = occ;
        }
        }
 
 
      et_recomp_min (gf);
      et_recomp_min (gf);
      et_recomp_min (f);
      et_recomp_min (f);
#ifdef DEBUG_ET
#ifdef DEBUG_ET
      et_check_tree_sanity (occ);
      et_check_tree_sanity (occ);
#endif
#endif
    }
    }
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  et_check_sanity (occ);
  et_check_sanity (occ);
  check_path_after (occ);
  check_path_after (occ);
#endif
#endif
}
}
 
 
/* Create a new et tree occurrence of NODE.  */
/* Create a new et tree occurrence of NODE.  */
 
 
static struct et_occ *
static struct et_occ *
et_new_occ (struct et_node *node)
et_new_occ (struct et_node *node)
{
{
  struct et_occ *nw;
  struct et_occ *nw;
 
 
  if (!et_occurrences)
  if (!et_occurrences)
    et_occurrences = create_alloc_pool ("et_occ pool", sizeof (struct et_occ), 300);
    et_occurrences = create_alloc_pool ("et_occ pool", sizeof (struct et_occ), 300);
  nw = pool_alloc (et_occurrences);
  nw = pool_alloc (et_occurrences);
 
 
  nw->of = node;
  nw->of = node;
  nw->parent = NULL;
  nw->parent = NULL;
  nw->prev = NULL;
  nw->prev = NULL;
  nw->next = NULL;
  nw->next = NULL;
 
 
  nw->depth = 0;
  nw->depth = 0;
  nw->min_occ = nw;
  nw->min_occ = nw;
  nw->min = 0;
  nw->min = 0;
 
 
  return nw;
  return nw;
}
}
 
 
/* Create a new et tree containing DATA.  */
/* Create a new et tree containing DATA.  */
 
 
struct et_node *
struct et_node *
et_new_tree (void *data)
et_new_tree (void *data)
{
{
  struct et_node *nw;
  struct et_node *nw;
 
 
  if (!et_nodes)
  if (!et_nodes)
    et_nodes = create_alloc_pool ("et_node pool", sizeof (struct et_node), 300);
    et_nodes = create_alloc_pool ("et_node pool", sizeof (struct et_node), 300);
  nw = pool_alloc (et_nodes);
  nw = pool_alloc (et_nodes);
 
 
  nw->data = data;
  nw->data = data;
  nw->father = NULL;
  nw->father = NULL;
  nw->left = NULL;
  nw->left = NULL;
  nw->right = NULL;
  nw->right = NULL;
  nw->son = NULL;
  nw->son = NULL;
 
 
  nw->rightmost_occ = et_new_occ (nw);
  nw->rightmost_occ = et_new_occ (nw);
  nw->parent_occ = NULL;
  nw->parent_occ = NULL;
 
 
  return nw;
  return nw;
}
}
 
 
/* Releases et tree T.  */
/* Releases et tree T.  */
 
 
void
void
et_free_tree (struct et_node *t)
et_free_tree (struct et_node *t)
{
{
  while (t->son)
  while (t->son)
    et_split (t->son);
    et_split (t->son);
 
 
  if (t->father)
  if (t->father)
    et_split (t);
    et_split (t);
 
 
  pool_free (et_occurrences, t->rightmost_occ);
  pool_free (et_occurrences, t->rightmost_occ);
  pool_free (et_nodes, t);
  pool_free (et_nodes, t);
}
}
 
 
/* Releases et tree T without maintaining other nodes.  */
/* Releases et tree T without maintaining other nodes.  */
 
 
void
void
et_free_tree_force (struct et_node *t)
et_free_tree_force (struct et_node *t)
{
{
  pool_free (et_occurrences, t->rightmost_occ);
  pool_free (et_occurrences, t->rightmost_occ);
  if (t->parent_occ)
  if (t->parent_occ)
    pool_free (et_occurrences, t->parent_occ);
    pool_free (et_occurrences, t->parent_occ);
  pool_free (et_nodes, t);
  pool_free (et_nodes, t);
}
}
 
 
/* Release the alloc pools, if they are empty.  */
/* Release the alloc pools, if they are empty.  */
 
 
void
void
et_free_pools (void)
et_free_pools (void)
{
{
  free_alloc_pool_if_empty (&et_occurrences);
  free_alloc_pool_if_empty (&et_occurrences);
  free_alloc_pool_if_empty (&et_nodes);
  free_alloc_pool_if_empty (&et_nodes);
}
}
 
 
/* Sets father of et tree T to FATHER.  */
/* Sets father of et tree T to FATHER.  */
 
 
void
void
et_set_father (struct et_node *t, struct et_node *father)
et_set_father (struct et_node *t, struct et_node *father)
{
{
  struct et_node *left, *right;
  struct et_node *left, *right;
  struct et_occ *rmost, *left_part, *new_f_occ, *p;
  struct et_occ *rmost, *left_part, *new_f_occ, *p;
 
 
  /* Update the path represented in the splay tree.  */
  /* Update the path represented in the splay tree.  */
  new_f_occ = et_new_occ (father);
  new_f_occ = et_new_occ (father);
 
 
  rmost = father->rightmost_occ;
  rmost = father->rightmost_occ;
  et_splay (rmost);
  et_splay (rmost);
 
 
  left_part = rmost->prev;
  left_part = rmost->prev;
 
 
  p = t->rightmost_occ;
  p = t->rightmost_occ;
  et_splay (p);
  et_splay (p);
 
 
  set_prev (new_f_occ, left_part);
  set_prev (new_f_occ, left_part);
  set_next (new_f_occ, p);
  set_next (new_f_occ, p);
 
 
  p->depth++;
  p->depth++;
  p->min++;
  p->min++;
  et_recomp_min (new_f_occ);
  et_recomp_min (new_f_occ);
 
 
  set_prev (rmost, new_f_occ);
  set_prev (rmost, new_f_occ);
 
 
  if (new_f_occ->min + rmost->depth < rmost->min)
  if (new_f_occ->min + rmost->depth < rmost->min)
    {
    {
      rmost->min = new_f_occ->min + rmost->depth;
      rmost->min = new_f_occ->min + rmost->depth;
      rmost->min_occ = new_f_occ->min_occ;
      rmost->min_occ = new_f_occ->min_occ;
    }
    }
 
 
  t->parent_occ = new_f_occ;
  t->parent_occ = new_f_occ;
 
 
  /* Update the tree.  */
  /* Update the tree.  */
  t->father = father;
  t->father = father;
  right = father->son;
  right = father->son;
  if (right)
  if (right)
    left = right->left;
    left = right->left;
  else
  else
    left = right = t;
    left = right = t;
 
 
  left->right = t;
  left->right = t;
  right->left = t;
  right->left = t;
  t->left = left;
  t->left = left;
  t->right = right;
  t->right = right;
 
 
  father->son = t;
  father->son = t;
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  et_check_tree_sanity (rmost);
  et_check_tree_sanity (rmost);
  record_path_before (rmost);
  record_path_before (rmost);
#endif
#endif
}
}
 
 
/* Splits the edge from T to its father.  */
/* Splits the edge from T to its father.  */
 
 
void
void
et_split (struct et_node *t)
et_split (struct et_node *t)
{
{
  struct et_node *father = t->father;
  struct et_node *father = t->father;
  struct et_occ *r, *l, *rmost, *p_occ;
  struct et_occ *r, *l, *rmost, *p_occ;
 
 
  /* Update the path represented by the splay tree.  */
  /* Update the path represented by the splay tree.  */
  rmost = t->rightmost_occ;
  rmost = t->rightmost_occ;
  et_splay (rmost);
  et_splay (rmost);
 
 
  for (r = rmost->next; r->prev; r = r->prev)
  for (r = rmost->next; r->prev; r = r->prev)
    continue;
    continue;
  et_splay (r);
  et_splay (r);
 
 
  r->prev->parent = NULL;
  r->prev->parent = NULL;
  p_occ = t->parent_occ;
  p_occ = t->parent_occ;
  et_splay (p_occ);
  et_splay (p_occ);
  t->parent_occ = NULL;
  t->parent_occ = NULL;
 
 
  l = p_occ->prev;
  l = p_occ->prev;
  p_occ->next->parent = NULL;
  p_occ->next->parent = NULL;
 
 
  set_prev (r, l);
  set_prev (r, l);
 
 
  et_recomp_min (r);
  et_recomp_min (r);
 
 
  et_splay (rmost);
  et_splay (rmost);
  rmost->depth = 0;
  rmost->depth = 0;
  rmost->min = 0;
  rmost->min = 0;
 
 
  pool_free (et_occurrences, p_occ);
  pool_free (et_occurrences, p_occ);
 
 
  /* Update the tree.  */
  /* Update the tree.  */
  if (father->son == t)
  if (father->son == t)
    father->son = t->right;
    father->son = t->right;
  if (father->son == t)
  if (father->son == t)
    father->son = NULL;
    father->son = NULL;
  else
  else
    {
    {
      t->left->right = t->right;
      t->left->right = t->right;
      t->right->left = t->left;
      t->right->left = t->left;
    }
    }
  t->left = t->right = NULL;
  t->left = t->right = NULL;
  t->father = NULL;
  t->father = NULL;
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  et_check_tree_sanity (rmost);
  et_check_tree_sanity (rmost);
  record_path_before (rmost);
  record_path_before (rmost);
 
 
  et_check_tree_sanity (r);
  et_check_tree_sanity (r);
  record_path_before (r);
  record_path_before (r);
#endif
#endif
}
}
 
 
/* Finds the nearest common ancestor of the nodes N1 and N2.  */
/* Finds the nearest common ancestor of the nodes N1 and N2.  */
 
 
struct et_node *
struct et_node *
et_nca (struct et_node *n1, struct et_node *n2)
et_nca (struct et_node *n1, struct et_node *n2)
{
{
  struct et_occ *o1 = n1->rightmost_occ, *o2 = n2->rightmost_occ, *om;
  struct et_occ *o1 = n1->rightmost_occ, *o2 = n2->rightmost_occ, *om;
  struct et_occ *l, *r, *ret;
  struct et_occ *l, *r, *ret;
  int mn;
  int mn;
 
 
  if (n1 == n2)
  if (n1 == n2)
    return n1;
    return n1;
 
 
  et_splay (o1);
  et_splay (o1);
  l = o1->prev;
  l = o1->prev;
  r = o1->next;
  r = o1->next;
  if (l)
  if (l)
    l->parent = NULL;
    l->parent = NULL;
  if (r)
  if (r)
    r->parent = NULL;
    r->parent = NULL;
  et_splay (o2);
  et_splay (o2);
 
 
  if (l == o2 || (l && l->parent != NULL))
  if (l == o2 || (l && l->parent != NULL))
    {
    {
      ret = o2->next;
      ret = o2->next;
 
 
      set_prev (o1, o2);
      set_prev (o1, o2);
      if (r)
      if (r)
        r->parent = o1;
        r->parent = o1;
    }
    }
  else
  else
    {
    {
      ret = o2->prev;
      ret = o2->prev;
 
 
      set_next (o1, o2);
      set_next (o1, o2);
      if (l)
      if (l)
        l->parent = o1;
        l->parent = o1;
    }
    }
 
 
  if (0 < o2->depth)
  if (0 < o2->depth)
    {
    {
      om = o1;
      om = o1;
      mn = o1->depth;
      mn = o1->depth;
    }
    }
  else
  else
    {
    {
      om = o2;
      om = o2;
      mn = o2->depth + o1->depth;
      mn = o2->depth + o1->depth;
    }
    }
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
  et_check_tree_sanity (o2);
  et_check_tree_sanity (o2);
#endif
#endif
 
 
  if (ret && ret->min + o1->depth + o2->depth < mn)
  if (ret && ret->min + o1->depth + o2->depth < mn)
    return ret->min_occ->of;
    return ret->min_occ->of;
  else
  else
    return om->of;
    return om->of;
}
}
 
 
/* Checks whether the node UP is an ancestor of the node DOWN.  */
/* Checks whether the node UP is an ancestor of the node DOWN.  */
 
 
bool
bool
et_below (struct et_node *down, struct et_node *up)
et_below (struct et_node *down, struct et_node *up)
{
{
  struct et_occ *u = up->rightmost_occ, *d = down->rightmost_occ;
  struct et_occ *u = up->rightmost_occ, *d = down->rightmost_occ;
  struct et_occ *l, *r;
  struct et_occ *l, *r;
 
 
  if (up == down)
  if (up == down)
    return true;
    return true;
 
 
  et_splay (u);
  et_splay (u);
  l = u->prev;
  l = u->prev;
  r = u->next;
  r = u->next;
 
 
  if (!l)
  if (!l)
    return false;
    return false;
 
 
  l->parent = NULL;
  l->parent = NULL;
 
 
  if (r)
  if (r)
    r->parent = NULL;
    r->parent = NULL;
 
 
  et_splay (d);
  et_splay (d);
 
 
  if (l == d || l->parent != NULL)
  if (l == d || l->parent != NULL)
    {
    {
      if (r)
      if (r)
        r->parent = u;
        r->parent = u;
      set_prev (u, d);
      set_prev (u, d);
#ifdef DEBUG_ET
#ifdef DEBUG_ET
      et_check_tree_sanity (u);
      et_check_tree_sanity (u);
#endif
#endif
    }
    }
  else
  else
    {
    {
      l->parent = u;
      l->parent = u;
 
 
      /* In case O1 and O2 are in two different trees, we must just restore the
      /* In case O1 and O2 are in two different trees, we must just restore the
         original state.  */
         original state.  */
      if (r && r->parent != NULL)
      if (r && r->parent != NULL)
        set_next (u, d);
        set_next (u, d);
      else
      else
        set_next (u, r);
        set_next (u, r);
 
 
#ifdef DEBUG_ET
#ifdef DEBUG_ET
      et_check_tree_sanity (u);
      et_check_tree_sanity (u);
#endif
#endif
      return false;
      return false;
    }
    }
 
 
  if (0 >= d->depth)
  if (0 >= d->depth)
    return false;
    return false;
 
 
  return !d->next || d->next->min + d->depth >= 0;
  return !d->next || d->next->min + d->depth >= 0;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.