regvar.c 3.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
  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. * Author: Hans van Staveren
  6. */
  7. #include "assert.h"
  8. #include "param.h"
  9. #include "tables.h"
  10. #ifdef REGVARS
  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. #include "utils.h"
  19. #include "salloc.h"
  20. #include "reg.h"
  21. #include "fillem.h"
  22. #include "mach_dep.h"
  23. struct regvar *rvlist;
  24. struct regvar *linkreg(long of, int sz, int tp, int sc)
  25. {
  26. struct regvar *rvlp;
  27. rvlp= (struct regvar *) myalloc(sizeof *rvlp);
  28. rvlp->rv_next = rvlist;
  29. rvlist=rvlp;
  30. rvlp->rv_off = of;
  31. rvlp->rv_size = sz;
  32. rvlp->rv_type = tp;
  33. rvlp->rv_score = sc;
  34. rvlp->rv_reg = 0; /* no register assigned yet */
  35. return(rvlp);
  36. }
  37. void tryreg(struct regvar *rvlp, int typ)
  38. {
  39. int score;
  40. int i;
  41. struct regassigned *ra;
  42. struct regvar *save;
  43. if (typ != reg_any && nregvar[typ]!=0) {
  44. if (machregs[rvnumbers[typ][0]].r_size!=rvlp->rv_size)
  45. score = -1;
  46. else
  47. score = regscore(rvlp->rv_off,
  48. rvlp->rv_size,
  49. rvlp->rv_type,
  50. rvlp->rv_score,
  51. typ); /* machine dependent */
  52. ra = regassigned[typ];
  53. if (score>ra[nregvar[typ]-1].ra_score) {
  54. save = ra[nregvar[typ]-1].ra_rv;
  55. for (i=nregvar[typ]-1;i>0 && ra[i-1].ra_score<score;i--)
  56. ra[i] = ra[i-1];
  57. ra[i].ra_rv = rvlp;
  58. ra[i].ra_score = score;
  59. if((rvlp=save)==0)
  60. return;
  61. }
  62. }
  63. if (nregvar[reg_any]==0)
  64. return;
  65. if (machregs[rvnumbers[reg_any][0]].r_size!=rvlp->rv_size)
  66. score = -1;
  67. else
  68. score = regscore(rvlp->rv_off,
  69. rvlp->rv_size,
  70. rvlp->rv_type,
  71. rvlp->rv_score,
  72. reg_any); /* machine dependent */
  73. ra = regassigned[reg_any];
  74. if (score>ra[nregvar[reg_any]-1].ra_score) {
  75. for (i=nregvar[reg_any]-1;i>0 && ra[i-1].ra_score<score;i--)
  76. ra[i] = ra[i-1];
  77. ra[i].ra_rv = rvlp;
  78. ra[i].ra_score = score;
  79. }
  80. }
  81. void fixregvars(int saveall)
  82. {
  83. struct regvar *rv;
  84. int rvtyp,i;
  85. swtxt();
  86. i_regsave(); /* machine dependent initialization */
  87. for (rvtyp=reg_any;rvtyp<=reg_float;rvtyp++) {
  88. for(i=0;i<nregvar[rvtyp];i++)
  89. if (saveall) {
  90. struct reginfo *rp;
  91. rp= &machregs[rvnumbers[rvtyp][i]];
  92. regsave(codestrings[rp->r_repr],(long)-TEM_WSIZE,rp->r_size);
  93. } else if(regassigned[rvtyp][i].ra_score>0) {
  94. rv=regassigned[rvtyp][i].ra_rv;
  95. rv->rv_reg=rvnumbers[rvtyp][i];
  96. rv->rv_type = rvtyp;
  97. regsave(codestrings[machregs[rv->rv_reg].r_repr],
  98. rv->rv_off,rv->rv_size);
  99. }
  100. }
  101. f_regsave();
  102. }
  103. int isregvar(long off)
  104. {
  105. struct regvar *rvlp;
  106. for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
  107. if(rvlp->rv_off == off)
  108. return(rvlp->rv_reg);
  109. return(-1);
  110. }
  111. int isregtyp(long off)
  112. {
  113. struct regvar *rvlp;
  114. for(rvlp=rvlist;rvlp!=0;rvlp=rvlp->rv_next)
  115. if(rvlp->rv_off == off)
  116. return(rvlp->rv_reg ? rvlp->rv_type+1 : 0);
  117. return(-1);
  118. }
  119. void unlinkregs()
  120. {
  121. struct regvar *rvlp,*t;
  122. struct regassigned *ra;
  123. int rvtyp,i;
  124. for(rvlp=rvlist;rvlp!=0;rvlp=t) {
  125. t=rvlp->rv_next;
  126. myfree((string)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. #endif /* REGVARS */
  138. /* nothing after this */