ordering.c

Go to the documentation of this file.

/*
 
  $Id: ordering.c 23495 2018-10-24 09:19:47Z 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/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
/** @file ordering.c
 
    Defines a static mapping from orderings to statements.
    must be initialize_ordering_to_statement, and afterwards
    reset_ordering_to_statement.
 
    For information on ordering, see control/reorder.c
 */
 
#include <stdio.h>
 
#include "linear.h"
 
#include "genC.h"
#include "ri.h"
 
#include "misc.h"
#include "ri-util.h"
 
/* a hash table to map orderings (integer) to statements (pointers)
 * assumed to be valid for the current module returned by
 * get_current_module_entity(). This is assumed to hold when
 * pipsmake issues a request to lower level libraries.
 *
 * db_get_current_module() returns the module used in the request
 * to pipsmake and is usually different.
 *
 * It would be possible to expose a lower level interface to manage
 * several ordering_to_statement hash tables
 */
static hash_table OrderingToStatement = hash_table_undefined;
 
 
/* Test if the ordering to statement is initialized */
bool
ordering_to_statement_initialized_p()
{
    return OrderingToStatement != hash_table_undefined;
}
 
 
/* Dump the ordering with the corresponding statement address */
void
print_ordering_to_statement(void)
{
    HASH_MAP(ko, vs, {
        _int o = (_int) ko;
        statement s = (statement) vs;
 
        fprintf(stderr,"%td (%td,%td)->%s\n",
                o, ORDERING_NUMBER(o), ORDERING_STATEMENT(o),
                statement_identification(s));
    }, OrderingToStatement);
}
 
 
/* Get the statement from an ordering in a given ordering to statement
   table */
static statement
apply_ordering_to_statement(hash_table ots, _int o)
{
    statement s;
    pips_assert("defined hash table...",
                ots != NULL && ots != hash_table_undefined);
 
    if(o == STATEMENT_ORDERING_UNDEFINED)
        pips_internal_error("Illegal ordering %td", o);
 
    s = (statement) hash_get(ots, (char *) o);
 
    if(s == statement_undefined)
        pips_internal_error("no statement for order %td=(%td,%td)",
                            o, ORDERING_NUMBER(o), ORDERING_STATEMENT(o));
 
    return s;
}
 
 
/* Get the statement associated to a given ordering.
 
   It is useful for retrieve the statements associated with the arcs in
   the dependence graphs for example. */
statement
ordering_to_statement(int o)
{
    statement s;
    s = apply_ordering_to_statement(OrderingToStatement, o);
    return s;
}
 
 
/* Add the statement for its ordering, if any, in the hash-map. */
static bool add_ordering_of_the_statement(statement stat, hash_table ots)
{
  pips_assert("ordering is defined",
              statement_ordering(stat) != STATEMENT_ORDERING_UNDEFINED);
  hash_put(ots, (void *) statement_ordering(stat), (void *) stat);
  return true;
}
 
 
/* Add the statement for its ordering, if any, in the hash-map. */
bool add_ordering_of_the_statement_to_current_mapping( statement stat )
{
  pips_assert("ordering is defined",
        statement_ordering(stat) != STATEMENT_ORDERING_UNDEFINED);
  hash_put(OrderingToStatement, (void *) statement_ordering(stat), (void *) stat);
  return true;
}
 
/* Overwrite the statement for its ordering, if any, in the hash-map.
 * The difference with add_ordering_of_the_statement_to_current_mapping() is
 * that this version won't trigger a warning if the mapping already exist
 */
bool overwrite_ordering_of_the_statement_to_current_mapping( statement stat )
{
  pips_assert("ordering is defined",
        statement_ordering(stat) != STATEMENT_ORDERING_UNDEFINED);
  hash_overwrite(OrderingToStatement, (void *) statement_ordering(stat), (void *) stat);
  return true;
}
 
 
/* Initialize the ordering to statement mapping by iterating from a given
   statement
 
   @param ots is ordering to statement hash-table to fill
 
   @param s is the statement to start with. Typically the module
   statement.
*/
static void rinitialize_ordering_to_statement(hash_table ots, statement s)
{
  /* Simplify this with a gen_recurse to avoid dealing with all the new
     cases by hand (for-loops...).
 
     Apply a prefix hash-map add to be compatible with previous
     implementation and avoid different hash-map iteration later. */
  gen_context_recurse(s, ots, statement_domain, add_ordering_of_the_statement, gen_null2);
}
 
 
/* To be used instead of initialize_ordering_to_statement() to make
   sure that the hash table ots is in sync with the current module. */
hash_table set_ordering_to_statement(statement s)
{
    pips_assert("hash table \"OrderingToStatement\" is undefined",
                OrderingToStatement==hash_table_undefined);
    hash_table ots =  hash_table_make(hash_int, 0);
    rinitialize_ordering_to_statement(ots, s);
    OrderingToStatement = ots;
    return ots;
}
 
 
/* Reset the mapping from ordering to statement. */
void
reset_ordering_to_statement(void)
{
    pips_assert("hash table is defined",
                OrderingToStatement!=hash_table_undefined);
 
    hash_table_free(OrderingToStatement),
    OrderingToStatement = hash_table_undefined;
}