home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / vbcc / regs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-12-30  |  41.9 KB  |  1,081 lines
  1. /*  $VER: vbcc (regs.c) V0.4    */
  2. /*  Registerzuteilung           */
  3.  
  4. #include "opt.h"
  5.  
  6. static char FILE_[]=__FILE__;
  7.  
  8. #ifndef NO_OPTIMIZER
  9.  
  10. int (*savings)[MAXR+1],regu[MAXR+1];
  11. int *rvlist;
  12.  
  13. struct regp {int treg;struct Var *tvar,*tmp;};
  14. void do_load_parms(struct regp [],struct flowgraph *);
  15. void load_one_parm(int,int,struct Var *,struct Var *,struct flowgraph *);
  16.  
  17. int cmp_savings(const void *v1,const void *v2)
  18. /*  Vergleichsfkt, um rvlist nach savings zu sortieren  */
  19. {
  20.     return savings[*(int *)v2][0]-savings[*(int *)v1][0];
  21. }
  22. int entry_load(struct flowgraph *fg,int i)
  23. /*  Testet, ob die Variable in Register i am Anfang von Block fg geladen    */
  24. /*  werden muss, d.h. ein Vorgaenger sie nicht im selben Register hat.      */
  25. {
  26.     struct flowlist *lp;
  27.     lp=fg->in;
  28.     while(lp){
  29.         if(lp->graph&&lp->graph->regv[i]!=fg->regv[i]&&BTST(lp->graph->av_out,fg->regv[i]->index)) return(1);
  30.         lp=lp->next;
  31.     }
  32.     return(0);
  33. }
  34.  
  35. int exit_save(struct flowgraph *fg,int i)
  36. /*  Testet, ob die Variable in Register i am Ende von Block fg gespeichert  */
  37. /*  werden muss, d.h. der Vorgaenger eines Nachfolgers nicht dieselbe       */
  38. /*  Variable im selben Register hat.                                        */
  39. {
  40.     struct flowlist *lp;
  41.     if((fg->normalout&&(!fg->end||fg->end->code!=BRA))&&BTST(fg->normalout->av_in,fg->regv[i]->index)){
  42.         if(fg->normalout->regv[i]!=fg->regv[i]) return(1);
  43.         lp=fg->normalout->in;
  44.         while(lp){
  45.             if(lp->graph&&lp->graph->regv[i]!=fg->regv[i]) return(1);
  46.             lp=lp->next;
  47.         }
  48.     }
  49.     if(fg->branchout&&BTST(fg->branchout->av_in,fg->regv[i]->index)){
  50.         if(fg->branchout->regv[i]!=fg->regv[i]) return(1);
  51.         lp=fg->branchout->in;
  52.         while(lp){
  53.             if(lp->graph&&lp->graph->regv[i]!=fg->regv[i]) return(1);
  54.             lp=lp->next;
  55.         }
  56.     }
  57.     return(0);
  58. }
  59. void load_reg_parms(struct flowgraph *fg)
  60. /*  Laedt Registerparameter, falls noetig.                              */
  61. {
  62.     int i,j; struct Var *v;
  63.     struct regp regp[MAXR+1]={0};
  64. /*     for(i=1;i<=MAXR;i++){ regp[i].treg=0;regp[i].tvar=0;} */
  65.     for(i=0;i<vcount-rcount;i++){
  66.         v=vilist[i];
  67.         if((v->flags®PARM)&&fg->regv[v->reg]!=v&&(BTST(fg->av_in,i)||(v->flags&USEDASADR))){
  68.       regp[v->reg].tvar=v;
  69.       for(j=1;j<=MAXR;j++)
  70.         if(fg->regv[j]==v) regp[v->reg].treg=j;
  71.     }
  72.     }
  73.     do_load_parms(regp,fg);
  74. }
  75.  
  76. void insert_regs(struct flowgraph *fg1)
  77. /*  Fuegt Registervariablen in die ICs ein.                             */
  78. {
  79.     int i;struct IC *p,*lic=0,*new;struct flowgraph *lfg=0,*fg;
  80.     if(DEBUG&9216) printf("inserting register variables\n");
  81.     fg=fg1;
  82.     while(fg){
  83.         if(DEBUG&8192) printf("block %d:\n",fg->index);
  84.         p=fg->start;
  85.         while(p){
  86.             for(i=1;i<=MAXR;i++){
  87.                 if(!fg->regv[i]) continue;
  88.                 if(p->code==ALLOCREG&&p->q1.reg==i) ierror(0);
  89.                 if((p->q1.flags&(VAR|DONTREGISTERIZE))==VAR&&p->q1.v==fg->regv[i]){
  90.                     p->q1.flags|=REG;
  91.                     p->q1.reg=i;
  92.                 }
  93.                 if((p->q2.flags&(VAR|DONTREGISTERIZE))==VAR&&p->q2.v==fg->regv[i]){
  94.                     p->q2.flags|=REG;
  95.                     p->q2.reg=i;
  96.                 }
  97.                 if((p->z.flags&(VAR|DONTREGISTERIZE))==VAR&&p->z.v==fg->regv[i]){
  98.                     p->z.flags|=REG;
  99.                     p->z.reg=i;
  100.                 }
  101.             }
  102.             if(DEBUG&8192) pric2(stdout,p);
  103.             if(p==fg->end) break;
  104.             p=p->next;
  105.         }
  106.         if(fg->start&&fg->start->code==LABEL) lic=fg->start;
  107.         for(i=1;i<=MAXR;i++){
  108.             if(fg->regv[i]){
  109.                 if(DEBUG&8192){
  110.                     printf("(%s),%ld assigned to %s\n",fg->regv[i]->identifier,zl2l(fg->regv[i]->offset),regnames[i]);
  111.                     if(BTST(fg->av_in,fg->regv[i]->index)) printf("active at the start of block\n");
  112.                     if(BTST(fg->av_out,fg->regv[i]->index)) printf("active at the end of block\n");
  113.                 }
  114.  
  115.                 if(BTST(fg->av_out,fg->regv[i]->index)){
  116.                 /*  Variable beim Austritt aktiv?   */
  117.                     if(exit_save(fg,i)){
  118.                         struct IC *tp;
  119.                         if(DEBUG&8192) printf("\thave to save it at end of block\n");
  120.                         new=mymalloc(ICS);
  121.                         new->line=0;
  122.                         new->file=0;
  123.                         new->code=ASSIGN;
  124.                         new->typf=fg->regv[i]->vtyp->flags;
  125.                         /*  cc  */
  126.                         if(new->typf==0) ierror(0);
  127.                         new->q1.flags=VAR|REG;
  128.                         new->q1.val.vlong=l2zl(0L);
  129.                         new->q1.v=fg->regv[i];
  130.                         new->q1.reg=i;
  131.                         new->q2.flags=0;
  132.                         new->q2.val.vlong=szof(fg->regv[i]->vtyp);
  133.                         new->z.flags=VAR|DONTREGISTERIZE;
  134.                         new->z.val.vlong=l2zl(0L);
  135.                         new->z.v=fg->regv[i];
  136.                         new->q1.am=new->q2.am=new->z.am=0;
  137.                         new->use_cnt=new->change_cnt=0;
  138.                         new->use_list=new->change_list=0;
  139.                         /*  Vor FREEREGs und evtl. Branch+COMPARE/TEST setzen   */
  140.                         if(fg->end){
  141.                             tp=fg->end;
  142.                             while(tp!=fg->start&&tp->code==FREEREG)
  143.                                 tp=tp->prev;
  144.                             if(tp&&tp->code>=BEQ&&tp->code<=BRA){
  145.                                 if(tp->code<BRA){
  146.                                     int c;
  147.                                     do{
  148.                                         tp=tp->prev;
  149.                                         c=tp->code;
  150.                                         if(c!=FREEREG&&c!=COMPARE&&c!=TEST) ierror(0);
  151.                                     }while(c!=COMPARE&&c!=TEST);
  152.                                 }
  153.                                 tp=tp->prev;
  154.                             }
  155.                         }else tp=lic;
  156.                         insert_IC_fg(fg,tp,new);
  157.                     }
  158.                 }
  159.                 if(BTST(fg->av_in,fg->regv[i]->index)){
  160.                     if((fg==fg1||entry_load(fg,i))&&(fg!=fg1||!(fg->regv[i]->flags®PARM))){
  161.                         if(DEBUG&8192) printf("\thave to load it at start of block\n");
  162.  
  163.                         new=mymalloc(ICS);
  164.                         new->line=0;
  165.                         new->file=0;
  166.                         new->code=ASSIGN;
  167.                         new->typf=fg->regv[i]->vtyp->flags;
  168.                         /*  cc  */
  169.                         if(new->typf==0) ierror(0);
  170.                         new->q1.flags=VAR|DONTREGISTERIZE;
  171.                         new->q1.val.vlong=l2zl(0L);
  172.                         new->q1.v=fg->regv[i];
  173.                         new->q2.flags=0;
  174.                         new->q2.val.vlong=szof(fg->regv[i]->vtyp);
  175.                         new->z.flags=VAR|REG;
  176.                         new->z.val.vlong=l2zl(0L);
  177.                         new->z.v=fg->regv[i];
  178.                         new->z.reg=i;
  179.                         new->q1.am=new->q2.am=new->z.am=0;
  180.                         new->use_cnt=new->change_cnt=0;
  181.                         new->use_list=new->change_list=0;
  182.                         insert_IC_fg(fg,lic,new);
  183.                     }
  184.                 }
  185.                 if(!lfg||!lfg->regv[i]) insert_allocreg(fg,lic,ALLOCREG,i);
  186.                 if(!fg->normalout||!fg->normalout->regv[i])
  187.                     insert_allocreg(fg,fg->end?fg->end:lic,FREEREG,i);
  188.             }
  189.         }
  190.         if(fg->end) lic=fg->end;
  191.         lfg=fg;
  192.         fg=fg->normalout;
  193.     }
  194.     load_reg_parms(fg1);
  195. }
  196.  
  197. void do_loop_regs(struct flowgraph *start,struct flowgraph *end)
  198. /*  Macht die Variablenzuweisung in Schleife start-end.                 */
  199. /*  Wenn end==0 Registerzuweisung fuer die ganze Funktion, ansonsten    */
  200. /*  fuer die Schleife, die zum Header start gehoert.                    */
  201. {
  202.     struct flowgraph *g;
  203.     int i,r;
  204.     struct Var *lregs[MAXR+1]={0};
  205.     unsigned char rused[(MAXR+CHAR_BIT)/CHAR_BIT];
  206.     /*  Berechnen, wieviel ungefaehr eingespart wird, wenn eine Variable    */
  207.     /*  fuer diese Schleife in einem best. Register gehalten wird.          */
  208.     /*  Die savings in einer Schleife werden multipliziert, um das          */
  209.     /*  Laden/Speichern ausserhalb der Schleife geringer zu wichten.        */
  210. /*    if(end&&(!g->normalout||!g->normalout->loopend||g->normalout->loopend->normalout->index!=-2)) ierror(0);*/
  211.     /*  alle auf 0  */
  212.     for(i=0;i<vcount-rcount;i++){
  213.         for(r=1;r<=MAXR;r++){
  214.             savings[i][r]=0;
  215.         }
  216.     }
  217.     if(end){
  218.         struct Var *v;
  219.         /*  Evtl. Kosten fuers Laden/Speichern beim Ein-/Austritt in die    */
  220.         /*  Schleife.                                                       */
  221.         end=start->normalout->loopend;
  222.         g=end->normalout;
  223.         if(DEBUG&9216) printf("assigning regs to blocks %d to %d\n",start->normalout->index,end->index);
  224.         /*  Werte modifizieren, falls Variable am Anfang/Ende der Schleife  */
  225.         /*  geladen/gespeichert werden muss.                                */
  226.         for(i=0;i<vcount-rcount;i++){
  227.             v=vilist[i];
  228.             if(BTST(start->av_in,i)){
  229.                 for(r=1;r<=MAXR;r++)
  230.                     if(start->regv[r]!=v) savings[i][r]--;
  231.             }
  232.             if(BTST(g->av_out,i)){
  233.                 for(r=1;r<=MAXR;r++)
  234.                     if(g->regv[r]!=v) savings[i][r]--;
  235.             }
  236.         }
  237.         /*  Werte modifizieren, falls eine andere Variable gespeichert oder */
  238.         /*  geladen werden muss. Hmm..stimmt das so?                        */
  239.         for(r=1;r<=MAXR;r++){
  240.             v=start->regv[r];
  241.             if(v&&BTST(start->av_in,v->index)){
  242.                 for(i=0;i<vcount-rcount;i++)
  243.                     if(v->index!=i) savings[i][r]--;
  244.             }
  245.             if(v&&BTST(g->av_out,v->index)){
  246.                 for(i=0;i<vcount-rcount;i++)
  247.                     if(v->index!=i) savings[i][r]--;
  248.             }
  249.         }
  250.         g=start->normalout;
  251.     }else{
  252.         /*  Bei Registervergabe fuer die ganze Funktion muessen alle beim   */
  253.         /*  Eintritt der Funktion aktiven Variablen geladen werden.         */
  254.         if(DEBUG&9216) printf("assigning regs to whole function\n");
  255.         for(i=0;i<vcount-rcount;i++){
  256.             if(BTST(start->av_in,i)){
  257.                 int pr=vilist[i]->reg;
  258.                 for(r=1;r<=MAXR;r++){
  259.                     if(pr==0||!regok(r,vilist[i]->vtyp->flags,0)||regsa[r]){
  260.                         savings[i][r]-=8;
  261.                     }else{
  262.                         if(r==pr) savings[i][r]+=8; else savings[i][r]+=4;
  263.                     }
  264.                 }
  265.             }
  266.         }
  267.         g=start;
  268.     }
  269.     if(DEBUG&9216) printf("calculating approximate savings\n");
  270.  
  271.     for(;g;g=g->normalout){
  272.         struct IC *p;struct Var *v;
  273.         int t,vt;
  274.         if(g->calls>0){
  275.         /*  bei Funktionsaufrufen muessen Scratchregister gespeichert werden */
  276.             for(r=1;r<=MAXR;r++)
  277.                 if(regscratch[r])
  278.                     for(i=0;i<vcount-rcount;i++) savings[i][r]-=g->calls*16;
  279.         }
  280.         /*  Wenn das Register in dem Block benutzt wird, muss man es retten */
  281.         for(r=1;r<=MAXR;r++){
  282.             if(BTST(g->regused,r)){
  283.                 int vi;
  284.                 if(g->regv[r]) vi=g->regv[r]->index; else vi=-1;
  285.                 for(i=0;i<vcount-rcount;i++)
  286.                     if(vi!=i) savings[i][r]-=16;
  287.             }
  288.         }
  289.         for(p=g->start;p;p=p->next){
  290.             if((p->q1.flags&(VAR|VARADR|REG))==VAR){
  291.                 v=p->q1.v;
  292.                 if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  293.                     vt=v->vtyp->flags&NU;
  294.                     i=v->index;
  295.                     if(p->q1.flags&DREFOBJ) t=p->typf&NU; else t=0;
  296.                     for(r=1;r<=MAXR;r++){
  297.                         if(!regsa[r]&&!BTST(g->regused,r)){
  298.                             /*  extra saving, falls passendes Reg fuer DREF */
  299.                             if(t&®ok(r,vt,t)) savings[i][r]+=8;
  300.                             if(regok(r,vt,0)) savings[i][r]+=8;
  301.                         }
  302.                     }
  303.                 }
  304.             }
  305.             if((p->q2.flags&(VAR|VARADR|REG))==VAR){
  306.                 v=p->q2.v;
  307.                 if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  308.                     vt=v->vtyp->flags&NU;
  309.                     i=v->index;
  310.                     if(p->q2.flags&DREFOBJ) t=p->typf&NU; else t=0;
  311.                     for(r=1;r<=MAXR;r++){
  312.                         if(!regsa[r]&&!BTST(g->regused,r)){
  313.                             /*  extra saving, falls passendes Reg fuer DREF */
  314.                             if(t&®ok(r,vt,t)) savings[i][r]+=8;
  315.                             if(regok(r,vt,0)) savings[i][r]+=8;
  316.                         }
  317.                     }
  318.                 }
  319.             }
  320.             if((p->z.flags&(VAR|VARADR|REG))==VAR){
  321.                 v=p->z.v;
  322.                 if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  323.                     vt=v->vtyp->flags&NU;
  324.                     i=v->index;
  325.                     if(p->z.flags&DREFOBJ) t=p->typf&NU; else t=0;
  326.                     for(r=1;r<=MAXR;r++){
  327.                         if(!regsa[r]&&!BTST(g->regused,r)){
  328.                             /*  extra saving, falls passendes Reg fuer DREF */
  329.                             if(t&®ok(r,vt,t)) savings[i][r]+=8;
  330.                             if(regok(r,vt,0)) savings[i][r]+=8;
  331.                         }
  332.                     }
  333.                 }
  334.             }
  335.             if(p==g->end) break;
  336.         }
  337.         if(g==end) break;
  338.     }
  339.     /*  Maximum ermitteln   */
  340.     for(i=0;i<vcount-rcount;i++){
  341.         int m=0;
  342.         for(r=1;r<=MAXR;r++){
  343.             /*  Falls Variable in best. Register muss.  */
  344.             if(r==vilist[i]->reg&&!(vilist[i]->flags®PARM)) savings[i][r]*=4;
  345.             if(savings[i][r]>m) m=savings[i][r];
  346.         }
  347.         savings[i][0]=m;
  348.     }
  349.  
  350.     if(DEBUG&8192){
  351.         for(i=0;i<vcount-rcount;i++){
  352.             printf("(%s),%ld(best=%d):\n",vilist[i]->identifier,zl2l(vilist[i]->offset),savings[i][0]);
  353.             for(r=1;r<=MAXR;r++)
  354.                 printf("%s=%d ",regnames[r],savings[i][r]);
  355.             printf("\n");
  356.         }
  357.     }
  358.     /*  Suchen, welche Variablen/Registerkombination das beste Ergebnis */
  359.     /*  liefert. Nur angenaehert, da sonst wohl zu aufwendig. Simplex?  */
  360.     memset(rused,0,(MAXR+CHAR_BIT)/CHAR_BIT);
  361.     for(i=0;i<vcount-rcount;i++) rvlist[i]=i;
  362.     qsort(rvlist,vcount-rcount,sizeof(*rvlist),cmp_savings);
  363.     for(i=0;i<vcount-rcount;i++){
  364.         int use,m=0,vi;
  365.         vi=rvlist[i];
  366.         if(vilist[vi]->flags&USEDASADR) continue;
  367.         if(DEBUG&8192) printf("%d: (%s),%ld(best=%d)\n",i,vilist[vi]->identifier,zl2l(vilist[vi]->offset),savings[vi][0]);
  368.         for(r=1;r<=MAXR;r++){
  369.             if(!lregs[r]&&savings[vi][r]>m){
  370.                 m=savings[vi][r];
  371.                 use=r;
  372.                 if(m==savings[vi][0]) break;
  373.             }
  374.         }
  375.         if(m>0){
  376.             if(DEBUG&9216) printf("assigned (%s),%ld to %s, saving=%d\n",vilist[vi]->identifier,zl2l(vilist[vi]->offset),regnames[use],m);
  377.             lregs[use]=vilist[vi];
  378.             BSET(rused,use);
  379.         }
  380.     }
  381.     /*  Registervariablen in alle Bloecke der Schleife eintragen    */
  382.     /*  dabei beruecksichtigen, dass sie in manchen Bloecken nicht  */
  383.     /*  in Register kommen koennen, wenn das Register da schon von  */
  384.     /*  local_regs benutzt wird                                     */
  385.     /*  Gegebenenfalls auch in Header/Footer einer Schleife         */
  386.     /*  eintragen.                                                  */
  387.     if(DEBUG&9216) printf("propagate register vars\n");
  388.     for(g=start;g;g=g->normalout){
  389.         for(r=1;r<=MAXR;r++){
  390.             if(lregs[r]&&!BTST(g->regused,r)){
  391.                 /*  Falls Variable schon in anderem Register, loeschen  */
  392.                 for(i=1;i<=MAXR;i++){
  393.                     if(g->regv[i]==lregs[r]) g->regv[i]=0;
  394.                 }
  395.                 g->regv[r]=lregs[r];
  396.             }
  397.         }
  398.         if(end&&g==end->normalout) break;
  399.     }
  400. }
  401. void block_regs(struct flowgraph *fg)
  402. /*  macht die Variablenzuweisung fuer einzelne Bloecke  */
  403. {
  404.     struct flowgraph *g,**fgp;
  405.     int i,r,changed,fgz;
  406.     if(DEBUG&9216) printf("block_regs\n");
  407.  
  408.     savings=mymalloc((vcount-rcount)*sizeof(*savings));
  409.     rvlist=mymalloc((vcount-rcount)*sizeof(*rvlist));
  410.  
  411.     /*  Array auf Bloecke im Flussgraphen mangels doppelter Verkettung  */
  412.     fgp=mymalloc(basic_blocks*sizeof(*fgp));
  413.     g=fg;fgz=0;
  414.     while(g){
  415.         fgp[fgz]=g;fgz++;
  416.         g=g->normalout;
  417.     }
  418.     if(fgz>basic_blocks) ierror(0); else basic_blocks=fgz;
  419.     /*  alle auf 0  */
  420.     do{
  421.         changed=0;
  422.         if(DEBUG&9216) printf("block_regs pass\n");
  423.         for(fgz=basic_blocks-1;fgz>=0;fgz--){
  424.             struct IC *p;struct Var *v;struct flowlist *lp;
  425.             int t,vt;
  426.             g=fgp[fgz];
  427.             if(DEBUG&8192) printf("assigning regs to block %d\n",g->index);
  428.             /*  berechnen, wieviel ungefaehr eingespart wird, wenn eine Variable    */
  429.             /*  fuer diesen Block in einem best. Register gehalten wird             */
  430.             if(DEBUG&8192) printf("calculating approximate savings\n");
  431.  
  432.             for(i=0;i<vcount-rcount;i++){
  433.                 for(r=1;r<=MAXR;r++){
  434.                     if(!g->regv[r]||g->regv[r]->index!=i){
  435.                         int w=0;
  436.                         /*  Variable muss evtl. geladen/gespeichert werden  */
  437.                         if(BTST(g->av_in,i)) w--;
  438.                         if(BTST(g->av_out,i)) w--;
  439.                         savings[i][r]=w;
  440.                     }
  441.                 }
  442.             }
  443.             if(g->calls>0){
  444.             /*  bei Funktionsaufrufen muessen Scratchregister gespeichert werden */
  445.                 for(r=1;r<=MAXR;r++)
  446.                     if(regscratch[r])
  447.                         for(i=0;i<vcount-rcount;i++) savings[i][r]-=g->calls*2;
  448.             }
  449.             /*  Wenn Vorgaenger/Nachfolger selbe Variable im selben */
  450.             /*  Register hat, entfaellt Laden/Speichern in diesem   */
  451.             /*  Block und vermutlich auch im Vorgaenger/Nachfolger  */
  452.             /*  nicht immer, aber naeherungsweise...                */
  453.             lp=g->in;
  454.             while(lp){
  455.                 if(lp->graph){
  456.                     for(r=1;r<=MAXR;r++){
  457.                         if(lp->graph->regv[r]&&BTST(g->av_in,lp->graph->regv[r]->index)) savings[lp->graph->regv[r]->index][r]+=2;
  458.                     }
  459.                 }
  460.                 lp=lp->next;
  461.             }
  462.             if(g->branchout){
  463.                 for(r=1;r<=MAXR;r++){
  464.                     if(g->branchout->regv[r]&&BTST(g->av_out,g->branchout->regv[r]->index)) savings[g->branchout->regv[r]->index][r]+=2;
  465.                 }
  466.             }
  467.             if(g->normalout&&(!g->normalout->end||g->normalout->end->code!=BRA)){
  468.                 for(r=1;r<=MAXR;r++){
  469.                     if(g->normalout->regv[r]&&BTST(g->av_out,g->normalout->regv[r]->index)) savings[g->normalout->regv[r]->index][r]+=2;
  470.                 }
  471.             }
  472.  
  473.             p=g->start;
  474.             while(p){
  475.                 if((p->q1.flags&(VAR|VARADR|REG))==VAR){
  476.                     v=p->q1.v;
  477.                     if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  478.                         vt=v->vtyp->flags&NU;
  479.                         i=v->index;
  480.                         if(p->q1.flags&DREFOBJ) t=p->typf&NU; else t=0;
  481.                         for(r=1;r<=MAXR;r++){
  482.                             if(!regsa[r]&&!BTST(g->regused,r)){
  483.                                 /*  extra saving, falls passendes Reg fuer DREF */
  484.                                 if(t&®ok(r,vt,t)) savings[i][r]++;
  485.                                 if(regok(r,vt,0)) savings[i][r]++;
  486.                             }
  487.                         }
  488.                     }
  489.                 }
  490.                 if((p->q2.flags&(VAR|VARADR|REG))==VAR){
  491.                     v=p->q2.v;
  492.                     if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  493.                         vt=v->vtyp->flags&NU;
  494.                         i=v->index;
  495.                         if(p->q2.flags&DREFOBJ) t=p->typf&NU; else t=0;
  496.                         for(r=1;r<=MAXR;r++){
  497.                             if(!regsa[r]&&!BTST(g->regused,r)){
  498.                                 /*  extra saving, falls passendes Reg fuer DREF */
  499.                                 if(t&®ok(r,vt,t)) savings[i][r]++;
  500.                                 if(regok(r,vt,0)) savings[i][r]++;
  501.                             }
  502.                         }
  503.                     }
  504.                 }
  505.                 if((p->z.flags&(VAR|VARADR|REG))==VAR){
  506.                     v=p->z.v;
  507.                     if((v->storage_class==AUTO||v->storage_class==REGISTER)&&!(v->flags&USEDASADR)){
  508.                         vt=v->vtyp->flags&NU;
  509.                         i=v->index;
  510.                         if(p->z.flags&DREFOBJ) t=p->typf&NU; else t=0;
  511.                         for(r=1;r<=MAXR;r++){
  512.                             if(!regsa[r]&&!BTST(g->regused,r)){
  513.                                 /*  extra saving, falls passendes Reg fuer DREF */
  514.                                 if(t&®ok(r,vt,t)) savings[i][r]++;
  515.                                 if(regok(r,vt,0)) savings[i][r]++;
  516.                             }
  517.                         }
  518.                     }
  519.                 }
  520.                 if(p==g->end) break;
  521.                 p=p->next;
  522.             }
  523.             /*  moegliche Kandidaten suchen; muss nicht immer die beste */
  524.             /*  Kombination finden, sollte aber bei lokaler Vergabe     */
  525.             /*  selten einen Unterschied machen                         */
  526.             for(r=1;r<=MAXR;r++){
  527.                 if(g->regv[r]||BTST(g->regused,r)) continue;
  528.                 for(i=0;i<vcount-rcount;i++){
  529.                     if(savings[i][r]>0){
  530.                         int flag;struct Var *v=vilist[i];
  531.                         /*  Variable schon in anderem Register? */
  532.                         for(flag=1;flag<=MAXR;flag++)
  533.                             if(g->regv[flag]==v){flag=-1;break;}
  534.                         if(flag>0){
  535.                             if(DEBUG&9216) printf("assigned (%s),%ld to %s; saving=%d\n",vilist[i]->identifier,zl2l(vilist[i]->offset),regnames[r],savings[i][r]);
  536.                             g->regv[r]=vilist[i];
  537.                             changed=1;
  538.                             break;
  539.                         }
  540.                     }
  541.                 }
  542.             }
  543.         }
  544.     }while(changed);
  545.     /*  jetzt nochmal globale Register vergeben */
  546. /*    do_loop_regs(fgp[0],fgp[basic_blocks-1]);*/
  547.  
  548.     free(fgp);
  549.     free(rvlist);
  550.     free(savings);
  551. }
  552.  
  553. void loop_regs(struct flowgraph *fg)
  554. /*  weist Variablen in Schleifen Register zu    */
  555. {
  556.     struct flowgraph *g;
  557.     if(DEBUG&9216) printf("assigning regs to function\n");
  558.     savings=mymalloc((vcount-rcount)*sizeof(*savings));
  559.     rvlist=mymalloc((vcount-rcount)*sizeof(*rvlist));
  560.     do_loop_regs(fg,0);
  561.     if(DEBUG&9216) printf("assigning regs in loops\n");
  562.     for(g=fg;g;g=g->normalout){
  563.         if(g->index==-1) do_loop_regs(g,g);
  564.     }
  565.     free(rvlist);
  566.     free(savings);
  567. }
  568. void insert_allocreg(struct flowgraph *fg,struct IC *p,int code,int reg)
  569. /*  Fuegt ein ALLOCREG/FREEREG (in code) hinter p ein - bei p==0 in */
  570. /*  first_ic.                                                       */
  571. {
  572.     struct IC *new=mymalloc(ICS);
  573.     /*    printf("%s %s",code==FREEREG?"freereg":"allocreg",regnames[reg]);pric2(stdout,p);*/
  574.     new->line=0;
  575.     new->file=0;
  576.     BSET(fg->regused,reg);
  577.     regused[reg]=1;
  578.     new->code=code;
  579.     new->typf=0;
  580.     new->q1.am=new->q2.am=new->z.am=0;
  581.     new->q1.flags=REG;
  582.     new->q1.reg=reg;
  583.     new->q2.flags=new->z.flags=0;
  584.     new->use_cnt=new->change_cnt=0;
  585.     new->use_list=new->change_list=0;
  586.     insert_IC_fg(fg,p,new);
  587. }
  588.  
  589. struct Var *lregv[MAXR+1];
  590. struct flowgraph *lfg;
  591.  
  592. void free_hreg(struct flowgraph *fg,struct IC *p,int reg,int mustr)
  593. /*  Macht das Register reg frei, damit es als lokale Variable im IC p   */
  594. /*  zur Verfuegung steht. Wenn mustr!=0, muss das Register unbedingt    */
  595. /*  freigemacht werden, ansonsten kann davon abgesehen werden.          */
  596. {
  597.     struct IC *m,*first;struct Var *v;
  598.     int preg[MAXR+1]={0},calls=0,rreg,i;
  599.     first=0; v=lregv[reg];
  600.     if(!v) ierror(0);
  601.     if(DEBUG&8192) printf("free_hreg %s,%s,%d\n",regnames[reg],v->identifier,mustr);
  602.     if(v->reg) error(218,regnames[reg]);
  603.     for(m=p;m;m=m->next){
  604.         if(m->code==CALL) calls++;
  605.         if(m->code==ALLOCREG){
  606.             preg[m->q1.reg]=1;
  607.             if(m->q1.reg==reg) ierror(0);
  608.         }
  609.         if(m->code==FREEREG){
  610.             preg[m->q1.reg]=1;
  611.             if(m->q1.reg==reg) break;
  612.         }
  613.         if(!USEQ2ASZ){
  614.             if((m->q2.flags&VAR)&&m->q2.v==v&&(m->z.flags&(REG|DREFOBJ))==REG&&
  615.                (!(m->z.flags&VAR)||m->z.v!=v))
  616.                 preg[m->z.reg]=1;
  617.         }
  618.         if(((m->q1.flags&VAR)&&m->q1.v==v)||
  619.            ((m->q2.flags&VAR)&&m->q2.v==v)||
  620.            ((m->z.flags&(VAR|DREFOBJ))==(VAR|DREFOBJ)&&m->z.v==v))
  621.             first=m;
  622. /*        if((m->z.flags&(REG|DREFOBJ))==REG&&m->z.reg==reg) break;*/
  623.     }
  624.     if(!first) {pric(stdout,p);ierror(0);}
  625.     for(rreg=0,i=1;i<=MAXR;i++){
  626.         if(preg[i]||regu[i]||regsa[i]||!regok(i,v->vtyp->flags,0)) continue;
  627.         if(calls==0&®scratch[i]){rreg=i;break;}
  628.         if(calls>0&&!regscratch[i]){rreg=i;break;}
  629.         if(calls==0&&mustr) rreg=i;
  630.     }
  631.     if(!rreg&&!mustr) return;
  632.     for(m=p;m!=first->next;m=m->next){
  633.         if((m->q1.flags&VAR)&&m->q1.v==v)
  634.             {if(!rreg) m->q1.flags&=~REG; else m->q1.reg=rreg;}
  635.         if((m->q2.flags&VAR)&&m->q2.v==v)
  636.             {if(!rreg) m->q2.flags&=~REG; else m->q2.reg=rreg;}
  637.         if((m->z.flags&VAR)&&m->z.v==v)
  638.             {if(!rreg) m->z.flags&=~REG; else m->z.reg=rreg;}
  639.     }
  640.     if(rreg){lregv[rreg]=lregv[reg];regused[rreg]=1;regu[rreg]=1;BSET(fg->regused,rreg);}
  641.     lregv[reg]=0;regu[reg]=0;
  642.  
  643.     for(m=first->next;m&&m->code==FREEREG;m=m->next){
  644.         if(m->q1.reg==reg){
  645.             if(!rreg) remove_IC_fg(fg,m); else m->q1.reg=rreg;
  646. /*            if(rreg) insert_allocreg(fg,first,FREEREG,rreg);*/
  647.             return;
  648.         }
  649.     }
  650.     insert_allocreg(fg,first->prev,ALLOCREG,reg);
  651.     if(rreg) insert_allocreg(fg,first,FREEREG,rreg);
  652. }
  653. int replace_local_reg(struct obj *o)
  654. /*  tested, ob o eine Scratch-Variable ist und ersetzt sie gegebenenfalls   */
  655. {
  656.     int i;struct Var *v;
  657.     if((o->flags&(VAR|REG|VARADR))==VAR){
  658.         v=o->v;i=v->index;
  659.         if(BTST(lfg->av_kill,i)&&!BTST(lfg->av_out,i)){
  660.             for(i=1;i<=MAXR;i++){
  661.                 if(lregv[i]==v){
  662.                     o->flags|=(REG|SCRATCH);
  663. /*                    o->flags&=~VAR;*/
  664.                     o->reg=i;
  665.                     return(i);
  666.                 }
  667.             }
  668.         }
  669.     }
  670.     return(0);
  671. }
  672. void local_regs(struct flowgraph *fg)
  673. /*  versucht Variablen, die nur innerhalb eines Basic Blocks benutzt    */
  674. /*  werden (kill==true und out==false), Register zuzuweisen.            */
  675. {
  676.     struct IC *p;
  677.     int i,j,t,r,nr,mustalloc;
  678.     unsigned char *inmem=mymalloc(vsize);
  679.     if(DEBUG&9216) printf("assigning temporary variables to registers\n");
  680.     memset(inmem,0,vsize);
  681.     lfg=fg;
  682.     while(lfg){
  683.         if(DEBUG&1024) printf("block %d\n",lfg->index);
  684.         for(i=1;i<=MAXR;i++){lregv[i]=0; regu[i]=regsa[i]; lfg->regv[i]=0;}
  685.         memset(&lfg->regused,0,(MAXR+CHAR_BIT)/CHAR_BIT);
  686.         lfg->calls=0;
  687.         p=lfg->end;
  688.         while(p){
  689.             nr=0;
  690.             i=replace_local_reg(&p->z);
  691.             if((p->z.flags&(VAR|DREFOBJ))==VAR){
  692.                 if(i){
  693.                     lregv[i]=0;regu[i]--;
  694.                     nr=i;mustalloc=1;
  695.                     if(DEBUG&8192) printf("regu[%s] decremented to %d\n",regnames[i],regu[i]);
  696.                 }else{
  697.                     BCLR(inmem,p->z.v->index);
  698.                 }
  699.             }
  700.             if(p->code!=ADDRESS){
  701.                 if(replace_local_reg(&p->q1)==nr) mustalloc=0;
  702.                 if(replace_local_reg(&p->q2)==nr) mustalloc=0;
  703.             }
  704.             /*  hier wegen USEQ2ASZ aufpassen; kommutative ICs sollten so   */
  705.             /*  angeordnet werden, dass ein evtl. Register rechts steht     */
  706.             if((p->q2.flags&(VAR|REG|VARADR))==VAR&&!(p->q2.v->flags&USEDASADR)&&!(p->q2.v->vtyp->flags&VOLATILE)&&(p->q2.v->storage_class==AUTO||p->q2.v->storage_class==REGISTER)){
  707.                 j=p->q2.v->index;
  708.                 if(BTST(lfg->av_kill,j)&&!BTST(lfg->av_out,j)&&!BTST(inmem,j)){
  709.                     t=p->q2.v->vtyp->flags;
  710.                     if(USEQ2ASZ&&nr&®ok(nr,t,0)&&!regu[nr]&&!regsa[nr]&&(!(p->q2.flags&DREFOBJ)||regok(nr,t,p->typf))) r=nr; else r=0;
  711.                     if(p->q2.v->reg){ r=p->q2.v->reg;if(regu[r]) free_hreg(lfg,p,r,1);}
  712.                     for(i=0;r==0&&i<=MAXR;i++){
  713.                         if(!regu[i]&&!regsa[i]&®ok(i,t,0)&&(USEQ2ASZ||i!=nr)) {r=i;break;}
  714.                     }
  715.                     if(r){
  716.                         if(r!=nr) insert_allocreg(lfg,p,FREEREG,r);
  717.                             else mustalloc=0;
  718.                         lregv[r]=p->q2.v;regused[r]=regu[r]=1;
  719.                         if(replace_local_reg(&p->q2)!=r) ierror(0);
  720.                         replace_local_reg(&p->q1);
  721.                         replace_local_reg(&p->z);
  722.                         if((DEBUG&9216)&&*p->q2.v->identifier) printf("temporary <%s> assigned to %s\n",p->q2.v->identifier,regnames[r]);
  723.                         if(DEBUG&8192) printf("temporary <%s> assigned to %s\n",p->q2.v->identifier,regnames[r]);
  724.                     }else BSET(inmem,j);
  725.                 }
  726.             }
  727.             if((p->z.flags&(VAR|REG|DREFOBJ))==(VAR|DREFOBJ)&&!(p->z.v->flags&USEDASADR)&&!(p->z.v->vtyp->flags&VOLATILE)&&(p->z.v->storage_class==AUTO||p->z.v->storage_class==REGISTER)){
  728.                 j=p->z.v->index;
  729.                 if(BTST(lfg->av_kill,j)&&!BTST(lfg->av_out,j)&&!BTST(inmem,j)){
  730.                     r=0;
  731.                     if(p->z.v->reg){ r=p->z.v->reg;if(regu[r]) free_hreg(lfg,p,r,1);}
  732.                     for(i=0,t=p->z.v->vtyp->flags;i<=MAXR;i++){
  733.                         if(!regu[i]&&!regsa[i]&®ok(i,t,0)) {r=i;break;}
  734.                     }
  735.                     if(r){
  736.                         insert_allocreg(lfg,p,FREEREG,r);
  737.                         lregv[r]=p->z.v;regused[r]=regu[r]=1;
  738.                         if(replace_local_reg(&p->z)!=r){
  739.                             for(i=1;i<=MAXR;i++) if(lregv[i]) printf("%d:%s=%s(%p)\n",i,regnames[i],lregv[i]->identifier,(void*)lregv[i]);
  740.                             ierror(r);}
  741.                         replace_local_reg(&p->q1);
  742.                         if((DEBUG&9216)&&*p->z.v->identifier) printf("temporary <%s> assigned to %s\n",p->z.v->identifier,regnames[r]);
  743.                         if(DEBUG&8192) printf("temporary <%s> assigned to %s\n",p->z.v->identifier,regnames[r]);
  744.                     }else BSET(inmem,j);
  745.                 }
  746.             }
  747.             if((p->q1.flags&(VAR|REG|VARADR))==VAR&&!(p->q1.v->flags&USEDASADR)&&!(p->q1.v->vtyp->flags&VOLATILE)&&(p->q1.v->storage_class==AUTO||p->q1.v->storage_class==REGISTER)){
  748.                 j=p->q1.v->index;
  749.                 if(BTST(lfg->av_kill,j)&&!BTST(lfg->av_out,j)&&!BTST(inmem,j)){
  750.                     t=p->q1.v->vtyp->flags;
  751.                     if(nr&®ok(nr,t,0)&&!regu[nr]&&!regsa[nr]&&(!(p->q1.flags&DREFOBJ)||regok(nr,t,p->typf))) r=nr; else r=0;
  752.                     if(p->code==SETRETURN&&p->z.reg&®ok(p->z.reg,t,p->typf)) r=p->z.reg;
  753.                     if(p->q1.v->reg){ r=p->q1.v->reg;if(regu[r]) free_hreg(lfg,p,r,1);}
  754.                     for(i=0;r==0&&i<=MAXR;i++){
  755.                         if(!regu[i]&&!regsa[i]&®ok(i,t,0)) {r=i;break;}
  756.                     }
  757.                     if(r){
  758.                         if(r!=nr) insert_allocreg(lfg,p,FREEREG,r);
  759.                             else mustalloc=0;
  760.                         lregv[r]=p->q1.v;regused[r]=regu[r]=1;
  761.                         if(replace_local_reg(&p->q1)!=r) ierror(0);
  762.                         if((DEBUG&9216)&&*p->q1.v->identifier) printf("temporary <%s> assigned to %s\n",p->q1.v->identifier,regnames[r]);
  763.                         if(DEBUG&8192) printf("temporary <%s> assigned to %s\n",p->q1.v->identifier,regnames[r]);
  764.                     }else BSET(inmem,j);
  765.                 }
  766.             }
  767.             if(p->code==CALL){
  768.                 lfg->calls++;
  769.                 /*  falls Scratchregister bei Funktionsaufruf benutzt   */
  770.                 /*  wird, moeglichst auf ein anderes ausweichen         */
  771.                 for(i=1;i<=MAXR;i++){
  772.                     if(lregv[i]&®scratch[i]&&!lregv[i]->reg)
  773.                         free_hreg(lfg,p,i,0);
  774.                 }
  775.             }
  776.             /*  die Faelle beachten, wenn schon im IC ein Register          */
  777.             /*  angesprochen wird (sollte nur bei CALL und return auftreten */
  778.             if(p->code==FREEREG){
  779.                 ierror(0);
  780.                 if(regu[p->q1.reg]) remove_IC_fg(lfg,p);
  781.                 regu[p->q1.reg]++;
  782.             }
  783.             if(p->code==ALLOCREG){
  784.                 ierror(0);
  785.                 if(regu[p->q1.reg]==2) remove_IC_fg(lfg,p);
  786.                 regu[p->q1.reg]--;
  787.             }
  788.             if(p==lfg->start) i=1; else i=0;;
  789.             p=p->prev;
  790.             if(nr&&mustalloc) insert_allocreg(lfg,p,ALLOCREG,nr);
  791.             if(i) break;
  792.         }
  793.         lfg=lfg->normalout;
  794.     }
  795.     free(inmem);
  796. }
  797. void insert_saves(void)
  798. /*  fuegt speichern von Registern bei Funktionsaufrufen ein */
  799. {
  800.     int i,c;struct IC *p;
  801.     if(DEBUG&9216) printf("insert_saves\n");
  802.     for(i=1;i<=MAXR;i++) regs[i]=regsa[i];
  803.     for(p=first_ic;p;p=p->next){
  804.         c=p->code;
  805.         if(c==ALLOCREG) regs[p->q1.reg]=1;
  806.         if(c==FREEREG)  regs[p->q1.reg]=0;
  807.         if(c==CALL){
  808.             struct IC *s;
  809.             /*  das Wiederherstellen nach dem GETRETURN     */
  810.             s=p; i=0;
  811.             if(s->next&&s->next->code==FREEREG) {s=s->next;regs[s->q1.reg]=0;}
  812.             if(s->next&&s->next->code==GETRETURN){
  813.                 s=s->next;
  814.                 if((s->z.flags&(REG|DREFOBJ))==REG) i=s->z.reg;
  815.             }
  816.             if(s->next&&s->next->code==ALLOCREG&&s->next->next&&s->next->next->code==GETRETURN){
  817.                 s=s->next->next;
  818.                 if((s->z.flags&(REG|DREFOBJ))==REG) i=s->z.reg;
  819.             }
  820.             savescratch(MOVEFROMREG,p->prev,0);
  821.             savescratch(MOVETOREG,s,i);
  822.         }
  823.     }
  824. }
  825.  
  826. #endif
  827.  
  828. void insert_simple_allocreg(struct IC *p,int code,int reg)
  829. /*  Fuegt ein ALLOCREG/FREEREG (in code) hinter p ein - bei p==0 in */
  830. /*  first_ic.                                                       */
  831. {
  832.     struct IC *new=mymalloc(ICS);
  833.     new->line=0;
  834.     new->file=0;
  835.     regused[reg]=1;
  836.     new->code=code;
  837.     new->typf=0;
  838.     new->q1.am=new->q2.am=new->z.am=0;
  839.     new->q1.flags=REG;
  840.     new->q1.reg=reg;
  841.     new->q2.flags=new->z.flags=0;
  842.     new->use_cnt=new->change_cnt=0;
  843.     new->use_list=new->change_list=0;
  844.     insert_IC(p,new);
  845. }
  846.  
  847. void load_simple_reg_parms(void)
  848. /*  Laedt Registerparameter, falls noetig. Nicht-optimierende Version.  */
  849. {
  850.   int i,j; struct Var *v;
  851.   struct regp regp[MAXR+1]={0};
  852. /*   for(i=1;i<=MAXR;i++) {regp[i].treg=0;regp[i].tvar=0;} */
  853.   for(i=0;i<=1;i++){
  854.     if(i==0) v=vl3; else v=vl2;
  855.     for(;v;v=v->next){
  856.       if((v->flags®PARM)&®sv[v->reg]!=v){
  857.     regp[v->reg].tvar=v;
  858.     for(j=1;j<=MAXR;j++)
  859.       if(regsv[j]==v) regp[v->reg].treg=j;
  860.       }
  861.     }
  862.   }
  863.   do_load_parms(regp,0);
  864. }
  865. void do_load_parms(struct regp regp[],struct flowgraph *fg)
  866. {
  867.   int i,j,c,notdone;
  868.   struct {int freg,treg;struct Var *tvar,*tmp;} order[MAXR]={0};
  869.   if(DEBUG&1){
  870.     printf("do_load_parms:\n");
  871.     for(i=1;i<=MAXR;i++)
  872.       if(regp[i].tvar)
  873.     printf("%s->%s(%s)\n",regnames[i],regnames[regp[i].treg],regp[i].tvar->identifier);
  874.   }
  875.   do{
  876.     c=0;
  877.     do{
  878.       notdone=0;
  879.       for(i=1;i<=MAXR;i++){
  880.     if(!regp[i].tvar) continue;
  881.     j=regp[i].treg;
  882.     if(j==0||regp[j].tvar==0||regp[i].tmp){
  883.       order[c].freg=i;
  884.       order[c].treg=j;
  885.       order[c].tvar=regp[i].tvar;
  886.       if(regp[i].tmp){order[c].treg=0;order[c].tvar=regp[i].tmp;}
  887.       c++; notdone=1;
  888.       regp[i].treg=0;
  889.       regp[i].tvar=0;
  890.     }
  891.       }
  892.     }while(notdone);
  893.     for(i=c-1;i>=0;i--)
  894.       load_one_parm(order[i].freg,order[i].treg,0,order[i].tvar,fg);
  895.     notdone=0;
  896.     for(i=1;i<=MAXR;i++){
  897.       if(regp[i].tvar){
  898.     regp[i].tmp=add_tmp_var(clone_typ(regp[i].tvar->vtyp));
  899.     load_one_parm(0,regp[i].treg,regp[i].tmp,regp[i].tvar,fg);
  900.     notdone=1; break;
  901.       }
  902.     }
  903.   }while(notdone);
  904. }
  905. void load_one_parm(int freg,int treg,struct Var *fvar,struct Var *tvar,struct flowgraph *fg)
  906. {
  907.   struct IC *new;
  908.   if(DEBUG&1) printf("lop: %s(%s)->%s(%s)\n",regnames[freg],fvar?fvar->identifier:empty,regnames[treg],tvar?tvar->identifier:empty);
  909.   if(freg){
  910.     if(fg)
  911.       insert_allocreg(fg,0,FREEREG,freg);
  912.     else
  913.       insert_simple_allocreg(0,FREEREG,freg);
  914.   }
  915.   new=mymalloc(ICS);
  916.   new->line=0;
  917.   new->file=0;
  918.   new->code=ASSIGN;
  919.   new->typf=tvar->vtyp->flags;
  920.   if((new->typf&NQ)==FLOAT||(new->typf&NQ)==DOUBLE) float_used=1;
  921.   if(fvar){
  922.     new->q1.flags=VAR;
  923.     new->q1.v=fvar;
  924.     new->q1.val.vlong=l2zl(0L);
  925.   }else{
  926.     new->q1.flags=REG;
  927.     new->q1.reg=freg;
  928.   }
  929.   new->q2.flags=0;
  930.   new->q2.val.vlong=szof(tvar->vtyp);
  931.   if(treg)
  932.     new->z.flags=REG|VAR;
  933.   else
  934.     new->z.flags=VAR;
  935.   new->z.val.vlong=l2zl(0L);
  936.   new->z.v=tvar;
  937.   new->z.reg=treg;
  938.   new->q1.am=new->q2.am=new->z.am=0;
  939.   new->use_cnt=new->change_cnt=0;
  940.   new->use_list=new->change_list=0;  
  941.   if(fg){
  942.     insert_IC_fg(fg,0,new);
  943.     if(freg) insert_allocreg(fg,0,ALLOCREG,freg);
  944.   }else{
  945.     insert_IC(0,new);
  946.     if(freg) insert_simple_allocreg(0,ALLOCREG,freg);
  947.   }
  948.   if(new->z.flags®){
  949.     /*  ALLOCREG verschieben    */
  950.     struct IC *p;
  951.     if(fg)
  952.       insert_allocreg(fg,0,ALLOCREG,treg);
  953.     else
  954.       insert_simple_allocreg(0,ALLOCREG,treg);
  955.     for(p=new->next;p;p=p->next){
  956.       if(p->code==ALLOCREG&&p->q1.reg==treg){
  957.     if(fg)
  958.       remove_IC_fg(fg,p);
  959.     else
  960.       remove_IC(p);
  961.     break;
  962.       }
  963.     }
  964.     if(!p) ierror(0);
  965.   }
  966. }
  967.  
  968. void simple_regs(void)
  969. /*  haelt Variablen in Registern, simple Version            */
  970. {
  971.     int i2,i,j;int pri;struct Var *v;
  972.     struct IC *icp,*start=first_ic;
  973.     if(!first_ic) return;
  974.     for(i=1;i<=MAXR;i++) regsv[i]=0;
  975.     for(i2=0;i2<=MAXR*4;i2++){
  976.         int only_best,pointertype;
  977.         if(i2<=MAXR*2){i=i2;only_best=1;} else {i=i2/2;pointertype=only_best=0;}
  978.         if(i>MAXR||!regsv[i]){
  979.             if(i>MAXR){
  980.                 i-=MAXR;
  981.                 if(regsv[i]) continue;
  982.             }else{
  983.                 /*  Ziehe Scratchregister vor, wenn kein Funktionsaufruf */
  984.                 /*  erfolgt, sonst erst andere                           */
  985.                 if(!function_calls&&!regscratch[i]) continue;
  986.                 if(function_calls&®scratch[i]) continue;
  987.             }
  988.             if(regused[i]) continue;
  989.             /* Nicht-Scratchregister muessen einmal gesichert und wieder    */
  990.             /* hergestellt werden, Scratchregister bei jedem Call           */
  991.             if(regscratch[i]&&function_calls) continue;
  992.             /*pri=2;*/ pri=0;
  993.             for(j=0;j<=1;j++){
  994.                 if(j==0) v=vl3; else v=vl2;
  995.                 while(v){
  996.                     if(v->storage_class==AUTO||v->storage_class==REGISTER){
  997.                         if(!(v->flags&USEDASADR)&&!(v->vtyp->flags&VOLATILE)){
  998.                             if(only_best&&v->vtyp->next) pointertype=v->vtyp->next->flags;
  999.                             if(v->priority>pri&®ok(i,v->vtyp->flags&NU,pointertype)){
  1000.                                 regsv[i]=v;pri=v->priority;
  1001.                             }
  1002.                         }
  1003.                     }
  1004.                     v=v->next;
  1005.                 }
  1006.             }
  1007.         }
  1008.         if(regsv[i]){
  1009.             if(DEBUG&1) printf("Assigned <%s> to %s\n",regsv[i]->identifier,regnames[i]);
  1010.             regsv[i]->priority=0;regused[i]=1;
  1011.             if(!zlleq(l2zl(0L),regsv[i]->offset)&&!(regsv[i]->flags&CONVPARAMETER)){
  1012.                 icp=mymalloc(ICS);
  1013.                 icp->line=0;
  1014.                 icp->file=0;
  1015.                 icp->q1.am=icp->q2.am=icp->z.am=0;
  1016.                 icp->code=ASSIGN;
  1017.                 icp->typf=regsv[i]->vtyp->flags&NU;
  1018.                 icp->q1.flags=VAR;
  1019.                 icp->q1.v=regsv[i];
  1020.                 icp->q1.val.vlong=l2zl(0L);
  1021.                 icp->q2.flags=0;
  1022.                 icp->q2.val.vlong=szof(regsv[i]->vtyp);
  1023.                 icp->z.flags=REG;
  1024.                 icp->z.reg=i;
  1025.                 icp->next=first_ic;
  1026.                 icp->prev=0;
  1027.                 first_ic->prev=icp;
  1028.                 first_ic=icp;
  1029.             }
  1030.             icp=mymalloc(ICS);
  1031.             icp->line=0;
  1032.             icp->file=0;
  1033.             icp->q1.am=icp->q2.am=icp->z.am=0;
  1034.             icp->code=ALLOCREG;
  1035.             icp->q1.flags=REG;
  1036.             icp->q1.reg=i;
  1037.             icp->q2.flags=icp->z.flags=icp->typf=0;
  1038.             icp->next=first_ic;
  1039.             icp->prev=0;
  1040.             first_ic->prev=icp;
  1041.             first_ic=icp;
  1042.             icp=mymalloc(ICS);
  1043.             icp->q1.am=icp->q2.am=icp->z.am=0;
  1044.             icp->code=FREEREG;
  1045.             icp->q1.flags=REG;
  1046.             icp->q1.reg=i;
  1047.             icp->q2.flags=icp->z.flags=icp->typf=0;
  1048.             icp->next=0;
  1049.             add_IC(icp);
  1050.         }
  1051.     }
  1052.     icp=start;
  1053.     while(icp){
  1054.         if((icp->code==ALLOCREG||icp->code==FREEREG)&®sv[icp->q1.reg]){
  1055.         /*  irgendwelche allocreg/freereg im Code entfernen     */
  1056.         /*  sollte nur beim Returnregister vorkommen            */
  1057.             struct IC *m=icp->next;
  1058.             remove_IC(icp);
  1059.             icp=m;continue;
  1060.         }
  1061.         for(i=1;i<=MAXR;i++){
  1062.             if(!regsv[i]) continue;
  1063.             if((icp->q1.flags&(VAR|DONTREGISTERIZE))==VAR&&icp->q1.v==regsv[i]){
  1064.                 icp->q1.flags|=REG;
  1065.                 icp->q1.reg=i;
  1066.             }
  1067.             if((icp->q2.flags&(VAR|DONTREGISTERIZE))==VAR&&icp->q2.v==regsv[i]){
  1068.                 icp->q2.flags|=REG;
  1069.                 icp->q2.reg=i;
  1070.             }
  1071.             if((icp->z.flags&(VAR|DONTREGISTERIZE))==VAR&&icp->z.v==regsv[i]){
  1072.                 icp->z.flags|=REG;
  1073.                 icp->z.reg=i;
  1074.             }
  1075.         }
  1076.         icp=icp->next;
  1077.     }
  1078. }
  1079.  
  1080.  
  1081.