[BACK]Return to peephole.c CVS log [TXT] [DIR] Up to [gforth] / gforth / engine

Diff for /gforth/engine/peephole.c between versions 1.2 and 1.6

version 1.2, 2001/02/27 21:17:11 version 1.6, 2002/02/10 14:02:25
Line 22 Line 22
 #include "config.h"  #include "config.h"
 #include "forth.h"  #include "forth.h"
 #include <stdlib.h>  #include <stdlib.h>
   #include <string.h>
   #include <assert.h>
   
 /* the numbers in this struct are primitive indices */  /* the numbers in this struct are primitive indices */
 typedef struct Combination {  typedef struct Combination {
Line 34  Combination peephole_table[] = { Line 36  Combination peephole_table[] = {
 #include "peephole.i"  #include "peephole.i"
 };  };
   
 Xt *primtable(Label symbols[], Cell size)  #ifdef PRINT_SUPER_LENGTHS
   char *prim_names[] = {
   #include "prim_names.i"
   };
   
   Combination *find_super(Cell prim)
 {  {
 #ifdef DIRECT_THREADED  
   return symbols;  
 #else /* !defined(DIRECT_THREADED) */  
   Xt *xts = (Xt *)malloc(size*sizeof(Xt));  
   Cell i;    Cell i;
   
   for (i=0; i<size; i++)    for (i=0; i<sizeof(peephole_table)/sizeof(peephole_table[0]); i++) {
     xts[i] = &symbols[i];      if (peephole_table[i].combination_prim == prim)
   return xts;        return &peephole_table[i];
 #endif /* !defined(DIRECT_THREADED) */    }
     return NULL;
   }
   
   Cell sum_length(Cell prim)
   {
     Combination *super=find_super(prim);
   
     if (super)
       return sum_length(super->prefix)+prim_length(super->lastprim);
     else
       return prim_length(prim);
 }  }
   
 /* we are currently using a simple linear search; we can refine this  void print_prim(Cell prim)
    once the interface has settled and this works */  {
     fprintf(stderr, "%s", prim_names[prim]);
   }  
   
   void print_super(Cell prim)
   {
     Combination *super=find_super(prim);
     
     if (super) {
       print_super(super->prefix);
       fprintf(stderr, " ");
       print_prim(super->lastprim);
     } else {
       print_prim(prim);
     }
   }
   
 Cell prepare_peephole_table(Xt xts[])  void print_super_lengths()
 {  {
   return (Cell)xts;    Cell i;
   
     for (i=0; i<sizeof(peephole_table)/sizeof(peephole_table[0]); i++) {
       Cell super_length = prim_length(peephole_table[i].combination_prim);
       Cell sum_super_length = sum_length(peephole_table[i].combination_prim);
   
       fprintf(stderr, "%6.4f %3d %3d ", ((double)super_length)/sum_super_length,
               super_length, sum_super_length);
       print_super(peephole_table[i].combination_prim);
       fprintf(stderr,"\n");
     }
 }  }
   #endif
   
   int use_super = 1;
   
   typedef Xt Inst;
   
   typedef struct Peeptable_entry {
     struct Peeptable_entry *next;
     Inst prefix;
     Inst lastprim;
     Inst combination_prim;
   } Peeptable_entry;
   
 Xt peephole_opt(Xt xt1, Xt xt2, Cell peeptable)  #define HASH_SIZE 1024
   #define hash(_i1,_i2) (((((Cell)(_i1))^((Cell)(_i2)))>>4)&(HASH_SIZE-1))
   
   Cell peeptable;
   
   Cell prepare_peephole_table(Inst insts[])
 {  {
   Xt *xts = (Xt *)peeptable;  
   Cell i;    Cell i;
     Peeptable_entry **pt = (Peeptable_entry **)calloc(HASH_SIZE,sizeof(Peeptable_entry *));
   
   for (i=0; i<(sizeof(peephole_table)/sizeof(Combination)); i++) {    for (i=0; i<sizeof(peephole_table)/sizeof(peephole_table[0]); i++) {
     Combination *c = &peephole_table[i];      Combination *c = &peephole_table[i];
     if (xt1 == xts[c->prefix] && xt2 == xts[c->lastprim])      Peeptable_entry *p = (Peeptable_entry *)malloc(sizeof(Peeptable_entry));
       return xts[c->combination_prim];      Cell h;
       p->prefix =           insts[c->prefix];
       p->lastprim =         insts[c->lastprim];
       p->combination_prim = insts[c->combination_prim];
       h = hash(p->prefix,p->lastprim);
       p->next = pt[h];
       pt[h] = p;
   }    }
   return 0;    return (Cell)pt;
   }
   
   Inst peephole_opt(Inst inst1, Inst inst2, Cell peeptable)
   {
     Peeptable_entry **pt = (Peeptable_entry **)peeptable;
     Peeptable_entry *p;
   
     if (use_super == 0)
         return 0;
     for (p = pt[hash(inst1,inst2)]; p != NULL; p = p->next)
       if (inst1 == p->prefix && inst2 == p->lastprim)
         return p->combination_prim;
     return NULL;
 }  }
Removed from v.1.2  
changed lines
  Added in v.1.6

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>