rename_operator.c

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#include <stdlib.h>
#include <stdio.h>
 
#include "genC.h"
#include "newgen_set.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "control.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
 
#include "callgraph.h"
 
#include "misc.h"
 
static set ops_set = NULL;
static set suffixes_set = NULL;
static const char* prefix = NULL;
 
//Helper macro for tiedous tasks.
#define __KV(key, value) if(strcmp( key ,s) == 0) return value;
#define __MKV(key, value) __KV(TOP_LEVEL_MODULE_NAME MODULE_SEP_STRING key , value)
 
//Returns the name of an operation.
//NULL if not found.
static const char* opname(const char* s)
{
        // /!\ When adding operators to this list,
        // don’t forget to update the corresponding table in the
        // Rename Operator section of pipsmake-rc.tex
         
        __MKV(POST_INCREMENT_OPERATOR_NAME, "post_inc")
        __MKV(PRE_INCREMENT_OPERATOR_NAME, "inc_pre")
 
        __MKV(POST_DECREMENT_OPERATOR_NAME, "post_dec")
        __MKV(PRE_DECREMENT_OPERATOR_NAME, "dec_pre")
 
        __MKV(PLUS_C_OPERATOR_NAME, "plus")
        __MKV(PLUS_OPERATOR_NAME, "plus")
        __MKV(UNARY_PLUS_OPERATOR_NAME, "un_plus")
        __MKV(MINUS_C_OPERATOR_NAME, "minus")
        __MKV(MINUS_OPERATOR_NAME, "minus")
        __MKV(UNARY_MINUS_OPERATOR_NAME, "un_minus")
 
        __MKV(MULTIPLY_OPERATOR_NAME, "mul")
        __MKV(DIVIDE_OPERATOR_NAME, "div")
        __MKV(MODULO_OPERATOR_NAME, "mod")
 
        __MKV(ASSIGN_OPERATOR_NAME, "assign")
        __MKV(MULTIPLY_UPDATE_OPERATOR_NAME, "mul_up")
        __MKV(DIVIDE_UPDATE_OPERATOR_NAME, "div_up")
        __MKV(MODULO_UPDATE_OPERATOR_NAME, "mod_up")
        __MKV(PLUS_UPDATE_OPERATOR_NAME, "plus_up")
        __MKV(MINUS_UPDATE_OPERATOR_NAME, "minus_up")
 
        __MKV(C_LESS_OR_EQUAL_OPERATOR_NAME, "leq")
        __MKV(C_LESS_THAN_OPERATOR_NAME, "lt")
        __MKV(C_GREATER_OR_EQUAL_OPERATOR_NAME, "geq")
        __MKV(C_GREATER_THAN_OPERATOR_NAME, "gt")
        __MKV(C_EQUAL_OPERATOR_NAME, "eq")
        __MKV(C_NON_EQUAL_OPERATOR_NAME, "neq")
        return NULL;
}
 
static bool take_lvalue(const char* s)
{
        __MKV(ASSIGN_OPERATOR_NAME, true)
        __MKV(MULTIPLY_UPDATE_OPERATOR_NAME, true)
        __MKV(DIVIDE_UPDATE_OPERATOR_NAME, true)
        __MKV(MODULO_UPDATE_OPERATOR_NAME, true)
        __MKV(PLUS_UPDATE_OPERATOR_NAME, true)
        __MKV(MINUS_UPDATE_OPERATOR_NAME, true)
        return false;
}
 
//Returns the short suffix associated with a type.
//NULL if not found.
static const char* typesuffix(const char* s)
{
        // /!\ When adding types to this list,
        // don’t forget to update the corresponding table in the
        // Rename Operator section of pipsmake-rc.tex
        
        __KV("char","c")
        __KV("short","s")
        __KV("int","i")
        __KV("long","l")
        __KV("float","f")
        __KV("double","d")
        __KV("_Bool","b")
        __KV("_Complex","C")
        __KV("_Imaginary","I")
        return NULL;
}
 
static
void rename_op(call c)
{
    //TODO: Unary operators
 
    //Retrieve operator name
    entity f = call_function(c);
    string fname = entity_name(f);
 
    const char* name = opname(fname);
 
    if(!name || !set_belong_p(ops_set, name))
        return; //Not an operator, skip it !
 
    //Retrieve arguments type.
    //All arguments should have the same type
 
    list args = call_arguments(c);
 
    string tname = NULL; //Arguments type
 
    FOREACH(EXPRESSION, arg, args)
    {
        type t = expression_to_type(arg); //Get argument type
        
        if(type_variable_p(t))
        {
            string n = basic_to_string(variable_basic(type_variable(t)));
            if(tname && !same_string_p(tname,n))
            {
                //Arguments have not the same type
                //Skip it
                free_type(t); free(n);
                return;
            }
            free(tname);
            tname = n;
        }
        else
        {
                //Not a basic type, maybe a compound type
                //Skip it
                free_type(t);
                return;
        }
        free_type(t);
    }
 
    if(!tname)
            //Nullary function, quite strange for an operator
            return;
 
    //Try to find the suffix
    const char* suffix = typesuffix(tname);
    if(!suffix || !set_belong_p(suffixes_set, suffix))
    {
        free(tname);
        return; //Unknow suffix, is it really a basic type ?
    }
 
    //Now try to construct a complete function name for the operator
    //Function name look like TOP-LEVEL:<prefix><op name><type suffix>
 
    string fullname = malloc(1 + strlen(prefix)  + strlen(name) + strlen(suffix));
    strcat(strcat(strcpy(fullname, prefix), name), suffix);
 
    //Find the associated function in the entity list
    entity newe = FindEntity(TOP_LEVEL_MODULE_NAME, fullname);
 
    if(newe == entity_undefined)
    {
            //Missing function ?
            pips_user_warning("No function %s found, skipping operator %s\n", fullname, fname);
        free(fullname);
        free(tname);
            return;
    }
 
    if(take_lvalue(fname))
    {
            //Takes a lvalue as first argument
            expression farg = EXPRESSION(CAR(args));
            list l = CONS(EXPRESSION, copy_expression(farg), NIL);
        entity ifunc = entity_intrinsic(ADDRESS_OF_OPERATOR_NAME);
            update_expression_syntax(farg, make_syntax_call(make_call(ifunc, l)));
    }
 
    call_function(c) = newe; //Replace the operator by the new function
 
    free(fullname);
    free(tname);
}
 
static
void rw_loop(statement sl)
{
    if(statement_loop_p(sl))
        do_loop_to_for_loop(sl);
}
 
static 
set make_string_set_from_prop(const char* prop)
{
    set s = set_make(set_string);
    list l = strsplit(prop," ");
    set_append_list(s, l);
    //list_free(l);
    return s;
}
 
 
/* A short pass that replace operators by function calls
 */
bool rename_operator(const char* module_name)
{
    /* prelude */
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    
    /* some properties */
    const char* ops_string = get_string_property("RENAME_OPERATOR_OPS");
    ops_set = make_string_set_from_prop(ops_string);
 
    const char* suffixes_string = get_string_property("RENAME_OPERATOR_SUFFIXES");
    suffixes_set = make_string_set_from_prop(suffixes_string);
    
    prefix = get_string_property("RENAME_OPERATOR_PREFIX");
    
    /* search */
    if(get_bool_property("RENAME_OPERATOR_REWRITE_DO_LOOP_RANGE"))
        gen_recurse(get_current_module_statement(), statement_domain, gen_true, rw_loop);
    gen_recurse(get_current_module_statement(), call_domain, gen_true, rename_op);
 
    /* free properties */
    set_free(ops_set);
    ops_set = NULL;
 
    set_free(suffixes_set);
    suffixes_set = NULL;
 
    prefix = NULL;
 
    /* update ressources */
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
        return true;
}