phrase_distributor.c

Go to the documentation of this file.

/*
 
  $Id: phrase_distributor.c 23412 2017-08-09 15:07:09Z irigoin $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS 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 3 of the License, or
  any later version.
 
  PIPS 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 PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
#include <stdio.h>
#include <ctype.h>
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
 
#include "resources.h"
 
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "syntheses.h"
#include "effects-util.h"
#include "pipsdbm.h"
 
#include "text-util.h"
#include "properties.h"
 
#include "dg.h"
#include "transformer.h"
 
typedef dg_arc_label arc_label;
typedef dg_vertex_label vertex_label;
 
#include "graph.h"
 
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
#include "semantics.h"
#include "control.h"
#include "callgraph.h"
#include "preprocessor.h"
#include "pipsmake.h"
 
#include "phrase_tools.h"
 
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
 
#include "phrase_distribution.h"
 
static entity create_module_with_statement (statement stat, 
                                            string new_module_name,
                                            list l_params,
                                            list l_priv);
 
/**
 * Return the identified function name of the externalized portion of code
 * by searching comment matching tag 
 */
string get_function_name_by_searching_tag(statement stat,
                                          const char* tag) 
{
  string comments;
  string searched_string;
  string comment_portion = strdup(tag);
  char* function_name = NULL;
  char*  next_line;
  instruction i = statement_instruction(stat);
 
  ifdebug(5) {
    pips_debug(5, "BEGIN get_function_name_by_searching_tag [%s] on \n", tag);
    print_statement(stat);
  }
 
  if (instruction_tag(i) == is_instruction_sequence) {
    stat = STATEMENT(gen_nth(0,sequence_statements(instruction_sequence(i))));
  }
 
  if (!statement_with_empty_comment_p(stat)) {
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok (comments, "\n");
    if (next_line != NULL) {
      do {
        string first_occurence = strstr(next_line,searched_string);
        if (first_occurence != NULL) {
          function_name = malloc(256);
          sscanf (first_occurence, comment_portion, function_name);
          pips_debug(5, "Found function: [%s]\n", function_name);
        }
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
  }
 
  pips_debug(5, "END get_function_name_by_searching_tag [%s] on \n", tag);
  return function_name;
}
 
/**
 * Remove begin tag for statement stat and function function_name
 */
static void remove_begin_tag (statement stat, string function_name)
{
  char* removed_tag ;
  asprintf (&removed_tag,EXTERNALIZED_CODE_PRAGMA_BEGIN,function_name);
  ifdebug(2) {
    pips_debug(2, "REMOVE %s from\n", removed_tag);
    print_statement (stat);
  }
  clean_statement_from_tags (removed_tag, stat);
}
 
/**
 * Remove end tag for statement stat and function function_name
 */
static void remove_end_tag (statement stat, string function_name)
{
  char* removed_tag ;
  asprintf (&removed_tag,EXTERNALIZED_CODE_PRAGMA_END,function_name);
  ifdebug(2) {
    pips_debug(2, "REMOVE %s from\n", removed_tag);
    print_statement (stat);
  }
  clean_statement_from_tags (removed_tag, stat);
}
 
 
 
/** At this point, we have a sequence statement sequence_statement which
 * contains a statement with a begin tag and a statement with a end
 * tag. The goal is to transform this statement in a sequence statement
 * with a single statement, which is the embedded statement that will be
 * distributed. 
 * This function returns this isolated statement
 */
static statement isolate_code_portion (statement begin_tag_statement, 
                                       statement end_tag_statement, 
                                       statement sequence_statement) 
{
  instruction i = statement_instruction(sequence_statement);
  list seq_stats = sequence_statements(instruction_sequence(i));
  list new_seq_stats = NIL;
  list isolated_seq_stats = NIL;
  bool statement_to_isolate;
  int nb_of_statements_to_isolate;
  string function_name = get_externalizable_function_name(begin_tag_statement);
 
 
  pips_assert ("sequence_statement is a sequence",
               instruction_tag(i) == is_instruction_sequence);
 
  pips_assert ("function_name is not NULL",
               function_name != NULL);
 
  /* First, count the number of statements to isolate in a single statement */
  statement_to_isolate = false;
  nb_of_statements_to_isolate = 0;
  MAP (STATEMENT, s, {
 
    if ((statement_to_isolate && (s != end_tag_statement))
        || ((!statement_to_isolate) && (s == begin_tag_statement))) {
      nb_of_statements_to_isolate++;
      isolated_seq_stats = CONS(STATEMENT, s, isolated_seq_stats);
    }
    if (statement_to_isolate && (s == end_tag_statement)) {
      statement_to_isolate = false;
    }
    if ((!statement_to_isolate) && (s == begin_tag_statement)) {
      statement_to_isolate = true;
    }
    
  }, seq_stats);
 
  remove_begin_tag (begin_tag_statement, function_name);
  remove_end_tag (end_tag_statement, function_name);
 
  /* Insert an analyzed tag */
  {
    char* new_tag ;
    asprintf (&new_tag, 
             (concatenate("! ",
                                EXTERNALIZED_CODE_PRAGMA_ANALYZED,
                                "\n",
                                NULL)),
             function_name,
             nb_of_statements_to_isolate);
    insert_comments_to_statement(begin_tag_statement, new_tag);
  }
 
  pips_debug(5, "Found %d statement to isolate\n",
             nb_of_statements_to_isolate);      
 
  if (nb_of_statements_to_isolate > 1) {
 
    /* Build new isolated sequence statement */
    
    sequence new_sequence = make_sequence (gen_nreverse(isolated_seq_stats));
    instruction sequence_instruction
      = make_instruction(is_instruction_sequence,
                         new_sequence);
    statement returned_statement 
      = make_statement(entity_empty_label(),
                       statement_number(sequence_statement),
                       statement_ordering(sequence_statement),
                       empty_comments,
                       sequence_instruction,NIL,NULL,
                       statement_extensions(sequence_statement), make_synchronization_none());
 
    bool isolated_seq_stats_is_inserted = false;
    
    /* Build new sequence containing isolated sequence statement */
 
    MAP (STATEMENT, s, {
      if ((statement_to_isolate && (s != end_tag_statement))
          || ((!statement_to_isolate) && (s == begin_tag_statement))) {
        if (!isolated_seq_stats_is_inserted) {
          new_seq_stats = CONS(STATEMENT, returned_statement, new_seq_stats);
          isolated_seq_stats_is_inserted = true;
        }
      }
      else {
        new_seq_stats = CONS(STATEMENT, s, new_seq_stats);
      }
      if (statement_to_isolate && (s == end_tag_statement)) {
        statement_to_isolate = false;
      }
      if ((!statement_to_isolate) && (s == begin_tag_statement)) {
        statement_to_isolate = true;
      }
    }, seq_stats); 
 
    /* Rebuild the sequence in the GOOD order */
    sequence_statements(instruction_sequence(i)) 
      = gen_nreverse(new_seq_stats);
 
    ifdebug(5) {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(returned_statement);
    }
 
    return returned_statement;
  }
  else if (nb_of_statements_to_isolate == 1) {
    /* Nothing to do, the code is already isolated ! */
    ifdebug(5) {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(begin_tag_statement);
    }
    return begin_tag_statement;
  }
  else {
    pips_user_warning("Malformed externalized code portion identified. No operation to do. Ignored.\n");
    return NULL;
  }
 
}
 
 
/* 
 * This function return a list of statements that were previously marked
 * for externalization during phase PHRASE_DISTRIBUTOR_INIT
 */
list identify_analyzed_statements_to_distribute (statement stat) 
{
  /* We identify all the statement containing an analyzed tag */
  return get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_ANALYZED,
                                                 stat); 
  
}
 
 
/* 
 * This function return a list of statements that are marked for
 * externalization.  A well-formed externalizable code must be one or more
 * continuous statements defined in a sequence statement framed with
 * comments containing tags EXTERNALIZED_CODE_PRAGMA_BEGIN and
 * EXTERNALIZED_CODE_PRAGMA_END
 */
static list identify_statements_to_distribute (statement module_stat) 
{
  list statements_containing_begin_tag = NIL;
  list statements_contained_in_a_sequence = NIL;
  list statements_to_distribute = NIL;
  
  /* We identify all the statement containing a begin tag */
  statements_containing_begin_tag 
    = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN,
                                              module_stat); 
  /* We restructure the code to avoid imbricated sequences only if
   * some portions are found (to allow more than one INIT) */
  if (gen_length(statements_containing_begin_tag) > 0) {
    simple_restructure_statement(module_stat);
  }
 
  /* We identify again (after code restructuration) all the statement
   * containing a begin tag */
  statements_containing_begin_tag = NIL;
  statements_containing_begin_tag
    = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN,
                                              module_stat);
 
  /* We check that all those statements are contained in a sequence */
  MAP (STATEMENT, s, {
    ifdebug(5) {
      pips_debug(5, "Potential externalizable statement:\n");
      print_statement(s);
    }
    if (statement_is_contained_in_a_sequence_p (module_stat,s)) {
      statements_contained_in_a_sequence
        = CONS (STATEMENT,
                s,
                statements_contained_in_a_sequence);
    }
    else {
      pips_user_warning("Malformed externalized code portion identified. Ignored.\n");
    }
  }, statements_containing_begin_tag);
 
  /* */
  FOREACH (STATEMENT, s, statements_contained_in_a_sequence){
      statement sequence_statement;
      string function_name;
      string end_tag;
      list potential_end_statement = NIL;
      sequence_statement = sequence_statement_containing (module_stat,s);
      ifdebug(5) {
          pips_debug(5, "Potential externalizable statement contained in a sequence \n");
          print_statement(s);
      }
      function_name = get_externalizable_function_name(s);
      if (function_name != NULL) {
          pips_debug(5, "Name: [%s] \n", function_name);
          asprintf (&end_tag, EXTERNALIZED_CODE_PRAGMA_END,function_name);
          potential_end_statement
              = get_statements_with_comments_containing (end_tag,
                      sequence_statement);
          if (gen_length(potential_end_statement) == 1) {
              statement begin_tag_statement = s;
              statement end_tag_statement 
                  = STATEMENT(gen_nth(0,potential_end_statement));
              statement container_of_end_tag_statement
                  = sequence_statement_containing (sequence_statement, end_tag_statement);
              if (container_of_end_tag_statement == sequence_statement) {
                  statement externalized_code
                      = isolate_code_portion (begin_tag_statement, 
                              end_tag_statement, 
                              sequence_statement);
                  statements_to_distribute 
                      = CONS (STATEMENT,
                              externalized_code,
                              statements_to_distribute);
              }
              else {
                  pips_user_warning("Malformed externalized code portion identified [%s]. End tag found at a bad place!!!. Ignored.\n", function_name);
              }
          }
          else {
              pips_user_warning("Malformed externalized code portion identified [%s]. %d end tags found!!!. Ignored.\n", function_name, gen_length(potential_end_statement));
          }
      }
      else {
          pips_user_warning("Malformed externalized code portion identified [Unnamed]!!!. Ignored.\n");
      }
  }
 
  return statements_to_distribute;
}
                                              
/**
 * This function is called after identification and isolation of a portion
 * of code to externalize. Externalization of specified code is done here.
 */
static void distribute_code (string function_name,
                             statement externalized_code, 
                             statement module_stat, 
                             list l_params,
                             list l_priv) 
{
  entity new_module;
  statement call_statement;
  list call_params;
  string call_comments;
 
  new_module 
    = create_module_with_statement (externalized_code, 
                                    function_name,
                                    l_params,
                                    l_priv);
  
  call_params = NIL;
  MAP (REFERENCE, ref, {
    call_params = CONS(EXPRESSION, entity_to_expression(reference_variable(ref)), call_params);
  }, references_for_regions(l_params));
  
  // Insert an analyzed tag 
  {
    asprintf (&call_comments, 
             (concatenate("! ",
                                EXTERNALIZED_CODE_PRAGMA_CALL,
                                "\n",
                                NULL)),
             function_name);
  }
 
  call_statement = make_statement(entity_empty_label(),
                                  statement_number(externalized_code),
                                  statement_ordering(externalized_code),
                                  call_comments,
                                  make_instruction(is_instruction_call,
                                                   make_call(new_module,call_params)),
                                  NIL,NULL,
                                  statement_extensions(externalized_code), make_synchronization_none());
 
  ifdebug(5) {
    pips_debug(5, "BEFORE REPLACING\n");
    pips_debug(5, "externalized_code=\n");
    print_statement(externalized_code);
    pips_debug(5, "call_statement=\n");
    print_statement(call_statement);
    pips_debug(5, "module_stat=\n");
    print_statement(module_stat);
  }
 
  replace_in_sequence_statement_with(externalized_code,
                                     call_statement,
                                     module_stat);
 
  ifdebug(5) {
    pips_debug(5, "AFTER REPLACING\n");
    pips_debug(5, "externalized_code=\n");
    print_statement(externalized_code);
    pips_debug(5, "call_statement=\n");
    print_statement(call_statement);
    pips_debug(5, "module_stat=\n");
    print_statement(module_stat);
  }
 
  pips_assert("Module structure is consistent after DISTRIBUTE_CODE", 
              gen_consistent_p((gen_chunk*)new_module));
              
  pips_assert("Statement structure is consistent after DISTRIBUTE_CODE", 
              gen_consistent_p((gen_chunk*)externalized_code));
              
  pips_assert("Statement is consistent after DISTRIBUTE_CODE", 
              statement_consistent_p(externalized_code));
  
  pips_debug(5, "Code distribution for : [%s] is DONE\n", function_name);
}
/**
 * Main function for PHRASE_DISTRIBUTION: phrase distribution for main
 * module module, with root statement stat
 */
static void distribute (statement module_stat, 
                        entity module) 
{
  list l_stats;
  hash_table ht_stats;
  hash_table ht_params;
  hash_table ht_private;
  hash_table ht_in_regions;
  hash_table ht_out_regions;
 
  l_stats = identify_analyzed_statements_to_distribute (module_stat);
 
  compute_distribution_context (l_stats, 
                                module_stat,
                                module,
                                &ht_stats,
                                &ht_params,
                                &ht_private,
                                &ht_in_regions,
                                &ht_out_regions);
  
  HASH_MAP (function_name, stat, {
    distribute_code (function_name,
                     stat, 
                     module_stat, 
                     hash_get(ht_params,function_name),
                     hash_get(ht_private,function_name));
  },ht_stats);
  
  hash_table_free(ht_stats);
  hash_table_free(ht_params);
  hash_table_free(ht_private);
  hash_table_free(ht_in_regions);
  hash_table_free(ht_out_regions);
}
 
/**
 * Main function for PHRASE_DISTRIBUTION_INIT: phrase distribution for
 * module module_stat
 */
static void prepare_distribute (statement module_stat) 
{
  identify_statements_to_distribute (module_stat);
}
 
/*
 * Return EXTERNALIZED_FUNCTION_PARAM_NAME
 */
static string get_externalized_function_param_name (entity variable, int param_nb) 
{
  char *buffer;
  asprintf(&buffer,
          EXTERNALIZED_FUNCTION_PARAM_NAME,
          entity_local_name(variable),
          param_nb);
  return (buffer);
}
 
/*
 * Return EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME
 */
static string get_externalized_function_private_param_name (entity variable) 
{
  char *buffer;
  asprintf(&buffer,
          EXTERNALIZED_FUNCTION_PRIVATE_PARAM_NAME,
          entity_local_name(variable));
  return (buffer);
}
 
/**
 * Creates a variable declared as a parameter in specified module
 */
static entity create_parameter_variable_for_new_module (entity a_variable,
                                                        string new_name, 
                                                        string new_module_name,
                                                        entity module,
                                                        int param_nb)
{
  entity new_variable;
 
  if ((gen_find_tabulated(concatenate(new_module_name, 
                                      MODULE_SEP_STRING, 
                                      new_name, 
                                      NULL),
                          entity_domain)) == entity_undefined) 
    { 
      /* This entity does not exist, we can safely create it */
      
      new_variable = make_entity (strdup(concatenate(new_module_name, 
                                                     MODULE_SEP_STRING, 
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  make_storage_formal (make_formal(module, param_nb)),
                                  copy_value (entity_initial(a_variable)));
 
      return new_variable;
    }
  else 
    {
      pips_internal_error("Entity already exist: %s", new_name);
      return NULL;
    }
}
 
/**
 * Creates a private variable in specified module
 */
entity create_private_variable_for_new_module (entity a_variable,
                                               const char* new_name, 
                                               const char* new_module_name,
                                               entity module)
{
  entity new_variable;
  entity a;
  basic base;
  
  if ((gen_find_tabulated(concatenate(new_module_name, 
                                      MODULE_SEP_STRING, 
                                      new_name, 
                                      NULL),
                          entity_domain)) == entity_undefined) 
    { 
      /* This entity does not exist, we can safely create it */
      
      new_variable = make_entity (strdup(concatenate(new_module_name, 
                                                     MODULE_SEP_STRING, 
                                                     new_name, NULL)),
                                  copy_type (entity_type(a_variable)),
                                  storage_undefined,
                                  copy_value (entity_initial(a_variable)));
      a = FindEntity(new_module_name, DYNAMIC_AREA_LOCAL_NAME); 
      base = variable_basic(type_variable(entity_type(a_variable)));
      entity_storage(new_variable) = 
        make_storage(is_storage_ram,
                     make_ram(module, a,
                              (basic_tag(base)!=is_basic_overloaded)?
                              (add_variable_to_area(a, new_variable)):(0),
                              NIL));
      pips_debug(2, "Created new private variable: %s\n", entity_global_name(new_variable));
      return new_variable;
    }
  else 
    {
      pips_internal_error("Entity already exist: %s", new_name);
      return NULL;
    }
}
 
 
/**
 * Declare in the newly created module a new variable (which will be a
 * parameter of the module), and replace all occurences to the old
 * variable by the new created
 */
void add_parameter_variable_to_module (reference ref,
                                       entity module,
                                       statement stat, /* Statement of the new module */
                                       string new_module_name,
                                       int param_nb)
{
  parameter new_parameter;
  list module_declarations;
  list module_parameters;
  entity new_variable;
  string variable_name;
 
  pips_debug(2, "Registering parameter: %s\n", entity_local_name(reference_variable(ref)));
 
  /* Assert that entity represent a value code */
  pips_assert("It is a module", entity_module_p(module));
 
  /* Get the variable name */
  variable_name 
    = get_externalized_function_param_name (reference_variable(ref),param_nb); 
 
  new_variable = create_parameter_variable_for_new_module (reference_variable(ref),
                                                           variable_name,
                                                           new_module_name,
                                                           module,
                                                           param_nb);
  
  replace_reference (stat, ref, new_variable);
  
  module_declarations = code_declarations(value_code(entity_initial(module)));
  
  code_declarations(value_code(entity_initial(module)))
    = CONS (ENTITY, new_variable, module_declarations);
  
  new_parameter = make_parameter (entity_type(new_variable),
                                  make_mode_reference(),
                                  /*strdup("")*/make_dummy_identifier(new_variable));
  
  module_parameters = functional_parameters(type_functional(entity_type(module)));
 
  functional_parameters(type_functional(entity_type(module))) 
    = CONS(PARAMETER, new_parameter, module_parameters);
 
}
 
/**
 * Declare in the newly created module a new variable (which will be a
 * private to the module), and replace all occurences to the old
 * variable by the new created
 */
void add_private_variable_to_module (reference ref,
                                            entity module,
                                            statement stat, /* Statement of the new module */
                                            string new_module_name)
{
  list module_declarations;
  entity new_variable;
  string variable_name;
  
  pips_debug(2, "Registering private variable: %s\n", entity_local_name(reference_variable(ref)));
  
  /* Assert that entity represent a value code */
  pips_assert("It is a module", entity_module_p(module));
  
  /* Get the variable name */
  variable_name = get_externalized_function_private_param_name (reference_variable(ref)); 
 
  /* Creates the variable */
  new_variable 
    = create_private_variable_for_new_module (reference_variable(ref),
                                              variable_name,
                                              new_module_name,
                                              module);  
  
  replace_reference (stat, ref, new_variable);
    
  module_declarations = code_declarations(value_code(entity_initial(module)));
  
  code_declarations(value_code(entity_initial(module)))
    = CONS (ENTITY, new_variable, module_declarations);
  
}
 
/**
 * Dynamically build a new module with specified statement.
 * After creation, return it.
 */
static entity create_module_with_statement (statement stat, 
                                            string new_module_name,
                                            list l_params,
                                            list l_priv) 
{
    entity new_module;
    int param_nb = 0;
 
    pips_debug(2, "Creating new module: [%s]\n", new_module_name);
 
    new_module = make_empty_subroutine(new_module_name,make_language_unknown());
 
    /* Deal with private variables */
    FOREACH (REFERENCE, ref, references_for_regions (l_priv)){
        add_private_variable_to_module (ref, 
                new_module, 
                stat, 
                new_module_name);
    }
 
    // Deal with parameters variables 
    param_nb = gen_length(l_params);
    FOREACH (REFERENCE, ref, references_for_regions(l_params)){
        add_parameter_variable_to_module (ref, 
                new_module, 
                stat, 
                new_module_name, 
                param_nb);
        param_nb--;
    }
 
    pips_debug(2, "Making new module: [%s]\n", new_module_name);
    ifdebug(5) {
        pips_debug(5, "With statement: \n");
        print_statement (stat);
    }
    text t = text_named_module(new_module, new_module, stat);
    add_new_module_from_text(new_module_name, t, fortran_module_p(get_current_module_entity()), compilation_unit_of_module(get_current_module_name()) );
 
    free_text(t);
 
    return new_module;
}
 
/*********************************************************
 * Phase main for PHRASE_DISTRIBUTOR_INIT
 *********************************************************/
 
bool phrase_distributor_init(const char* module_name)
{
  
  /* get the resources */
  statement stat = (statement) db_get_memory_resource(DBR_CODE, 
                                                      module_name, 
                                                      true);
  
  
  set_current_module_statement(stat);
  set_current_module_entity(module_name_to_entity(module_name)); //FI: redundant
  
  debug_on("PHRASE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Now do the job */
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR_INIT\n");
  prepare_distribute (stat);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR_INIT\n");
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR_INIT", 
              gen_consistent_p((gen_chunk*)stat));
              
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR_INIT", 
               statement_consistent_p(stat));
 
  
  /* Reorder the module, because new statements have been added */  
  module_reorder(stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, 
                         compute_callees(stat));
  
  /* update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  
  debug_off();
  
  return true;
}
 
/*********************************************************
 * Phase main for PHRASE_DISTRIBUTOR
 *********************************************************/
 
static entity dynamic_area = entity_undefined;
 
bool phrase_distributor(const char* module_name)
{
  statement module_stat;
  entity module;
  
  /* set and get the current properties concerning regions */
  set_bool_property("MUST_REGIONS", true);
  set_bool_property("EXACT_REGIONS", true);
  get_regions_properties();
  
  /* get the resources */
  module_stat = (statement) db_get_memory_resource(DBR_CODE, 
                                                   module_name, 
                                                   true);
  
  module = module_name_to_entity(module_name);
  
  set_current_module_statement(module_stat);
  set_current_module_entity(module_name_to_entity(module_name)); // FI: redundant
  
  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);
  
  /* sets dynamic_area */
  if (entity_undefined_p(dynamic_area)) {       
    dynamic_area = FindOrCreateEntity(module_local_name(module),
                                      DYNAMIC_AREA_LOCAL_NAME); 
  }
 
  debug_on("PHRASE_DISTRIBUTOR_DEBUG_LEVEL");
 
     /* Get the READ, WRITE, IN and OUT regions of the module
      */
    set_rw_effects((statement_effects) 
        db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_in_effects((statement_effects) 
        db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
    set_out_effects((statement_effects) 
        db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
  /* Now do the job */
 
  pips_debug(2, "BEGIN of PHRASE_DISTRIBUTOR\n");
  distribute (module_stat, module);
  pips_debug(2, "END of PHRASE_DISTRIBUTOR\n");
 
  //print_statement(module_stat);
 
  pips_assert("Statement structure is consistent after PHRASE_DISTRIBUTOR", 
              gen_consistent_p((gen_chunk*)module_stat));
              
  pips_assert("Statement is consistent after PHRASE_DISTRIBUTOR", 
              statement_consistent_p(module_stat));
  
  /* Reorder the module, because new statements have been added */  
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, 
                         compute_callees(module_stat));
  
  /* update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  dynamic_area = entity_undefined;
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_rw_effects();
  reset_in_effects();
  reset_out_effects();
  free_value_mappings();
  
  debug_off();
  
  return true;
}