Subversion Repositories scarts

/* Alias analysis for trees.

   Copyright (C) 2004, 2005 Free Software Foundation, Inc.

   Contributed by Diego Novillo <dnovillo@redhat.com>

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 2, 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 COPYING.  If not, write to

the Free Software Foundation, 51 Franklin Street, Fifth Floor,

Boston, MA 02110-1301, USA.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "timevar.h"

#include "expr.h"

#include "ggc.h"

#include "langhooks.h"

#include "flags.h"

#include "function.h"

#include "diagnostic.h"

#include "tree-dump.h"

#include "tree-gimple.h"

#include "tree-flow.h"

#include "tree-inline.h"

#include "tree-pass.h"

#include "tree-ssa-structalias.h"

#include "convert.h"

#include "params.h"

#include "ipa-type-escape.h"

#include "vec.h"

#include "bitmap.h"

/* Obstack used to hold grouping bitmaps and other temporary bitmaps used by

   aliasing  */

static bitmap_obstack alias_obstack;

/* 'true' after aliases have been computed (see compute_may_aliases).  */

bool aliases_computed_p;

/* Structure to map a variable to its alias set and keep track of the

   virtual operands that will be needed to represent it.  */

struct alias_map_d

{

  /* Variable and its alias set.  */

  tree var;

  HOST_WIDE_INT set;

  /* Total number of virtual operands that will be needed to represent

     all the aliases of VAR.  */

  long total_alias_vops;

  /* Nonzero if the aliases for this memory tag have been grouped

     already.  Used in group_aliases.  */

  unsigned int grouped_p : 1;

  /* Set of variables aliased with VAR.  This is the exact same

     information contained in VAR_ANN (VAR)->MAY_ALIASES, but in

     bitmap form to speed up alias grouping.  */

  bitmap may_aliases;

};

/* Counters used to display statistics on alias analysis.  */

struct alias_stats_d

{

  unsigned int alias_queries;

  unsigned int alias_mayalias;

  unsigned int alias_noalias;

  unsigned int simple_queries;

  unsigned int simple_resolved;

  unsigned int tbaa_queries;

  unsigned int tbaa_resolved;

  unsigned int structnoaddress_queries;

  unsigned int structnoaddress_resolved;

};

/* Local variables.  */

static struct alias_stats_d alias_stats;

/* Local functions.  */

static void compute_flow_insensitive_aliasing (struct alias_info *);

static void dump_alias_stats (FILE *);

static bool may_alias_p (tree, HOST_WIDE_INT, tree, HOST_WIDE_INT, bool);

static tree create_memory_tag (tree type, bool is_type_tag);

static tree get_tmt_for (tree, struct alias_info *);

static tree get_nmt_for (tree);

static void add_may_alias (tree, tree);

static void replace_may_alias (tree, size_t, tree);

static struct alias_info *init_alias_info (void);

static void delete_alias_info (struct alias_info *);

static void compute_flow_sensitive_aliasing (struct alias_info *);

static void setup_pointers_and_addressables (struct alias_info *);

static void create_global_var (void);

static void maybe_create_global_var (struct alias_info *ai);

static void group_aliases (struct alias_info *);

static void set_pt_anything (tree ptr);

/* Global declarations.  */

/* Call clobbered variables in the function.  If bit I is set, then

   REFERENCED_VARS (I) is call-clobbered.  */

bitmap call_clobbered_vars;

/* Addressable variables in the function.  If bit I is set, then

   REFERENCED_VARS (I) has had its address taken.  Note that

   CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related.  An

   addressable variable is not necessarily call-clobbered (e.g., a

   local addressable whose address does not escape) and not all

   call-clobbered variables are addressable (e.g., a local static

   variable).  */

bitmap addressable_vars;

/* When the program has too many call-clobbered variables and call-sites,

   this variable is used to represent the clobbering effects of function

   calls.  In these cases, all the call clobbered variables in the program

   are forced to alias this variable.  This reduces compile times by not

   having to keep track of too many V_MAY_DEF expressions at call sites.  */

tree global_var;

/* Compute may-alias information for every variable referenced in function

   FNDECL.

   Alias analysis proceeds in 3 main phases:

   1- Points-to and escape analysis.

   This phase walks the use-def chains in the SSA web looking for three

   things:

        * Assignments of the form P_i = &VAR

        * Assignments of the form P_i = malloc()

        * Pointers and ADDR_EXPR that escape the current function.

   The concept of 'escaping' is the same one used in the Java world.  When

   a pointer or an ADDR_EXPR escapes, it means that it has been exposed

   outside of the current function.  So, assignment to global variables,

   function arguments and returning a pointer are all escape sites, as are

   conversions between pointers and integers.

   This is where we are currently limited.  Since not everything is renamed

   into SSA, we lose track of escape properties when a pointer is stashed

   inside a field in a structure, for instance.  In those cases, we are

   assuming that the pointer does escape.

   We use escape analysis to determine whether a variable is

   call-clobbered.  Simply put, if an ADDR_EXPR escapes, then the variable

   is call-clobbered.  If a pointer P_i escapes, then all the variables

   pointed-to by P_i (and its memory tag) also escape.

   2- Compute flow-sensitive aliases

   We have two classes of memory tags.  Memory tags associated with the

   pointed-to data type of the pointers in the program.  These tags are

   called "type memory tag" (TMT).  The other class are those associated

   with SSA_NAMEs, called "name memory tag" (NMT). The basic idea is that

   when adding operands for an INDIRECT_REF *P_i, we will first check

   whether P_i has a name tag, if it does we use it, because that will have

   more precise aliasing information.  Otherwise, we use the standard type

   tag.

   In this phase, we go through all the pointers we found in points-to

   analysis and create alias sets for the name memory tags associated with

   each pointer P_i.  If P_i escapes, we mark call-clobbered the variables

   it points to and its tag.

   3- Compute flow-insensitive aliases

   This pass will compare the alias set of every type memory tag and every

   addressable variable found in the program.  Given a type memory tag TMT

   and an addressable variable V.  If the alias sets of TMT and V conflict

   (as computed by may_alias_p), then V is marked as an alias tag and added

   to the alias set of TMT.

   For instance, consider the following function:

            foo (int i)

            {

              int *p, a, b;

              if (i > 10)

                p = &a;

              else

                p = &b;

              *p = 3;

              a = b + 2;

              return *p;

            }

   After aliasing analysis has finished, the type memory tag for pointer

   'p' will have two aliases, namely variables 'a' and 'b'.  Every time

   pointer 'p' is dereferenced, we want to mark the operation as a

   potential reference to 'a' and 'b'.

            foo (int i)

            {

              int *p, a, b;

              if (i_2 > 10)

                p_4 = &a;

              else

                p_6 = &b;

              # p_1 = PHI <p_4(1), p_6(2)>;

              # a_7 = V_MAY_DEF <a_3>;

              # b_8 = V_MAY_DEF <b_5>;

              *p_1 = 3;

              # a_9 = V_MAY_DEF <a_7>

              # VUSE <b_8>

              a_9 = b_8 + 2;

              # VUSE <a_9>;

              # VUSE <b_8>;

              return *p_1;

            }

   In certain cases, the list of may aliases for a pointer may grow too

   large.  This may cause an explosion in the number of virtual operands

   inserted in the code.  Resulting in increased memory consumption and

   compilation time.

   When the number of virtual operands needed to represent aliased

   loads and stores grows too large (configurable with @option{--param

   max-aliased-vops}), alias sets are grouped to avoid severe

   compile-time slow downs and memory consumption.  See group_aliases.  */

static void

compute_may_aliases (void)

{

  struct alias_info *ai;

  memset (&alias_stats, 0, sizeof (alias_stats));

  /* Initialize aliasing information.  */

  ai = init_alias_info ();

  /* For each pointer P_i, determine the sets of variables that P_i may

     point-to.  For every addressable variable V, determine whether the

     address of V escapes the current function, making V call-clobbered

     (i.e., whether &V is stored in a global variable or if its passed as a

     function call argument).  */

  compute_points_to_sets (ai);

  /* Collect all pointers and addressable variables, compute alias sets,

     create memory tags for pointers and promote variables whose address is

     not needed anymore.  */

  setup_pointers_and_addressables (ai);

  /* Compute flow-sensitive, points-to based aliasing for all the name

     memory tags.  Note that this pass needs to be done before flow

     insensitive analysis because it uses the points-to information

     gathered before to mark call-clobbered type tags.  */

  compute_flow_sensitive_aliasing (ai);

  /* Compute type-based flow-insensitive aliasing for all the type

     memory tags.  */

  compute_flow_insensitive_aliasing (ai);

  /* If the program has too many call-clobbered variables and/or function

     calls, create .GLOBAL_VAR and use it to model call-clobbering

     semantics at call sites.  This reduces the number of virtual operands

     considerably, improving compile times at the expense of lost

     aliasing precision.  */

  maybe_create_global_var (ai);

  /* Debugging dumps.  */

  if (dump_file)

    {

      dump_referenced_vars (dump_file);

      if (dump_flags & TDF_STATS)

        dump_alias_stats (dump_file);

      dump_points_to_info (dump_file);

      dump_alias_info (dump_file);

    }

  /* Deallocate memory used by aliasing data structures.  */

  delete_alias_info (ai);

  {

    block_stmt_iterator bsi;

    basic_block bb;

    FOR_EACH_BB (bb)

      {

        for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))

          {

            update_stmt_if_modified (bsi_stmt (bsi));

          }

      }

  }

}

struct tree_opt_pass pass_may_alias =

{

  "alias",                              /* name */

  NULL,                                 /* gate */

  compute_may_aliases,                  /* execute */

  NULL,                                 /* sub */

  NULL,                                 /* next */

  0,                                     /* static_pass_number */

  TV_TREE_MAY_ALIAS,                    /* tv_id */

  PROP_cfg | PROP_ssa,                  /* properties_required */

  PROP_alias,                           /* properties_provided */

  0,                                     /* properties_destroyed */

  0,                                     /* todo_flags_start */

  TODO_dump_func | TODO_update_ssa

    | TODO_ggc_collect | TODO_verify_ssa

    | TODO_verify_stmts,                /* todo_flags_finish */

};

/* Data structure used to count the number of dereferences to PTR

   inside an expression.  */

struct count_ptr_d

{

  tree ptr;

  unsigned count;

};

/* Helper for count_uses_and_derefs.  Called by walk_tree to look for

   (ALIGN/MISALIGNED_)INDIRECT_REF nodes for the pointer passed in DATA.  */

static tree

count_ptr_derefs (tree *tp, int *walk_subtrees, void *data)

{

  struct count_ptr_d *count_p = (struct count_ptr_d *) data;

  /* Do not walk inside ADDR_EXPR nodes.  In the expression &ptr->fld,

     pointer 'ptr' is *not* dereferenced, it is simply used to compute

     the address of 'fld' as 'ptr + offsetof(fld)'.  */

  if (TREE_CODE (*tp) == ADDR_EXPR)

    {

      *walk_subtrees = 0;

      return NULL_TREE;

    }

  if (INDIRECT_REF_P (*tp) && TREE_OPERAND (*tp, 0) == count_p->ptr)

    count_p->count++;

  return NULL_TREE;

}

/* Count the number of direct and indirect uses for pointer PTR in

   statement STMT.  The two counts are stored in *NUM_USES_P and

   *NUM_DEREFS_P respectively.  *IS_STORE_P is set to 'true' if at

   least one of those dereferences is a store operation.  */

void

count_uses_and_derefs (tree ptr, tree stmt, unsigned *num_uses_p,

                       unsigned *num_derefs_p, bool *is_store)

{

  ssa_op_iter i;

  tree use;

  *num_uses_p = 0;

  *num_derefs_p = 0;

  *is_store = false;

  /* Find out the total number of uses of PTR in STMT.  */

  FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)

    if (use == ptr)

      (*num_uses_p)++;

  /* Now count the number of indirect references to PTR.  This is

     truly awful, but we don't have much choice.  There are no parent

     pointers inside INDIRECT_REFs, so an expression like

     '*x_1 = foo (x_1, *x_1)' needs to be traversed piece by piece to

     find all the indirect and direct uses of x_1 inside.  The only

     shortcut we can take is the fact that GIMPLE only allows

     INDIRECT_REFs inside the expressions below.  */

  if (TREE_CODE (stmt) == MODIFY_EXPR

      || (TREE_CODE (stmt) == RETURN_EXPR

          && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)

      || TREE_CODE (stmt) == ASM_EXPR

      || TREE_CODE (stmt) == CALL_EXPR)

    {

      tree lhs, rhs;

      if (TREE_CODE (stmt) == MODIFY_EXPR)

        {

          lhs = TREE_OPERAND (stmt, 0);

          rhs = TREE_OPERAND (stmt, 1);

        }

      else if (TREE_CODE (stmt) == RETURN_EXPR)

        {

          tree e = TREE_OPERAND (stmt, 0);

          lhs = TREE_OPERAND (e, 0);

          rhs = TREE_OPERAND (e, 1);

        }

      else if (TREE_CODE (stmt) == ASM_EXPR)

        {

          lhs = ASM_OUTPUTS (stmt);

          rhs = ASM_INPUTS (stmt);

        }

      else

        {

          lhs = NULL_TREE;

          rhs = stmt;

        }

      if (lhs && (TREE_CODE (lhs) == TREE_LIST || EXPR_P (lhs)))

        {

          struct count_ptr_d count;

          count.ptr = ptr;

          count.count = 0;

          walk_tree (&lhs, count_ptr_derefs, &count, NULL);

          *is_store = true;

          *num_derefs_p = count.count;

        }

      if (rhs && (TREE_CODE (rhs) == TREE_LIST || EXPR_P (rhs)))

        {

          struct count_ptr_d count;

          count.ptr = ptr;

          count.count = 0;

          walk_tree (&rhs, count_ptr_derefs, &count, NULL);

          *num_derefs_p += count.count;

        }

    }

  gcc_assert (*num_uses_p >= *num_derefs_p);

}

/* Initialize the data structures used for alias analysis.  */

static struct alias_info *

init_alias_info (void)

{

  struct alias_info *ai;

  referenced_var_iterator rvi;

  tree var;

  bitmap_obstack_initialize (&alias_obstack);

  ai = xcalloc (1, sizeof (struct alias_info));

  ai->ssa_names_visited = sbitmap_alloc (num_ssa_names);

  sbitmap_zero (ai->ssa_names_visited);

  VARRAY_TREE_INIT (ai->processed_ptrs, 50, "processed_ptrs");

  ai->written_vars = BITMAP_ALLOC (&alias_obstack);

  ai->dereferenced_ptrs_store = BITMAP_ALLOC (&alias_obstack);

  ai->dereferenced_ptrs_load = BITMAP_ALLOC (&alias_obstack);

  /* If aliases have been computed before, clear existing information.  */

  if (aliases_computed_p)

    {

      unsigned i;

      /* Similarly, clear the set of addressable variables.  In this

         case, we can just clear the set because addressability is

         only computed here.  */

      bitmap_clear (addressable_vars);

      /* Clear flow-insensitive alias information from each symbol.  */

      FOR_EACH_REFERENCED_VAR (var, rvi)

        {

          var_ann_t ann = var_ann (var);

          ann->is_alias_tag = 0;

          ann->may_aliases = NULL;

          NUM_REFERENCES_CLEAR (ann);

          /* Since we are about to re-discover call-clobbered

             variables, clear the call-clobbered flag.  Variables that

             are intrinsically call-clobbered (globals, local statics,

             etc) will not be marked by the aliasing code, so we can't

             remove them from CALL_CLOBBERED_VARS.

             NB: STRUCT_FIELDS are still call clobbered if they are for

             a global variable, so we *don't* clear their call clobberedness

             just because they are tags, though we will clear it if they

             aren't for global variables.  */

          if (ann->mem_tag_kind == NAME_TAG

              || ann->mem_tag_kind == TYPE_TAG

              || !is_global_var (var))

            clear_call_clobbered (var);

        }

      /* Clear flow-sensitive points-to information from each SSA name.  */

      for (i = 1; i < num_ssa_names; i++)

        {

          tree name = ssa_name (i);

          if (!name || !POINTER_TYPE_P (TREE_TYPE (name)))

            continue;

          if (SSA_NAME_PTR_INFO (name))

            {

              struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);

              /* Clear all the flags but keep the name tag to

                 avoid creating new temporaries unnecessarily.  If

                 this pointer is found to point to a subset or

                 superset of its former points-to set, then a new

                 tag will need to be created in create_name_tags.  */

              pi->pt_anything = 0;

              pi->pt_null = 0;

              pi->value_escapes_p = 0;

              pi->is_dereferenced = 0;

              if (pi->pt_vars)

                bitmap_clear (pi->pt_vars);

            }

        }

    }

  /* Next time, we will need to reset alias information.  */

  aliases_computed_p = true;

  return ai;

}

/* Deallocate memory used by alias analysis.  */

static void

delete_alias_info (struct alias_info *ai)

{

  size_t i;

  referenced_var_iterator rvi;

  tree var;

  sbitmap_free (ai->ssa_names_visited);

  ai->processed_ptrs = NULL;

  for (i = 0; i < ai->num_addressable_vars; i++)

    free (ai->addressable_vars[i]);

  FOR_EACH_REFERENCED_VAR(var, rvi)

    {

      var_ann_t ann = var_ann (var);

      NUM_REFERENCES_CLEAR (ann);

    }

  free (ai->addressable_vars);

  for (i = 0; i < ai->num_pointers; i++)

    free (ai->pointers[i]);

  free (ai->pointers);

  BITMAP_FREE (ai->written_vars);

  BITMAP_FREE (ai->dereferenced_ptrs_store);

  BITMAP_FREE (ai->dereferenced_ptrs_load);

  bitmap_obstack_release (&alias_obstack);

  free (ai);

  delete_points_to_sets ();

}

/* Create name tags for all the pointers that have been dereferenced.

   We only create a name tag for a pointer P if P is found to point to

   a set of variables (so that we can alias them to *P) or if it is

   the result of a call to malloc (which means that P cannot point to

   anything else nor alias any other variable).

   If two pointers P and Q point to the same set of variables, they

   are assigned the same name tag.  */

static void

create_name_tags (void)

{

  size_t i;

  VEC (tree, heap) *with_ptvars = NULL;

  tree ptr;

  /* Collect the list of pointers with a non-empty points to set.  */

  for (i = 1; i < num_ssa_names; i++)

    {

      tree ptr = ssa_name (i);

      struct ptr_info_def *pi;

      if (!ptr

          || !POINTER_TYPE_P (TREE_TYPE (ptr))

          || !SSA_NAME_PTR_INFO (ptr))

        continue;

      pi = SSA_NAME_PTR_INFO (ptr);

      if (pi->pt_anything || !pi->is_dereferenced)

        {

          /* No name tags for pointers that have not been

             dereferenced or point to an arbitrary location.  */

          pi->name_mem_tag = NULL_TREE;

          continue;

        }

      /* Set pt_anything on the pointers without pt_vars filled in so

         that they are assigned a type tag.  */

      if (pi->pt_vars && !bitmap_empty_p (pi->pt_vars))

        VEC_safe_push (tree, heap, with_ptvars, ptr);

      else

        set_pt_anything (ptr);

    }

  /* If we didn't find any pointers with pt_vars set, we're done.  */

  if (!with_ptvars)

    return;

  /* Now go through the pointers with pt_vars, and find a name tag

     with the same pt_vars as this pointer, or create one if one

     doesn't exist.  */

  for (i = 0; VEC_iterate (tree, with_ptvars, i, ptr); i++)

    {

      struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);

      size_t j;

      tree ptr2;

      tree old_name_tag = pi->name_mem_tag;

      /* If PTR points to a set of variables, check if we don't

         have another pointer Q with the same points-to set before

         creating a tag.  If so, use Q's tag instead of creating a

         new one.

         This is important for not creating unnecessary symbols

         and also for copy propagation.  If we ever need to

         propagate PTR into Q or vice-versa, we would run into

         problems if they both had different name tags because

         they would have different SSA version numbers (which

         would force us to take the name tags in and out of SSA).  */

      for (j = 0; j < i && VEC_iterate (tree, with_ptvars, j, ptr2); j++)

        {

          struct ptr_info_def *qi = SSA_NAME_PTR_INFO (ptr2);

          if (bitmap_equal_p (pi->pt_vars, qi->pt_vars))

            {

              pi->name_mem_tag = qi->name_mem_tag;

              break;

            }

        }

      /* If we didn't find a pointer with the same points-to set

         as PTR, create a new name tag if needed.  */

      if (pi->name_mem_tag == NULL_TREE)

        pi->name_mem_tag = get_nmt_for (ptr);

      /* If the new name tag computed for PTR is different than

         the old name tag that it used to have, then the old tag

         needs to be removed from the IL, so we mark it for

         renaming.  */

      if (old_name_tag && old_name_tag != pi->name_mem_tag)

        mark_sym_for_renaming (old_name_tag);

      TREE_THIS_VOLATILE (pi->name_mem_tag)

        |= TREE_THIS_VOLATILE (TREE_TYPE (TREE_TYPE (ptr)));

      /* Mark the new name tag for renaming.  */

      mark_sym_for_renaming (pi->name_mem_tag);

    }

  VEC_free (tree, heap, with_ptvars);

}

/* For every pointer P_i in AI->PROCESSED_PTRS, create may-alias sets for

   the name memory tag (NMT) associated with P_i.  If P_i escapes, then its

   name tag and the variables it points-to are call-clobbered.  Finally, if

   P_i escapes and we could not determine where it points to, then all the

   variables in the same alias set as *P_i are marked call-clobbered.  This

   is necessary because we must assume that P_i may take the address of any

   variable in the same alias set.  */

static void

compute_flow_sensitive_aliasing (struct alias_info *ai)

{

  size_t i;

  for (i = 0; i < VARRAY_ACTIVE_SIZE (ai->processed_ptrs); i++)

    {

      tree ptr = VARRAY_TREE (ai->processed_ptrs, i);

      if (!find_what_p_points_to (ptr))

        set_pt_anything (ptr);

    }

  create_name_tags ();

  for (i = 0; i < VARRAY_ACTIVE_SIZE (ai->processed_ptrs); i++)

    {

      unsigned j;

      tree ptr = VARRAY_TREE (ai->processed_ptrs, i);

      struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);

      var_ann_t v_ann = var_ann (SSA_NAME_VAR (ptr));

      bitmap_iterator bi;

      if (pi->value_escapes_p || pi->pt_anything)

        {

          /* If PTR escapes or may point to anything, then its associated

             memory tags and pointed-to variables are call-clobbered.  */

          if (pi->name_mem_tag)

            mark_call_clobbered (pi->name_mem_tag);

          if (v_ann->type_mem_tag)

            mark_call_clobbered (v_ann->type_mem_tag);

          if (pi->pt_vars)

            EXECUTE_IF_SET_IN_BITMAP (pi->pt_vars, 0, j, bi)

              mark_call_clobbered (referenced_var (j));

        }

      /* Set up aliasing information for PTR's name memory tag (if it has

         one).  Note that only pointers that have been dereferenced will

         have a name memory tag.  */

      if (pi->name_mem_tag && pi->pt_vars)

        EXECUTE_IF_SET_IN_BITMAP (pi->pt_vars, 0, j, bi)

          {

            add_may_alias (pi->name_mem_tag, referenced_var (j));

            add_may_alias (v_ann->type_mem_tag, referenced_var (j));

          }

      /* If the name tag is call clobbered, so is the type tag

         associated with the base VAR_DECL.  */

      if (pi->name_mem_tag

          && v_ann->type_mem_tag

          && is_call_clobbered (pi->name_mem_tag))

        mark_call_clobbered (v_ann->type_mem_tag);

    }

}

/* Compute type-based alias sets.  Traverse all the pointers and

   addressable variables found in setup_pointers_and_addressables.

   For every pointer P in AI->POINTERS and addressable variable V in

   AI->ADDRESSABLE_VARS, add V to the may-alias sets of P's type

   memory tag (TMT) if their alias sets conflict.  V is then marked as

   an alias tag so that the operand scanner knows that statements

   containing V have aliased operands.  */

static void

compute_flow_insensitive_aliasing (struct alias_info *ai)

{

  size_t i;

  /* Initialize counter for the total number of virtual operands that