sys/src/cmd/7l/noop.c

   1 #include        "l.h"
   2
   3 void
   4 noops(void)
   5 {
   6         Prog *p, *q, *q1;
   7         int o, aoffset, curframe, curbecome, maxbecome;
   8
   9         /*
  10          * find leaf subroutines
  11          * become sizes
  12          * frame sizes
  13          * strip NOPs
  14          * expand RET
  15          * expand BECOME pseudo
  16          */
  17
  18         if(debug['v'])
  19                 Bprint(&bso, "%5.2f noops\n", cputime());
  20         Bflush(&bso);
  21
  22         curframe = 0;
  23         curbecome = 0;
  24         maxbecome = 0;
  25         curtext = 0;
  26
  27         q = P;
  28         for(p = firstp; p != P; p = p->link) {
  29
  30                 /* find out how much arg space is used in this TEXT */
  31                 if(p->to.type == D_OREG && p->to.reg == REGSP)
  32                         if(p->to.offset > curframe)
  33                                 curframe = p->to.offset;
  34
  35                 switch(p->as) {
  36                 case ATEXT:
  37                         if(curtext && curtext->from.sym) {
  38                                 curtext->from.sym->frame = curframe;
  39                                 curtext->from.sym->become = curbecome;
  40                                 if(curbecome > maxbecome)
  41                                         maxbecome = curbecome;
  42                         }
  43                         curframe = 0;
  44                         curbecome = 0;
  45
  46                         p->mark |= LEAF;
  47                         curtext = p;
  48                         break;
  49
  50                 case ARETURN:
  51                         /* special form of RETURN is BECOME */
  52                         if(p->from.type == D_CONST)
  53                                 if(p->from.offset > curbecome)
  54                                         curbecome = p->from.offset;
  55                         break;
  56
  57                 case ANOP:
  58                         q1 = p->link;
  59                         q->link = q1;           /* q is non-nop */
  60                         q1->mark |= p->mark;
  61                         continue;
  62
  63                 case ABL:
  64                         if(curtext != P)
  65                                 curtext->mark &= ~LEAF;
  66
  67                 case ACBNZ:
  68                 case ACBZ:
  69                 case ACBNZW:
  70                 case ACBZW:
  71                 case ATBZ:
  72                 case ATBNZ:
  73
  74                 case ABCASE:
  75                 case AB:
  76
  77                 case ABEQ:
  78                 case ABNE:
  79                 case ABCS:
  80                 case ABHS:
  81                 case ABCC:
  82                 case ABLO:
  83                 case ABMI:
  84                 case ABPL:
  85                 case ABVS:
  86                 case ABVC:
  87                 case ABHI:
  88                 case ABLS:
  89                 case ABGE:
  90                 case ABLT:
  91                 case ABGT:
  92                 case ABLE:
  93
  94                 case AADR:              /* strange */
  95                 case AADRP:
  96
  97                         q1 = p->cond;
  98                         if(q1 != P) {
  99                                 while(q1->as == ANOP) {
 100                                         q1 = q1->link;
 101                                         p->cond = q1;
 102                                 }
 103                         }
 104                         break;
 105                 }
 106                 q = p;
 107         }
 108
 109         if(curtext && curtext->from.sym) {
 110                 curtext->from.sym->frame = curframe;
 111                 curtext->from.sym->become = curbecome;
 112                 if(curbecome > maxbecome)
 113                         maxbecome = curbecome;
 114         }
 115
 116         if(debug['b'])
 117                 print("max become = %d\n", maxbecome);
 118         xdefine("ALEFbecome", STEXT, maxbecome);
 119
 120         curtext = 0;
 121         for(p = firstp; p != P; p = p->link) {
 122                 switch(p->as) {
 123                 case ATEXT:
 124                         curtext = p;
 125                         break;
 126                 case ABL:
 127                         if(curtext != P && curtext->from.sym != S && curtext->to.offset >= 0) {
 128                                 o = maxbecome - curtext->from.sym->frame;
 129                                 if(o <= 0)
 130                                         break;
 131                                 /* calling a become or calling a variable */
 132                                 if(p->to.sym == S || p->to.sym->become) {
 133                                         curtext->to.offset += o;
 134                                         if(debug['b']) {
 135                                                 curp = p;
 136                                                 print("%D calling %D increase %d\n",
 137                                                         &curtext->from, &p->to, o);
 138                                         }
 139                                 }
 140                         }
 141                         break;
 142                 }
 143         }
 144
 145         for(p = firstp; p != P; p = p->link) {
 146                 o = p->as;
 147                 switch(o) {
 148                 case ATEXT:
 149                         curtext = p;
 150                         if(p->to.offset < 0)
 151                                 autosize = 0;
 152                         else
 153                                 autosize = p->to.offset + PCSZ;
 154                         if((curtext->mark & LEAF) && autosize <= PCSZ)
 155                                 autosize = 0;
 156                         else if(autosize & (STACKALIGN-1))
 157                                 autosize += STACKALIGN - (autosize&(STACKALIGN-1));
 158                         p->to.offset = autosize - PCSZ;
 159
 160                         if(autosize == 0 && !(curtext->mark & LEAF)) {
 161                                 if(debug['v'])
 162                                         Bprint(&bso, "save suppressed in: %s\n",
 163                                                 curtext->from.sym->name);
 164                                 Bflush(&bso);
 165                                 curtext->mark |= LEAF;
 166                         }
 167
 168                         aoffset = autosize;
 169                         if(aoffset > 0xF0)
 170                                 aoffset = 0xF0;
 171
 172                         if(curtext->mark & LEAF) {
 173                                 if(curtext->from.sym)
 174                                         curtext->from.sym->type = SLEAF;
 175                                 if(autosize == 0)
 176                                         break;
 177                                 aoffset = 0;
 178                         }
 179
 180                         q = p;
 181                         if(autosize > aoffset){
 182                                 q = prg();
 183                                 q->as = ASUB;
 184                                 q->line = p->line;
 185                                 q->from.type = D_CONST;
 186                                 q->from.offset = autosize - aoffset;
 187                                 q->to.type = D_REG;
 188                                 q->to.reg = REGSP;
 189                                 q->link = p->link;
 190                                 p->link = q;
 191
 192                                 if(curtext->mark & LEAF)
 193                                         break;
 194                         }
 195
 196                         q1 = prg();
 197                         q1->as = AMOV;
 198                         q1->line = p->line;
 199                         q1->from.type = D_REG;
 200                         q1->from.reg = REGLINK;
 201                         q1->to.type = D_XPRE;
 202                         q1->to.offset = -aoffset;
 203                         q1->to.reg = REGSP;
 204
 205                         q1->link = q->link;
 206                         q->link = q1;
 207                         break;
 208
 209                 case ARETURN:
 210                         nocache(p);
 211                         if(p->from.type == D_CONST)
 212                                 goto become;
 213                         if(curtext->mark & LEAF) {
 214                                 if(autosize != 0){
 215                                         p->as = AADD;
 216                                         p->from.type = D_CONST;
 217                                         p->from.offset = autosize;
 218                                         p->to.type = D_REG;
 219                                         p->to.reg = REGSP;
 220                                 }
 221                         }else{
 222                                 /* want write-back pre-indexed SP+autosize -> SP, loading REGLINK*/
 223                                 aoffset = autosize;
 224                                 if(aoffset > 0xF0)
 225                                         aoffset = 0xF0;
 226
 227                                 p->as = AMOV;
 228                                 p->from.type = D_XPOST;
 229                                 p->from.offset = aoffset;
 230                                 p->from.reg = REGSP;
 231                                 p->to.type = D_REG;
 232                                 p->to.reg = REGLINK;
 233
 234                                 if(autosize > aoffset) {
 235                                         q = prg();
 236                                         q->as = AADD;
 237                                         q->from.type = D_CONST;
 238                                         q->from.offset = autosize - aoffset;
 239                                         q->to.type = D_REG;
 240                                         q->to.reg = REGSP;
 241
 242                                         q->link = p->link;
 243                                         p->link = q;
 244                                         p = q;
 245                                 }
 246                         }
 247
 248                         if(p->as != ARETURN) {
 249                                 q = prg();
 250                                 q->line = p->line;
 251                                 q->link = p->link;
 252                                 p->link = q;
 253                                 p = q;
 254                         }
 255
 256                         p->as = ARET;
 257                         p->line = p->line;
 258                         p->to.type = D_OREG;
 259                         p->to.offset = 0;
 260                         p->to.reg = REGLINK;
 261
 262                         break;
 263
 264                 become:
 265                         if(curtext->mark & LEAF) {
 266
 267                                 if(!autosize) {
 268                                         p->as = AB;
 269                                         p->from = zprg.from;
 270                                         break;
 271                                 }
 272
 273 #ifdef optimise_time
 274                                 q = prg();
 275                                 q->line = p->line;
 276                                 q->as = AB;
 277                                 q->from = zprg.from;
 278                                 q->to = p->to;
 279                                 q->cond = p->cond;
 280                                 q->link = p->link;
 281                                 p->link = q;
 282
 283                                 p->as = AADD;
 284                                 p->from = zprg.from;
 285                                 p->from.type = D_CONST;
 286                                 p->from.offset = autosize;
 287                                 p->to = zprg.to;
 288                                 p->to.type = D_REG;
 289                                 p->to.reg = REGSP;
 290
 291                                 break;
 292 #endif
 293                         }
 294                         q = prg();
 295                         q->line = p->line;
 296                         q->as = AB;
 297                         q->from = zprg.from;
 298                         q->to = p->to;
 299                         q->cond = p->cond;
 300                         q->link = p->link;
 301                         p->link = q;
 302
 303                         p->as = AMOV;
 304                         p->from = zprg.from;
 305                         p->from.type = D_XPRE;
 306                         p->from.offset = -autosize;
 307                         p->from.reg = REGSP;
 308                         p->to = zprg.to;
 309                         p->to.type = D_REG;
 310                         p->to.reg = REGLINK;
 311
 312                         break;
 313
 314                 }
 315         }
 316 }
 317
 318 void
 319 nocache(Prog *p)
 320 {
 321         p->optab = 0;
 322         p->from.class = 0;
 323         p->to.class = 0;
 324 }