#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 dependency graph for alias_lists.c:

Functions
static bool	same_reg (region reg1, region reg2)
	tests if reg1 and reg2 are the same, including same action_tags (IN/OUT) and precision (may/exact) More...

static void	add_unmatched_alias_pairs ()
	global variables IN: unmatched_alias_pairs, l_alias_lists modifies global variable: l_alias_lists More...

static bool	compare_matched_alias_pairs (bool result, region alias_list_reg, list callee_alias_list)
	global variables IN: matched_alias_pairs, l_alias_lists modifies global variable: l_alias_lists More...

static bool	compare_unmatched_alias_pairs (region alias_list_reg, list callee_alias_list)
	global variables IN: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists More...

static void	add_alias_lists_callee (string callee_name)
	global variables IN: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists More...

static void	add_alias_lists_callees (const char *module_name)
	global variables IN: unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists More...

bool	alias_lists (const string module_name)
	modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists More...

Variables
static list	l_alias_lists

static list	unmatched_alias_pairs

static list	matched_alias_pairs

Function Documentation

◆ add_alias_lists_callee()

static void add_alias_lists_callee ( string callee_name )

static

global variables IN: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists

Definition at line 250 of file alias_lists.c.

 {
     list callee_alias_lists;
     bool result;
     region alias_list_reg;
  
     pips_debug(4,"begin for callee %s\n",callee_name);
  
     callee_alias_lists =
         effects_classes_classes((effects_classes)
                                 db_get_memory_resource(DBR_ALIAS_LISTS,
                                                        callee_name,
                                                        true));
     MAP(EFFECTS,callee_alias_list_effects,
             {
                 list callee_alias_list =
                     effects_effects(callee_alias_list_effects);
  
                 ifdebug(9)
                     {
                         pips_debug(9,"add list:\n");
                         print_inout_regions(callee_alias_list);
                     }
  
                 if (callee_alias_list != NIL)
                 {
                     alias_list_reg = EFFECT(CAR(gen_last(callee_alias_list)));
                     result =
                         compare_unmatched_alias_pairs(alias_list_reg,
                                                       callee_alias_list);
                     result =
                         compare_matched_alias_pairs(result,
                                                     alias_list_reg,
                                                     callee_alias_list);
                     if (result == false)
                         l_alias_lists =
                             CONS(EFFECTS,
                                  make_effects(regions_dup(callee_alias_list)),
                                  l_alias_lists);
                 }
             },callee_alias_lists);
  
     pips_debug(4,"end\n");
 }

References CAR, compare_matched_alias_pairs(), compare_unmatched_alias_pairs(), CONS, db_get_memory_resource(), EFFECT, EFFECTS, effects_classes_classes, effects_effects, gen_last(), ifdebug, l_alias_lists, make_effects(), MAP, NIL, pips_debug, print_inout_regions(), region, and regions_dup().

Referenced by add_alias_lists_callees().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_alias_lists_callees()

static void add_alias_lists_callees ( const char * module_name )

static

global variables IN: unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists

Definition at line 303 of file alias_lists.c.

 {
     callees l_callees;
  
     pips_debug(4,"begin\n");
  
     matched_alias_pairs = NIL;
  
     l_callees = (callees) db_get_memory_resource(DBR_CALLEES,
                                                  module_name,
                                                  true);
  
     MAP(STRING, callee_name,
         {
             add_alias_lists_callee(callee_name);
         },callees_callees(l_callees));
  
     pips_debug(4,"end\n");
 }

References add_alias_lists_callee(), callees_callees, db_get_memory_resource(), MAP, matched_alias_pairs, module_name(), NIL, pips_debug, and STRING.

Referenced by alias_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_unmatched_alias_pairs()

static void add_unmatched_alias_pairs ( )

static

global variables IN: unmatched_alias_pairs, l_alias_lists modifies global variable: l_alias_lists

Definition at line 115 of file alias_lists.c.

 {
     pips_debug(4,"begin\n");
  
     MAP(LIST,alias_pair,
         {
             l_alias_lists =
                 CONS(EFFECTS,
                      make_effects(regions_dup(alias_pair)),
                      l_alias_lists);
         },unmatched_alias_pairs);
  
     pips_debug(4,"end\n");
 }

References CONS, EFFECTS, l_alias_lists, LIST, make_effects(), MAP, pips_debug, regions_dup(), and unmatched_alias_pairs.

Referenced by alias_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alias_lists()

bool alias_lists ( const string module_name )

modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists

alias_lists.c

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

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

make alias lists from the IN_alias_pairs

DBR_IN_ALIAS_PAIRS is a newgen structure of type effects_classes which has one field called classes which is a list of newgen structures of type effects (and each newgen structure of type effects has one field called effects which is a list of elements of type effect)

wrong but did work:

in_alias_pairs = effects_to_list((effects) db_get_memory_resource(DBR_IN_ALIAS_PAIRS, module_name, true));

MAP(LIST, alias_pair, { list in_alias_pair = regions_dup(alias_pair);

make alias lists from the OUT_alias_pairs

MAP(LIST, alias_pair, { list out_alias_pair = regions_dup(alias_pair);

Parameters

module_name odule_name

Definition at line 328 of file alias_lists.c.

     {
     list in_alias_pairs, out_alias_pairs;
     entity module;
  
     l_alias_lists = NIL;
     unmatched_alias_pairs = NIL;
  
     debug_on("ALIAS_LISTS_DEBUG_LEVEL");
     pips_debug(4,"begin for module %s\n",module_name);
  
     ifdebug(1)
         {
             /* 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_CUMULATED_EFFECTS,
                                          module_name,
                                          true));
             module_to_value_mappings(module);
             /* that's it, but we musn't forget to reset everything below */
         }
  
     /* make alias lists from the IN_alias_pairs */
  
     /* DBR_IN_ALIAS_PAIRS is a newgen structure of type effects_classes
      * which has one field called classes
      * which is a list of newgen structures of type effects
      * (and each newgen structure of type effects
      * has one field called effects which is a list of elements
      * of type effect)
      */
  
     in_alias_pairs =
         effects_classes_classes((effects_classes)
                                 db_get_memory_resource(DBR_IN_ALIAS_PAIRS,
                                                        module_name,
                                                        true));
  
  
 /* wrong but did work:
  
     in_alias_pairs =
         effects_to_list((effects)
                         db_get_memory_resource(DBR_IN_ALIAS_PAIRS,
                                                module_name,
                                                true));
 */
  
 /*    MAP(LIST, alias_pair,
         {
             list in_alias_pair = regions_dup(alias_pair);
             */
  
     MAP(EFFECTS, alias_pair_effects,
         {
             list alias_pair = effects_effects(alias_pair_effects);
  
             ifdebug(9)
                 {
                     pips_debug(9,"IN alias pair : \n");
                     print_inout_regions(alias_pair);
                 }
             unmatched_alias_pairs =
                 CONS(LIST,alias_pair,unmatched_alias_pairs);
         },in_alias_pairs);
  
     /* make alias lists from the OUT_alias_pairs */
     out_alias_pairs =
         effects_classes_classes((effects_classes)
                                 db_get_memory_resource(DBR_OUT_ALIAS_PAIRS,
                                                        module_name,
                                                        true));
  
 /*    MAP(LIST, alias_pair,
         {
             list out_alias_pair = regions_dup(alias_pair);*/
  
     MAP(EFFECTS, alias_pair_effects,
         {
             list alias_pair = effects_effects(alias_pair_effects);
  
             ifdebug(9)
                 {
                     pips_debug(9,"OUT alias pair : \n");
                     print_inout_regions(alias_pair);
                 }
  
             unmatched_alias_pairs =
                 CONS(LIST,alias_pair,unmatched_alias_pairs);
         },out_alias_pairs);
  
     ifdebug(9)
         {
             pips_debug(9,"unmatched_alias_pairs:\n");
             MAP(LIST,alias_pair,
                 {
                     print_inout_regions(alias_pair);
                     pips_debug(9,"---\n");
                 },unmatched_alias_pairs);
         }
  
     add_alias_lists_callees(module_name);
  
     ifdebug(9)
         {
             pips_debug(9,"l_alias_lists:\n");
             MAP(EFFECTS,alias_list,
                 {
                     print_inout_regions(effects_effects(alias_list));
                     pips_debug(9,"---\n");
                 },l_alias_lists);
             pips_debug(9,"matched_alias_pairs:\n");
             MAP(LIST,alias_pair,
                 {
                     print_inout_regions(alias_pair);
                     pips_debug(9,"---\n");
                 },matched_alias_pairs);
             pips_debug(9,"unmatched_alias_pairs:\n");
             MAP(LIST,alias_pair,
                 {
                     print_inout_regions(alias_pair);
                     pips_debug(9,"---\n");
                 },unmatched_alias_pairs);
         }
  
     add_unmatched_alias_pairs();
  
     ifdebug(9)
         {
             pips_debug(9,"l_alias_lists:\n");
             MAP(EFFECTS,alias_list,
                 {
                     print_inout_regions(effects_effects(alias_list));
                     pips_debug(9,"---\n");
                 },l_alias_lists);
             }
  
     DB_PUT_MEMORY_RESOURCE(DBR_ALIAS_LISTS, 
                            strdup(module_name),
                            (char*) make_effects_classes(l_alias_lists));    
  
     ifdebug(1)
         {
             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_alias_lists_callees(), add_unmatched_alias_pairs(), 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, in_alias_pairs(), l_alias_lists, LIST, local_name_to_top_level_entity(), make_effects_classes(), MAP, matched_alias_pairs, module, module_name(), module_to_value_mappings(), NIL, out_alias_pairs(), 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(), and unmatched_alias_pairs.

Referenced by alias_classes(), and aliases_text().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_matched_alias_pairs()

static bool compare_matched_alias_pairs	(	bool	result,
		region	alias_list_reg,
		list	callee_alias_list
	)

static

global variables IN: matched_alias_pairs, l_alias_lists modifies global variable: l_alias_lists

must take the action of the regions into account here because we are checking whether formal_reg is the result of the propagation of alias_list_reg

Definition at line 135 of file alias_lists.c.

 {
     region formal_reg;
  
     pips_debug(4,"begin\n");
  
     MAP(LIST,alias_pair,
         {
             formal_reg = EFFECT(CAR(alias_pair));
  
             ifdebug(9)
                 {
                     set_action_interpretation(ACTION_IN,ACTION_OUT);
                     pips_debug(9,"compare to:\n");
                     print_region(formal_reg);
                     reset_action_interpretation();
                 }
  
 /* must take the action of the regions into account here because
  * we are checking whether formal_reg is the result of the
  * propagation of alias_list_reg
  */
             if ( same_reg(formal_reg,alias_list_reg) )
             {
                 pips_debug(9,"match\n");
  
                 l_alias_lists =
                     CONS(EFFECTS,
                          make_effects(gen_nconc(regions_dup(callee_alias_list),
                                                 regions_dup(CDR(alias_pair)))),
                          l_alias_lists);
                 result = true;
             }
         },matched_alias_pairs);
  
     pips_debug(4,"end\n");
  
     return result;
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, CONS, EFFECT, EFFECTS, gen_nconc(), ifdebug, l_alias_lists, LIST, make_effects(), MAP, matched_alias_pairs, pips_debug, print_region, region, regions_dup(), reset_action_interpretation(), same_reg(), and set_action_interpretation().

Referenced by add_alias_lists_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_unmatched_alias_pairs()

static bool compare_unmatched_alias_pairs	(	region	alias_list_reg,
		list	callee_alias_list
	)

static

global variables IN: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists modifies global variables: matched_alias_pairs, unmatched_alias_pairs, l_alias_lists

must take the action of the regions into account here because we are checking whether formal_reg is the result of the propagation of alias_list_reg

Definition at line 186 of file alias_lists.c.

 {
     region formal_reg;
     list rest_unmatched_alias_pairs = unmatched_alias_pairs;
     bool result = false;
  
     ifdebug(4)
         {
             set_action_interpretation(ACTION_IN,ACTION_OUT);
             pips_debug(4,"begin for alias_list_reg:\n");
             print_region(alias_list_reg);
             reset_action_interpretation();
         }
  
     unmatched_alias_pairs = NIL;
  
     MAP(LIST,alias_pair,
         {
             formal_reg = EFFECT(CAR(alias_pair));
  
             ifdebug(9)
                 {
                     set_action_interpretation(ACTION_IN,ACTION_OUT);
                     pips_debug(9,"compare to:\n");
                     print_region(formal_reg);
                     reset_action_interpretation();
                 }
  
 /* must take the action of the regions into account here because
  * we are checking whether formal_reg is the result of the
  * propagation of alias_list_reg
  */
             if ( same_reg(formal_reg,alias_list_reg) )
             {
                 pips_debug(9,"match\n");
  
                 l_alias_lists =
                     CONS(EFFECTS,
                          make_effects(gen_nconc(regions_dup(callee_alias_list),
                                                 regions_dup(CDR(alias_pair)))),
                          l_alias_lists);
                 matched_alias_pairs =
                     CONS(LIST,alias_pair,matched_alias_pairs);
                 result = true;
             }
             else
                 unmatched_alias_pairs =
                     CONS(LIST,alias_pair,unmatched_alias_pairs);
         },rest_unmatched_alias_pairs);
  
     pips_debug(4,"end\n");
  
     return result;
 }

References ACTION_IN, ACTION_OUT, CAR, CDR, CONS, EFFECT, EFFECTS, gen_nconc(), ifdebug, l_alias_lists, LIST, make_effects(), MAP, matched_alias_pairs, NIL, pips_debug, print_region, region, regions_dup(), reset_action_interpretation(), same_reg(), set_action_interpretation(), and unmatched_alias_pairs.

Referenced by add_alias_lists_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ same_reg()

static bool same_reg	(	region	reg1,
		region	reg2
	)

static

tests if reg1 and reg2 are the same, including same action_tags (IN/OUT) and precision (may/exact)

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

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

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

Definition at line 59 of file alias_lists.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"); */
  
                 if (effect_action_tag(reg1) == 
                     effect_action_tag(reg2))
                 {
 /*              pips_debug(1,"same action\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;
     }