prettyprint.c

Go to the documentation of this file.

/*
 
  $Id: prettyprint.c 22777 2015-08-23 20:56:50Z irigoin $
 
  Copyright 1989-2009 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/>.
 
*/
/*
 * (prettyg)print of POINTS TO.
 *
 * AM, August 2009.
 */
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "genC.h"
 
#include "text.h"
#include "text-util.h"
 
#include "top-level.h"
 
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "points_to_private.h"
 
#include "ri-util.h"
#include "prettyprint.h"
#include "pipsdbm.h"
#include "workspace-util.h"
#include "effects-util.h"
 
#include "database.h"
#include "resources.h"
#include "properties.h"
//#include "preprocessor.h"
#include "misc.h"
 
 
 
/************* EFFECT REFERENCES */
 
/* made from words_reference
 * this function can print entity_name instead of entity_local_name,
 * when the entity is not called in the current program.
 */
list /* of string */ effect_words_reference(reference obj)
{
  list pc = NIL;
  string begin_attachment;
  entity e = reference_variable(obj);
 
  if (get_bool_property("PRETTYPRINT_WITH_COMMON_NAMES")
      && entity_in_common_p(e)) {
    pc = CHAIN_SWORD(pc, entity_and_common_name(e));
  } else if (get_bool_property("PRETTYPRINT_EFFECT_WITH_FULL_ENTITY_NAME")) {
    pc = CHAIN_SWORD(pc, entity_name(e));
  } else {
    pc = CHAIN_SWORD(pc, entity_minimal_name(e));
  }
 
  begin_attachment = STRING(CAR(pc));
 
  if (reference_indices(obj) != NIL)
    {
      string before_first_index = string_undefined;
      string before_index = string_undefined;
      string after_index = string_undefined;
      string after_last_index = string_undefined;
      string before_field = string_undefined;
      string after_field = string_undefined;
 
      switch(get_prettyprint_language_tag())
        {
        case is_language_fortran95:
        case is_language_fortran:
          before_first_index = "(";
          before_index = "";
          after_index = ",";
          after_last_index = ")";
          before_field = "";
          after_field = "";
          break;
        case is_language_c:
          before_first_index = "[";
          before_index = "[";
          after_index = "]";
          after_last_index = "]";
          before_field = ".";
          after_field = "";
          break;
        default:
          pips_internal_error("Language unknown !");
          break;
        }
 
      bool first = true;
      for(list pi = reference_indices(obj); !ENDP(pi); POP(pi))
        {
          expression ind_exp = EXPRESSION(CAR(pi));
          syntax s = expression_syntax(ind_exp);
          if (syntax_reference_p(s) &&
              entity_field_p(reference_variable(syntax_reference(s))))
            {
              // add a '.' to disambiguate field names from variable names
              pc = CHAIN_SWORD(pc, before_field);
              pc = gen_nconc(pc, Words_Expression(ind_exp));
              pc = CHAIN_SWORD(pc, after_field);
            }
          else
            {
              if (first)
                {
                  pc = CHAIN_SWORD(pc,before_first_index);
                  first = false;
                }
              else
                pc = CHAIN_SWORD(pc,before_index);
 
              pc = gen_nconc(pc, Words_Expression(ind_exp));
              if (CDR(pi) != NIL)
                pc = CHAIN_SWORD(pc,after_index);
              else
                pc = CHAIN_SWORD(pc,after_last_index);
            }
        }
    }
 
  attach_reference_to_word_list(begin_attachment, STRING(CAR(gen_last(pc))),
                                obj);
  return(pc);
}
 
string effect_reference_to_string(reference ref)
{
  return words_to_string(effect_words_reference(ref));
}
 
/************* CELL DESCRIPTORS */
 
/* char * pips_region_user_name(entity ent)
 * output   : the name of entity.
 * modifies : nothing.
 * comment  : allows to "catch" the PHIs entities, else, it works like
 *            pips_user_value_name() (see semantics.c).
 */
const char *
pips_region_user_name(entity ent)
{
    /* external_value_name cannot be used because there is no need for
       the #new suffix, but the #old one is necessary */
    const char* name;
    if(ent == NULL)
        /* take care of the constant term TCST */
        name = "";
    else {
        char *ent_name = entity_name(ent);
 
        if (strncmp(ent_name, REGIONS_MODULE_NAME, 7) == 0)
            /* ent is a PHI entity from the regions module */
            name = entity_local_name(ent);
        else
          {
            /* if (!hash_entity_to_values_undefined_p() && !entity_has_values_p(ent)) */
/*            name = external_value_name(ent); */
/*          else */
              name = entity_minimal_name(ent);
          }
    }
 
    return name;
}
 
 
 
/********** POINTS_TO *************/
 
 
 
#define PT_TO_SUFFIX ".points_to"
#define PT_TO_DECO "points to = "
#define SUMMARY_PT_TO_SUFFIX ".summary_points_to"
#define SUMMARY_PT_TO_DECO "summary points to = "
 
/*Already exist in cprettyprint but in mode static. To be removed later.*/
static bool variable_p(entity e)
{
        return type_undefined_p(entity_type(e));
}
 
/* To modelize the heap locations we manufacture fictious reference,
 * that triggered a bug when it appears as an argument of entity_user_name(). */
list
words_fictious_reference(reference obj)
{
  list pc = NIL;
  entity e = reference_variable(obj);
  pc = CHAIN_SWORD(pc, entity_name(e));
  return(pc);
}
 
#if 0
/* For debugging points-to: use this function in points_to_words_reference() */
static string entity_full_name(entity e)
{
  return entity_name(e);
}
#endif
 
/* Specific handling of references appearing in points_to */
list points_to_words_reference(reference r)
{
  extern const char* entity_minimal_user_name(entity);
 
  // Normal implementation, used for validation:
  return Words_Any_Reference(r, NIL, entity_minimal_user_name);
  // To ease debugging, use:
  //return words_any_reference(r, NIL, entity_full_name);
}
 
list word_points_to(points_to pt)
{
  list l2 = NIL, l1 = NIL, rlt1 = NIL;
 
  pips_assert("pt is defined", !points_to_undefined_p(pt));
  points_to_consistent_p(pt);
  cell c1 = points_to_source(pt);
  cell c2 = points_to_sink(pt);
  // FI->AM: check all your copy_xxxx(); you often copy a large object
  // to obtain a small part of it
  reference r1 = cell_to_reference(c1);
  reference r2 = cell_to_reference(c2);
  approximation rel = points_to_approximation(pt);
  string l3 = "-MAY-";
 
  if (approximation_exact_p(rel))
    l3 = "-Exact-";
  if(variable_p(reference_variable(r2)))
    l2 = words_fictious_reference(r2);
  else
    l2 = points_to_words_reference(r2);
 
  l1 = points_to_words_reference(r1);
 
  rlt1 = gen_nconc((CONS(STRING,strdup("("), NIL)),l1);
  rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(","), NIL)));
 
  rlt1 = gen_nconc(rlt1, l2);
  rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(","), NIL)));
  rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(l3), NIL)));
  rlt1 = gen_nconc(rlt1,(CONS(STRING,strdup(")"), NIL)));
  return rlt1;
}
 
/* Comparison of two points-to arcs based on their source and sink nodes.
 *
 * This comparison function is used to sort a list of points-to before
 * storage and print-out.
 *
 * It must return -1, 0 or 1 like strcmp(). It should avoid 0 because
 * we want a total order to avoid validation problems. Hence the
 * exploitation of the references, number of indices, subscript
 * expressions, etc. if the entity names are not sufficient to
 * disambiguate the references.
 *
 * When subscript expressions are used, fields are replaced by the
 * corresponding field number. So the sort is based on the field ranks
 * in the data structure and not on the the field names.
 *
 * For abstract locations, the local name is used for the sort and the
 * global names is sometimes used in the prettyprint. Hence, the
 * alphabetical order is not obvious in the print-out.
 */
int points_to_compare_cells(const void * vpt1, const void * vpt2)
{
  int i = 0;
 
  points_to pt1 = *((points_to *) vpt1);
  points_to pt2 = *((points_to *) vpt2);
 
  cell c1so = points_to_source(pt1);
  cell c2so = points_to_source(pt2);
  cell c1si = points_to_sink(pt1);
  cell c2si = points_to_sink(pt2);
 
  //cell c1 = CELL(CAR(vc1));
  //cell c2 = CELL(CAR(vc2));
  // FI: bypass of GAP case
  reference r1so = cell_to_reference(c1so);
  reference r2so = cell_to_reference(c2so);
  reference r1si = cell_to_reference(c1si);
  reference r2si = cell_to_reference(c2si);
 
  entity v1so = reference_variable(r1so);
  entity v2so = reference_variable(r2so);
  entity v1si = reference_variable(r1si);
  entity v2si = reference_variable(r2si);
  list sl1 = NIL, sl2 = NIL, sli1 = NIL, sli2 = NIL ;
  // FI: memory leak? generation of a new string?
  extern const char* entity_minimal_user_name(entity);
  string n1so =   entity_abstract_location_p(v1so)?
    (string) entity_local_name(v1so) :  (string) entity_minimal_user_name(v1so);
  string n2so =   entity_abstract_location_p(v2so)?
    (string) entity_local_name(v2so) : (string) entity_minimal_user_name(v2so);
  string n1si =   entity_abstract_location_p(v1si)?
   (string)  entity_local_name(v1si) : (string) entity_minimal_user_name(v1si);
  string n2si =   entity_abstract_location_p(v2si)?
    (string) entity_local_name(v2si) : (string) entity_minimal_user_name(v2si);
 
  i = strcmp(n1so, n2so);
  if(i==0) {
    i = strcmp(n1si, n2si);
    if(i==0) {
      sl1 = reference_indices(r1so);
      sl2 = reference_indices(r2so);
      int i1 = gen_length(sl1);
      int i2 = gen_length(sl2);
 
      i = i2>i1? 1 : (i2<i1? -1 : 0);
 
      if(i==0) {
        sli1 = reference_indices(r1si);
        sli2 = reference_indices(r2si);
        int i1 = gen_length(sli1);
        int i2 = gen_length(sli2);
 
        i = i2>i1? 1 : (i2<i1? -1 : 0);
        //      if(i==0) {
        for(;i==0 && !ENDP(sl1); POP(sl1), POP(sl2)){
          expression se1 = EXPRESSION(CAR(sl1));
          expression se2 = EXPRESSION(CAR(sl2));
          if(expression_constant_p(se1) && expression_constant_p(se2)){
            int i1 = expression_to_int(se1);
            int i2 = expression_to_int(se2);
            i = i2>i1? -11 : (i2<i1? 1 : 0);
          } else {
            string s1 = expression_to_string(se1);
            string s2 = expression_to_string(se2);
            i = strcmp(s1, s2);
          }
        }
        // if(i==0) {
        // i = strcmp(entity_minimal_user_name(v1si), entity_minimal_user_name(v2si));
        for(;i==0 && !ENDP(sli1); POP(sli1), POP(sli2)){
          expression sei1 = EXPRESSION(CAR(sli1));
          expression sei2 = EXPRESSION(CAR(sli2));
          if(expression_constant_p(sei1) && expression_constant_p(sei2)){
            int i1 = expression_to_int(sei1);
            int i2 = expression_to_int(sei2);
            i = i2>i1? -1 : (i2<i1? 1 : 0);
          } else {
            // FI: memory leak?
            string s1 = expression_to_string(sei1);
            string s2 = expression_to_string(sei2);
            i = strcmp(s1, s2);
          }
        }
      }
    }
  }
  // }
  return i;
}
 
/* Allocate a copy of ptl and sort it. It might be better to admit a
   side effect on ptl and to let the caller copy the liste before
   sorting. */
list points_to_list_sort(list ptl)
{
  list sptl = gen_full_copy_list(ptl);
 
  gen_sort_list(sptl, /* (gen_cmp_func_t) */ points_to_compare_cells);
 
  return sptl;
}
 
//extern void print_points_to(
/* Make sure that points-to are fully ordered before prettyprinting
   them or validation will be in trouble sooner or later. The sort
   could occur before storing the points-to information into the hash
   table or just before prettypriting it. */
list words_points_to_list(__attribute__((unused))string note, points_to_list s)
{
  list l = NIL;
  int i = 0;
  list ptl = points_to_list_list(s);
  list sptl = points_to_list_sort(ptl);
 
  FOREACH(POINTS_TO, j, sptl) {
    if(i>0)
      l = gen_nconc(l, (CONS(STRING,strdup(";"), NIL)));
    else
      i++;
    l = gen_nconc(l,word_points_to(j));
  }
  l = CONS(STRING,strdup("{"), l);
  l = gen_nconc(l,(CONS(STRING,strdup("}"), NIL)));
 
  gen_full_free_list(sptl);
 
  return l;
}
 
 
/************* POINTER VALUES */
 
list words_pointer_value(cell_relation pv)
{
  cell first_c = cell_relation_first_cell(pv);
  cell second_c = cell_relation_second_cell(pv);
 
  pips_assert("there should not be preference cells in pointer values (first) \n",
              !cell_preference_p(first_c));
  pips_assert("there should not be preference cells in pointer values (second) \n",
              !cell_preference_p(second_c));
 
  pips_assert("gaps not handled yet (first)", !cell_gap_p(first_c));
  pips_assert("gaps not handled yet (second)", !cell_gap_p(second_c));
 
  pips_assert("the first cell must have value_of interpretation\n",
              cell_relation_first_value_of_p(pv));
 
  list w = NIL;
 
  reference first_r = cell_reference(first_c);
  reference second_r = cell_reference(second_c);
  approximation ap = cell_relation_approximation(pv);
  pips_assert("approximation is not must\n", !approximation_exact_p(ap));
 
  w= gen_nconc(w, effect_words_reference(first_r));
  w = CHAIN_SWORD(w," == ");
  w= gen_nconc(w, effect_words_reference(second_r));
  w = CHAIN_SWORD(w, approximation_may_p(ap) ? " (may)" : " (exact)" );
  return (w);
}
 
string approximation_to_string(approximation a)
{
  string as = string_undefined;
  if(approximation_may_p(a))
    as = "may";
  else if(approximation_must_p(a))
    as = "must"; // could be "exact"
  else if(approximation_exact_p(a))
    as = "exact";
  else
    pips_internal_error("Unknown approximation tag.\n");
  return as;
}
 
#define append(s) add_to_current_line(line_buffer, s, str_prefix, tpv)
 
/* text text_region(effect reg)
 * input    : a region
 * output   : a text consisting of several lines of commentaries,
 *            representing the region
 * modifies : nothing
 */
text text_pointer_value(cell_relation pv)
{
  text tpv = text_undefined;
 
  bool foresys = false;
  string str_prefix = get_comment_continuation();
  char line_buffer[MAX_LINE_LENGTH];
  Psysteme sc;
  list /* of string */ ls;
 
  if (cell_relation_undefined_p(pv))
    {
      ifdebug(1)
        {
          return make_text(CONS(SENTENCE,
                                make_sentence(is_sentence_formatted,
                                              strdup(concatenate(str_prefix,
                                                                 "undefined pointer value\n",
                                                                 NULL))),
                                NIL));
        }
      else
        pips_user_warning("unexpected pointer value undefined\n");
    }
  else
    tpv = make_text(NIL);
 
  cell first_c = cell_relation_first_cell(pv);
  cell second_c = cell_relation_second_cell(pv);
 
  pips_assert("there should not be preference cells in pointer values (first) \n",
              !cell_preference_p(first_c));
  pips_assert("there should not be preference cells in pointer values (second) \n",
              !cell_preference_p(second_c));
 
  pips_assert("gaps not handled yet (first)", !cell_gap_p(first_c));
  pips_assert("gaps not handled yet (second)", !cell_gap_p(second_c));
 
  pips_assert("the first cell must have value_of interpretation\n",
              cell_relation_first_value_of_p(pv));
 
 
  reference first_r = cell_reference(first_c);
  reference second_r = cell_reference(second_c);
  approximation ap = cell_relation_approximation(pv);
  descriptor d = cell_relation_descriptor(pv);
 
  /* PREFIX
   */
  strcpy(line_buffer, get_comment_sentinel());
  append(" ");
 
  /* REFERENCES */
  ls = effect_words_reference(first_r);
 
  FOREACH(STRING, s, ls) {append(s);}
  gen_free_string_list(ls); ls = NIL;
 
  append(" == ");
 
  ls = effect_words_reference(second_r);
  if (cell_relation_second_address_of_p(pv))
    append("&");
 
  FOREACH(STRING, s, ls) {append(s);}
  gen_free_string_list(ls); ls = NIL;
 
  /* DESCRIPTOR */
  /* sorts in such a way that constraints with phi variables come first.
   */
  if(!descriptor_none_p(d))
    {
      sc = sc_copy(descriptor_convex(d));
      sc_lexicographic_sort(sc, is_inferior_cell_descriptor_pvarval);
      system_sorted_text_format(line_buffer, str_prefix, tpv, sc,
                                (get_variable_name_t) pips_region_user_name,
                                vect_contains_phi_p, foresys);
      sc_rm(sc);
    }
 
  /* APPROXIMATION */
  append(approximation_may_p(ap) ? " (may);" : " (exact);");
 
  /* CLOSE */
  close_current_line(line_buffer, tpv,str_prefix);
 
  return tpv;
}
 
 
text
text_pointer_values(list lpv, string header)
{
    text tpv = make_text(NIL);
    /* in case of loose_prettyprint, at least one region to print? */
    bool loose_p = get_bool_property("PRETTYPRINT_LOOSE");
 
    /* GO: No redundant test anymore, see  text_statement_array_regions */
    if (lpv != (list) HASH_UNDEFINED_VALUE && lpv != list_undefined)
    {
      /* header first */
      char line_buffer[MAX_LINE_LENGTH];
      string str_prefix = get_comment_continuation();
      if (loose_p)
        {
          strcpy(line_buffer,"\n");
          append(get_comment_sentinel());
        }
      else
        {
          strcpy(line_buffer,get_comment_sentinel());
        }
      append(" ");
      append(header);
      if(ENDP(lpv))
        append(" none\n");
      else
        append("\n");
      ADD_SENTENCE_TO_TEXT(tpv,
                           make_sentence(is_sentence_formatted,
                                         strdup(line_buffer)));
      gen_sort_list(lpv, (int (*)(const void *,const void *)) pointer_value_compare);
      FOREACH(CELL_RELATION, pv, lpv)
        {
          MERGE_TEXTS(tpv, text_pointer_value(pv));
        }
 
      if (loose_p)
        ADD_SENTENCE_TO_TEXT(tpv,
                             make_sentence(is_sentence_formatted,
                                           strdup("\n")));
    }
    return tpv;
}
 
void print_pointer_value(cell_relation pv)
{
  text t = text_pointer_value(pv);
  print_text(stderr, t);
  free_text(t);
}
 
void print_pointer_values(list lpv)
{
  fprintf(stderr,"\n");
  if (ENDP(lpv))
    fprintf(stderr,"<none>");
  else
    {
      FOREACH(CELL_RELATION, pv, lpv)
        {
          print_pointer_value(pv);
        }
    }
  fprintf(stderr,"\n");
}