points_to_prettyprint.c

Go to the documentation of this file.

/*
 
  $Id: points_to_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/>.
 
*/
/*
 * (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 "linear.h"
 
#include "text.h"
#include "text-util.h"
 
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
 
#include "pipsdbm.h"
#include "properties.h"
#include "misc.h"
 
#include "prettyprint.h"
#include "semantics.h" // ??? bound_printed_points_to_list_p
 
#include "points-to.h"
 
#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 = "
 
/****************************************************** STATIC INFORMATION */
GENERIC_GLOBAL_FUNCTION(printed_points_to_list, statement_points_to)
 
/************************************************************* BASIC WORDS */
 
text text_points_to(entity module __attribute__ ((__unused__)),int margin __attribute__ ((__unused__)), statement s)
{
 
  text t;
  t = bound_printed_points_to_list_p(s)?
    words_predicate_to_commentary
    (words_points_to_list(PT_TO_DECO,
                          load_printed_points_to_list(s)),
                              get_comment_sentinel())
    :words_predicate_to_commentary
    (CONS(STRING,PT_TO_DECO, CONS(STRING, strdup("{}"), NIL)),
        get_comment_sentinel());
 
 
  return t;
}
 
 
 text text_code_points_to(statement s)
{
  text t;
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  init_prettyprint(text_points_to);
  t = text_module(get_current_module_entity(), s);
  close_prettyprint();
  debug_off();
  return t;
}
 
/* bool print_code_points_to(const char* module_name, */
/*                        string resource_name __attribute__ ((__unused__)), */
/*                        string file_suffix) */
/* { */
/*   list wl = list_undefined; */
/*   text t, st = text_undefined; */
/*   bool res; */
/*   debug_on("POINTS_TO_DEBUG_LEVEL"); */
/*   set_current_module_entity(local_name_to_top_level_entity(module_name)); */
/*   points_to_list summary_pts_to = (points_to_list) */
/*     db_get_memory_resource(DBR_SUMMARY_POINTS_TO_LIST, module_name, true); */
/*   wl = words_points_to_list(PT_TO_DECO, summary_pts_to); */
/*   pips_debug(1, "considering module %s \n", */
/*           module_name); */
 
/*   /\*  FI: just for debugging *\/ */
/*   // check_abstract_locations(); */
/*   set_printed_points_to_list((statement_points_to) */
/*                           db_get_memory_resource(DBR_POINTS_TO_LIST, module_name, true)); */
/*   statement_points_to_consistent_p(get_printed_points_to_list()); */
/*   set_current_module_statement((statement) */
/*                             db_get_memory_resource(DBR_CODE, */
/*                                                    module_name, */
/*                                                    true)); */
/*   // FI: should be language neutral... */
 
/*   st = words_predicate_to_commentary(wl, get_comment_sentinel()); */
/*   t = text_code_points_to(get_current_module_statement()); */
/*   MERGE_TEXTS(st, t); */
/*   res= make_text_resource_and_free(module_name,DBR_PRINTED_FILE,file_suffix, st); */
/*   reset_current_module_entity(); */
/*   reset_current_module_statement(); */
/*   reset_printed_points_to_list(); */
/*   debug_off(); */
/*   return true; */
/* } */
bool print_code_points_to(const char* module_name,
                          string resource_name __attribute__ ((__unused__)),
                          string file_suffix)
{
  //list wl = list_undefined;
  bool res;
  debug_on("POINTS_TO_DEBUG_LEVEL");
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  
  
  /* Load IN  pts-to */
  points_to_list pts_to_in = (points_to_list)
    db_get_memory_resource(DBR_POINTS_TO_IN, module_name, true);
  //list l_pt_to_in = points_to_list_list(pts_to_in);
 
 /* Load OUT  pts-to */
  points_to_list pts_to_out = (points_to_list)
    db_get_memory_resource(DBR_POINTS_TO_OUT, module_name, true);
  //list l_pt_to_out = points_to_list_list(pts_to_out);
 
  pips_debug(1, "considering module %s \n",
             module_name);
 
  /*  FI: just for debugging */
  // check_abstract_locations();
  set_printed_points_to_list((statement_points_to)
                             db_get_memory_resource(DBR_POINTS_TO, module_name, true));
  /* statement_points_to_consistent_p(get_printed_points_to_list()); */
  set_current_module_statement((statement)
                               db_get_memory_resource(DBR_CODE,
                                                      module_name,
                                                      true));
 
  init_prettyprint(text_pt_to);
  /* text sum_tex = text_points_to_relations(l_sum_pt_to, "Points To:"); */
  text in_tex = text_points_to_relations(pts_to_in, "Points To IN:");
  text out_tex = text_points_to_relations(pts_to_out, "Points To OUT:");
  text t = make_text(NIL);
  /* MERGE_TEXTS( t, sum_tex ); */
  MERGE_TEXTS( t, in_tex );
  MERGE_TEXTS( t, out_tex );
  MERGE_TEXTS(t, text_module(get_current_module_entity(),
                             get_current_module_statement()));
  res = make_text_resource_and_free(module_name,DBR_PRINTED_FILE,file_suffix, t);
  close_prettyprint();
  reset_current_module_entity();
  reset_current_module_statement();
  reset_printed_points_to_list();
  debug_off();
  return res;
}
 
void print_points_to_list(points_to_list ptl)
{
  text t = text_points_to_relations(ptl, "");
  print_text(stderr, t);
  free_text(t);
}
 
void print_points_to_graph(points_to_graph ptg)
{
  bool ok = !points_to_graph_bottom(ptg);
  if(!ok)
    fprintf(stderr, "Points-to graph does not exist, dead code\n");
  else {
    set s = points_to_graph_set(ptg);
    print_points_to_set("", s);
  }
}
 
//Handlers for PIPSMAKE
bool print_code_points_to_list(const char* module_name)
{
        return print_code_points_to(module_name,
                                    DBR_POINTS_TO,
                                    PT_TO_SUFFIX);
}
 
 
list words_points_to(points_to pt)
{
  cell source = points_to_source(pt);
  cell sink = points_to_sink(pt);
 
  pips_assert("there should not be preference cells in points to (source) \n",
              !cell_preference_p(source));
  pips_assert("there should not be preference cells in points to (sink) \n",
              !cell_preference_p(sink));
 
  pips_assert("gaps not handled yet (source)", !cell_gap_p(source));
  pips_assert("gaps not handled yet (sink)", !cell_gap_p(sink));
 
 
  list w = NIL;
 
  reference source_ref = cell_reference(source);
  reference sink_ref = cell_reference(sink);
  approximation ap = points_to_approximation(pt);
  pips_assert("approximation is not must\n", !approximation_exact_p(ap));
 
  w = gen_nconc(w, effect_words_reference(source_ref));
  w = CHAIN_SWORD(w," -> ");
  if(!nowhere_cell_p(sink)) {
    w = gen_nconc(w, effect_words_reference(sink_ref));
  }
  else {
    string undef = "undefined" ;
    w = gen_nconc(w, CONS(STRING,undef,NIL));
  }
    
  w = CHAIN_SWORD(w, approximation_may_p(ap) ? " (may)" : " (exact)" );
  return (w);
}
 
#define append(s) add_to_current_line(line_buffer, s, str_prefix, tpt_to)
 
/* text text_region(effect reg)
 * input    : a region
 * output   : a text consisting of several lines of commentaries,
 *            representing the region
 * modifies : nothing
 */
text text_points_to_relation(points_to pt_to)
{
  text tpt_to = text_undefined;
 
  bool foresys = false;
  string str_prefix = get_comment_continuation();
  char line_buffer[MAX_LINE_LENGTH];
  Psysteme sc;
  list /* of string */ ls;
 
  if (points_to_undefined_p(pt_to))
    {
      ifdebug(1)
        {
          return make_text(CONS(SENTENCE,
                                make_sentence(is_sentence_formatted,
                                              strdup(concatenate(str_prefix,
                                                                 "undefined points to relation\n",
                                                                 NULL))),
                                NIL));
        }
      else
        pips_user_warning("unexpected points-to relation undefined\n");
    }
  else
    tpt_to = make_text(NIL);
 
  cell source = points_to_source(pt_to);
  cell sink = points_to_sink(pt_to);
 
  pips_assert("there should not be preference cells in points to relation (source) \n",
              !cell_preference_p(source));
  pips_assert("there should not be preference cells in points to relation (sink) \n",
              !cell_preference_p(sink));
 
  pips_assert("gaps not handled yet (source)", !cell_gap_p(source));
  pips_assert("gaps not handled yet (sink)", !cell_gap_p(sink));
 
 
  reference source_r = cell_reference(source);
  reference sink_r = cell_reference(sink);
  approximation ap = points_to_approximation(pt_to);
  descriptor d = points_to_descriptor(pt_to);
 
  /* PREFIX
   */
  strcpy(line_buffer, get_comment_sentinel());
  append(" ");
 
  /* REFERENCES */
  ls = effect_words_reference(source_r);
 
  FOREACH(STRING, s, ls) {append(s);}
  gen_free_string_list(ls); ls = NIL;
 
  append(" -> ");
 
  /* Change nowhere cells into undefined to comply with the C standard */
  entity e = reference_variable(sink_r);
  if(! entity_typed_nowhere_locations_p(e)) {
    ls = effect_words_reference(sink_r);
  }
  else {
    string undef = "undefined" ;
    ls =  CONS(STRING,strdup(undef),NIL);
  }
  //  ls = effect_words_reference(sink_r);
  /* if (points_to_second_address_of_p(pt_to)) */
  /*   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, tpt_to, 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, tpt_to, str_prefix);
 
  return tpt_to;
}
 
text
text_points_to_relations(points_to_list ptl, string header)
{
  list l_pt_to = points_to_list_list(ptl);
  bool bottom_p = points_to_list_bottom(ptl);
 
    text tpt_to = 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 (l_pt_to != (list) HASH_UNDEFINED_VALUE && l_pt_to != 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(bottom_p)
        append(" unreachable\n");
      else if(ENDP(l_pt_to))
        append(" none\n");
      else
        append("\n");
      ADD_SENTENCE_TO_TEXT(tpt_to,
                           make_sentence(is_sentence_formatted,
                                         strdup(line_buffer)));
      l_pt_to = points_to_list_sort(l_pt_to);
      FOREACH(points_to, pt_to, l_pt_to)
        {
          MERGE_TEXTS(tpt_to, text_points_to_relation(pt_to));
        }
 
      if (loose_p)
        ADD_SENTENCE_TO_TEXT(tpt_to,
                             make_sentence(is_sentence_formatted,
                                           strdup("\n")));
    }
    return tpt_to;
}
 
/* print a points-to arc, print_points_to() or print_points_to_arc() */
void print_points_to_relation(points_to pt_to)
{
  text t = text_points_to_relation(pt_to);
  print_text(stderr, t);
  free_text(t);
}
 
/* print a list of points-to arcs */
void print_points_to_relations(list l_pt_to)
{
  fprintf(stderr,"\n");
  if (ENDP(l_pt_to))
    fprintf(stderr,"<none>");
  else
    {
      FOREACH(POINTS_TO, pt, l_pt_to)
        {
          print_points_to_relation(pt);
        }
    }
  fprintf(stderr,"\n");
}
 
text text_pt_to(entity __attribute__ ((unused)) module_name, int __attribute__ ((unused)) margin, statement s)
{
  points_to_list ptl = load_printed_points_to_list(s);
  text t = text_points_to_relations(ptl, "Points To:");
  return t;
}