1 #include "gc.h" 2 3 void 4 swit1(C1 *q, int nc, long def, Node *n) 5 { 6 Node tn; 7 8 regalloc(&tn, ®node, Z); 9 swit2(q, nc, def, n, &tn); 10 regfree(&tn); 11 } 12 13 void 14 swit2(C1 *q, int nc, long def, Node *n, Node *tn) 15 { 16 C1 *r; 17 int i; 18 Prog *sp; 19 20 if(nc < 5) { 21 for(i=0; i<nc; i++) { 22 if(sval(q->val)) { 23 gopcode(OEQ, n, Z, nodconst(q->val)); 24 } else { 25 gopcode(OSUB, nodconst(q->val), n, tn); 26 gopcode(OEQ, tn, Z, nodconst(0)); 27 } 28 patch(p, q->label); 29 q++; 30 } 31 gbranch(OGOTO); 32 patch(p, def); 33 return; 34 } 35 i = nc / 2; 36 r = q+i; 37 if(sval(r->val)) { 38 gopcode(OGT, n, Z, nodconst(r->val)); 39 sp = p; 40 } else { 41 gopcode(OSUB, nodconst(r->val), n, tn); 42 gopcode(OGT, tn, Z, nodconst(0)); 43 sp = p; 44 } 45 gbranch(OGOTO); 46 p->as = ABE; 47 patch(p, r->label); 48 swit2(q, i, def, n, tn); 49 50 patch(sp, pc); 51 swit2(r+1, nc-i-1, def, n, tn); 52 } 53 54 void 55 bitload(Node *b, Node *n1, Node *n2, Node *n3, Node *nn) 56 { 57 int sh; 58 long v; 59 Node *l; 60 61 /* 62 * n1 gets adjusted/masked value 63 * n2 gets address of cell 64 * n3 gets contents of cell 65 */ 66 l = b->left; 67 if(n2 != Z) { 68 regalloc(n1, l, nn); 69 reglcgen(n2, l, Z); 70 regalloc(n3, l, Z); 71 gopcode(OAS, n2, Z, n3); 72 gopcode(OAS, n3, Z, n1); 73 } else { 74 regalloc(n1, l, nn); 75 cgen(l, n1); 76 } 77 if(b->type->shift == 0 && typeu[b->type->etype]) { 78 v = ~0 + (1L << b->type->nbits); 79 gopcode(OAND, nodconst(v), Z, n1); 80 } else { 81 sh = 32 - b->type->shift - b->type->nbits; 82 if(sh > 0) 83 gopcode(OASHL, nodconst(sh), Z, n1); 84 sh += b->type->shift; 85 if(sh > 0) 86 if(typeu[b->type->etype]) 87 gopcode(OLSHR, nodconst(sh), Z, n1); 88 else 89 gopcode(OASHR, nodconst(sh), Z, n1); 90 } 91 } 92 93 void 94 bitstore(Node *b, Node *n1, Node *n2, Node *n3, Node *nn) 95 { 96 long v; 97 Node nod, *l; 98 int sh; 99 100 /* 101 * n1 has adjusted/masked value 102 * n2 has address of cell 103 * n3 has contents of cell 104 */ 105 l = b->left; 106 regalloc(&nod, l, Z); 107 v = ~0 + (1L << b->type->nbits); 108 gopcode(OAND, nodconst(v), Z, n1); 109 gopcode(OAS, n1, Z, &nod); 110 if(nn != Z) 111 gopcode(OAS, n1, Z, nn); 112 sh = b->type->shift; 113 if(sh > 0) 114 gopcode(OASHL, nodconst(sh), Z, &nod); 115 v <<= sh; 116 gopcode(OAND, nodconst(~v), Z, n3); 117 gopcode(OOR, n3, Z, &nod); 118 gopcode(OAS, &nod, Z, n2); 119 120 regfree(&nod); 121 regfree(n1); 122 regfree(n2); 123 regfree(n3); 124 } 125 126 long 127 outstring(char *s, long n) 128 { 129 long r; 130 131 r = nstring; 132 while(n) { 133 string[mnstring] = *s++; 134 mnstring++; 135 nstring++; 136 if(mnstring >= NSNAME) { 137 gpseudo(ADATA, symstring, nodconst(0L)); 138 p->from.offset += nstring - NSNAME; 139 p->reg = NSNAME; 140 p->to.type = D_SCONST; 141 memmove(p->to.sval, string, NSNAME); 142 mnstring = 0; 143 } 144 n--; 145 } 146 return r; 147 } 148 149 int 150 mulcon(Node *n, Node *nn) 151 { 152 Node *l, *r, nod1, nod2; 153 Multab *m; 154 long v; 155 int o; 156 char code[sizeof(m->code)+2], *p; 157 158 if(typefd[n->type->etype]) 159 return 0; 160 l = n->left; 161 r = n->right; 162 if(l->op == OCONST) { 163 l = r; 164 r = n->left; 165 } 166 if(r->op != OCONST) 167 return 0; 168 v = convvtox(r->vconst, n->type->etype); 169 if(v != r->vconst) { 170 if(debug['M']) 171 print("%L multiply conv: %lld\n", n->lineno, r->vconst); 172 return 0; 173 } 174 m = mulcon0(n, v); 175 if(!m) { 176 if(debug['M']) 177 print("%L multiply table: %lld\n", n->lineno, r->vconst); 178 return 0; 179 } 180 181 memmove(code, m->code, sizeof(m->code)); 182 code[sizeof(m->code)] = 0; 183 184 p = code; 185 if(p[1] == 'i') 186 p += 2; 187 regalloc(&nod1, n, nn); 188 cgen(l, &nod1); 189 if(v < 0) 190 gopcode(OSUB, &nod1, nodconst(0), &nod1); 191 regalloc(&nod2, n, Z); 192 193 loop: 194 switch(*p) { 195 case 0: 196 regfree(&nod2); 197 gopcode(OAS, &nod1, Z, nn); 198 regfree(&nod1); 199 return 1; 200 case '+': 201 o = OADD; 202 goto addsub; 203 case '-': 204 o = OSUB; 205 addsub: /* number is r,n,l */ 206 v = p[1] - '0'; 207 r = &nod1; 208 if(v&4) 209 r = &nod2; 210 n = &nod1; 211 if(v&2) 212 n = &nod2; 213 l = &nod1; 214 if(v&1) 215 l = &nod2; 216 gopcode(o, l, n, r); 217 break; 218 default: /* op is shiftcount, number is r,l */ 219 v = p[1] - '0'; 220 r = &nod1; 221 if(v&2) 222 r = &nod2; 223 l = &nod1; 224 if(v&1) 225 l = &nod2; 226 v = *p - 'a'; 227 if(v < 0 || v >= 32) { 228 diag(n, "mulcon unknown op: %c%c", p[0], p[1]); 229 break; 230 } 231 gopcode(OASHL, nodconst(v), l, r); 232 break; 233 } 234 p += 2; 235 goto loop; 236 } 237 238 239 void 240 gextern(Sym *s, Node *a, long o, long w) 241 { 242 if(a->op == OCONST && typev[a->type->etype]) { 243 if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ 244 gpseudo(ADATA, s, nod32const(a->vconst>>32)); 245 else 246 gpseudo(ADATA, s, nod32const(a->vconst)); 247 p->from.offset += o; 248 p->reg = 4; 249 if(align(0, types[TCHAR], Aarg1)) /* isbigendian */ 250 gpseudo(ADATA, s, nod32const(a->vconst)); 251 else 252 gpseudo(ADATA, s, nod32const(a->vconst>>32)); 253 p->from.offset += o + 4; 254 p->reg = 4; 255 return; 256 } 257 gpseudo(ADATA, s, a); 258 p->from.offset += o; 259 p->reg = w; 260 if(p->to.type == D_OREG) 261 p->to.type = D_CONST; 262 } 263 264 void zname(Biobuf*, Sym*, int); 265 void zaddr(Biobuf*, Adr*, int); 266 void zwrite(Biobuf*, Prog*, int, int); 267 void outhist(Biobuf*); 268 269 void 270 outcode(void) 271 { 272 struct { Sym *sym; short type; } h[NSYM]; 273 Prog *p; 274 Sym *s; 275 int sf, st, t, sym; 276 277 if(debug['S']) { 278 for(p = firstp; p != P; p = p->link) 279 if(p->as != ADATA && p->as != AGLOBL) 280 pc--; 281 for(p = firstp; p != P; p = p->link) { 282 print("%P\n", p); 283 if(p->as != ADATA && p->as != AGLOBL) 284 pc++; 285 } 286 } 287 outhist(&outbuf); 288 for(sym=0; sym<NSYM; sym++) { 289 h[sym].sym = S; 290 h[sym].type = 0; 291 } 292 sym = 1; 293 for(p = firstp; p != P; p = p->link) { 294 jackpot: 295 sf = 0; 296 s = p->from.sym; 297 while(s != S) { 298 sf = s->sym; 299 if(sf < 0 || sf >= NSYM) 300 sf = 0; 301 t = p->from.name; 302 if(h[sf].type == t) 303 if(h[sf].sym == s) 304 break; 305 s->sym = sym; 306 zname(&outbuf, s, t); 307 h[sym].sym = s; 308 h[sym].type = t; 309 sf = sym; 310 sym++; 311 if(sym >= NSYM) 312 sym = 1; 313 break; 314 } 315 st = 0; 316 s = p->to.sym; 317 while(s != S) { 318 st = s->sym; 319 if(st < 0 || st >= NSYM) 320 st = 0; 321 t = p->to.name; 322 if(h[st].type == t) 323 if(h[st].sym == s) 324 break; 325 s->sym = sym; 326 zname(&outbuf, s, t); 327 h[sym].sym = s; 328 h[sym].type = t; 329 st = sym; 330 sym++; 331 if(sym >= NSYM) 332 sym = 1; 333 if(st == sf) 334 goto jackpot; 335 break; 336 } 337 zwrite(&outbuf, p, sf, st); 338 } 339 firstp = P; 340 lastp = P; 341 } 342 343 void 344 zwrite(Biobuf *b, Prog *p, int sf, int st) 345 { 346 long l; 347 348 Bputc(b, p->as); 349 Bputc(b, p->reg); 350 l = p->lineno; 351 Bputc(b, l); 352 Bputc(b, l>>8); 353 Bputc(b, l>>16); 354 Bputc(b, l>>24); 355 zaddr(b, &p->from, sf); 356 zaddr(b, &p->to, st); 357 } 358 359 void 360 outhist(Biobuf *b) 361 { 362 Hist *h; 363 char *p, *q, *op, c; 364 Prog pg; 365 int n; 366 367 pg = zprog; 368 pg.as = AHISTORY; 369 c = pathchar(); 370 for(h = hist; h != H; h = h->link) { 371 p = h->name; 372 op = 0; 373 /* on windows skip drive specifier in pathname */ 374 if(systemtype(Windows) && p && p[1] == ':'){ 375 p += 2; 376 c = *p; 377 } 378 if(p && p[0] != c && h->offset == 0 && pathname){ 379 /* on windows skip drive specifier in pathname */ 380 if(systemtype(Windows) && pathname[1] == ':') { 381 op = p; 382 p = pathname+2; 383 c = *p; 384 } else if(pathname[0] == c){ 385 op = p; 386 p = pathname; 387 } 388 } 389 while(p) { 390 q = utfrune(p, c); 391 if(q) { 392 n = q-p; 393 if(n == 0){ 394 n = 1; /* leading "/" */ 395 *p = '/'; /* don't emit "\" on windows */ 396 } 397 q++; 398 } else { 399 n = strlen(p); 400 q = 0; 401 } 402 if(n) { 403 Bputc(b, ANAME); 404 Bputc(b, D_FILE); 405 Bputc(b, 1); 406 Bputc(b, '<'); 407 Bwrite(b, p, n); 408 Bputc(b, 0); 409 } 410 p = q; 411 if(p == 0 && op) { 412 p = op; 413 op = 0; 414 } 415 } 416 pg.lineno = h->line; 417 pg.to.type = zprog.to.type; 418 pg.to.offset = h->offset; 419 if(h->offset) 420 pg.to.type = D_CONST; 421 422 zwrite(b, &pg, 0, 0); 423 } 424 } 425 426 void 427 zname(Biobuf *b, Sym *s, int t) 428 { 429 char *n; 430 ulong sig; 431 432 if(debug['T'] && t == D_EXTERN && s->sig != SIGDONE && s->type != types[TENUM] && s != symrathole){ 433 sig = sign(s); 434 Bputc(b, ASIGNAME); 435 Bputc(b, sig); 436 Bputc(b, sig>>8); 437 Bputc(b, sig>>16); 438 Bputc(b, sig>>24); 439 s->sig = SIGDONE; 440 } 441 else 442 Bputc(b, ANAME); /* as */ 443 Bputc(b, t); /* type */ 444 Bputc(b, s->sym); /* sym */ 445 n = s->name; 446 while(*n) { 447 Bputc(b, *n); 448 n++; 449 } 450 Bputc(b, 0); 451 } 452 453 void 454 zaddr(Biobuf *b, Adr *a, int s) 455 { 456 long l; 457 int i; 458 char *n; 459 Ieee e; 460 461 Bputc(b, a->type); 462 Bputc(b, a->reg); 463 Bputc(b, s); 464 Bputc(b, a->name); 465 switch(a->type) { 466 default: 467 diag(Z, "unknown type %d in zaddr", a->type); 468 469 case D_NONE: 470 case D_REG: 471 case D_FREG: 472 case D_CREG: 473 break; 474 475 case D_OREG: 476 case D_CONST: 477 case D_BRANCH: 478 l = a->offset; 479 Bputc(b, l); 480 Bputc(b, l>>8); 481 Bputc(b, l>>16); 482 Bputc(b, l>>24); 483 break; 484 485 case D_SCONST: 486 n = a->sval; 487 for(i=0; i<NSNAME; i++) { 488 Bputc(b, *n); 489 n++; 490 } 491 break; 492 493 case D_FCONST: 494 ieeedtod(&e, a->dval); 495 l = e.l; 496 Bputc(b, l); 497 Bputc(b, l>>8); 498 Bputc(b, l>>16); 499 Bputc(b, l>>24); 500 l = e.h; 501 Bputc(b, l); 502 Bputc(b, l>>8); 503 Bputc(b, l>>16); 504 Bputc(b, l>>24); 505 break; 506 } 507 } 508 509 long 510 align(long i, Type *t, int op) 511 { 512 long o; 513 Type *v; 514 int w; 515 516 o = i; 517 w = 1; 518 switch(op) { 519 default: 520 diag(Z, "unknown align opcode %d", op); 521 break; 522 523 case Asu2: /* padding at end of a struct */ 524 w = SZ_LONG; 525 if(packflg) 526 w = packflg; 527 break; 528 529 case Ael1: /* initial allign of struct element */ 530 for(v=t; v->etype==TARRAY; v=v->link) 531 ; 532 w = ewidth[v->etype]; 533 if(w <= 0 || w >= SZ_LONG) 534 w = SZ_LONG; 535 if(packflg) 536 w = packflg; 537 break; 538 539 case Ael2: /* width of a struct element */ 540 o += t->width; 541 break; 542 543 case Aarg0: /* initial passbyptr argument in arg list */ 544 if(typesuv[t->etype]) { 545 o = align(o, types[TIND], Aarg1); 546 o = align(o, types[TIND], Aarg2); 547 } 548 break; 549 550 case Aarg1: /* initial allign of parameter */ 551 w = ewidth[t->etype]; 552 if(w <= 0 || w >= SZ_LONG) { 553 w = SZ_LONG; 554 break; 555 } 556 o += SZ_LONG - w; /* big endian adjustment */ 557 w = 1; 558 break; 559 560 case Aarg2: /* width of a parameter */ 561 o += t->width; 562 w = SZ_LONG; 563 break; 564 565 case Aaut3: /* total allign of automatic */ 566 o = align(o, t, Ael1); 567 o = align(o, t, Ael2); 568 break; 569 } 570 o = round(o, w); 571 if(debug['A']) 572 print("align %s %ld %T = %ld\n", bnames[op], i, t, o); 573 return o; 574 } 575 576 long 577 maxround(long max, long v) 578 { 579 v += SZ_LONG-1; 580 if(v > max) 581 max = round(v, SZ_LONG); 582 return max; 583 } 584