prettyprint.c

Go to the documentation of this file.

/*
 
  $Id: prettyprint.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/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
 * (pretty)print of reductions.
 *
 * FC, June 1996.
 */
 
#include "local-header.h"
#include "text.h"
#include "text-util.h"
#include "semantics.h"
#include "prettyprint.h"
 
#define PROP_SUFFIX ".proper_reductions"
#define CUMU_SUFFIX ".cumulated_reductions"
 
#define PROP_DECO "proper reductions"
#define CUMU_DECO "cumulated reductions"
 
/****************************************************** STATIC INFORMATION */
 
GENERIC_GLOBAL_FUNCTION(printed_reductions, pstatement_reductions)
static string reduction_decoration = NULL;
 
/************************************************************* BASIC WORDS */
 
/* generates a short note to tell about the type of the statement
 * being decorated.
 */
string note_for_statement(statement s)
{
    instruction i = statement_instruction(s);
    switch (instruction_tag(i))
    {
    case is_instruction_sequence: return "seq  ";
    case is_instruction_loop: return "loop ";
    case is_instruction_test: return "test ";
    case is_instruction_call: return "call ";
    case is_instruction_unstructured: return "unst ";
    case is_instruction_whileloop: return "while ";
    case is_instruction_goto: return "goto ";
    case is_instruction_forloop: return "for ";
    case is_instruction_expression: return "expr ";
    default: 
      pips_internal_error("unexpected instruction tag");
      break;
    }
    return "";
}
 
/* returns a (static) string describing the tag t reduction
 */
string reduction_operator_tag_name(tag t)
{
    switch(t)
    {
    case is_reduction_operator_none:        return "none";
    case is_reduction_operator_sum:         return "sum";
    case is_reduction_operator_csum:        return "csum";
    case is_reduction_operator_prod:        return "prod";
    case is_reduction_operator_min:         return "min";
    case is_reduction_operator_max:         return "max";
    case is_reduction_operator_and:         return "and";
    case is_reduction_operator_or:          return "or";
    case is_reduction_operator_bitwise_or:  return "bitwise_or";
    case is_reduction_operator_bitwise_xor: return "bitwise_xor";
    case is_reduction_operator_bitwise_and: return "bitwise_and";
    case is_reduction_operator_eqv:         return "eqv";
    case is_reduction_operator_neqv:        return "neqv";
    default: pips_internal_error("unexpected reduction operator tag!");
    }
 
    return NULL;
}
 
/* allocates and returns the name of the operator
 */
string reduction_operator_name(reduction_operator o)
{
    return strdup(reduction_operator_tag_name(reduction_operator_tag(o)));
}
 
/* returns the name of the reduction (!!! not allocated)
 */
string reduction_name(reduction r)
{
    return reduction_operator_tag_name(reduction_tag(r));
}
 
/* allocates and returns a list of strings for reduction r
 */
static list /* of string */ words_reduction(reduction r)
{
    return CONS(STRING, reduction_operator_name(reduction_op(r)),
           CONS(STRING, strdup("["),
                gen_nconc( Words_Reference(reduction_reference(r)),
           CONS(STRING, strdup("],"), NIL))));
}
 
/* allocates and returns a list of string with note ahead if not empty.
 * it describes the reductions in rs.
 */
static list /* of string */ words_reductions(string note, reductions rs)
{
  list /* of string */ ls = NIL;
  FOREACH (REDUCTION, r,reductions_list(rs)) {
    ls = gen_nconc(words_reduction(r), ls);
  }
  return ls? CONS(STRING, strdup(note), ls): NIL;
}
 
void print_reduction(reduction r)
{
    reference ref = reduction_reference(r);
    fprintf(stderr, "reduction is %s[",
            reduction_operator_tag_name
                (reduction_operator_tag(reduction_op(r))));
    if (!reference_undefined_p(ref)) print_reference(ref);
    fprintf(stderr, "]\n");
}
 
/************************************************* REDUCTION PRETTY PRINT */
 
/* function to allocate and returns a text, passed to the prettyprinter
 * uses some static variables:
 * - printed_reductions function
 * -
 */
/************************************************* REDUCTION PRETTY PRINT */
 
/* function to allocate and returns a text, passed to the prettyprinter
 * uses some static variables:
 * - printed_reductions function
 * -
 */
static text text_reductions(__attribute__((unused)) entity module, __attribute__((unused)) int margin, statement s)
{
    text t;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering statement %p\n", s);
 
    t = bound_printed_reductions_p(s)? /* unreachable statements? */
        words_predicate_to_commentary
            (words_reductions(note_for_statement(s),
                              load_printed_reductions(s)),
                                  get_comment_sentinel()):
                make_text(NIL);
 
    debug_off();
    return t;
}
 
/* returns a reduction-decorated text for statement s
 */
static text text_code_reductions(statement s)
{
    text t;
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
    init_prettyprint(text_reductions);
    t = text_module(get_current_module_entity(), s);
    close_prettyprint();
    debug_off();
    return t;
}
 
/* handles the required prettyprint
 * ??? what about summary reductions?
 * should be pprinted with cumulated regions.
 * @ return true if succeed
 * @param module_name the module name to process
 * @param resource_name the resource to use
 * @param decoration_name
 * @param summary_name
 * @param file_suffix
 */
static bool
print_any_reductions(
    const char* module_name,
    string resource_name,
    string decoration_name,
    string summary_name,
    string file_suffix)
{
    text t;
 
    debug_on("REDUCTIONS_DEBUG_LEVEL");
    pips_debug(1, "considering module %s for %s\n",
               module_name, decoration_name);
 
    set_current_module_entity(local_name_to_top_level_entity(module_name));
    set_printed_reductions((pstatement_reductions)
         db_get_memory_resource(resource_name, module_name, true));
    set_current_module_statement((statement)
         db_get_memory_resource(DBR_CODE, module_name, true));
    reduction_decoration = decoration_name;
 
    t = text_code_reductions(get_current_module_statement());
 
    if (summary_name)
    {
        reductions rs = (reductions)
            db_get_memory_resource(summary_name, module_name, true);
        text p =
            words_predicate_to_commentary(words_reductions("summary ", rs),
                                          get_comment_sentinel());
        MERGE_TEXTS(p, t);
        t=p;
    }
 
    make_text_resource_and_free(module_name, DBR_PRINTED_FILE, file_suffix, t);
 
    reset_current_module_entity();
    reset_current_module_statement();
    reset_printed_reductions();
    reduction_decoration = NULL;
 
    debug_off();
    return true;
}
 
/* Handlers for PIPSMAKE
 */
bool print_code_proper_reductions(const char* module_name)
{
    return print_any_reductions(module_name,
                                DBR_PROPER_REDUCTIONS,
                                PROP_DECO,
                                NULL,
                                PROP_SUFFIX);
}
 
bool print_code_cumulated_reductions(const char* module_name)
{
    return print_any_reductions(module_name,
                                DBR_CUMULATED_REDUCTIONS,
                                CUMU_DECO,
                                DBR_SUMMARY_REDUCTIONS,
                                CUMU_SUFFIX);
}
 
/* end of it
 */