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
/* package convex effects :  Be'atrice Creusillet 5/97
 *
 * File: prettyprint.c
 * ~~~~~~~~~~~~~~~~~~~
 *
 * This File contains the prettyprinting functions.
 *
 */
 
#include <stdio.h>
#include <string.h>
#include <limits.h>
 
#include "linear.h"
 
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "text.h"
#include "database.h"
 
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "top-level.h"
#include "properties.h"
 
#include "effects-generic.h"
#include "effects-convex.h"
 
#include "text-util.h"
#include "pipsdbm.h"
#include "resources.h"
 
#define REGION_FORESYS_PREFIX "C$REG"
 
 
string
region_sc_to_string(string __attribute__ ((unused)) s,
                    Psysteme __attribute__ ((unused)) ps)
{
    pips_internal_error("implementation dropped");
    return string_undefined;
}
 
 
 
#define append(s) add_to_current_line(line_buffer, s, str_prefix, t_reg)
 
/* text text_region(effect reg)
 * input    : a region
 * output   : a text consisting of several lines of commentaries,
 *            representing the region
 * modifies : nothing
 */
text text_region(effect reg)
{
    text t_reg = make_text(NIL);
 
    if(store_effect_p(reg)
       || !get_bool_property("PRETTYPRINT_MEMORY_EFFECTS_ONLY")) {
      bool foresys = get_bool_property("PRETTYPRINT_FOR_FORESYS");
      string str_prefix =
        foresys ? FORESYS_CONTINUATION_PREFIX
        : get_comment_continuation();
      char line_buffer[MAX_LINE_LENGTH];
      reference r;
      action ac;
      action_kind ak;
      approximation ap;
      descriptor ed = effect_descriptor(reg);
      Psysteme sc;
      list /* of string */ ls;
 
      if(effect_undefined_p(reg))
        {
          free_text(t_reg); // t_reg should be used instead of make_text()
          user_log("[text_region] unexpected effect undefined\n");
          return make_text(CONS(SENTENCE,
                                make_sentence(is_sentence_formatted,
                                              strdup(concatenate(str_prefix, "<REGION_UNDEFINED>\n", NULL))),
                                NIL));
        }
      /* else the effect is defined...
       */
 
      /* PREFIX
       */
      strcpy(line_buffer, foresys? REGION_FORESYS_PREFIX: get_comment_sentinel());
      if (!foresys) append("  <");
 
      /* REFERENCE
       */
      r = effect_any_reference(reg);
      ls = foresys? Words_Reference(r): effect_words_reference(r);
 
      MAP(STRING, s, append(s), ls);
      gen_free_string_list(ls); ls = NIL;
 
      /* ACTION and APPROXIMATION
       */
      ac = effect_action(reg);
      ak = action_to_action_kind(ac);
      ap = effect_approximation(reg);
 
      if (foresys)
        {
          append(", RGSTAT(");
          append(action_read_p(ac) ? "R," : "W,");
          append(approximation_may_p(ap) ? "MAY), " : "EXACT), ");
        }
      else /* PIPS prettyprint */
        {
          append("-");
          append(action_interpretation(action_tag(ac)));
          /* To preserve the current output, actions on store are
             implicit, actions on environment and type declaration are
             specified */
          if(!action_kind_store_p(ak))
            append(action_kind_to_string(ak));
          append(approximation_may_p(ap) ? "-MAY" : "-EXACT");
          append("-");
        }
 
      /* SYSTEM
       * sorts in such a way that constraints with phi variables come first.
       */
      if(descriptor_none_p(ed)) {
        /* FI: there is no system; it's equivalent to an empty one... */
          append("{}");
      } else {
        sc = sc_copy(region_system(reg));
        sc_lexicographic_sort(sc, is_inferior_cell_descriptor_pvarval);
        system_sorted_text_format(line_buffer, str_prefix, t_reg, sc,
                                  (get_variable_name_t) pips_region_user_name,
                                  vect_contains_phi_p, foresys);
 
        sc_rm(sc);
      }
      /* CLOSE
       */
      if (!foresys) append(">");
      close_current_line(line_buffer, t_reg,str_prefix);
    }
 
    return t_reg;
}
 
/* print the constraint system of a region
 *
 * Used for debugging, e.g. called from gdb
 */
void print_region_sc(effect r)
{
  descriptor d = effect_descriptor(r);
  if(descriptor_none_p(d)) {
    fprintf(stderr, "No descriptor\n");
  }
  else {
    Psysteme sc = region_system(r);
    sc_print(sc, (get_variable_name_t) pips_region_user_name);
  }
}
 
 
/* text text_array_regions(list l_reg, string ifread, string ifwrite)
 * input    : a list of regions
 * output   : a text representing this list of regions.
 * comment  : if the number of array regions is not nul, and if
 *            PRETTYPRINT_LOOSE is true, then empty lines are
 *            added before and after the text of the list of regions.
 */
static text
text_array_regions(list l_reg, string ifread, string ifwrite)
{
    text reg_text = make_text(NIL);
    /* in case of loose_prettyprint, at least one region to print? */
    bool loose_p = get_bool_property("PRETTYPRINT_LOOSE");
    bool one_p = false;
 
    set_action_interpretation(ifread, ifwrite);
 
    /* GO: No redundant test anymore, see  text_statement_array_regions */
    if (l_reg != (list) HASH_UNDEFINED_VALUE && l_reg != list_undefined)
    {
      gen_sort_list(l_reg, (int (*)(const void *,const void *)) effect_compare);
        FOREACH(EFFECT, reg, l_reg)
        {
          if(store_effect_p(reg)
             || !get_bool_property("PRETTYPRINT_MEMORY_EFFECTS_ONLY")) {
            entity ent = effect_entity(reg);
            if (  anywhere_effect_p(reg)
                  || malloc_effect_p(reg)
                  || get_bool_property("PRETTYPRINT_SCALAR_REGIONS")
                  || ! entity_non_pointer_scalar_p(ent))
            {
                if (loose_p && !one_p )
                {
                    ADD_SENTENCE_TO_TEXT(reg_text,
                                         make_sentence(is_sentence_formatted,
                                                       strdup("\n")));
                    one_p = true;
                }
                MERGE_TEXTS(reg_text, text_region(reg));
            }
          }
        }
 
        if (loose_p && one_p)
            ADD_SENTENCE_TO_TEXT(reg_text,
                                 make_sentence(is_sentence_formatted,
                                               strdup("\n")));
    }
 
    reset_action_interpretation();
    return reg_text;
}
␌
/* practical interfaces
 */
text text_inout_array_regions(list l)
{ return text_array_regions(l, ACTION_IN, ACTION_OUT);}
 
text text_rw_array_regions(list l)
{ return text_array_regions(l, ACTION_READ, ACTION_WRITE);}
 
text text_copyinout_array_regions(list l)
{ return text_array_regions(l, ACTION_COPYIN, ACTION_COPYOUT);}
 
text text_private_array_regions(list l)
{ return text_array_regions(l, ACTION_PRIVATE, ACTION_PRIVATE);}
 
/*********************************************************** ABSOLETE MAYBE? */
 
/* CALLGRAPH/ICFG stuff (should be OBSOLETE?)
 */
static text
get_text_regions_for_module(
  const char* module_name,
  string resource_name,
  string ifread,
  string ifwrite)
{
  text t;
  entity mod;
  list /* of effect */ le =
    effects_effects((effects)
                    db_get_memory_resource(resource_name, module_name, true));
 
  /* the current entity may be used for minimal names... */
  mod = module_name_to_entity(module_name);
  set_current_module_entity(mod);
  t = text_array_regions(le, ifread, ifwrite);
  reset_current_module_entity();
  return t;
}
 
text get_text_regions(const string module_name)
{
  return get_text_regions_for_module
    (module_name, DBR_SUMMARY_REGIONS, ACTION_READ, ACTION_WRITE);
}
 
text get_text_in_regions(const string module_name)
{
  return get_text_regions_for_module
    (module_name, DBR_IN_SUMMARY_REGIONS, ACTION_IN, ACTION_OUT);
}
 
text get_text_out_regions(const string module_name)
{
  return get_text_regions_for_module
    (module_name, DBR_OUT_SUMMARY_REGIONS, ACTION_IN, ACTION_OUT);
}
 
/*********************************************************** DEBUG FUNCTIONS */
 
/* void print_regions(list pc)
 * input    : a list of regions.
 * modifies : nothing.
 * comment  : prints the list of regions on stderr .
 */
static void print_regions_with_action(list pc, string ifread, string ifwrite)
{
  set_action_interpretation(ifread, ifwrite);
 
  if (pc == NIL) {
    fprintf(stderr,"\t<NONE>\n");
  }
  else {
    FOREACH(EFFECT, ef, pc) {
      print_region(ef);
      fprintf(stderr,"\n");
    }
  }
 
  reset_action_interpretation();
}
 
/* external interfaces
 *
 * NW:
 * before calling
 * "print_inout_regions"
 * or "print_rw_regions"
 * or "print_copyinout_regions"
 * or "print_private_regions"
 *
 * "module_to_value_mappings" must be called to set up the
 * hash table to translate value into value names
 */
void print_rw_regions(list l)
{ print_regions_with_action(l, ACTION_READ, ACTION_WRITE);}
 
void print_inout_regions(list l)
{ print_regions_with_action(l, ACTION_IN, ACTION_OUT);}
 
void print_copyinout_regions(list l)
{ print_regions_with_action(l, ACTION_COPYIN, ACTION_COPYOUT);}
 
void print_private_regions(list l)
{ print_regions_with_action(l, ACTION_PRIVATE, ACTION_PRIVATE);}
 
void print_regions(list l) { print_rw_regions(l);}
 
/* void print_regions(effect r)
 * input    : a region.
 * modifies : nothing.
 * comment  : prints the region on stderr using words_region.
 *
 * NW:
 * before calling "print_region" or "text_region"
 *
 * "module_to_value_mappings" must be called to set up the
 * hash table to translate value into value names
 * (see comment for "module_to_value_mappings" for what must be done
 * before that is called)
 *
 * and also "set_action_interpretation" with arguments:
 * ACTION_READ, ACTION_WRITE to label regions as R/W
 * ACTION_IN, ACTION_OUT to label regions as IN/OUT
 * ACTION_COPYIN, ACTION_COPYOUT to label regions as COPYIN/COPYOUT
 * ACTION_PRIVATE, ACTION_PRIVATE to label regions as PRIVATE
 *
 * like this:
 *
 * const char* module_name;
 * entity module;
 * ...
 * (set up call to module_to_value_mappings as indicated in its comments)
 * ...
 * module_to_value_mappings(module);
 * set_action_interpretation(ACTION_IN, ACTION_OUT);
 *
 * (that's it, but after the call to "print_region" or "text_region",
 * don't forget to do:)
 *
 * reset_action_interpretation();
 * (resets after call to module_to_value_mappings as indicated in its comments)
 *
 * FI: Regions/Effects related to store and environment mutations are not
 * displayed because they have no descriptors, but by two LFs.
 */
void print_region(effect r)
{
    fprintf(stderr,"\n");
    if(effect_region_p(r)) {
        text t = text_region(r);
        print_text(stderr, t);
        free_text(t);
    }
    /* FI: uncommented to introduce environment and type declaration
       regions/effects */
    /* else print_words(stderr, words_effect(r)); */
    else {
      // FI: this is not homogeneous with the regions
      //print_words(stderr, words_effect(r));
      // This is even worse
      /*
      list el = CONS(EFFECT, r, NIL);
      text t = simple_rw_effects_to_text(el);
      print_text(stderr, t);
      free_text(t);
      gen_free_list(el);
      */
      // FI: let's homogeneize the outputs...
        text t = text_region(r);
        print_text(stderr, t);
        free_text(t);
    }
    fprintf(stderr,"\n");
}
 
 
 
/************************************************* STATISTICS FOR OPERATORS */
 
 
void print_regions_op_statistics(char __attribute__ ((unused)) *mod_name,
                                 int regions_type)
{
  pips_assert("true", mod_name==mod_name && regions_type==regions_type);
    /*
    string prefix = string_undefined;
 
    switch (regions_type) {
    case R_RW :
        prefix = "rrw-";
        break;
    case R_IN :
        prefix = "rin-";
        break;
    case R_OUT :
        prefix = "rout-";
        break;
    }
 
    print_proj_op_statistics(mod_name, prefix);
    print_umust_statistics(mod_name, prefix);
    print_umay_statistics(mod_name, prefix);
    print_dsup_statistics(mod_name, prefix); */
    /* print_dinf_statistics(mod_name, prefix); */
 
}
 
 
/***************************************************************** SORTING */