mach/proto/cg/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 2.9 1994/06/24 13:24:09 ceriel Exp $";
   9 #endif
  10
  11 #include "types.h"
  12 #include <cg_pattern.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         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) struct regvar *rvlp; {
  44         int score;
  45         register i;
  46         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                         regsave(codestrings[machregs[rv->rv_reg].r_repr],
 104                                     rv->rv_off,rv->rv_size);
 105                 }
 106         }
 107         f_regsave();
 108 }
 109
 110 isregvar(off) long off; {
 111         register struct regvar *rvlp;
 112
 113         for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
 114                 if(rvlp->rv_off == off)
 115                         return(rvlp->rv_reg);
 116         return(-1);
 117 }
 118
 119 unlinkregs() {
 120         register struct regvar *rvlp,*t;
 121         register struct regassigned *ra;
 122         int rvtyp,i;
 123
 124         for(rvlp=rvlist;rvlp!=0;rvlp=t) {
 125                 t=rvlp->rv_next;
 126                 myfree(rvlp);
 127         }
 128         rvlist=0;
 129         for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
 130             for(i=0;i<nregvar[rvtyp];i++) {
 131                 ra= &regassigned[rvtyp][i];
 132                 ra->ra_rv = 0;
 133                 ra->ra_score = 0;
 134             }
 135         }
 136 }
 137
 138 #endif /* REGVARS */
 139
 140 /* nothing after this */