util/ncgg/set.c

   1 /*
   2  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
   3  * See the copyright notice in the ACK home directory, in the file "Copyright".
   4  */
   5 #ifndef NORCSID
   6 static char rcsid[]= "$Id: set.c,v 0.5 1994/06/24 10:38:14 ceriel Exp $";
   7 #endif
   8
   9 #include "param.h"
  10 #include "property.h"
  11 #include "set.h"
  12 #include "token.h"
  13 #include "lookup.h"
  14 #include "reg.h"
  15 #include <cgg_cg.h>
  16 #include "extern.h"
  17
  18 extern set_t l_sets[];
  19
  20 setlookup(s) set_t s; {
  21         register set_p p;
  22         register i;
  23         int setno;
  24
  25         for(p=l_sets;p<&l_sets[nsets];p++) {
  26                 if (p->set_size != s.set_size)
  27                         continue;
  28                 for (i=0;i<SETSIZE;i++)
  29                         if (p->set_val[i] != s.set_val[i])
  30                                 goto cont;
  31                 return(p-l_sets);
  32             cont:;
  33         }
  34         setno = NEXT(nsets,MAXSETS,"Sets");
  35         l_sets[setno] = s;
  36         return(setno);
  37 }
  38
  39 make_std_sets() {
  40         set_t s;
  41         register i;
  42
  43         for(i=0;i<SETSIZE;i++)
  44                 s.set_val[i]=0;
  45         for(i=0;i<nregs+ntokens;i++)
  46                 BIS(s.set_val,i);
  47         s.set_size = 0;
  48         allsetno = setlookup(s);
  49         n_set("ALL",allsetno);
  50 }
  51
  52 set_t emptyset;
  53
  54 set_t ident_to_set(name) char *name; {
  55         register symbol *sy_p;
  56         register i;
  57         register struct propinfo *pp;
  58         int bitno;
  59         set_t result;
  60
  61         sy_p = lookup(name,symany,mustexist);
  62         switch(sy_p->sy_type) {
  63         default:
  64                 error("%s is wrong kind of symbol",name);
  65                 return(emptyset);
  66         case symprop:
  67                 pp = &l_props[sy_p->sy_value.syv_propno];
  68                 result.set_size = pp->pr_size;
  69                 for (i=0;i<SZOFSET(MAXREGS);i++)
  70                         result.set_val[i] = pp->pr_regset[i];
  71                 BIS(result.set_val,0);
  72                 for (;i<SETSIZE;i++)
  73                         result.set_val[i] = 0;
  74                 break;
  75         case symtok:
  76                 bitno = sy_p->sy_value.syv_tokno+nregs;
  77                 for (i=0;i<SETSIZE;i++)
  78                         result.set_val[i] = 0;
  79                 BIS(result.set_val,bitno);
  80                 result.set_size = l_tokens[sy_p->sy_value.syv_tokno]->tk_size;
  81                 break;
  82         case symset:
  83                 return(l_sets[sy_p->sy_value.syv_setno]);
  84         }
  85         return(result);
  86 }
  87
  88 static
  89 checksize(s)
  90         register set_p s;
  91 {
  92         register int i;
  93         register int size = -1;
  94
  95         s->set_size = 0;
  96         for (i = 1; i <= nregs; i++) {
  97                 if (BIT(s->set_val, i)) {
  98                         register int sz = l_regs[i].ri_size;
  99
 100                         if (size == -1) size = sz;
 101                         else if (size != sz) return;
 102                 }
 103         }
 104         for (i = 1; i <= ntokens; i++) {
 105                 if (BIT(s->set_val, i+nregs)) {
 106                         register int sz = l_tokens[i]->tk_size;
 107                         if (size == -1) size = sz;
 108                         else if (size != sz) return;
 109                 }
 110         }
 111         if (size != -1) s->set_size = size;
 112 }
 113
 114 set_t setproduct(s1,s2) set_t s1,s2; {
 115         set_t result;
 116         register i;
 117
 118         for(i=0;i<SETSIZE;i++)
 119                 result.set_val[i] = s1.set_val[i] & s2.set_val[i];
 120         checksize(&result);
 121         return(result);
 122 }
 123
 124 set_t setsum(s1,s2) set_t s1,s2; {
 125         set_t result;
 126         register i;
 127
 128         if (s1.set_size == s2.set_size)
 129                 result.set_size = s1.set_size;
 130         else
 131                 result.set_size = 0;
 132         for(i=0;i<SETSIZE;i++)
 133                 result.set_val[i] = s1.set_val[i] | s2.set_val[i];
 134         return(result);
 135 }
 136
 137 set_t setdiff(s1,s2) set_t s1,s2; {
 138         set_t result;
 139         register i;
 140
 141         for(i=0;i<SETSIZE;i++)
 142                 result.set_val[i] = s1.set_val[i] & ~ s2.set_val[i];
 143         /* make sure that we don't loose the lowest bit of the set, which
 144            indicates that it contains registers
 145         */
 146         for (i=1;i <= nregs; i++) {
 147                 if (BIT(result.set_val, i)) {
 148                         BIS(result.set_val,0);
 149                         break;
 150                 }
 151         }
 152         checksize(&result);
 153         return(result);
 154 }