clone.c

Go to the documentation of this file.

/*
 
  $Id: clone.c 23065 2016-03-02 09:05:50Z coelho $
 
  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/>.
 
*/
 
// do not compile unless required
#include "phases.h"
#if defined(BUILDER_CLONE) ||                   \
  defined(BUILDER_CLONE_ONLY) ||                \
  defined(BUILDER_CLONE_ON_ARGUMENT) ||         \
  defined(BUILDER_CLONE_SUBSTITUTE)
 
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
 * Cloning of a subroutine.
 * debug: CLONE_DEBUG_LEVEL
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "genC.h"
#include "linear.h"
 
#include "misc.h"
#include "properties.h"
#include "pipsdbm.h"
 
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "prettyprint.h" // for text_named_module
#include "effects-util.h"
 
#include "pipsmake.h" // add_new_module_from_text
#include "preprocessor.h" // compilation_unit_of_module
#include "semantics.h" // used
#include "callgraph.h" // used
 
#include "syntheses.h"
 
#define DEBUG_ON   debug_on("CLONE_DEBUG_LEVEL")
#define ALL_DECLS  "PRETTYPRINT_ALL_DECLARATIONS"
#define STAT_ORDER "PRETTYPRINT_STATEMENT_NUMBER"
#define undefined_number_p(n) ((n)==STATEMENT_NUMBER_UNDEFINED)
 
 
 
/************************************************** BUILD THE CLONE VERSIONS */
 
/* build a new clone version. if argn is not null, generate a check.
 */
static statement
build_statement_for_clone(
    entity cloned, 
    int argn, 
    int val)
{
    statement stat, check_arg_value;
 
    if (argn>0)
    {
        entity arg = find_ith_parameter(cloned, argn);
 
        /* IF (PARAM#ARGN.NE.VAL) STOP
         */
        check_arg_value = test_to_statement
           (make_test(MakeBinaryCall(entity_intrinsic(NON_EQUAL_OPERATOR_NAME),
             entity_to_expression(arg), int_to_expression(val)),
                       call_to_statement(make_call(entity_intrinsic
                                                   (STOP_FUNCTION_NAME), NIL)),
                       make_continue_statement(entity_undefined)));
 
        statement_comments(check_arg_value) =
          strdup(concatenate(fortran_module_p(get_current_module_entity())?
                             "!! PIPS: " : "// PIPS: ",
                             entity_user_name(arg),
                             " is assumed a constant reaching value\n", NULL));
    }
    else
        check_arg_value = make_continue_statement(entity_undefined);
 
    stat = make_block_statement(
            make_statement_list(check_arg_value, copy_statement(get_current_module_statement()))
            );
 
    return stat;
}
 
/* create an clone, and returns the corresponding entity,
 * which looks like a not yet parsed routine.
 * it puts the initial_file for the routine, and updates its user_file.
 */
static entity build_a_clone_for(entity cloned,
                                int argn,
                                int val)
{
  const char* name = entity_local_name(cloned);
  char* comments, *new_name;
  entity new_fun;
  statement stat;
  bool saved_b1, saved_b2;
  text t;
  language l = module_language(cloned);
  
  const char* suffix = get_string_property("RSTREAM_CLONE_SUFFIX");
  int size = 0;
 
  pips_debug(2, "building a version of %s with arg %d val=%d\n",
             name, argn, val);
 
  /* builds some kind of module / statement for the clone.
   */
  if (empty_string_p(suffix)) {
    const char *clone_name = get_string_property("CLONE_NAME");
    new_name = empty_string_p(clone_name) ?
      build_new_top_level_module_name(name,false) :
      strdup(clone_name);
  }
  else {
    size = strlen(name) + strlen(suffix) + 1;
    new_name = (char*)malloc(sizeof(char)*size);
    new_name[0] = '\0';
    new_name = strcat(new_name, name);
    new_name = strcat(new_name, "_");
    new_name = strcat(new_name, suffix);
  }
 
  new_fun = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,new_name);
  entity_type(new_fun) = copy_type(entity_type(cloned));
  entity_storage(new_fun) = copy_storage(entity_storage(cloned));
  entity_initial(new_fun) = entity_initial(cloned); /* no copy, reseted later*/
 
  saved_b1 = get_bool_property(ALL_DECLS);
  saved_b2 = get_bool_property(STAT_ORDER);
  set_bool_property(ALL_DECLS, true);
  set_bool_property(STAT_ORDER, false);
 
  stat = build_statement_for_clone(cloned, argn, val);
  t = text_named_module(new_fun, cloned, stat);
 
 
  set_bool_property(ALL_DECLS, saved_b1);
  set_bool_property(STAT_ORDER, saved_b2);
 
  /* add some comments before the code.
   */
  char *comment_prefix = fortran_module_p(cloned) ? "!!" : "//";
  comments = strdup(concatenate(
                                comment_prefix,"\n",
                                comment_prefix," PIPS: please caution!\n",
                                comment_prefix,"\n",
                                comment_prefix," this routine has been generated as a clone of ", name, "\n",
                                comment_prefix," the code may change significantly with respect to the original\n",
                                comment_prefix," version, especially after program transformations such as dead\n",
                                comment_prefix," code elimination and partial evaluation, hence the function may\n",
                                comment_prefix," not have the initial behavior, if called under some other context.\n",
                                comment_prefix,"\n", NULL));
  text_sentences(t) =
    CONS(SENTENCE, make_sentence(is_sentence_formatted, comments), text_sentences(t));
  add_new_module_from_text(new_name,t,fortran_module_p(cloned),fortran_module_p(cloned)?string_undefined:compilation_unit_of_module(get_current_module_name()));
  free_text(t);
 
  /* should fix the declarations ... but not the language... */
  entity_initial(new_fun) =
    make_value(is_value_code,
               make_code(NIL, strdup(""),
                         make_sequence(NIL),
                         NIL,
                         copy_language(l)));
 
  free_statement(stat);
  free(new_name);
  return new_fun;
}
 
 
/********************************************* STORE ALREADY CLONED VERSIONS */
 
/* already cloned version are kept in a dynamically allocated structure.
 * it is provided with init/close/get/set functions.
 */
typedef struct 
{
    entity the_ref;
    entity the_clone;
    int argn;
    int val;
} clone_t;
 
static int clones_index = 0 /* next available */, clones_size = 0;
static clone_t * clones = (clone_t*) NULL;
 
#define INITIALIZED pips_assert("clones initialized", clones && clones_size>0)
 
static void 
init_clone(void)
{
    pips_assert("clones undefined", clones==NULL && clones_size==0);
    clones_index = 0;
    clones_size = 10;
    clones = (clone_t*) malloc(sizeof(clone_t)*clones_size);
    pips_assert("malloc ok", clones);
}
 
static void
close_clone(void)
{
    INITIALIZED;
    free(clones), clones = NULL;
    clones_size = 0;
    clones_index = 0;
}
 
static entity 
get_clone(entity the_ref, int argn, int val)
{
    int i;
    INITIALIZED;
    pips_debug(8, "get %s %d %d\n", entity_name(the_ref), argn, val);
    for (i=0; i<clones_index; i++)
    {
        if (clones[i].the_ref == the_ref &&
            clones[i].argn == argn &&
            clones[i].val == val)
            return clones[i].the_clone;
    }
    return entity_undefined;
}
 
static void
set_clone(entity the_ref, entity the_clone, int argn, int val)
{
    INITIALIZED;
    pips_debug(8, "put %s %s %d %d\n", 
               entity_name(the_ref), entity_name(the_clone), argn, val);
 
    if (clones_index==clones_size)
    {
        clones_size+=10;
        clones = (clone_t*) realloc(clones, sizeof(clone_t)*clones_size);
        pips_assert("realloc ok", clones);
    }
 
    clones[clones_index].the_ref = the_ref;
    clones[clones_index].the_clone = the_clone;
    clones[clones_index].argn = argn;
    clones[clones_index].val = val;
 
    clones_index++;
}
 
 
/**************************************************** CLONING TRANSFORMATION */
 
/* static structures used for driving the cloning transformation.
 */
DEFINE_LOCAL_STACK(stmt, statement)
 
static entity module_to_clone = entity_undefined;
static int argument_to_clone = 0;
static int statement_to_clone = STATEMENT_NUMBER_UNDEFINED;
static entity clonee_to_substitute = entity_undefined;
static bool some_cloning_performed = false;
 
static void clone_error_handler()
{
    error_reset_stmt_stack();
    module_to_clone = entity_undefined;
    argument_to_clone = 0;
    statement_to_clone = STATEMENT_NUMBER_UNDEFINED;
    clonee_to_substitute = entity_undefined;
    some_cloning_performed = false;
}
 
/* returns if the expression is a constant, maybe thanks to the preconditions.
 */
static bool
this_expression_constant_p(
    expression e, /* expression to be tested */
    int * pval    /* returned integer value if one was found */)
{  
    bool ok = false;
    if (expression_constant_p(e)) 
    {
        pips_debug(7, "constant expression\n");
        *pval = expression_to_int(e);
        ok = true;
    }
    else if (expression_reference_p(e))
    {   
        entity ref;
        statement current;
        Psysteme prec;
        Pbase b;
        Value val;
 
        ref = reference_variable(expression_reference(e));
        if (entity_integer_scalar_p(ref)) 
        {
            pips_debug(7, "integer scalar reference\n");
            
            /* try with the precondition...
             */
            current = stmt_head();
            prec = sc_dup(predicate_system(transformer_relation(
                load_statement_precondition(current))));
            b = base_dup(sc_base(prec));
            vect_erase_var(&b, (Variable) ref);
            prec = sc_projection_optim_along_vecteur(prec, b);
            ok = sc_value_of_variable(prec, (Variable) ref, &val);
            sc_rm(prec), base_rm(b);
            
            if (ok) *pval = VALUE_TO_INT(val);
        }
        else pips_debug(7, "not an integer scalar reference\n");
    }
    else if (expression_call_p(e))
    {
        call c = syntax_call(expression_syntax(e));
        entity fun = call_function(c);
        value v = entity_initial(fun);
        
        if (value_symbolic_p(v) &&
            constant_int_p(symbolic_constant(value_symbolic(v)))) 
        {
            pips_debug(7, "is an int PARAMETER\n");
            ok = true;
            *pval = constant_int(symbolic_constant(value_symbolic(v)));
        }
        else pips_debug(7, "not a symbolic integer constant\n");
    }
    else pips_debug(7, "not a constant nor a reference not a parameter\n");
 
    pips_debug(5, "ok = %s, val = %d\n", ok? "TRUE": "FALSE", ok? *pval: 0);
    return ok;
}
 
/* perform a cloning for a given call
 */
static void
do_clone(
    call c,            /* call to be replaced */
    int argn, int val, /* arg number and associated value */
    entity clonee      /* if provided */)
{
    entity cloned = call_function(c);
    pips_debug(3, "%s cloned on argument %d for value %d\n", 
               entity_name(cloned), argn, val);
    
    /* first check whether the cloning was already performed.
     */
    if (entity_undefined_p(clonee))
    {
        clonee = get_clone(cloned, argn, val);
        if (clonee==entity_undefined)
        {
            clonee = build_a_clone_for(cloned, argn, val);
            if (argn!=0) set_clone(cloned, clonee, argn, val);
        }
    }
 
    some_cloning_performed = true;
    call_function(c) = clonee;
}
 
static void 
clone_rwt(call c)
{
    expression nth_arg;
    int val = 0;
 
    if (call_function(c)!=module_to_clone) return;
    pips_debug(3, "considering call to %s\n", entity_name(module_to_clone));
 
    if (argument_to_clone)
    {
        nth_arg = EXPRESSION(gen_nth(argument_to_clone-1, call_arguments(c)));
        if (this_expression_constant_p(nth_arg, &val)) /* yeah! */
            do_clone(c, argument_to_clone, val, entity_undefined);
    }
    else if (!undefined_number_p(statement_to_clone) &&
             statement_to_clone==statement_number(stmt_head()))
    {
        do_clone(c, 0, 0, clonee_to_substitute);
    }
}
 
/* clone module calls on argument arg in caller.
 * formal parameter of module number argn must be an integer scalar.
 * also used for user-directed cloning or substitution.
 * @return whether okay.
 */
static bool
perform_clone(
    entity module      /* the module being cloned */,
    string caller_name /* the caller of interest */,
    int argn           /* the argument number to be cloned */,
    int number         /* the statement number to clone a call */,
    entity substitute  /* entity to substitute to module */)
{
  statement stat;
 
  pips_assert("coherent arguments",
              (argn!=0 && undefined_number_p(number) &&
               entity_undefined_p(substitute)) ||
              (argn==0 && !undefined_number_p(number)));
 
  pips_debug(2, "cloning %s in %s on %d\n",
             entity_local_name(module), caller_name, argn);
 
  stat = (statement) db_get_memory_resource(DBR_CODE, caller_name, true);
 
  if (argn!=0)
    set_precondition_map((statement_mapping)
      db_get_memory_resource(DBR_PRECONDITIONS, caller_name, true));
 
  /* init
   */
  make_stmt_stack();
  module_to_clone = module;
  argument_to_clone = argn;
  statement_to_clone = number;
  clonee_to_substitute = substitute;
  some_cloning_performed = false;
 
  reset_hooks_register(clone_error_handler);
 
  /* perform cloning
   */
  gen_multi_recurse(stat,
                    statement_domain, stmt_filter, stmt_rewrite,
                    call_domain, gen_true, clone_rwt,
                    NULL);
 
  /* update CALLEES and CODE if necessary.
   */
  if (some_cloning_performed)
  {
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, caller_name, stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, caller_name,
                           (char *) compute_callees(stat));
  }
 
  /* close
   */
  reset_hooks_unregister(clone_error_handler);
  module_to_clone = entity_undefined;
  argument_to_clone = 0;
  statement_to_clone = STATEMENT_NUMBER_UNDEFINED;
  clonee_to_substitute = entity_undefined;
  free_stmt_stack();
  if (argn!=0) reset_precondition_map();
 
  return some_cloning_performed;
}
 
 
/********************************************************************* UTILS */
 
/* global initializations needed */
static void
set_currents(string name)
{
    entity module;
    statement stat;
 
    pips_debug(1, "considering module %s\n", name);
 
    init_clone();
 
    module = module_name_to_entity(name);
    pips_assert("is a function", type_functional_p(entity_type(module)));
    set_current_module_entity(module);
    
    stat = (statement) db_get_memory_resource(DBR_CODE, name, true);
    set_current_module_statement(stat);
}
 
/* global resets
 */
static void
reset_currents(const char* name)
{
    close_clone();
    reset_current_module_entity();
    reset_current_module_statement();
    pips_debug(1, "done with module %s\n", name);
}
 
/* check that caller is indeed a caller of name.
 */
static void
is_a_caller_or_error(
    string name,
    string caller)
{
    callees callers = (callees)db_get_memory_resource(DBR_CALLERS, name, true);
    MAP(STRING, s, 
        if (same_string_p(s, caller)) return, /* ok */
        callees_callees(callers));
 
    reset_currents(name);
    pips_user_error("%s is not a caller of %s\n", caller, name);    
}
 
#define invalid_request_result(s) \
        (!(s) || string_undefined_p((s) || (strlen((s))==0))
 
static string
checked_string_user_request(
    string fmt, string arg,
    string error)
{
    string result = user_request(fmt, arg);
    if (!result || string_undefined_p(result) || (strlen(result)==0))
    {
        reset_currents(entity_local_name(get_current_module_entity()));
        pips_user_error("invalid string for %s\n", error); /* exception */
        return NULL;
    }
    return result;
}
 
static int
checked_int_user_request(
    string fmt, string arg,
    string error)
{
    int result;
    string si = checked_string_user_request(fmt, arg, error);
 
    if (sscanf(si, "%d", &result)!=1)
    {
        reset_currents(entity_local_name(get_current_module_entity()));
        pips_user_error("invalid int for %s\n", error); /* throw */
        return 0;
    }
    free(si);
    return result;
}
 
/******************************************************* PIPSMAKE INTERFACES */
 
#define ARG_TO_CLONE "TRANSFORMATION_CLONE_ON_ARGUMENT"
 
/* clone module name, on the argument specified by property
 * int TRANSFORMATION_CLONE_ON_ARGUMENT.
 *
 * clone_on_argument    > CALLERS.callees
 *                      > CALLERS.code
 *       < MODULE.code
 *       < MODULE.callers
 *       < MODULE.user_file
 *       < CALLERS.callees
 *       < CALLERS.preconditions
 *       < CALLERS.code
 */
bool clone_on_argument(const string name)
{
    entity module;
    callees callers; /* warf, warf */
    int argn;
 
    DEBUG_ON;
    set_currents(name);
    module = get_current_module_entity();
    callers = (callees) db_get_memory_resource(DBR_CALLERS, name, true);
    argn = get_int_property(ARG_TO_CLONE);
 
    if (argn<=0)
    {
        do /* perform a user request to get the argument, 0 to stop */
        {
            argn = checked_int_user_request("argument of %s to clone", name,
                                            "argument number to clone");
        }
        while (argn<0);
    }
 
    /* check the argument type: must be an integer scalar */
    {
        entity arg = find_ith_parameter(module, argn);
        type t;
        variable v;
 
        if (entity_undefined_p(arg))
        {
            reset_currents(name);
            pips_user_error("%s: no #%d formal\n", name, argn);
            return false;
        }
        
        t = entity_type(arg);
        pips_assert("arg is a variable", type_variable_p(t));
        v = type_variable(t);
 
        if (basic_tag(variable_basic(v))!=is_basic_int ||
            variable_dimensions(v))
        {
            reset_currents(name);
            pips_user_error("%s: %d formal not a scalar int\n", name, argn);
            return false;
        }
    }
 
    MAP(STRING, caller_name, 
        perform_clone(module, caller_name, argn, 
                      STATEMENT_NUMBER_UNDEFINED, entity_undefined),
        callees_callees(callers));    
 
    reset_currents(name);
    debug_off();
    return true;
}
 
/* clone a routine in a caller. the user is requested the caller and
 * ordering to perform the cloning of that instance. can also be used
 * to force a function substitution at a call site.
 *
 * clone        > CALLERS.code
 *              > CALLERS.callees
 *      < MODULE.code
 *      < MODULE.user_file
 *      < CALLERS.code
 *      < CALLERS.callees
 */
static bool
clone_or_clone_substitute(
    string name,
    bool clone_substitute_p)
{
    entity module, substitute;
    string caller;
    int number;
    bool okay;
 
    DEBUG_ON;
    set_currents(name);
    module = get_current_module_entity();
    
    caller = checked_string_user_request("%s caller to update?", name,
                                         "caller to update");
 
    /* checks whether it is an actual caller. */
    is_a_caller_or_error(name, caller);
        
    number = checked_int_user_request(
        "statement number of %s to clone?", caller,
        "statement number to clone");
 
    if (clone_substitute_p)
    {
        string substitute_s = 
            checked_string_user_request("replacement for %s?", name,
                                        "replacement function");
 
        /* must be a top-level entity or a C static function */
        substitute = module_name_to_entity(substitute_s);
        if (entity_undefined_p(substitute) || 
            !type_functional_p(entity_type(substitute)))
        {
            reset_currents(name);
            pips_user_error("%s is not an existing function\n", substitute_s);
            return false;
        }
        free(substitute_s);
    }
    else
        substitute = entity_undefined;
 
    okay = perform_clone(module, caller, 0, number, substitute);
 
    if (!okay)
    {
        pips_user_warning("substitution of %s by %s at %s:%d not performed\n",
                          name, 
                          entity_undefined_p(substitute)? 
                              "<none>": entity_local_name(substitute), 
                          caller, number);
    }
 
    free(caller);
    reset_currents(name);
    debug_off();
    return okay;
}
 
/* clone name in one of its callers/statement number
 */
bool clone(const string name)
{
    return clone_or_clone_substitute(name, false);
}
 
/* substitute name in one of its callers/statement number 
 */
bool clone_substitute(const string name)
{
    return clone_or_clone_substitute(name, true);
}
 
/* use get_current_entity()
 * and get_current_statement()
 * to build a new copy entity
 */
static entity
clone_current_entity()
{
    return build_a_clone_for(get_current_module_entity(), 0,0);
}
 
/* similar to previous clone and clone_substitute
 * but does not try to make any substitution
 */
#include "preprocessor.h"
bool clone_only(const string mod_name)
{
    /* get the resources */
    statement mod_stmt = (statement)db_get_memory_resource(DBR_CODE, mod_name, true);
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
    
    entity cloned_entity = clone_current_entity();
    
    // Used to add the cloned function declaration
    AddEntityToModuleCompilationUnit(cloned_entity, get_current_module_entity());
    
    /* update/release resources */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name,mod_stmt);
    
    reset_current_module_statement();
    reset_current_module_entity();
 
    return !entity_undefined_p(cloned_entity);
}
 
#endif // BUILDER_CLONE*