find_iteration_domain.c

Go to the documentation of this file.

/*
 
  $Id: find_iteration_domain.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
 /* Code Generation for Distributed Memory Machines
  *
  * Build the iteration domain and the basis associated to a loop nest
  *
  * File: find_iteration_domain.c
  *
  * PUMA, ESPRIT contract 2701
  * Corinne Ancourt
  * 1994
  */
 
#include <stdio.h>
 
#include "genC.h"
 
#include "linear.h"
 
#include "ri.h"
#include "effects.h"
#include "dg.h"
typedef dg_arc_label arc_label;
typedef dg_vertex_label vertex_label;
#include "graph.h"
 
#include "matrice.h"
#include "tiling.h"
#include "database.h"
#include "text.h"
 
#include "misc.h"
#include "text-util.h"
#include "ri-util.h"
#include "effects-util.h"
#include "resources.h"
 
#include "constants.h"
#include "conversion.h"
#include "wp65.h"
 
void find_iteration_domain(s, sc, basis, nested_level,
                                    list_statement_block, inst)
statement s;
Psysteme *sc; 
Pbase *basis;
int * nested_level ;
list *list_statement_block;
instruction * inst;
{
    list list_loop_statement=NIL;
  
    debug(8, "find_iteration_domain", "begin\n");
    iteration_domain_from_statement(&list_loop_statement,s,
                                    nested_level,
                                    list_statement_block,inst);
    compute_iteration_domain(list_loop_statement,sc,basis);
        ifdebug(8) {
            (void) fprintf(stderr,"[find_iteration_domain] initial basis \n");
            vect_fprint(stderr,*basis,(string(*)(void*))entity_local_name);
            sc_fprint(stderr,*sc,(string(*)(void*))entity_local_name);
        }
    debug(8, "find_iteration_domain", "end\n");
}
 
 
 
void compute_iteration_domain(list_loop_statement,sc,basis)
list  list_loop_statement;
Psysteme *sc; 
Pbase *basis;
{
 
    Psysteme sci;
    Pbase base_index = BASE_NULLE;
 
    /* computation of the list of loop indices base_index 
       and of the iteration domain sci*/
       
    debug(8,"compute_iteration_domain","begin\n");
 
    sci = loop_iteration_domaine_to_sc(list_loop_statement, &base_index);
    sci->base = base_reversal(sci->base);
    ifdebug(8) { (void) fprintf(stderr,"compute_iteration_domain\n");
                 vect_fprint(stderr,base_index,(string(*)(void*))entity_local_name);
             }
    *sc = sci;
    *basis = base_index;
    debug(8,"compute_iteration_domain","end\n");
}
␌
void iteration_domain_from_statement(list_loop_statement, s,nested_level, blocks,inst)
list *list_loop_statement;
statement s;
int * nested_level;
list *blocks;
instruction *inst;
{
    instruction i;
    cons *b;
    loop l;
   debug(8, "iteration_domain_from_statement", "begin\n");
        
    i = statement_instruction(s);
    switch (instruction_tag(i)) {
 
    case is_instruction_loop:
        l = instruction_loop(i);
        *list_loop_statement = CONS (STATEMENT,s,*list_loop_statement);
        iteration_domain_from_statement(list_loop_statement,loop_body(l),
                                        nested_level, 
                                        blocks,inst);
        break;
 
    case is_instruction_block: {
        int nbl = 0;
        bool simple_block = false;
        b= instruction_block(i);
        nbl = gen_length((list) b);
        simple_block = (nbl==1 
                        || (nbl ==2 && continue_statement_p(STATEMENT(CAR(CDR(b)))))) 
            ? true : false;
        
        if (simple_block && instruction_loop_p(statement_instruction(STATEMENT(CAR(b)))))
                iteration_domain_from_statement(list_loop_statement,
                                                STATEMENT(CAR(b))
                                                ,nested_level, blocks,inst);
        else { 
            *nested_level = gen_length(*list_loop_statement);
            *inst = i;
            *blocks = b;
            }
      
        break;
    }
    case is_instruction_call: {
        /* case where there is a unique assignment in do-enddo loop nest*/
         *nested_level = gen_length(*list_loop_statement);
         *inst =make_instruction_block(CONS(STATEMENT,s,NIL));  
         *blocks =CONS(STATEMENT,s,NIL);
        return;
           }
 
    case is_instruction_test:
         return;
        
    case is_instruction_unstructured:
         return;
        
    case is_instruction_goto:
        pips_internal_error("unexpected goto in code");
    default:
        pips_internal_error("unexpected tag");
    }
    
    debug(8, "search_array_from_statement", "end\n");
}