mach/proto/ncg/regvar.c

   1 #include "assert.h"
   2 #include "param.h"
   3 #include "tables.h"
   4
   5 #ifdef REGVARS
   6
   7 #ifndef NORCSID
   8 static char rcsid[] = "$Id: regvar.c,v 0.6 1994/06/24 13:27:56 ceriel Exp $";
   9 #endif
  10
  11 #include "types.h"
  12 #include <cgg_cg.h>
  13 #include "data.h"
  14 #include "regvar.h"
  15 #include <em_reg.h>
  16 #include "result.h"
  17 #include "extern.h"
  18
  19 /*
  20  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  21  * See the copyright notice in the ACK home directory, in the file "Copyright".
  22  *
  23  * Author: Hans van Staveren
  24  */
  25 extern string myalloc();
  26 struct regvar *rvlist;
  27
  28 struct regvar *
  29 linkreg(of,sz,tp,sc) long of; {
  30         register struct regvar *rvlp;
  31
  32         rvlp= (struct regvar *) myalloc(sizeof *rvlp);
  33         rvlp->rv_next = rvlist;
  34         rvlist=rvlp;
  35         rvlp->rv_off    = of;
  36         rvlp->rv_size   = sz;
  37         rvlp->rv_type   = tp;
  38         rvlp->rv_score  = sc;
  39         rvlp->rv_reg    = 0;    /* no register assigned yet */
  40         return(rvlp);
  41 }
  42
  43 tryreg(rvlp,typ) register struct regvar *rvlp; {
  44         int score;
  45         register i;
  46         register struct regassigned *ra;
  47         struct regvar *save;
  48
  49         if (typ != reg_any && nregvar[typ]!=0) {
  50                 if (machregs[rvnumbers[typ][0]].r_size!=rvlp->rv_size)
  51                         score = -1;
  52                 else
  53                         score = regscore(rvlp->rv_off,
  54                                          rvlp->rv_size,
  55                                          rvlp->rv_type,
  56                                          rvlp->rv_score,
  57                                          typ);  /* machine dependent */
  58                 ra = regassigned[typ];
  59                 if (score>ra[nregvar[typ]-1].ra_score) {
  60                         save = ra[nregvar[typ]-1].ra_rv;
  61                         for (i=nregvar[typ]-1;i>0 && ra[i-1].ra_score<score;i--)
  62                                 ra[i] = ra[i-1];
  63                         ra[i].ra_rv = rvlp;
  64                         ra[i].ra_score = score;
  65                         if((rvlp=save)==0)
  66                                 return;
  67                 }
  68         }
  69         if (nregvar[reg_any]==0)
  70                 return;
  71         if (machregs[rvnumbers[reg_any][0]].r_size!=rvlp->rv_size)
  72                 score = -1;
  73         else
  74                 score = regscore(rvlp->rv_off,
  75                                  rvlp->rv_size,
  76                                  rvlp->rv_type,
  77                                  rvlp->rv_score,
  78                                  reg_any);      /* machine dependent */
  79         ra = regassigned[reg_any];
  80         if (score>ra[nregvar[reg_any]-1].ra_score) {
  81                 for (i=nregvar[reg_any]-1;i>0 && ra[i-1].ra_score<score;i--)
  82                         ra[i] = ra[i-1];
  83                 ra[i].ra_rv = rvlp;
  84                 ra[i].ra_score = score;
  85         }
  86 }
  87
  88 fixregvars(saveall) {
  89         register struct regvar *rv;
  90         register rvtyp,i;
  91
  92         swtxt();
  93         i_regsave();    /* machine dependent initialization */
  94         for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
  95             for(i=0;i<nregvar[rvtyp];i++)
  96                 if (saveall) {
  97                         struct reginfo *rp;
  98                         rp= &machregs[rvnumbers[rvtyp][i]];
  99                         regsave(codestrings[rp->r_repr],(long)-TEM_WSIZE,rp->r_size);
 100                 } else if(regassigned[rvtyp][i].ra_score>0) {
 101                         rv=regassigned[rvtyp][i].ra_rv;
 102                         rv->rv_reg=rvnumbers[rvtyp][i];
 103                         rv->rv_type = rvtyp;
 104                         regsave(codestrings[machregs[rv->rv_reg].r_repr],
 105                                     rv->rv_off,rv->rv_size);
 106                 }
 107         }
 108         f_regsave();
 109 }
 110
 111 isregvar(off) long off; {
 112         register struct regvar *rvlp;
 113
 114         for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
 115                 if(rvlp->rv_off == off)
 116                         return(rvlp->rv_reg);
 117         return(-1);
 118 }
 119
 120 isregtyp(off) long off; {
 121         register struct regvar *rvlp;
 122
 123         for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
 124                 if(rvlp->rv_off == off)
 125                         return(rvlp->rv_reg ? rvlp->rv_type+1 : 0);
 126         return(-1);
 127 }
 128
 129 unlinkregs() {
 130         register struct regvar *rvlp,*t;
 131         register struct regassigned *ra;
 132         int rvtyp,i;
 133
 134         for(rvlp=rvlist;rvlp!=0;rvlp=t) {
 135                 t=rvlp->rv_next;
 136                 myfree((string)rvlp);
 137         }
 138         rvlist=0;
 139         for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
 140             for(i=0;i<nregvar[rvtyp];i++) {
 141                 ra= &regassigned[rvtyp][i];
 142                 ra->ra_rv = 0;
 143                 ra->ra_score = 0;
 144             }
 145         }
 146 }
 147
 148 #endif /* REGVARS */
 149
 150 /* nothing after this */