print.c

Go to the documentation of this file.

/*
 
  $Id: print.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
 
/* Name     : print.c
 * Package  : paf-util
 * Author   : Alexis Platonoff
 * Date     : july 1993
 *
 * Historic :
 * - 16 july 93, changes in paf_ri, AP
 * - 23 sept 93, change the name of this file, AP
 * - 17 nov 93, add of fprintf_indent() for a prettier imprime_quast(). AP
 *
 * Documents:
 * Comments : This file contains the functions used for printing the data
 * structures of paf_ri.
 */
 
/* Ansi includes        */
#include <stdio.h>
 
/* Newgen includes      */
#include "genC.h"
 
/* C3 includes          */
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "matrice.h"
#include "matrix.h"
 
/* Pips includes        */
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "workspace-util.h" // for fprint_list_of_exp() [~print_expressions()]
#include "prettyprint.h"
#include "constants.h"
#include "misc.h"
#include "paf_ri.h"
typedef dfg_arc_label arc_label;
typedef dfg_vertex_label vertex_label;
#include "graph.h"
#include "text.h"
#include "text-util.h"
#include "misc.h"
#include "paf-util.h"
 
/* Macro functions      */
#define IS_INEG 0
#define IS_EG 1
#define IS_VEC 2
 
/* Global variables     */
 
/* Internal variables   */
static int quast_depth = 0;     /* Used in imprime_quast() for correct indentation */
 
/* Local defines */
/* Moved higher because of Newgen's static typing */
/*
typedef dfg_vertex_label vertex_label;
typedef dfg_arc_label arc_label;
*/
 
/*============================================================================*/
/* static void pu_contrainte_fprint(FILE *fp, Pcontrainte c, int is_what,
 *                                   char *(*variable_name)()):
 *
 * prints in the file "fp" the constraint "c", of type equality, inequality or
 * vector according to the value of the integer argument "is_what", using the
 * function "variable_name" for the name of the variables.
 *
 * The function contrainte_fprint() exists, it is defined in contrainte.c (C3
 * library). We redefine this function because:
 *
 *      1. we want the constant term in the left hand side
 *      2. we want a third type of contrainte (vector) which does not print the
 *         inequality or equality symbol.
 *      3. we do not want a line feed at the end of the constraint
 *
 * We consider that CONTRAINTE_UNDEFINED => CONTRAINTE_NULLE
 *
 * Results for a constraint containing the following Pvecteur (2*I) (-J) (-4):
 *
 *   equality:          2 * I - J - 4 = 0
 *   inequality:        2 * I - J - 4 <= 0
 *   vector:            2 * I - J - 4
 *
 */
/* GRRRR this function is already/also in array_dfg... FC */
 
static void pu_contrainte_fprint(
  FILE *fp,
  Pcontrainte c,
  int is_what,
  const char * (*variable_name)(entity))
{
    Pvecteur v;
    short int debut = 1;
    Value constante = VALUE_ZERO;
 
    if (!CONTRAINTE_UNDEFINED_P(c))
        v = contrainte_vecteur(c);
    else
        v = VECTEUR_NUL;
 
    if(!vect_check(v))
       pips_internal_error("Non coherent vector");
 
    while (!VECTEUR_NUL_P(v)) {
        if (v->var!=TCST) {
            char signe;
            Value coeff = v->val;
 
            if (value_notzero_p(coeff)) {
                if (value_pos_p(coeff))
                    signe = (debut) ? ' ' : '+';
                else {
                    signe = '-';
                    value_oppose(coeff);
                };
                debut = 0;
                if (value_one_p(coeff))
                    (void) fprintf(fp,"%c %s ", signe, variable_name(v->var));
                else
                {
                    (void) fprintf(fp,"%c ", signe);
                    fprint_Value(fp, coeff);
                    fprintf(fp, " %s ", variable_name(v->var));
                }
            }
        }
        else    /* on admet plusieurs occurences du terme constant!?! */
            value_addto(constante, v->val);
 
        v = v->succ;
  }
 
  /* sign */
  if (value_pos_p(constante))
      fprintf(fp, "+ ");
  else if (value_neg_p(constante))
      value_oppose(constante), fprintf(fp, "- ");
 
  /* value */
  if (value_notzero_p(constante))
      fprint_Value(fp, constante), fprintf(fp, " ");
 
  /* trail */
  if (is_what == IS_INEG)
      fprintf (fp,"<= 0 ,");
  else if(is_what == IS_EG)
      fprintf (fp,"== 0 ,");
  else /* IS_VEC */
      fprintf (fp," ,");
}
 
/*============================================================================*/
/* void pu_inegalite_fprint(FILE *fp, Pcontraint ineg,
 *                           char *(*variable_name)()):
 * Redefinition of inegalite_fprint(). See pu_contrainte_fprint() for details.
 */
void pu_inegalite_fprint(FILE *fp,
                         Pcontrainte ineg,
                         const char * (*variable_name)(entity))
{
    pu_contrainte_fprint(fp,ineg,IS_INEG,variable_name);
}
 
/*============================================================================*/
/* void pu_egalite_fprint(FILE *fp, Pcontraint eg, char *(*variable_name)()):
 * Redefinition of egalite_fprint(). See pu_contrainte_fprint() for details.
 */
void pu_egalite_fprint(FILE *fp,
                       Pcontrainte eg,
                       const char * (*variable_name)(entity))
{
    pu_contrainte_fprint(fp, eg, IS_EG, variable_name);
}
 
/*============================================================================*/
/* void vecteur_fprint(FILE *fp, Pcontraint vec char *(*variable_name)()):
 * See pu_contrainte_fprint() for details.
 */
void vecteur_fprint(FILE *fp,
                    Pcontrainte vec,
                    const char * (*variable_name)(entity))
{
  pu_contrainte_fprint(fp,vec,IS_VEC,variable_name);
}
 
/*============================================================================*/
/* void fprint_dataflow(FILE *fp, int stmt, dataflow df)
 *
 * Prints in the file "fp" the dataflow "df" with a sink statement "stmt".
 *
 */
void fprint_dataflow(fp, stmt, df)
FILE *fp;
int stmt;
dataflow df;
{
 list trans_l = dataflow_transformation(df);
 reference ref = dataflow_reference(df);
 predicate gov_pred = dataflow_governing_pred(df);
 communication comm = dataflow_communication(df);
 
 fprintf(fp,
         " ---Def-Use---> ins_%d:\n  Reference: %s\n  Transformation: [",
         stmt, reference_to_string(ref));
 
 fprint_list_of_exp(fp, trans_l);
 fprintf(fp,"]\n");
 fprintf(fp,"  Governing predicate:\n");
 if(gov_pred != predicate_undefined)
    fprint_pred(fp, gov_pred);
 else
    fprintf(fp, " {nil} \n");
 
 if(comm == communication_undefined)
   {
    /*fprintf(fp, "\t\t Communication general \n");*/
   }
 else
   {
    predicate pred;
 
    pred = communication_broadcast(comm);
    if(pred != predicate_undefined)
      {
       fprintf(fp,"\t\t Broadcast vector(s):");
       fprint_sc_pvecteur(fp, (Psysteme) predicate_system(pred));
      }
 
    pred = communication_reduction(comm);
    if(pred != predicate_undefined)
      {
       fprintf(fp,"\t\t Reduction vector(s):");
       fprint_sc_pvecteur(fp, (Psysteme) predicate_system(pred));
      }
 
    pred = communication_shift(comm);
    if(pred != predicate_undefined)
      {
       fprintf(fp,"\t\t Shift vector(s):");
       fprint_sc_pvecteur(fp, (Psysteme) predicate_system(pred));
      }
   }
}
 
 
/*============================================================================*/
/* void fprint_pred(FILE *fp, predicate pred): prints in the file "fp" the
 * predicate "pred".
 */
void fprint_pred(fp, pred)
FILE *fp;
predicate pred;
{
 Psysteme ps = (Psysteme) predicate_system(pred);
 
 fprint_psysteme(fp, ps);
}
 
/*============================================================================*/
/* void fprint_psysteme(FILE *fp, Psysteme ps): prints in the file "fp" the
 * Psysteme "ps". Each constraint is printed either with pu_inegalite_fprint()
 * or pu_egalite_fprint(), both redefined above. See pu_contrainte_fprint()
 * for details.
 */
void fprint_psysteme(fp, ps)
FILE *fp;
Psysteme ps;
{
 Pcontrainte peq;
 
 if (ps != NULL) {
    fprintf(fp,"{\n");
    for (peq = ps->inegalites; peq!=NULL; peq=peq->succ) {
         pu_inegalite_fprint(fp,peq,entity_local_name);
         fprintf(fp, "\n");
    }
    for (peq = ps->egalites; peq!=NULL; peq=peq->succ) {
         pu_egalite_fprint(fp,peq,entity_local_name);
         fprintf(fp, "\n");
    }
    fprintf(fp,"} \n");
   }
 else
    fprintf(fp," { nil }\n");
}
 
/*============================================================================*/
/* void fprint_sc_pvecteur(FILE *fp, Psysteme ps): prints in the file "fp"
 * the Psysteme "ps" as a list of vectors. Each constraint is printed with
 * vecteur_fprint() defined above. See pu_contrainte_fprint() for details.
 */
void fprint_sc_pvecteur(fp, ps)
FILE *fp;
Psysteme ps;
{
 Pcontrainte peq;
 
 if (ps != NULL) {
    fprintf(fp,"{ ");
 
    for (peq = ps->inegalites; peq!=NULL;
         vecteur_fprint(fp,peq,entity_local_name),peq=peq->succ);
 
    for (peq = ps->egalites; peq!=NULL;
         vecteur_fprint(fp,peq,entity_local_name),peq=peq->succ);
 
    fprintf(fp," } \n");
   }
 else
    fprintf(fp,"(nil)\n");
}
 
 
/*============================================================================*/
void fprint_bdt(fp, obj)
FILE *fp;
bdt obj;
{
  list sched_l;
 
  fprintf(fp,"\n Scheduling:\n");
  fprintf(fp,"============\n");
 
  if(obj == bdt_undefined) {
    fprintf(fp, "\tNot computed\n\n");
    return;
  }
 
  sched_l = bdt_schedules(obj);
 
  for(; sched_l != NIL; sched_l = CDR(sched_l)) {
    schedule crt_sched;
    int crt_stmt;
    list dim_l;
    predicate crt_pred;
 
    crt_sched = SCHEDULE(CAR(sched_l));
    crt_stmt = schedule_statement(crt_sched);
    dim_l = schedule_dims(crt_sched);
    crt_pred = schedule_predicate(crt_sched);
 
    /* PRINT */
    /* Mod by AP, oct 6th 199595: the number of the instruction is the
       vertex number minus BASE_NODE_NUMBER. */
    fprintf(fp,"ins_%d:\n", crt_stmt-BASE_NODE_NUMBER);
 
    if(crt_pred != predicate_undefined) {
      Psysteme ps = (Psysteme) predicate_system(crt_pred);
      Pcontrainte peq;
 
      if (ps != NULL) {
        fprintf(fp,"\t pred: ");
 
        for (peq = ps->inegalites; peq!=NULL;
             pu_inegalite_fprint(fp,peq,entity_local_name),peq=peq->succ);
 
        for (peq = ps->egalites; peq!=NULL;
             pu_egalite_fprint(fp,peq,entity_local_name),peq=peq->succ);
 
        fprintf(fp,"\n");
      }
      else
        fprintf(fp, "\t pred: TRUE\n");
    }
    else
      fprintf(fp, "\t pred: TRUE\n");
 
    fprintf(fp, "\t dims: ");
    for(; dim_l != NIL; dim_l = CDR(dim_l)) {
      expression exp = EXPRESSION(CAR(dim_l));
      fprintf(fp,"%s", expression_to_string(exp));
      if(CDR(dim_l) != NIL)
        fprintf(fp," , ");
    }
    fprintf(fp,"\n");
  }
}
 
 
 /* package mapping : Alexis Platonoff, april 1993*/
 
 
/*============================================================================*/
const char* pu_variable_name(v)
Variable v;
{
 if(v == TCST)
    return("TCST");
 else
    return(entity_local_name((entity) v));
}
 
 
/*============================================================================*/
bool pu_is_inferior_var(Variable v1 __attribute__ ((unused)),
                           Variable v2 __attribute__ ((unused)))
{
 return(false);
}
 
 
/*============================================================================*/
/* void pu_vect_fprint(FILE *fp, Pvecteur v): impression d'un vecteur creux v
 * sur le fichier fp.
 *
 * There exist a function "vect_fprint" in C3 which takes a third argument.
 */
/* arg, also in array_dfg. */
void pu_vect_fprint(FILE * fp, Pvecteur v)
{
    short int debut = 1;
    Value constante = VALUE_ZERO;
    char signe;
    while (!VECTEUR_NUL_P(v)) {
        if (v->var!=TCST) {
            Value coeff = v->val;
 
            if (value_notzero_p(coeff)) {
                if (value_pos_p(coeff))
                    signe = (debut) ? ' ' : '+';
                else {
                    signe = '-';
                    value_oppose(coeff);
                }
                debut = 0;
                if (value_one_p(coeff))
                    fprintf(fp,"%c %s ", signe,
                            entity_local_name((entity) v->var));
                else
                {
                    fprintf(fp,"%c ", signe);
                    fprint_Value(fp, coeff);
                    fprintf(fp, " %s ", entity_local_name((entity) v->var));
                }
            }
        }
        else
            /* on admet plusieurs occurences du terme constant!?! */
            value_addto(constante, v->val);
        v = v->succ;
    }
    if(debut)
        fprint_Value(fp, constante);
    else if(value_notzero_p(constante)) {
        if(value_pos_p(constante))
            signe = (debut) ? ' ' : '+';
        else {
            signe = '-';
            value_oppose(constante);
        }
        (void) fprintf(fp,"%c ", signe);
        fprint_Value(fp, constante);
        fprintf(fp, "\n");
    }
    else
        (void) fprintf(fp, "\n");
}
 
 
 
 
#define INDENT_FACTOR 2
 
/*============================================================================*/
void fprint_indent(fp, indent)
FILE *fp;
int indent;
{
  int i;
 
  fprintf(fp, "\n");
  for(i = 0; i < (indent * INDENT_FACTOR); i++) fprintf(fp, " ");
}
 
 
/*============================================================================*/
void imprime_quast (fp, qu)
FILE *fp;
quast qu;
{
  Psysteme        paux  = SC_UNDEFINED;
  predicate       pred_aux = predicate_undefined;
  conditional     cond_aux;
  quast_value     quv;
  quast_leaf      qul;
  leaf_label      ll;
  list            sol;
 
  if( (qu == quast_undefined) || (qu == NULL) ) {
    fprint_indent(fp, quast_depth);
    fprintf(fp, "Empty Quast ");
    return;
  }
  quv = quast_quast_value(qu);
  if( quv == quast_value_undefined ) {
    fprint_indent(fp, quast_depth);
    fprintf(fp, "Empty Quast ");
    return;
  }
  quv = quast_quast_value(qu);
 
  switch( quast_value_tag(quv)) {
    case is_quast_value_conditional:
      cond_aux = quast_value_conditional(quv);
      pred_aux = conditional_predicate(cond_aux);
      if (pred_aux != predicate_undefined)
          paux = (Psysteme)  predicate_system(pred_aux);
 
      fprint_indent(fp, quast_depth);
      fprintf(fp, "IF ");
      fprint_psysteme(fp, paux);
 
      fprint_indent(fp, quast_depth);
      fprintf(fp, "THEN");
      quast_depth++;
      imprime_quast(fp, conditional_true_quast (cond_aux) );
      quast_depth--;
 
      fprint_indent(fp, quast_depth);
      fprintf(fp, "ELSE");
      quast_depth++;
      imprime_quast(fp, conditional_false_quast (cond_aux) );
      quast_depth--;
 
      fprint_indent(fp, quast_depth);
      fprintf(fp, "FI");
    break;
 
    case is_quast_value_quast_leaf:
      qul = quast_value_quast_leaf( quv );
      if (qul == quast_leaf_undefined) {fprintf(fp,"Empty Quast Leaf\n");break;}
      sol = quast_leaf_solution( qul );
      ll  = quast_leaf_leaf_label( qul );
      if (ll != leaf_label_undefined) {
        fprint_indent(fp, quast_depth);
        fprintf(fp, "Statement source number : %"PRIdPTR,
                statement_number(ordering_to_statement(leaf_label_statement(ll))));
 
        fprint_indent(fp, quast_depth);
        fprintf(fp, "Depth : %"PRIdPTR, leaf_label_depth(ll));
      }
      fprint_indent(fp, quast_depth);
      while (sol != NIL) {
        fprintf(fp, "%s, ", expression_to_string(EXPRESSION(CAR(sol))));
        sol = CDR(sol);
      }
    break;
  }
}