#include <stdio.h>
#include <string.h>
#include <setjmp.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
#include "misc.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "semantics.h"
#include "transformer.h"
#include "pipsdbm.h"
#include "alias-classes.h"

Include dependency graph for alias_classes.c:

Functions
static bool	same_reg_ignore_action (region reg1, region reg2)
	tests if reg1 and reg2 are the same, ignoring their action_tags (IN/OUT) but checking their precision (may/exact) More...

static bool	member (region reg, list reg_list)
	tests if reg and any member of reg_list are same_reg_ignore_action More...

static list	append_reg_if_not_present (list reg_list, region reg)
	adds reg as final element on the end of reg_list unless reg is already present in reg_list i.e. More...

static list	union_lists (list initial_reg_list, list additional_list)
	add a copy of each element in additional_list not already present in initial_reg_list to the end of initial_reg_list (ignoring the action) More...

static void	compare_other_list (region elem, list other_list)
	global variables IN: rest_list, l_lists global variables modified: rest_list, l_lists More...

static void	compare_rest_lists (region elem)
	global variables IN: rest_list, rest_lists, l_lists global variables modified: rest_list, l_lists, rest_lists compares "elem" (the current element from the list currently being made into a class) to each element of each list of "rest_lists" (the other lists not yet made into classes) if a match is found, "other_list" (the other list containing the matching element "other_elem") is appended to "rest_list" (the not yet treated elements from the list currently being made into a class) and "other_list" will no longer be a member of "l_lists" if not, "other_list" is appended to "l_lists" More...

static void	make_class_from_list (list reg_list)
	global variables IN: new_class, rest_lists, l_lists global variables modified: new_class, l_lists, rest_lists, rest_list More...

static void	unite_lists_containing_same_exact_region ()
	global variables IN: l_lists, l_alias_classes global variables modified:class, l_lists, rest_lists, rest_list, l_alias_classes More...

static list	compare_heads_rest_lists (region head, list new_list)
	global variables IN: l_alias_lists global variables modified: l_alias_lists compares "head" (the head of the current list) to the head of each list of "rest_lists" (the other lists not yet treated) if a match is found, "other_list" (the other list containing the matching head "other_head") is appended to "new_list" and "other_list" will no longer be a member of "l_alias_lists" if not, "other_list" is appended to "l_alias_lists" More...

static void	unite_lists_with_same_head ()
	global variables IN: l_alias_lists, l_lists global variables modified: l_alias_lists, l_lists More...

bool	alias_classes (const char *module_name)
	alias_classes.c More...

Variables
static list	l_alias_lists

static list	l_alias_classes

static list	l_lists

static list	new_class

static list	rest_list

static list	rest_lists

Function Documentation

◆ alias_classes()

bool alias_classes ( const char * module_name )

alias_classes.c

ATTENTION: we have to do ALL this just to call print_inout_regions for debug !!

and this to call print_region set_action_interpretation(ACTION_IN,ACTION_OUT);

that's it, but we musn't forget to reset everything below

ifdebug(9) { pips_debug(9,"add list:\n"); print_inout_regions(module_alias_list); }

Parameters

module_name odule_name

Definition at line 514 of file alias_classes.c.

 {
     entity module;
     list module_alias_lists;
  
     debug_on("ALIAS_CLASSES_DEBUG_LEVEL");
     pips_debug(4,"begin for module %s\n",module_name);
     ifdebug(4)
         {
             /* ATTENTION: we have to do ALL this
              * just to call print_inout_regions for debug !!
              */
             set_current_module_entity(
                 local_name_to_top_level_entity(module_name) );
             module = get_current_module_entity();
             set_current_module_statement( (statement)
                                           db_get_memory_resource(DBR_CODE,
                                                                  module_name,
                                                                  true) );
             set_cumulated_rw_effects((statement_effects)
                                      db_get_memory_resource(
                                          DBR_CUMULATED_EFFECTS,
                                          module_name,
                                          true));
             set_proper_rw_effects((statement_effects)
                                      db_get_memory_resource(
                                          DBR_PROPER_EFFECTS,
                                          module_name,
                                          true));
             module_to_value_mappings(module);
             /* and this to call print_region
             set_action_interpretation(ACTION_IN,ACTION_OUT);     */    
             /* that's it, but we musn't forget to reset everything below */
         }
  
     l_alias_lists = NIL;
     l_alias_classes = NIL;
     l_lists = NIL;
  
     module_alias_lists =
         effects_classes_classes((effects_classes)
                                 db_get_memory_resource(DBR_ALIAS_LISTS,
                                                        module_name,
                                                        true));
     MAP(EFFECTS,module_alias_list_effects,
             {
                 list module_alias_list =
                     effects_effects(module_alias_list_effects);
  
 /*              ifdebug(9)
                     {
                         pips_debug(9,"add list:\n");
                         print_inout_regions(module_alias_list);
                     }
                     */
                 l_alias_lists = CONS(LIST,module_alias_list,l_alias_lists);
             },module_alias_lists);
  
     ifdebug(9)
         {
             pips_debug(9,"alias lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);
                     pips_debug(9,"---\n");
                 },
                     l_alias_lists);
         }
  
     unite_lists_with_same_head();
  
     ifdebug(9)
         {
             pips_debug(9,"new lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);                
                     pips_debug(9,"---\n");
                 },
                     l_lists);
         }
  
     unite_lists_containing_same_exact_region();
  
     ifdebug(9)
         {
             pips_debug(9,"classes:\n");
             MAP(EFFECTS,alias_class,
                 {
                     print_inout_regions(effects_effects(alias_class));
                 },
                     l_alias_classes);
         }
  
     DB_PUT_MEMORY_RESOURCE(DBR_ALIAS_CLASSES, 
                            strdup(module_name),
                            (char*) make_effects_classes(l_alias_classes));    
  
     ifdebug(4)
         {
             free_value_mappings();
             reset_current_module_statement();
             reset_cumulated_rw_effects();
             reset_proper_rw_effects();
             reset_current_module_entity();
         }
     pips_debug(4,"end\n");
     debug_off();
  
     return true;
 }

References CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, EFFECTS, effects_classes_classes, effects_effects, free_value_mappings(), get_current_module_entity(), ifdebug, l_alias_classes, l_alias_lists, l_lists, LIST, local_name_to_top_level_entity(), make_effects_classes(), MAP, module, module_name(), module_to_value_mappings(), NIL, pips_debug, print_inout_regions(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), strdup(), unite_lists_containing_same_exact_region(), and unite_lists_with_same_head().

Here is the call graph for this function:

◆ append_reg_if_not_present()

static list append_reg_if_not_present	(	list	reg_list,
		region	reg
	)

static

adds reg as final element on the end of reg_list unless reg is already present in reg_list i.e.

is same_reg_ignore_action as an element of reg_list

Definition at line 160 of file alias_classes.c.

 {
     list new_reg_list;
  
     pips_debug(4,"begin\n");
  
  
 /*
   ifdebug(9)
   {
                     set_action_interpretation(ACTION_IN,ACTION_OUT);
   pips_debug(9,"add:\n\t");
   print_region(reg);
   pips_debug(9,"to:\n\t");
   print_inout_regions(reg_list);
                     reset_action_interpretation();
   }
 */
  
     if (!member(reg,reg_list))
         new_reg_list = gen_nconc(reg_list,CONS(EFFECT,reg,NIL));
     else
         new_reg_list = reg_list;
  
     pips_debug(4,"end\n");
  
     return new_reg_list;
 }

References CONS, EFFECT, gen_nconc(), member(), NIL, and pips_debug.

Referenced by union_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_heads_rest_lists()

static list compare_heads_rest_lists	(	region	head,
		list	new_list
	)

static

global variables IN: l_alias_lists global variables modified: l_alias_lists compares "head" (the head of the current list) to the head of each list of "rest_lists" (the other lists not yet treated) if a match is found, "other_list" (the other list containing the matching head "other_head") is appended to "new_list" and "other_list" will no longer be a member of "l_alias_lists" if not, "other_list" is appended to "l_alias_lists"

here, we don't need to account of the actions of the two regions: if a sub-program has the same IN and OUT regions for one array, then we will have created two alias lists which are identical except for the actions of the regions: now we get rid of one

Definition at line 403 of file alias_classes.c.

 {
     list rest_lists;
     region other_head;
  
     rest_lists = l_alias_lists;
     l_alias_lists = NIL;
  
     MAP(LIST, other_list,
     {
     ifdebug(4)
         {
             pips_debug(4,"begin for:\n");
             set_action_interpretation(ACTION_IN,ACTION_OUT);        
             print_region(head);
             reset_action_interpretation();          
         }
  
     if (other_list != NIL)
     {
             other_head = EFFECT(CAR(other_list));
  
             ifdebug(9)
                 {
                     pips_debug(9,"compare elem:\n");
                     set_action_interpretation(ACTION_IN,ACTION_OUT);        
                     print_region(other_head);
                     reset_action_interpretation();          
                 }
  
 /* here, we don't need to account of the actions of the
  * two regions: if a sub-program has the same IN and
  * OUT regions for one array, then we will have
  * created two alias lists which are identical except for
  * the actions of the regions: now we get rid of one
  */
             if ( same_reg_ignore_action(head,other_head) )
             {
                 pips_debug(9,"same\n");
  
                 new_list = union_lists(new_list,CDR(other_list));
             }
             else
             {
             l_alias_lists = CONS(LIST,other_list,l_alias_lists);
             }
     }
  
     },rest_lists);
  
     pips_debug(4,"end\n");
  
     return new_list;
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, CONS, EFFECT, ifdebug, l_alias_lists, LIST, MAP, NIL, pips_debug, print_region, region, reset_action_interpretation(), rest_lists, same_reg_ignore_action(), set_action_interpretation(), and union_lists().

Referenced by unite_lists_with_same_head().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_other_list()

static void compare_other_list	(	region	elem,
		list	other_list
	)

static

global variables IN: rest_list, l_lists global variables modified: rest_list, l_lists

here, it doesn't matter whether the regions have the same action

Definition at line 218 of file alias_classes.c.

 {
     bool result = false;
     region other_elem;
     list rest_other_list;
  
     ifdebug(4)
         {
             pips_debug(4,"begin for elem:\n");
             set_action_interpretation(ACTION_IN,ACTION_OUT);        
             print_region(elem);
             reset_action_interpretation();          
             pips_debug(4,"and list:\n");
             print_inout_regions(other_list);
         }
  
     if (other_list != NIL)
     {
         rest_other_list = other_list;
         do {
             other_elem = EFFECT(CAR(rest_other_list));
             rest_other_list = CDR(rest_other_list);
  
             ifdebug(9)
                 {
                     pips_debug(9,"compare elem:\n");
                     set_action_interpretation(ACTION_IN,ACTION_OUT);        
                     print_region(other_elem);
                     reset_action_interpretation();          
                 }
  
             if ( effect_exact_p(other_elem) )
             {
                 pips_debug(9,"exact\n");
  
 /* here, it doesn't matter whether the regions have the same action */
                 if ( same_reg_ignore_action(elem,other_elem) )
                 {
                     pips_debug(9,"same\n");
  
                     rest_list = union_lists(rest_list,other_list);
                     result = true;
                 }
             }
         } while (result == false && rest_other_list != NIL);
         if (result == false)
             l_lists = CONS(LIST,other_list,l_lists);
     }
     pips_debug(4,"end\n");
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, CONS, EFFECT, effect_exact_p, ifdebug, l_lists, LIST, NIL, pips_debug, print_inout_regions(), print_region, region, reset_action_interpretation(), rest_list, same_reg_ignore_action(), set_action_interpretation(), and union_lists().

Referenced by compare_rest_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_rest_lists()

static void compare_rest_lists ( region elem )

static

global variables IN: rest_list, rest_lists, l_lists global variables modified: rest_list, l_lists, rest_lists compares "elem" (the current element from the list currently being made into a class) to each element of each list of "rest_lists" (the other lists not yet made into classes) if a match is found, "other_list" (the other list containing the matching element "other_elem") is appended to "rest_list" (the not yet treated elements from the list currently being made into a class) and "other_list" will no longer be a member of "l_lists" if not, "other_list" is appended to "l_lists"

Definition at line 284 of file alias_classes.c.

 {
     list other_list;
  
     while (rest_lists != NIL)
     {
     ifdebug(4)
         {
             pips_debug(4,"begin for:\n");
             set_action_interpretation(ACTION_IN,ACTION_OUT);        
             print_region(elem);
             reset_action_interpretation();          
         }
  
     other_list = LIST(CAR(rest_lists));
     rest_lists = CDR(rest_lists);
     compare_other_list(elem, other_list);
     }
     pips_debug(4,"end\n");
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, compare_other_list(), ifdebug, LIST, NIL, pips_debug, print_region, reset_action_interpretation(), rest_lists, and set_action_interpretation().

Referenced by make_class_from_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_class_from_list()

static void make_class_from_list ( list reg_list )

static

global variables IN: new_class, rest_lists, l_lists global variables modified: new_class, l_lists, rest_lists, rest_list

Definition at line 310 of file alias_classes.c.

 {
     region elem;
  
     ifdebug(4)
         {
             pips_debug(4,"begin for:\n");
             print_inout_regions(reg_list);
         }
  
     rest_list = reg_list;
  
     while (rest_list != NIL)
     {
         elem = EFFECT(CAR(rest_list));
         rest_list = CDR(rest_list);
  
         ifdebug(9)
             {
                 pips_debug(9,"elem:\n");
                    set_action_interpretation(ACTION_IN,ACTION_OUT);         
                    print_region(elem);
                    reset_action_interpretation();           
             }
         
         if ( effect_exact_p(elem) )
         {
             pips_debug(9,"exact\n");
  
             rest_lists = l_lists;
             l_lists = NIL;
             compare_rest_lists(elem);
         }
         new_class = gen_nconc(new_class,CONS(EFFECT,elem,NIL));
     }
  
     pips_debug(4,"end\n");
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, compare_rest_lists(), CONS, EFFECT, effect_exact_p, gen_nconc(), ifdebug, l_lists, new_class, NIL, pips_debug, print_inout_regions(), print_region, region, reset_action_interpretation(), rest_list, rest_lists, and set_action_interpretation().

Referenced by unite_lists_containing_same_exact_region().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ member()

static bool member	(	region	reg,
		list	reg_list
	)

static

tests if reg and any member of reg_list are same_reg_ignore_action

Definition at line 113 of file alias_classes.c.

     {
         region elem;
         list rest_list;
         bool result = false;
  
         pips_debug(4,"begin\n");
  
 /*
             ifdebug(9)
                 {
                     set_action_interpretation(ACTION_IN,ACTION_OUT);
                     pips_debug(9,"test if:\n\t");
                     print_region(reg);
                     pips_debug(9,"is in:\n\t");
                     print_inout_regions(reg_list);
                     reset_action_interpretation();
                 }
                 */
  
         rest_list = reg_list;
  
         if (reg_list != NIL)
  
                         do{
                             elem = EFFECT(CAR(rest_list));
                             if (same_reg_ignore_action(elem,reg))
                                 {
                                     result = true;
  
                                     pips_debug(4,"is member\n");
                                 }
  
                             rest_list = CDR(rest_list);
                         }while (rest_list != NIL && result == false);
  
         pips_debug(4,"end\n");
  
         return result;
     }

References CAR, CDR, EFFECT, NIL, pips_debug, region, rest_list, and same_reg_ignore_action().

Referenced by append_reg_if_not_present(), and tile_membership().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ same_reg_ignore_action()

static bool same_reg_ignore_action	(	region	reg1,
		region	reg2
	)

static

tests if reg1 and reg2 are the same, ignoring their action_tags (IN/OUT) but checking their precision (may/exact)

pips_debug(1,"same entity\n");

pips_debug(1,"same approx\n");

Definition at line 63 of file alias_classes.c.

     {
     Psysteme reg1_sys, reg2_sys;
     bool result = false;
  
     pips_debug(4,"begin\n");
  
     if (effect_undefined_p(reg1) || effect_undefined_p(reg2)) return result;
  
     if (effect_entity(reg1) == effect_entity(reg2))
     {
 /*      pips_debug(1,"same entity\n"); */
  
         if (effect_approximation_tag(reg1) == 
                 effect_approximation_tag(reg2))
             {
 /*              pips_debug(1,"same approx\n"); */
  
             ifdebug(1)
                 {
                     set_action_interpretation(ACTION_IN,ACTION_OUT);
                     pips_debug(1,"compare:\n\t");
                     print_region(reg1);
                     pips_debug(1,"with:\n\t");
                     print_region(reg2);
                     reset_action_interpretation();
                 }
  
                 reg1_sys = region_system(reg1);
                 reg2_sys = region_system(reg2);
                 if ( sc_equal_p_ofl(reg1_sys,reg2_sys) )
                 {
                     result = true;
  
                     pips_debug(1,"same region\n");
                 }
                 else
                     pips_debug(1,"not same region\n");
             }
         }
     pips_debug(4,"end\n");
  
     return result;
     }

References ACTION_IN, ACTION_OUT, effect_approximation_tag, effect_entity(), effect_undefined_p, ifdebug, pips_debug, print_region, region_system, reset_action_interpretation(), sc_equal_p_ofl, and set_action_interpretation().

Referenced by compare_heads_rest_lists(), compare_other_list(), and member().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ union_lists()

static list union_lists	(	list	initial_reg_list,
		list	additional_list
	)

static

add a copy of each element in additional_list not already present in initial_reg_list to the end of initial_reg_list (ignoring the action)

Definition at line 196 of file alias_classes.c.

 {
     list new_reg_list = initial_reg_list;
  
     pips_debug(4,"begin\n");
  
     MAP(EFFECT,additional_reg,
         {
             new_reg_list =
                 append_reg_if_not_present(new_reg_list,additional_reg);
         },additional_list);
  
     pips_debug(4,"end\n");
  
     return new_reg_list;
 }

References append_reg_if_not_present(), EFFECT, MAP, and pips_debug.

Referenced by compare_heads_rest_lists(), and compare_other_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unite_lists_containing_same_exact_region()

static void unite_lists_containing_same_exact_region ( )

static

global variables IN: l_lists, l_alias_classes global variables modified:class, l_lists, rest_lists, rest_list, l_alias_classes

ifdebug(9) { pips_debug(9,"new_class:\n"); print_inout_regions(new_class);
pips_debug(9,"l_lists:\n"); MAP(LIST,alias_list, { print_inout_regions(alias_list);
pips_debug(9,"---\n"); }, l_lists); }

if (l_lists != NIL) unite_lists_containing_same_exact_region();

Definition at line 355 of file alias_classes.c.

 {
     list next_list;
  
     while (l_lists != NIL)
     {
     pips_debug(4,"begin\n");
  
     next_list = LIST(CAR(l_lists));
     l_lists = CDR(l_lists);
     new_class = NIL;
  
     make_class_from_list(next_list);
     l_alias_classes = CONS(EFFECTS,
                            make_effects(regions_dup(new_class)),
                            l_alias_classes);
  
 /*    ifdebug(9)
         {
             pips_debug(9,"new_class:\n");
             print_inout_regions(new_class);                 
             pips_debug(9,"l_lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);                
                     pips_debug(9,"---\n");
                 },
                     l_lists);
         }*/
  
 /*    if (l_lists != NIL) unite_lists_containing_same_exact_region(); */
     }
     pips_debug(4,"end\n");
 }

References CAR, CDR, CONS, EFFECTS, l_alias_classes, l_lists, LIST, make_class_from_list(), make_effects(), new_class, NIL, pips_debug, and regions_dup().

Referenced by alias_classes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unite_lists_with_same_head()

static void unite_lists_with_same_head ( )

static

global variables IN: l_alias_lists, l_lists global variables modified: l_alias_lists, l_lists

ifdebug(9) { pips_debug(9,"new_list:\n"); print_inout_regions(new_list);
pips_debug(9,"l_alias_lists:\n"); MAP(LIST,alias_list, { print_inout_regions(alias_list);
pips_debug(9,"---\n"); }, l_alias_lists); }

Definition at line 463 of file alias_classes.c.

 {
     list next_list, new_list;
     region head;
  
     pips_debug(4,"begin\n");
  
     while (l_alias_lists != NIL)
     {
  
     next_list = LIST(CAR(l_alias_lists));
     l_alias_lists = CDR(l_alias_lists);
     new_list = next_list;
  
     if (next_list != NIL)
     {
            head = EFFECT(CAR(next_list));
  
            ifdebug(9)
                {
                    pips_debug(9,"head:\n");
                    set_action_interpretation(ACTION_IN,ACTION_OUT);         
                    print_region(head);
                    reset_action_interpretation();           
                }
  
            new_list = compare_heads_rest_lists(head, new_list);
     }
  
     l_lists = CONS(LIST,new_list,l_lists);
  
 /*    ifdebug(9)
         {
             pips_debug(9,"new_list:\n");
             print_inout_regions(new_list);                  
             pips_debug(9,"l_alias_lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);                
                     pips_debug(9,"---\n");
                 },
                     l_alias_lists);
         }
         */
     }
  
     pips_debug(4,"end\n");
 }