clone_statement.c

Go to the documentation of this file.

/*
 
  $Id: clone_statement.c 23372 2017-05-05 15:35:30Z lossing $
 
  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 "linear.h"
 
#include "genC.h"
#include "misc.h"
#include "ri.h"
#include "cloning.h"
 
#include "ri-util.h"
 
 
/* forward declarations */
static expression do_clone_expression(expression e, clone_context cc, hash_table ht);
static call do_clone_call(call c, clone_context cc, hash_table ht);
static statement do_clone_statement(statement s, clone_context cc, hash_table ht);
static entity do_clone_label(entity l, clone_context cc/*, hash_table ht*/);
/*end formard declarations */
 
static gen_chunk*
do_clone_reference(reference r, clone_context cc, hash_table ht)
{
    entity new_entity = entity_undefined;
    if( (new_entity = hash_get(ht,entity_name(reference_variable(r)))) == HASH_UNDEFINED_VALUE )
    {
        new_entity = reference_variable(r);
        if( entity_constant_p(new_entity) )
        {
            return (gen_chunk*)make_call(new_entity,NIL);
        }
    }
    list new_indices = NIL;
    FOREACH(EXPRESSION,e,reference_indices(r))
        new_indices=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_indices);
    return (gen_chunk*)make_reference(new_entity,gen_nreverse(new_indices));
}
 
static range
do_clone_range(range r, clone_context cc, hash_table ht)
{
    return make_range(
            do_clone_expression(range_lower(r),cc, ht),
            do_clone_expression(range_upper(r),cc, ht),
            do_clone_expression(range_increment(r),cc, ht));
}
static cast
do_clone_cast(cast c, clone_context cc, hash_table ht)
{
    return make_cast(
            copy_type(cast_type(c)),
            do_clone_expression(cast_expression(c),cc, ht));
}
 
static sizeofexpression
do_clone_sizeofexpression(sizeofexpression s, clone_context cc, hash_table ht)
{
    switch(sizeofexpression_tag(s))
    {
        case is_sizeofexpression_type:
            return copy_sizeofexpression(s);
        case is_sizeofexpression_expression:
            return make_sizeofexpression_expression(do_clone_expression(sizeofexpression_expression(s),cc, ht));
    };
    return sizeofexpression_undefined;
}
 
static subscript
do_clone_subscript(subscript s, clone_context cc, hash_table ht)
{
    list new_indices = NIL;
    FOREACH(EXPRESSION,e,subscript_indices(s))
        new_indices=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_indices);
    return make_subscript(do_clone_expression(subscript_array(s),cc, ht),gen_nreverse(new_indices));
}
 
static application
do_clone_application(application a, clone_context cc, hash_table ht)
{
    list new_arguments = NIL;
    FOREACH(EXPRESSION,e,application_arguments(a))
        new_arguments=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_arguments);
    return make_application(do_clone_expression(application_function(a),cc, ht),gen_nreverse(new_arguments));
}
 
static syntax
do_clone_syntax(syntax s, clone_context cc, hash_table ht)
{
    switch(syntax_tag(s))
    {
        case is_syntax_reference:
            {
                gen_chunk* chunk = do_clone_reference(syntax_reference(s),cc, ht);
                if(INSTANCE_OF(reference,chunk))
                {
                    pips_assert("result of cloning is a reference", check_reference((reference)chunk));
                    return make_syntax_reference((reference)chunk);
                }
                else if(INSTANCE_OF(call,chunk))
                {
                    pips_assert("result of cloning is a call", check_call((call)chunk));
                    return make_syntax_call((call)chunk);
                }
                else
                    pips_internal_error("expecting a call or a reference as result of cloning");
            }
        case is_syntax_range:
            return make_syntax_range(do_clone_range(syntax_range(s),cc, ht));
        case is_syntax_call:
            return make_syntax_call(do_clone_call(syntax_call(s),cc, ht));
        case is_syntax_cast:
            return make_syntax_cast(do_clone_cast(syntax_cast(s),cc, ht));
        case is_syntax_sizeofexpression:
            return make_syntax_sizeofexpression(do_clone_sizeofexpression(syntax_sizeofexpression(s),cc, ht));
        case is_syntax_subscript:
            return make_syntax_subscript(do_clone_subscript(syntax_subscript(s),cc, ht));
        case is_syntax_application:
            return make_syntax_application(do_clone_application(syntax_application(s),cc, ht));
        case is_syntax_va_arg:
            {
                list new_va_args = NIL;
                FOREACH(SIZEOFEXPRESSION,soe,syntax_va_arg(s))
                    new_va_args=CONS(SIZEOFEXPRESSION,do_clone_sizeofexpression(soe,cc, ht),new_va_args);
                return make_syntax_va_arg(gen_nreverse(new_va_args));
            }
 
    };
    return syntax_undefined;
}
 
 
static expression
do_clone_expression(expression e, clone_context cc, hash_table ht)
{
    return make_expression(
            do_clone_syntax(expression_syntax(e),cc, ht),
            normalized_undefined);
}
 
 
static entity
do_clone_entity(entity e, clone_context cc, hash_table ht)
{
    pips_assert("entity is fine",entity_consistent_p(e));
    entity new_entity = entity_undefined;
    if( (new_entity=hash_get(ht,entity_name(e))) == HASH_UNDEFINED_VALUE)
    {
      //string ln = entity_user_name(e);
      string en = entity_name(e);
      string ms = strrchr(en, BLOCK_SEP_CHAR);
      if(ms==NULL)
        ms = strchr(en, MODULE_SEP);
      string ln = ms+1;
 
        if(entity_scalar_p(e))
            new_entity = make_new_scalar_variable_with_prefix(
                    //entity_user_name(e),
                    ln,
                    clone_context_new_module(cc),
                    copy_basic(entity_basic(e))
                    );
        else if(entity_array_p(e))
            new_entity = make_new_array_variable_with_prefix(
                    //entity_user_name(e),
                    ln,
                    clone_context_new_module(cc),
                    copy_basic(entity_basic(e)),
                    gen_full_copy_list(variable_dimensions(type_variable(entity_type(e))))
                    );
        else if(entity_struct_p(e) || entity_union_p(e) || entity_enum_p(e)) {
          /* There is no reason to replicate such an entity when
             cloning since they are left unchanged, except maybe if
             they contain dependent types... */
            new_entity = make_new_derived_entity_with_prefix(
                    ln,
                    clone_context_new_module(cc),
                    entity_type(e)
                    );
        }
        else {
          pips_internal_error("Unexpected case\n");
        }
 
        /* The entity can be a typedef instead of a
           variable... */
        if(typedef_entity_p(e)) {
          storage s = entity_storage(new_entity);
          free_storage(s);
          s = make_storage_rom();
          entity_storage(new_entity) = s;
        }
 
        /* The type of the entity can be a typedef that has been renamed... */
        /* FI: I am adding this for loop_unroll, but I believe 1) that
           typedef variables should not be renamed since only
           non-dependent types are supported, and 2) that loop unroll
           should be implemented in a simpler way and complemented by
           flatten_code */
        type nt = entity_type(new_entity);
        if(type_variable_p(nt)) {
          variable nv = type_variable(nt);
          /* For dependent types, the variables used in dimension
             might have been renamed, but the cloning is not
             compatible with dependent types because declarations are
             moved... */
          basic nb = variable_basic(nv);
          if(basic_typedef_p(nb)) {
            entity otd = basic_typedef(nb);
            entity ntd = hash_get(ht,entity_name(otd));
            if(ntd != HASH_UNDEFINED_VALUE)
              basic_typedef(nb) = ntd;
          }
          else if(basic_derived_p(nb)) {
            entity de = basic_derived(nb);
            entity nde = hash_get(ht,entity_name(de));
            if(nde != HASH_UNDEFINED_VALUE)
              basic_derived(nb) = nde;
          }
        }
 
        AddLocalEntityToDeclarations(new_entity,clone_context_new_module(cc),clone_context_new_module_statement(cc));
        hash_put(ht,entity_name(e),new_entity);
    }
    return new_entity;
}
 
static sequence
do_clone_sequence(sequence s, clone_context cc, hash_table ht)
{
    list new_statements = NIL;
    FOREACH(STATEMENT,st,sequence_statements(s))
    {
        new_statements=CONS(STATEMENT,do_clone_statement(st,cc, ht),new_statements);
    }
    new_statements=gen_nreverse(new_statements);
    return make_sequence(new_statements);
}
 
static test
do_clone_test(test t, clone_context cc, hash_table ht)
{
    if(test_undefined_p(t)) return t;
    return make_test(
            do_clone_expression(test_condition(t),cc, ht),
            do_clone_statement(test_true(t),cc, ht),
            do_clone_statement(test_false(t),cc, ht));
 
}
 
static loop
do_clone_loop(loop l, clone_context cc, hash_table ht)
{
    entity new_entity = 
         gen_chunk_undefined_p(gen_find_eq(loop_index(l),loop_locals(l))) ?
            do_clone_entity(loop_index(l),cc, ht):
            loop_index(l);
    return make_loop(
            new_entity,
            do_clone_range(loop_range(l),cc, ht),
            do_clone_statement(loop_body(l),cc, ht),
            do_clone_label(loop_label(l),cc/*, ht*/),
            make_execution_sequential(),
            NIL /* unsure ...*/);
}
 
static entity
do_clone_label(entity l, clone_context cc/*, hash_table ht*/)
{
    if(entity_empty_label_p(l)) return entity_empty_label();
 
    /* if the label was cloned in the past, we get the same clone this function
       returned before instead of creating a new one */
    entity replacement = entity_undefined;
 
    /* Checking if the entity is in the list of cloned labels */
    for (list iter = clone_context_labels(cc); !ENDP(iter); POP(iter)) {
        if (same_entity_p(ENTITY(CAR(iter)), l)) {
            POP(iter);
            replacement = ENTITY(CAR(iter));
        } else {
            POP(iter);
        }
    }
 
    if(entity_undefined_p(replacement)) {
        replacement=make_new_label(clone_context_new_module(cc));
        /* Insert those two values at beginning of the list (reverse inserting order
           as it's insterting before instead of inserting at the end) */
        clone_context_labels(cc) = CONS(ENTITY, replacement, clone_context_labels(cc));
        clone_context_labels(cc) = CONS(ENTITY, l, clone_context_labels(cc));
    }
 
    return replacement;
}
 
static whileloop
do_clone_whileloop(whileloop w, clone_context cc, hash_table ht)
{
    return make_whileloop(
            do_clone_expression(whileloop_condition(w),cc, ht),
            do_clone_statement(whileloop_body(w),cc, ht),
            do_clone_label(whileloop_label(w),cc/*, ht*/),
            copy_evaluation(whileloop_evaluation(w)));
}
 
static call
do_clone_call(call c, clone_context cc, hash_table ht)
{
    list new_arguments = NIL;
    FOREACH(EXPRESSION,e,call_arguments(c))
    {
        new_arguments=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_arguments);
    }
    return make_call(
            call_function(c),
            gen_nreverse(new_arguments));
}
 
static multitest
do_clone_multitest(multitest m, clone_context cc, hash_table ht)
{
    return make_multitest(
            do_clone_expression(multitest_controller(m),cc, ht),
            do_clone_statement(multitest_body(m),cc, ht));
}
 
static forloop
do_clone_forloop(forloop f, clone_context cc, hash_table ht)
{
    return make_forloop(
            do_clone_expression(forloop_initialization(f),cc, ht),
            do_clone_expression(forloop_condition(f),cc, ht),
            do_clone_expression(forloop_increment(f),cc, ht),
            do_clone_statement(forloop_body(f),cc, ht));
}
 
static instruction
do_clone_instruction(instruction i, clone_context cc, hash_table ht)
{
    if(instruction_undefined_p(i)) return i;
 
    switch(instruction_tag(i))
    {
        case is_instruction_sequence:
            return make_instruction_sequence(do_clone_sequence(instruction_sequence(i),cc, ht));
        case is_instruction_test:
            return make_instruction_test(do_clone_test(instruction_test(i),cc, ht));
        case is_instruction_loop:
            return make_instruction_loop(do_clone_loop(instruction_loop(i),cc, ht));
        case is_instruction_whileloop:
            return make_instruction_whileloop(do_clone_whileloop(instruction_whileloop(i),cc, ht));
        case is_instruction_goto:
            pips_user_error("don't know how to clone a goto");
        case is_instruction_call:
            return make_instruction_call(do_clone_call(instruction_call(i),cc, ht));
        case is_instruction_unstructured:
            pips_user_error("don't know how to clone an unstructured");
        case is_instruction_multitest:
            return make_instruction_multitest(do_clone_multitest(instruction_multitest(i),cc, ht));
        case is_instruction_forloop:
            return make_instruction_forloop(do_clone_forloop(instruction_forloop(i),cc, ht));
        case is_instruction_expression:
            return make_instruction_expression(do_clone_expression(instruction_expression(i),cc, ht));
    };
    return instruction_undefined;
}
 
static statement
do_clone_statement(statement s, clone_context cc, hash_table ht)
{
    if (statement_undefined_p(s)) return s;
 
    entity new_label = do_clone_label(statement_label(s),cc/*, ht*/);
    /* add new declarations to top level statement
     * this prevents difficult scope renaming in C
     */
    list new_declarations_initialization = NIL;
    FOREACH(ENTITY, e, statement_declarations(s))
    {
        entity new_entity = do_clone_entity(e,cc, ht);
        if( !value_unknown_p(entity_initial(e)) &&
            value_expression_p(entity_initial(e)) &&
            !expression_undefined_p( value_expression(entity_initial(e)) ) )
        {
            statement ns = make_assign_statement(
                    entity_to_expression(new_entity),
                    do_clone_expression(value_expression(entity_initial(e)),cc, ht) );
            new_declarations_initialization=CONS(STATEMENT,ns,new_declarations_initialization);
        }
    }
    instruction new_instruction = do_clone_instruction(statement_instruction(s),cc, ht);
    instruction new_instruction_with_decl = ENDP(new_declarations_initialization)?
        new_instruction:
        make_instruction_sequence(
            make_sequence(
                gen_nconc(
                    gen_nreverse(new_declarations_initialization),
                    CONS(STATEMENT,instruction_to_statement(new_instruction),NIL))
                ));
 
    return make_statement(
            new_label,
            STATEMENT_NUMBER_UNDEFINED,
            STATEMENT_ORDERING_UNDEFINED,
            empty_comments,
            new_instruction_with_decl,
            NIL,
            NULL,
            empty_extensions (), make_synchronization_none());
 
}
 
statement clone_statement(statement s, clone_context cc)
{
    hash_table ht = hash_table_make(hash_string,0);
    statement sout = do_clone_statement(s,cc,ht);
    hash_table_free(ht);
    return sout;
}
 
/* end of cloning */