diff options
Diffstat (limited to 'src/cmd/5g/cgen.c')
| -rw-r--r-- | src/cmd/5g/cgen.c | 1329 |
1 files changed, 0 insertions, 1329 deletions
diff --git a/src/cmd/5g/cgen.c b/src/cmd/5g/cgen.c deleted file mode 100644 index 76e2707fa..000000000 --- a/src/cmd/5g/cgen.c +++ /dev/null @@ -1,1329 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -#include "gg.h" - -/* - * generate: - * res = n; - * simplifies and calls gmove. - */ -void -cgen(Node *n, Node *res) -{ - Node *nl, *nr, *r; - Node n1, n2, n3, f0, f1; - int a, w; - Prog *p1, *p2, *p3; - Addr addr; - - if(debug['g']) { - dump("\ncgen-n", n); - dump("cgen-res", res); - } - if(n == N || n->type == T) - goto ret; - - if(res == N || res->type == T) - fatal("cgen: res nil"); - - while(n->op == OCONVNOP) - n = n->left; - - if(n->ullman >= UINF) { - if(n->op == OINDREG) - fatal("cgen: this is going to misscompile"); - if(res->ullman >= UINF) { - tempname(&n1, n->type); - cgen(n, &n1); - cgen(&n1, res); - goto ret; - } - } - - if(isfat(n->type)) { - if(n->type->width < 0) - fatal("forgot to compute width for %T", n->type); - sgen(n, res, n->type->width); - goto ret; - } - - - // update addressability for string, slice - // can't do in walk because n->left->addable - // changes if n->left is an escaping local variable. - switch(n->op) { - case OLEN: - if(isslice(n->left->type) || istype(n->left->type, TSTRING)) - n->addable = n->left->addable; - break; - case OCAP: - if(isslice(n->left->type)) - n->addable = n->left->addable; - break; - } - - // if both are addressable, move - if(n->addable && res->addable) { - if(is64(n->type) || is64(res->type) || - n->op == OREGISTER || res->op == OREGISTER || - iscomplex[n->type->etype] || iscomplex[res->type->etype]) { - gmove(n, res); - } else { - regalloc(&n1, n->type, N); - gmove(n, &n1); - cgen(&n1, res); - regfree(&n1); - } - goto ret; - } - - // if both are not addressable, use a temporary. - if(!n->addable && !res->addable) { - // could use regalloc here sometimes, - // but have to check for ullman >= UINF. - tempname(&n1, n->type); - cgen(n, &n1); - cgen(&n1, res); - return; - } - - // if result is not addressable directly but n is, - // compute its address and then store via the address. - if(!res->addable) { - igen(res, &n1, N); - cgen(n, &n1); - regfree(&n1); - return; - } - - if(complexop(n, res)) { - complexgen(n, res); - return; - } - - // if n is sudoaddable generate addr and move - if (!is64(n->type) && !is64(res->type) && !iscomplex[n->type->etype] && !iscomplex[res->type->etype]) { - a = optoas(OAS, n->type); - if(sudoaddable(a, n, &addr, &w)) { - if (res->op != OREGISTER) { - regalloc(&n2, res->type, N); - p1 = gins(a, N, &n2); - p1->from = addr; - if(debug['g']) - print("%P [ignore previous line]\n", p1); - gmove(&n2, res); - regfree(&n2); - } else { - p1 = gins(a, N, res); - p1->from = addr; - if(debug['g']) - print("%P [ignore previous line]\n", p1); - } - sudoclean(); - goto ret; - } - } - - // otherwise, the result is addressable but n is not. - // let's do some computation. - - nl = n->left; - nr = n->right; - - if(nl != N && nl->ullman >= UINF) - if(nr != N && nr->ullman >= UINF) { - tempname(&n1, nl->type); - cgen(nl, &n1); - n2 = *n; - n2.left = &n1; - cgen(&n2, res); - goto ret; - } - - // 64-bit ops are hard on 32-bit machine. - if(is64(n->type) || is64(res->type) || n->left != N && is64(n->left->type)) { - switch(n->op) { - // math goes to cgen64. - case OMINUS: - case OCOM: - case OADD: - case OSUB: - case OMUL: - case OLSH: - case ORSH: - case OAND: - case OOR: - case OXOR: - cgen64(n, res); - return; - } - } - - if(nl != N && isfloat[n->type->etype] && isfloat[nl->type->etype]) - goto flt; - switch(n->op) { - default: - dump("cgen", n); - fatal("cgen: unknown op %N", n); - break; - - case OREAL: - case OIMAG: - case OCOMPLEX: - fatal("unexpected complex"); - break; - - // these call bgen to get a bool value - case OOROR: - case OANDAND: - case OEQ: - case ONE: - case OLT: - case OLE: - case OGE: - case OGT: - case ONOT: - p1 = gbranch(AB, T); - p2 = pc; - gmove(nodbool(1), res); - p3 = gbranch(AB, T); - patch(p1, pc); - bgen(n, 1, p2); - gmove(nodbool(0), res); - patch(p3, pc); - goto ret; - - case OPLUS: - cgen(nl, res); - goto ret; - - // unary - case OCOM: - a = optoas(OXOR, nl->type); - regalloc(&n1, nl->type, N); - cgen(nl, &n1); - nodconst(&n2, nl->type, -1); - gins(a, &n2, &n1); - gmove(&n1, res); - regfree(&n1); - goto ret; - - case OMINUS: - nodconst(&n3, nl->type, 0); - regalloc(&n2, nl->type, res); - regalloc(&n1, nl->type, N); - gmove(&n3, &n2); - cgen(nl, &n1); - gins(optoas(OSUB, nl->type), &n1, &n2); - gmove(&n2, res); - regfree(&n1); - regfree(&n2); - goto ret; - - // symmetric binary - case OAND: - case OOR: - case OXOR: - case OADD: - case OMUL: - a = optoas(n->op, nl->type); - goto sbop; - - // asymmetric binary - case OSUB: - a = optoas(n->op, nl->type); - goto abop; - - case OLSH: - case ORSH: - cgen_shift(n->op, nl, nr, res); - break; - - case OCONV: - if(eqtype(n->type, nl->type) || noconv(n->type, nl->type)) { - cgen(nl, res); - break; - } - if(nl->addable && !is64(nl->type)) { - regalloc(&n1, nl->type, res); - gmove(nl, &n1); - } else { - if(n->type->width > widthptr || is64(nl->type) || isfloat[nl->type->etype]) - tempname(&n1, nl->type); - else - regalloc(&n1, nl->type, res); - cgen(nl, &n1); - } - if(n->type->width > widthptr || is64(n->type) || isfloat[n->type->etype]) - tempname(&n2, n->type); - else - regalloc(&n2, n->type, N); - gmove(&n1, &n2); - gmove(&n2, res); - if(n1.op == OREGISTER) - regfree(&n1); - if(n2.op == OREGISTER) - regfree(&n2); - break; - - case ODOT: - case ODOTPTR: - case OINDEX: - case OIND: - case ONAME: // PHEAP or PPARAMREF var - igen(n, &n1, res); - gmove(&n1, res); - regfree(&n1); - break; - - case OLEN: - if(istype(nl->type, TMAP) || istype(nl->type, TCHAN)) { - // map has len in the first 32-bit word. - // a zero pointer means zero length - regalloc(&n1, types[tptr], res); - cgen(nl, &n1); - - nodconst(&n2, types[tptr], 0); - regalloc(&n3, n2.type, N); - gmove(&n2, &n3); - gcmp(optoas(OCMP, types[tptr]), &n1, &n3); - regfree(&n3); - p1 = gbranch(optoas(OEQ, types[tptr]), T); - - n2 = n1; - n2.op = OINDREG; - n2.type = types[TINT32]; - gmove(&n2, &n1); - - patch(p1, pc); - - gmove(&n1, res); - regfree(&n1); - break; - } - if(istype(nl->type, TSTRING) || isslice(nl->type)) { - // both slice and string have len one pointer into the struct. - igen(nl, &n1, res); - n1.op = OREGISTER; // was OINDREG - regalloc(&n2, types[TUINT32], &n1); - n1.op = OINDREG; - n1.type = types[TUINT32]; - n1.xoffset = Array_nel; - gmove(&n1, &n2); - gmove(&n2, res); - regfree(&n1); - regfree(&n2); - break; - } - fatal("cgen: OLEN: unknown type %lT", nl->type); - break; - - case OCAP: - if(istype(nl->type, TCHAN)) { - // chan has cap in the second 32-bit word. - // a zero pointer means zero length - regalloc(&n1, types[tptr], res); - cgen(nl, &n1); - - nodconst(&n2, types[tptr], 0); - regalloc(&n3, n2.type, N); - gmove(&n2, &n3); - gcmp(optoas(OCMP, types[tptr]), &n1, &n3); - regfree(&n3); - p1 = gbranch(optoas(OEQ, types[tptr]), T); - - n2 = n1; - n2.op = OINDREG; - n2.xoffset = 4; - n2.type = types[TINT32]; - gmove(&n2, &n1); - - patch(p1, pc); - - gmove(&n1, res); - regfree(&n1); - break; - } - if(isslice(nl->type)) { - regalloc(&n1, types[tptr], res); - agen(nl, &n1); - n1.op = OINDREG; - n1.type = types[TUINT32]; - n1.xoffset = Array_cap; - gmove(&n1, res); - regfree(&n1); - break; - } - fatal("cgen: OCAP: unknown type %lT", nl->type); - break; - - case OADDR: - agen(nl, res); - break; - - case OCALLMETH: - cgen_callmeth(n, 0); - cgen_callret(n, res); - break; - - case OCALLINTER: - cgen_callinter(n, res, 0); - cgen_callret(n, res); - break; - - case OCALLFUNC: - cgen_call(n, 0); - cgen_callret(n, res); - break; - - case OMOD: - case ODIV: - a = optoas(n->op, nl->type); - goto abop; - } - goto ret; - -sbop: // symmetric binary - if(nl->ullman < nr->ullman) { - r = nl; - nl = nr; - nr = r; - } - -abop: // asymmetric binary - // TODO(kaib): use fewer registers here. - if(nl->ullman >= nr->ullman) { - regalloc(&n1, nl->type, res); - cgen(nl, &n1); - regalloc(&n2, nr->type, N); - cgen(nr, &n2); - } else { - regalloc(&n2, nr->type, N); - cgen(nr, &n2); - regalloc(&n1, nl->type, res); - cgen(nl, &n1); - } - gins(a, &n2, &n1); - gmove(&n1, res); - regfree(&n1); - regfree(&n2); - goto ret; - -flt: // floating-point. - regalloc(&f0, nl->type, res); - if(nr != N) - goto flt2; - - if(n->op == OMINUS) { - nr = nodintconst(-1); - convlit(&nr, n->type); - n->op = OMUL; - goto flt2; - } - - // unary - cgen(nl, &f0); - if(n->op != OCONV && n->op != OPLUS) - gins(optoas(n->op, n->type), &f0, &f0); - gmove(&f0, res); - regfree(&f0); - goto ret; - -flt2: // binary - if(nl->ullman >= nr->ullman) { - cgen(nl, &f0); - regalloc(&f1, n->type, N); - gmove(&f0, &f1); - cgen(nr, &f0); - gins(optoas(n->op, n->type), &f0, &f1); - } else { - cgen(nr, &f0); - regalloc(&f1, n->type, N); - cgen(nl, &f1); - gins(optoas(n->op, n->type), &f0, &f1); - } - gmove(&f1, res); - regfree(&f0); - regfree(&f1); - goto ret; - -ret: - ; -} - -/* - * generate array index into res. - * n might be any size; res is 32-bit. - * returns Prog* to patch to panic call. - */ -Prog* -cgenindex(Node *n, Node *res) -{ - Node tmp, lo, hi, zero, n1, n2; - - if(!is64(n->type)) { - cgen(n, res); - return nil; - } - - tempname(&tmp, types[TINT64]); - cgen(n, &tmp); - split64(&tmp, &lo, &hi); - gmove(&lo, res); - if(debug['B']) { - splitclean(); - return nil; - } - regalloc(&n1, types[TINT32], N); - regalloc(&n2, types[TINT32], N); - nodconst(&zero, types[TINT32], 0); - gmove(&hi, &n1); - gmove(&zero, &n2); - gcmp(ACMP, &n1, &n2); - regfree(&n2); - regfree(&n1); - splitclean(); - return gbranch(ABNE, T); -} - -/* - * generate: - * res = &n; - */ -void -agen(Node *n, Node *res) -{ - Node *nl, *nr; - Node n1, n2, n3, n4, n5, tmp; - Prog *p1, *p2; - uint32 w; - uint64 v; - int r; - - if(debug['g']) { - dump("\nagen-res", res); - dump("agen-r", n); - } - if(n == N || n->type == T || res == N || res->type == T) - fatal("agen"); - - while(n->op == OCONVNOP) - n = n->left; - - if(n->addable) { - memset(&n1, 0, sizeof n1); - n1.op = OADDR; - n1.left = n; - regalloc(&n2, types[tptr], res); - gins(AMOVW, &n1, &n2); - gmove(&n2, res); - regfree(&n2); - goto ret; - } - - nl = n->left; - nr = n->right; - - switch(n->op) { - default: - fatal("agen: unknown op %N", n); - break; - - case OCALLMETH: - case OCALLFUNC: - // Release res so that it is available for cgen_call. - // Pick it up again after the call. - r = -1; - if(n->ullman >= UINF) { - if(res->op == OREGISTER || res->op == OINDREG) { - r = res->val.u.reg; - reg[r]--; - } - } - if(n->op == OCALLMETH) - cgen_callmeth(n, 0); - else - cgen_call(n, 0); - if(r >= 0) - reg[r]++; - cgen_aret(n, res); - break; - - case OCALLINTER: - cgen_callinter(n, res, 0); - cgen_aret(n, res); - break; - - case OINDEX: - p2 = nil; // to be patched to panicindex. - w = n->type->width; - if(nr->addable) { - if(!isconst(nr, CTINT)) - tempname(&tmp, types[TINT32]); - if(!isconst(nl, CTSTR)) - agenr(nl, &n3, res); - if(!isconst(nr, CTINT)) { - p2 = cgenindex(nr, &tmp); - regalloc(&n1, tmp.type, N); - gmove(&tmp, &n1); - } - } else - if(nl->addable) { - if(!isconst(nr, CTINT)) { - tempname(&tmp, types[TINT32]); - p2 = cgenindex(nr, &tmp); - regalloc(&n1, tmp.type, N); - gmove(&tmp, &n1); - } - if(!isconst(nl, CTSTR)) { - regalloc(&n3, types[tptr], res); - agen(nl, &n3); - } - } else { - tempname(&tmp, types[TINT32]); - p2 = cgenindex(nr, &tmp); - nr = &tmp; - if(!isconst(nl, CTSTR)) - agenr(nl, &n3, res); - regalloc(&n1, tmp.type, N); - gins(optoas(OAS, tmp.type), &tmp, &n1); - } - - // &a is in &n3 (allocated in res) - // i is in &n1 (if not constant) - // w is width - - if(w == 0) - fatal("index is zero width"); - - // constant index - if(isconst(nr, CTINT)) { - if(isconst(nl, CTSTR)) - fatal("constant string constant index"); - v = mpgetfix(nr->val.u.xval); - if(isslice(nl->type) || nl->type->etype == TSTRING) { - if(!debug['B'] && !n->etype) { - n1 = n3; - n1.op = OINDREG; - n1.type = types[tptr]; - n1.xoffset = Array_nel; - regalloc(&n4, n1.type, N); - cgen(&n1, &n4); - nodconst(&n2, types[TUINT32], v); - regalloc(&n5, n2.type, N); - gmove(&n2, &n5); - gcmp(optoas(OCMP, types[TUINT32]), &n4, &n5); - regfree(&n4); - regfree(&n5); - p1 = gbranch(optoas(OGT, types[TUINT32]), T); - ginscall(panicindex, 0); - patch(p1, pc); - } - - n1 = n3; - n1.op = OINDREG; - n1.type = types[tptr]; - n1.xoffset = Array_array; - gmove(&n1, &n3); - } - - nodconst(&n2, types[tptr], v*w); - regalloc(&n4, n2.type, N); - gmove(&n2, &n4); - gins(optoas(OADD, types[tptr]), &n4, &n3); - regfree(&n4); - - gmove(&n3, res); - regfree(&n3); - break; - } - - regalloc(&n2, types[TINT32], &n1); // i - gmove(&n1, &n2); - regfree(&n1); - - if(!debug['B'] && !n->etype) { - // check bounds - regalloc(&n4, types[TUINT32], N); - if(isconst(nl, CTSTR)) { - nodconst(&n1, types[TUINT32], nl->val.u.sval->len); - gmove(&n1, &n4); - } else if(isslice(nl->type) || nl->type->etype == TSTRING) { - n1 = n3; - n1.op = OINDREG; - n1.type = types[tptr]; - n1.xoffset = Array_nel; - cgen(&n1, &n4); - } else { - nodconst(&n1, types[TUINT32], nl->type->bound); - gmove(&n1, &n4); - } - gcmp(optoas(OCMP, types[TUINT32]), &n2, &n4); - regfree(&n4); - p1 = gbranch(optoas(OLT, types[TUINT32]), T); - if(p2) - patch(p2, pc); - ginscall(panicindex, 0); - patch(p1, pc); - } - - if(isconst(nl, CTSTR)) { - regalloc(&n3, types[tptr], res); - p1 = gins(AMOVW, N, &n3); - datastring(nl->val.u.sval->s, nl->val.u.sval->len, &p1->from); - p1->from.type = D_CONST; - } else - if(isslice(nl->type) || nl->type->etype == TSTRING) { - n1 = n3; - n1.op = OINDREG; - n1.type = types[tptr]; - n1.xoffset = Array_array; - gmove(&n1, &n3); - } - - if(w == 1 || w == 2 || w == 4 || w == 8) { - memset(&n4, 0, sizeof n4); - n4.op = OADDR; - n4.left = &n2; - cgen(&n4, &n3); - if (w == 1) - gins(AADD, &n2, &n3); - else if(w == 2) - gshift(AADD, &n2, SHIFT_LL, 1, &n3); - else if(w == 4) - gshift(AADD, &n2, SHIFT_LL, 2, &n3); - else if(w == 8) - gshift(AADD, &n2, SHIFT_LL, 3, &n3); - } else { - regalloc(&n4, types[TUINT32], N); - nodconst(&n1, types[TUINT32], w); - gmove(&n1, &n4); - gins(optoas(OMUL, types[TUINT32]), &n4, &n2); - gins(optoas(OADD, types[tptr]), &n2, &n3); - regfree(&n4); - gmove(&n3, res); - } - - gmove(&n3, res); - regfree(&n2); - regfree(&n3); - break; - - case ONAME: - // should only get here with names in this func. - if(n->funcdepth > 0 && n->funcdepth != funcdepth) { - dump("bad agen", n); - fatal("agen: bad ONAME funcdepth %d != %d", - n->funcdepth, funcdepth); - } - - // should only get here for heap vars or paramref - if(!(n->class & PHEAP) && n->class != PPARAMREF) { - dump("bad agen", n); - fatal("agen: bad ONAME class %#x", n->class); - } - cgen(n->heapaddr, res); - if(n->xoffset != 0) { - nodconst(&n1, types[TINT32], n->xoffset); - regalloc(&n2, n1.type, N); - regalloc(&n3, types[TINT32], N); - gmove(&n1, &n2); - gmove(res, &n3); - gins(optoas(OADD, types[tptr]), &n2, &n3); - gmove(&n3, res); - regfree(&n2); - regfree(&n3); - } - break; - - case OIND: - cgen(nl, res); - break; - - case ODOT: - agen(nl, res); - if(n->xoffset != 0) { - nodconst(&n1, types[TINT32], n->xoffset); - regalloc(&n2, n1.type, N); - regalloc(&n3, types[TINT32], N); - gmove(&n1, &n2); - gmove(res, &n3); - gins(optoas(OADD, types[tptr]), &n2, &n3); - gmove(&n3, res); - regfree(&n2); - regfree(&n3); - } - break; - - case ODOTPTR: - cgen(nl, res); - if(n->xoffset != 0) { - // explicit check for nil if struct is large enough - // that we might derive too big a pointer. - if(nl->type->type->width >= unmappedzero) { - regalloc(&n1, types[tptr], N); - gmove(res, &n1); - p1 = gins(AMOVW, &n1, &n1); - p1->from.type = D_OREG; - p1->from.offset = 0; - regfree(&n1); - } - nodconst(&n1, types[TINT32], n->xoffset); - regalloc(&n2, n1.type, N); - regalloc(&n3, types[tptr], N); - gmove(&n1, &n2); - gmove(res, &n3); - gins(optoas(OADD, types[tptr]), &n2, &n3); - gmove(&n3, res); - regfree(&n2); - regfree(&n3); - } - break; - } - -ret: - ; -} - -/* - * generate: - * newreg = &n; - * res = newreg - * - * on exit, a has been changed to be *newreg. - * caller must regfree(a). - */ -void -igen(Node *n, Node *a, Node *res) -{ - regalloc(a, types[tptr], res); - agen(n, a); - a->op = OINDREG; - a->type = n->type; -} - -/* - * generate: - * newreg = &n; - * - * caller must regfree(a). - */ -void -agenr(Node *n, Node *a, Node *res) -{ - regalloc(a, types[tptr], res); - agen(n, a); -} - -void -gencmp0(Node *n, Type *t, int o, Prog *to) -{ - Node n1, n2, n3; - int a; - - regalloc(&n1, t, N); - cgen(n, &n1); - a = optoas(OCMP, t); - if(a != ACMP) { - nodconst(&n2, t, 0); - regalloc(&n3, t, N); - gmove(&n2, &n3); - gcmp(a, &n1, &n3); - regfree(&n3); - } else - gins(ATST, &n1, N); - a = optoas(o, t); - patch(gbranch(a, t), to); - regfree(&n1); -} - -/* - * generate: - * if(n == true) goto to; - */ -void -bgen(Node *n, int true, Prog *to) -{ - int et, a; - Node *nl, *nr, *r; - Node n1, n2, n3, n4, tmp; - Prog *p1, *p2; - - if(debug['g']) { - dump("\nbgen", n); - } - - if(n == N) - n = nodbool(1); - - if(n->ninit != nil) - genlist(n->ninit); - - nl = n->left; - nr = n->right; - - if(n->type == T) { - convlit(&n, types[TBOOL]); - if(n->type == T) - goto ret; - } - - et = n->type->etype; - if(et != TBOOL) { - yyerror("cgen: bad type %T for %O", n->type, n->op); - patch(gins(AEND, N, N), to); - goto ret; - } - nl = N; - nr = N; - - switch(n->op) { - default: - a = ONE; - if(!true) - a = OEQ; - gencmp0(n, n->type, a, to); - goto ret; - - case OLITERAL: - // need to ask if it is bool? - if(!true == !n->val.u.bval) - patch(gbranch(AB, T), to); - goto ret; - - case OANDAND: - if(!true) - goto caseor; - - caseand: - p1 = gbranch(AB, T); - p2 = gbranch(AB, T); - patch(p1, pc); - bgen(n->left, !true, p2); - bgen(n->right, !true, p2); - p1 = gbranch(AB, T); - patch(p1, to); - patch(p2, pc); - goto ret; - - case OOROR: - if(!true) - goto caseand; - - caseor: - bgen(n->left, true, to); - bgen(n->right, true, to); - goto ret; - - case OEQ: - case ONE: - case OLT: - case OGT: - case OLE: - case OGE: - nr = n->right; - if(nr == N || nr->type == T) - goto ret; - - case ONOT: // unary - nl = n->left; - if(nl == N || nl->type == T) - goto ret; - } - - switch(n->op) { - - case ONOT: - bgen(nl, !true, to); - goto ret; - - case OEQ: - case ONE: - case OLT: - case OGT: - case OLE: - case OGE: - a = n->op; - if(!true) { - if(isfloat[nl->type->etype]) { - // brcom is not valid on floats when NaN is involved. - p1 = gbranch(AB, T); - p2 = gbranch(AB, T); - patch(p1, pc); - bgen(n, 1, p2); - patch(gbranch(AB, T), to); - patch(p2, pc); - goto ret; - } - a = brcom(a); - true = !true; - } - - // make simplest on right - if(nl->op == OLITERAL || (nl->ullman < UINF && nl->ullman < nr->ullman)) { - a = brrev(a); - r = nl; - nl = nr; - nr = r; - } - - if(isslice(nl->type)) { - // only valid to cmp darray to literal nil - if((a != OEQ && a != ONE) || nr->op != OLITERAL) { - yyerror("illegal array comparison"); - break; - } - - regalloc(&n1, types[tptr], N); - agen(nl, &n1); - n2 = n1; - n2.op = OINDREG; - n2.xoffset = Array_array; - gencmp0(&n2, types[tptr], a, to); - regfree(&n1); - break; - - a = optoas(a, types[tptr]); - regalloc(&n1, types[tptr], N); - regalloc(&n3, types[tptr], N); - regalloc(&n4, types[tptr], N); - agen(nl, &n1); - n2 = n1; - n2.op = OINDREG; - n2.xoffset = Array_array; - gmove(&n2, &n4); - nodconst(&tmp, types[tptr], 0); - gmove(&tmp, &n3); - gcmp(optoas(OCMP, types[tptr]), &n4, &n3); - patch(gbranch(a, types[tptr]), to); - regfree(&n4); - regfree(&n3); - regfree(&n1); - break; - } - - if(isinter(nl->type)) { - // front end shold only leave cmp to literal nil - if((a != OEQ && a != ONE) || nr->op != OLITERAL) { - yyerror("illegal interface comparison"); - break; - } - - regalloc(&n1, types[tptr], N); - agen(nl, &n1); - n2 = n1; - n2.op = OINDREG; - n2.xoffset = 0; - gencmp0(&n2, types[tptr], a, to); - regfree(&n1); - break; - - a = optoas(a, types[tptr]); - regalloc(&n1, types[tptr], N); - regalloc(&n3, types[tptr], N); - regalloc(&n4, types[tptr], N); - agen(nl, &n1); - n2 = n1; - n2.op = OINDREG; - n2.xoffset = 0; - gmove(&n2, &n4); - nodconst(&tmp, types[tptr], 0); - gmove(&tmp, &n3); - gcmp(optoas(OCMP, types[tptr]), &n4, &n3); - patch(gbranch(a, types[tptr]), to); - regfree(&n1); - regfree(&n3); - regfree(&n4); - break; - } - - if(iscomplex[nl->type->etype]) { - complexbool(a, nl, nr, true, to); - break; - } - - if(is64(nr->type)) { - if(!nl->addable) { - tempname(&n1, nl->type); - cgen(nl, &n1); - nl = &n1; - } - if(!nr->addable) { - tempname(&n2, nr->type); - cgen(nr, &n2); - nr = &n2; - } - cmp64(nl, nr, a, to); - break; - } - - if(nr->op == OLITERAL) { - if(nr->val.ctype == CTINT && mpgetfix(nr->val.u.xval) == 0) { - gencmp0(nl, nl->type, a, to); - break; - } - if(nr->val.ctype == CTNIL) { - gencmp0(nl, nl->type, a, to); - break; - } - } - - a = optoas(a, nr->type); - - if(nr->ullman >= UINF) { - regalloc(&n1, nl->type, N); - cgen(nl, &n1); - - tempname(&tmp, nl->type); - gmove(&n1, &tmp); - regfree(&n1); - - regalloc(&n2, nr->type, N); - cgen(nr, &n2); - - regalloc(&n1, nl->type, N); - cgen(&tmp, &n1); - - gcmp(optoas(OCMP, nr->type), &n1, &n2); - patch(gbranch(a, nr->type), to); - - regfree(&n1); - regfree(&n2); - break; - } - - tempname(&n3, nl->type); - cgen(nl, &n3); - - tempname(&tmp, nr->type); - cgen(nr, &tmp); - - regalloc(&n1, nl->type, N); - gmove(&n3, &n1); - - regalloc(&n2, nr->type, N); - gmove(&tmp, &n2); - - gcmp(optoas(OCMP, nr->type), &n1, &n2); - if(isfloat[nl->type->etype]) { - p1 = gbranch(ABVS, nr->type); - patch(gbranch(a, nr->type), to); - if(n->op == ONE) - patch(p1, to); - else - patch(p1, pc); - } else { - patch(gbranch(a, nr->type), to); - } - regfree(&n1); - regfree(&n2); - break; - } - goto ret; - -ret: - ; -} - -/* - * n is on stack, either local variable - * or return value from function call. - * return n's offset from SP. - */ -int32 -stkof(Node *n) -{ - Type *t; - Iter flist; - int32 off; - - switch(n->op) { - case OINDREG: - return n->xoffset; - - case ODOT: - t = n->left->type; - if(isptr[t->etype]) - break; - off = stkof(n->left); - if(off == -1000 || off == 1000) - return off; - return off + n->xoffset; - - case OINDEX: - t = n->left->type; - if(!isfixedarray(t)) - break; - off = stkof(n->left); - if(off == -1000 || off == 1000) - return off; - if(isconst(n->right, CTINT)) - return off + t->type->width * mpgetfix(n->right->val.u.xval); - return 1000; - - case OCALLMETH: - case OCALLINTER: - case OCALLFUNC: - t = n->left->type; - if(isptr[t->etype]) - t = t->type; - - t = structfirst(&flist, getoutarg(t)); - if(t != T) - return t->width + 4; // correct for LR - break; - } - - // botch - probably failing to recognize address - // arithmetic on the above. eg INDEX and DOT - return -1000; -} - -/* - * block copy: - * memmove(&res, &n, w); - * NB: character copy assumed little endian architecture - */ -void -sgen(Node *n, Node *res, int32 w) -{ - Node dst, src, tmp, nend; - int32 c, odst, osrc; - int dir, align, op; - Prog *p, *ploop; - - if(debug['g']) { - print("\nsgen w=%d\n", w); - dump("r", n); - dump("res", res); - } - if(w == 0) - return; - if(w < 0) - fatal("sgen copy %d", w); - if(n->ullman >= UINF && res->ullman >= UINF) - fatal("sgen UINF"); - if(n->type == T) - fatal("sgen: missing type"); - - // determine alignment. - // want to avoid unaligned access, so have to use - // smaller operations for less aligned types. - // for example moving [4]byte must use 4 MOVB not 1 MOVW. - align = n->type->align; - op = 0; - switch(align) { - default: - fatal("sgen: invalid alignment %d for %T", align, n->type); - case 1: - op = AMOVB; - break; - case 2: - op = AMOVH; - break; - case 4: - op = AMOVW; - break; - } - if(w%align) - fatal("sgen: unaligned size %d (align=%d) for %T", w, align, n->type); - c = w / align; - - // offset on the stack - osrc = stkof(n); - odst = stkof(res); - if(osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000)) { - // osrc and odst both on stack, and at least one is in - // an unknown position. Could generate code to test - // for forward/backward copy, but instead just copy - // to a temporary location first. - tempname(&tmp, n->type); - sgen(n, &tmp, w); - sgen(&tmp, res, w); - return; - } - if(osrc%align != 0 || odst%align != 0) - fatal("sgen: unaligned offset src %d or dst %d (align %d)", osrc, odst, align); - // if we are copying forward on the stack and - // the src and dst overlap, then reverse direction - dir = align; - if(osrc < odst && odst < osrc+w) - dir = -dir; - - regalloc(&dst, types[tptr], res); - if(n->ullman >= res->ullman) { - agen(n, &dst); // temporarily use dst - regalloc(&src, types[tptr], N); - gins(AMOVW, &dst, &src); - agen(res, &dst); - } else { - agen(res, &dst); - regalloc(&src, types[tptr], N); - agen(n, &src); - } - - regalloc(&tmp, types[TUINT32], N); - - // set up end marker - memset(&nend, 0, sizeof nend); - if(c >= 4) { - regalloc(&nend, types[TUINT32], N); - - p = gins(AMOVW, &src, &nend); - p->from.type = D_CONST; - if(dir < 0) - p->from.offset = dir; - else - p->from.offset = w; - } - - // move src and dest to the end of block if necessary - if(dir < 0) { - p = gins(AMOVW, &src, &src); - p->from.type = D_CONST; - p->from.offset = w + dir; - - p = gins(AMOVW, &dst, &dst); - p->from.type = D_CONST; - p->from.offset = w + dir; - } - - // move - if(c >= 4) { - p = gins(op, &src, &tmp); - p->from.type = D_OREG; - p->from.offset = dir; - p->scond |= C_PBIT; - ploop = p; - - p = gins(op, &tmp, &dst); - p->to.type = D_OREG; - p->to.offset = dir; - p->scond |= C_PBIT; - - p = gins(ACMP, &src, N); - raddr(&nend, p); - - patch(gbranch(ABNE, T), ploop); - regfree(&nend); - } else { - while(c-- > 0) { - p = gins(op, &src, &tmp); - p->from.type = D_OREG; - p->from.offset = dir; - p->scond |= C_PBIT; - ploop = p; - - p = gins(op, &tmp, &dst); - p->to.type = D_OREG; - p->to.offset = dir; - p->scond |= C_PBIT; - } - } - - regfree(&dst); - regfree(&src); - regfree(&tmp); -} |