#include <stdio.h>
#include <string.h>
#include <setjmp.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "ri-util.h"
#include "effects-util.h"
#include "constants.h"
#include "misc.h"
#include "text.h"
#include "boolean.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"
#include "sommet.h"
#include "ray_dte.h"
#include "sg.h"
#include "polyedre.h"
#include "union.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "semantics.h"
#include "transformer.h"
#include "pipsdbm.h"
#include "resources.h"
#include "alias-classes.h"

Include dependency graph for sav_alias_classes.c:

Functions
static list	append_all_not_present (list initial_reg_list, list additional_list)
	The algorithms below depend on the following properties of Alias Lists and Alias Classes: More...

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

static void	compare_rest_other_lists (region elem)
	global variables IN: rest_list, rest_other_lists, other_lists global variables modified: rest_list, other_lists, rest_other_lists ATTENTION: recursive function compares "elem" (the current element from the list currently being made into a class) to each element of each list of "rest_other_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 "other_lists" if not, "other_list" is appended to "other_lists" More...

static void	make_class_from_list (list reg_list)
	global variables IN: class, rest_other_lists, other_lists global variables modified: class, other_lists, rest_other_lists, rest_list More...

static void	make_classes_from_lists ()
	global variables IN: other_lists global variables modified:class, other_lists, rest_other_lists, rest_list ATTENTION: recursive function More...

static bool	match_this_callee_class_elem (region callee_class_elem, list callee_alias_class)
	global variables IN: l_alias_lists global variables modified: l_alias_lists returns true if l_alias_lists modified, i.e. More...

static bool	add_callee_class_to_lists (list callee_alias_class)
	global variables IN: l_alias_lists global variables modified: l_alias_lists More...

static void	save_callee_class (list callee_alias_class)
	global variables IN: other_lists global variables modified: other_lists More...

static void	add_classes_for_this_callee (string callee_name)
	global variables IN: l_alias_lists, other_lists global variables modified: l_alias_lists, other_lists More...

static void	add_classes_callees (const char *module_name)

bool	alias_classes (const string module_name)

Variables
static list	l_alias_lists

static list	l_alias_classes

static list	other_lists

static list	class

static list	rest_list

static list	rest_other_lists

Function Documentation

◆ add_callee_class_to_lists()

static bool add_callee_class_to_lists ( list callee_alias_class )

static

global variables IN: l_alias_lists global variables modified: l_alias_lists

Definition at line 364 of file sav_alias_classes.c.

 {
     bool result = false;
  
     pips_debug(4,"begin\n");
  
     MAP(EFFECT,callee_class_elem,
         {
             if ( match_this_callee_class_elem(callee_class_elem,
                                               callee_alias_class) )
                 result = true;
         },
     callee_alias_class);
  
     pips_debug(4,"end\n");
  
     return result;
 }

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

Referenced by add_classes_for_this_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_classes_callees()

static void add_classes_callees ( const char * module_name )

static

Definition at line 432 of file sav_alias_classes.c.

 {
     callees all_callees;
  
     pips_debug(4,"begin\n");
  
     all_callees = (callees) db_get_memory_resource(DBR_CALLEES,
                                                module_name,
                                                true);
  
     MAP(STRING, callee_name,
         {
             add_classes_for_this_callee(callee_name);
         },
             callees_callees(all_callees));
  
     pips_debug(4,"end\n");
 }

References add_classes_for_this_callee(), callees_callees, db_get_memory_resource(), MAP, module_name(), pips_debug, and STRING.

Referenced by alias_classes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_classes_for_this_callee()

static void add_classes_for_this_callee ( string callee_name )

static

global variables IN: l_alias_lists, other_lists global variables modified: l_alias_lists, other_lists

Definition at line 404 of file sav_alias_classes.c.

 {
     list callee_alias_classes;
  
     pips_debug(4,"begin for callee %s\n",callee_name);
  
     callee_alias_classes = effects_to_list((effects)
                                   db_get_memory_resource(DBR_ALIAS_CLASSES,
                                                          callee_name,
                                                          true));
     MAP(LIST,callee_alias_class,
             {
                 ifdebug(9)
                     {
                         pips_debug(9,"add class:\n");
                         print_inout_regions(callee_alias_class);
                     }
  
                 if (!add_callee_class_to_lists(callee_alias_class))
                     save_callee_class(callee_alias_class);
             },
     callee_alias_classes);
  
     pips_debug(4,"end\n");
 }

References add_callee_class_to_lists(), db_get_memory_resource(), effects_to_list(), ifdebug, LIST, MAP, pips_debug, print_inout_regions(), and save_callee_class().

Referenced by add_classes_callees().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_classes()

bool alias_classes ( const string module_name )

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

reset_action_interpretation();

Definition at line 452 of file sav_alias_classes.c.

 {
     list alias_lists;
     entity module;
  
     debug_on("ALIAS_CLASSES_DEBUG_LEVEL");
     pips_debug(4,"begin for module %s\n",module_name);
     ifdebug(9)
         {
             /* 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;
     other_lists = NIL;
  
 /*
     alias_lists =
         effects_to_list((effects)
                         db_get_memory_resource(DBR_ALIAS_LISTS,
                                                module_name,
                                                true));
 */
  
     alias_lists =
         effects_classes_classes((effects_classes)
                                 db_get_memory_resource(DBR_ALIAS_LISTS,
                                                        module_name,
                                                        true));
  
     MAP(LIST,alias_list,
         {
             l_alias_lists =
                 gen_nconc(CONS(LIST,regions_dup(alias_list),NIL),
                           l_alias_lists);
         },
             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);
         }
  
     add_classes_callees(module_name);
  
     ifdebug(9)
         {
             pips_debug(9,"alias lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);
                     pips_debug(9,"---\n");
                 },
                     l_alias_lists);
             pips_debug(9,"callee classes:\n");
             MAP(LIST,alias_class,
                 {
                     print_inout_regions(alias_class);               
                     pips_debug(9,"---\n");
                 },
                     other_lists);
         }
  
     other_lists = gen_nconc(l_alias_lists,other_lists);
  
     make_classes_from_lists();
  
     DB_PUT_MEMORY_RESOURCE(DBR_ALIAS_CLASSES, 
                            strdup(module_name),
                            (char*) make_effects_classes(l_alias_classes));    
  
     ifdebug(9)
         {
 /*          reset_action_interpretation(); */
             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 add_classes_callees(), alias_lists(), CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, effects_classes_classes, free_value_mappings(), gen_nconc(), get_current_module_entity(), ifdebug, l_alias_classes, l_alias_lists, LIST, local_name_to_top_level_entity(), make_classes_from_lists(), make_effects_classes(), MAP, module, module_name(), module_to_value_mappings(), NIL, other_lists, pips_debug, print_inout_regions(), regions_dup(), 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(), and strdup().

Here is the call graph for this function:

◆ append_all_not_present()

static list append_all_not_present	(	list	initial_reg_list,
		list	additional_list
	)

static

The algorithms below depend on the following properties of Alias Lists and Alias Classes:

an Alias List contains no repeated elements
two Alias Lists of the same module never have the same head (distinct heads)
an element from one Alias List of a particular module can also be present in another Alias List of the same module (not disjoint sets)
no element from one Alias Class of a particular module is also present in another Alias Class of the same module (disjoint sets) global variables IN: l_alias_lists gloabl variables modified: l_alias_lists add a copy of each element in additional_list not already present in initial_reg_list to the end of initial_reg_list

Definition at line 89 of file sav_alias_classes.c.

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

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

Referenced by compare_other_list(), and match_this_callee_class_elem().

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, other_lists global variables modified: rest_list, other_lists

Definition at line 112 of file sav_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");
  
                 if ( same_reg_ignore_action(elem,other_elem) )
                 {
                     pips_debug(9,"same\n");
  
                     rest_list = append_all_not_present(rest_list,other_list);
                     result = true;
                 }
             }
         } while (result == false && rest_other_list != NIL);
         if (result == false)
             other_lists = gen_nconc(other_lists,CONS(LIST,other_list,NIL));
     }
     pips_debug(4,"end\n");
 }

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

Referenced by compare_rest_other_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_rest_other_lists()

static void compare_rest_other_lists ( region elem )

static

global variables IN: rest_list, rest_other_lists, other_lists global variables modified: rest_list, other_lists, rest_other_lists ATTENTION: recursive function compares "elem" (the current element from the list currently being made into a class) to each element of each list of "rest_other_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 "other_lists" if not, "other_list" is appended to "other_lists"

Definition at line 178 of file sav_alias_classes.c.

 {
     list other_list;
  
     if (rest_other_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_other_lists));
     rest_other_lists = CDR(rest_other_lists);
     compare_other_list(elem, other_list);
  
     if(rest_other_lists != NIL)
         compare_rest_other_lists(elem);
  
     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_other_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: class, rest_other_lists, other_lists global variables modified: class, other_lists, rest_other_lists, rest_list

Definition at line 208 of file sav_alias_classes.c.

 {
     region elem;
  
     ifdebug(4)
         {
             pips_debug(4,"begin for:\n");
             print_inout_regions(reg_list);
         }
  
     if (reg_list != NIL)
     {
         rest_list = reg_list;
         do {
            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_other_lists = other_lists;
                other_lists = NIL;
                compare_rest_other_lists(elem);
            }
            class = gen_nconc(class,CONS(EFFECT,elem,NIL));
         } while(rest_list != NIL);
     }
  
     pips_debug(4,"end\n");
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, class, compare_rest_other_lists(), CONS, EFFECT, effect_exact_p, gen_nconc(), ifdebug, NIL, other_lists, pips_debug, print_inout_regions(), print_region, region, reset_action_interpretation(), rest_list, rest_other_lists, and set_action_interpretation().

Referenced by make_classes_from_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_classes_from_lists()

static void make_classes_from_lists ( )

static

global variables IN: other_lists global variables modified:class, other_lists, rest_other_lists, rest_list ATTENTION: recursive function

rest_other_lists = CDR(other_lists);

other_lists = NIL;

Definition at line 254 of file sav_alias_classes.c.

 {
     list next_list;
  
     if (other_lists != NIL)
     {
     pips_debug(4,"begin\n");
  
     next_list = LIST(CAR(other_lists));
 /*    rest_other_lists = CDR(other_lists); */
 /*             other_lists = NIL; */
     other_lists = CDR(other_lists);
     class = NIL;
  
     make_class_from_list(next_list);
     l_alias_classes = gen_nconc(l_alias_classes,CONS(LIST,class,NIL));
  
     ifdebug(9)
         {
             pips_debug(9,"class:\n");
             print_inout_regions(class);             
             pips_debug(9,"other_lists:\n");
             MAP(LIST,alias_list,
                 {
                     print_inout_regions(alias_list);                
                     pips_debug(9,"---\n");
                 },
                     other_lists);
         }
  
     if (other_lists != NIL) make_classes_from_lists();
  
     pips_debug(4,"end\n");
     }
 }

References CAR, CDR, CONS, gen_nconc(), ifdebug, l_alias_classes, LIST, make_class_from_list(), MAP, NIL, other_lists, pips_debug, and print_inout_regions().

Referenced by alias_classes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ match_this_callee_class_elem()

static bool match_this_callee_class_elem	(	region	callee_class_elem,
		list	callee_alias_class
	)

static

global variables IN: l_alias_lists global variables modified: l_alias_lists returns true if l_alias_lists modified, i.e.

if callee_class_elem is present in one or more of the callers alias lists, in which case, the whole callee_alias_class is added to each of these caller alias lists

Definition at line 301 of file sav_alias_classes.c.

 {
     bool result = false;
     list rest_alias_lists, alias_list;
     region formal_reg_caller_list;
  
     ifdebug(4)
         {
             pips_debug(4,"begin for elem:\n");
             set_action_interpretation(ACTION_IN,ACTION_OUT);        
             print_region(callee_class_elem);
             reset_action_interpretation();          
         }
  
     rest_alias_lists = l_alias_lists;
     if (l_alias_lists != NIL)
         do{
             alias_list = LIST( CAR(rest_alias_lists) );
             formal_reg_caller_list = EFFECT( CAR(alias_list) );
  
             ifdebug(9)
                 {
                     pips_debug(9,"compare with:\n");
                     set_action_interpretation(ACTION_IN,ACTION_OUT);        
                     print_region(formal_reg_caller_list);
                     reset_action_interpretation();          
                 }
  
             if ( same_reg_ignore_action(formal_reg_caller_list,
                                         callee_class_elem) )
                     {
                         pips_debug(9,"match\n");
             ifdebug(9)
                 {
                     pips_debug(9,"old alias list:\n");
                     print_inout_regions(alias_list);
                 }
  
                         result = true;
                         alias_list =
                             append_all_not_present(alias_list,
                                                    callee_alias_class);
  
             ifdebug(9)
                 {
                     pips_debug(9,"new alias list:\n");
                     print_inout_regions(alias_list);
                 }
  
                     }
             rest_alias_lists = CDR(rest_alias_lists);
         }while (rest_alias_lists != NIL && result == false);
  
     pips_debug(4,"end\n");
  
     return result;
 }

References ACTION_IN, ACTION_OUT, append_all_not_present(), CAR, CDR, EFFECT, ifdebug, l_alias_lists, LIST, NIL, pips_debug, print_inout_regions(), print_region, region, reset_action_interpretation(), same_reg_ignore_action(), and set_action_interpretation().

Referenced by add_callee_class_to_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_callee_class()

static void save_callee_class ( list callee_alias_class )

static

global variables IN: other_lists global variables modified: other_lists

Definition at line 388 of file sav_alias_classes.c.

 {
     pips_debug(4,"begin\n");
  
     other_lists =
         gen_nconc(other_lists,
                   CONS(LIST,regions_dup(callee_alias_class),NIL));
  
     pips_debug(4,"end\n");
 }