/*  $VER: vbcc (loop.c) V0.8     */
/*  schleifenorientierte Optimierungen  */

#include "opt.h"

static char FILE_[]=__FILE__;

#define MOVE_IC 1
#define MOVE_COMP 2

/*  Liste, in die ICs eingetragen werden, die aus Schleifen */
/*  gezogen werden sollen.                                  */
struct movlist{
  struct movlist *next;
  struct IC *IC;
  struct flowgraph *target_fg;
  int flags;
};

struct movlist *first_mov,*last_mov;

int report_weird_code,report_suspicious_loops;

/*  Bitvektoren fuer schleifeninvariante ICs    */
bvtype *invariant,*inloop,*moved,*moved_completely;
bvtype *fg_tmp;
bvtype *not_movable;
size_t bsize;


/*  Liste, in die ICs fuer strength-reduction eingetragen   */
/*  werden.                                                 */
struct srlist{
  struct srlist *next;
  struct IC *ind_var;
  struct IC *IC;
  struct flowgraph *target_fg;
  /*  Hilfsvariable, falls eine aequivalente Operation schon reduziert    */
  /*  wurde.                                                              */
  struct Var *hv;
};

struct srlist *first_sr,*last_sr;

/*  Liste, in die Daten fuer loop-unrolling eingetragen werden. */
struct urlist{
  int flags;
  long total,unroll;
  struct IC *cmp,*branch,*ind;
  struct flowgraph *start,*head;
  struct urlist *next;
} *first_ur;

#define UNROLL_COMPLETELY 1
#define UNROLL_MODULO 2
#define UNROLL_INVARIANT 4
#define UNROLL_REVERSE 8
#define IND_ONLY_COUNTS 16
#define MULTIPLE_EXITS 32

/*  Hier werden Induktionsvariablen vermerkt    */
struct IC **ind_vars;

static struct flowgraph *first_fg;


void calc_movable(struct flowgraph *start,struct flowgraph *end)
/*  Berechnet, welche Definitionen nicht aus der Schleife start-end     */
/*  verschoben werden duerfen. Eine Def. p von z darf nur verschoben    */
/*  werden, wenn keine andere Def. von p existiert und alle             */
/*  Verwendungen von z nur von p erreicht werden.                       */
/*  Benutzt rd_defs.                                                    */
{
  struct flowgraph *g;struct IC *p;
  int i,j,k,d;
  bvtype *changed_vars;
  if(DEBUG&1024) printf("calculating not_movable for blocks %d to %d\n",start->index,end->index);
  if(0/*!(optflags&1024)*/){
    memset(not_movable,UCHAR_MAX,dsize);
    return;
  }
  memset(not_movable,0,dsize);
  changed_vars=mymalloc(vsize);
  memset(changed_vars,0,vsize);
  for(i=0;i<vcount-rcount;i++){
    if(vilist[i]->vtyp->flags&VOLATILE) BSET(changed_vars,i);
    if(i<rcount){
      if(!vilist[i]->vtyp->next||(vilist[i]->vtyp->next->flags&VOLATILE)) BSET(changed_vars,i+vcount-rcount);
    }
  }
  for(g=start;g;g=g->normalout){
    if(!g->rd_in) ierror(0);
    memcpy(rd_defs,g->rd_in,dsize);
    for(p=g->start;p;p=p->next){
      for(j=0;j<p->change_cnt;j++){
	i=p->change_list[j].v->index;
	if(p->change_list[j].flags&DREFOBJ) i+=vcount-rcount;
	if(i>=vcount) continue;
	if(BTST(changed_vars,i)||(q1typ(p)&VOLATILE)||(q2typ(p)&VOLATILE)||(ztyp(p)&VOLATILE)){
	  bvunite(not_movable,var_defs[i],dsize);
	}else{
	  BSET(changed_vars,i);
	}
      }
      for(k=0;k<p->use_cnt;k++){
	i=p->use_list[k].v->index;
	if(p->use_list[k].flags&DREFOBJ) i+=vcount-rcount;
	if(i>=vcount) continue;
	for(d=-1,j=1;j<=dcount;j++){
	  if(BTST(rd_defs,j)&&BTST(var_defs[i],j)){
	    if(d>=0){  /*  mehr als eine Def.  */
	      bvunite(not_movable,var_defs[i],dsize);
	      d=-1;break;
	    }else d=j;
	  }
	  if(BTST(rd_defs,UNDEF(j))&&BTST(var_defs[i],UNDEF(j))){
	    bvunite(not_movable,var_defs[i],dsize);
	    d=-1;break;
	  }
	}
      }
      /*  Das hier, um rd_defs zu aktualisieren.  */
      rd_change(p);
      if(p==g->end) break;
    }
    if(g==end) break;
  }
  free(changed_vars);
}