| // Inferno utils/cc/com.c |
| // http://code.google.com/p/inferno-os/source/browse/utils/cc/com.c |
| // |
| // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. |
| // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) |
| // Portions Copyright © 1997-1999 Vita Nuova Limited |
| // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) |
| // Portions Copyright © 2004,2006 Bruce Ellis |
| // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) |
| // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others |
| // Portions Copyright © 2009 The Go Authors. All rights reserved. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| #include <u.h> |
| #include "cc.h" |
| |
| int compar(Node*, int); |
| |
| void |
| complex(Node *n) |
| { |
| |
| if(n == Z) |
| return; |
| |
| nearln = n->lineno; |
| if(debug['t']) |
| if(n->op != OCONST) |
| prtree(n, "pre complex"); |
| if(tcom(n)) |
| return; |
| if(debug['t']) |
| if(n->op != OCONST) |
| prtree(n, "t complex"); |
| ccom(n); |
| if(debug['t']) |
| if(n->op != OCONST) |
| prtree(n, "c complex"); |
| acom(n); |
| if(debug['t']) |
| if(n->op != OCONST) |
| prtree(n, "a complex"); |
| xcom(n); |
| if(debug['t']) |
| if(n->op != OCONST) |
| prtree(n, "x complex"); |
| } |
| |
| /* |
| * evaluate types |
| * evaluate lvalues (addable == 1) |
| */ |
| enum |
| { |
| ADDROF = 1<<0, |
| CASTOF = 1<<1, |
| ADDROP = 1<<2, |
| }; |
| |
| int |
| tcom(Node *n) |
| { |
| |
| return tcomo(n, ADDROF); |
| } |
| |
| int |
| tcomo(Node *n, int f) |
| { |
| Node *l, *r; |
| Type *t; |
| int o; |
| static TRune zer; |
| |
| if(n == Z) { |
| diag(Z, "Z in tcom"); |
| errorexit(); |
| } |
| n->addable = 0; |
| l = n->left; |
| r = n->right; |
| |
| switch(n->op) { |
| default: |
| diag(n, "unknown op in type complex: %O", n->op); |
| goto bad; |
| |
| case ODOTDOT: |
| /* |
| * tcom has already been called on this subtree |
| */ |
| *n = *n->left; |
| if(n->type == T) |
| goto bad; |
| break; |
| |
| case OCAST: |
| if(n->type == T) |
| break; |
| if(n->type->width == types[TLONG]->width) { |
| if(tcomo(l, ADDROF|CASTOF)) |
| goto bad; |
| } else |
| if(tcom(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, n->type, tcast)) |
| goto bad; |
| break; |
| |
| case ORETURN: |
| if(l == Z) { |
| if(n->type->etype != TVOID) |
| diag(n, "null return of a typed function"); |
| break; |
| } |
| if(tcom(l)) |
| goto bad; |
| typeext(n->type, l); |
| if(tcompat(n, n->type, l->type, tasign)) |
| break; |
| constas(n, n->type, l->type); |
| if(!sametype(n->type, l->type)) { |
| l = new1(OCAST, l, Z); |
| l->type = n->type; |
| n->left = l; |
| } |
| break; |
| |
| case OASI: /* same as as, but no test for const */ |
| n->op = OAS; |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| |
| typeext(l->type, r); |
| if(tlvalue(l) || tcompat(n, l->type, r->type, tasign)) |
| goto bad; |
| if(!sametype(l->type, r->type)) { |
| r = new1(OCAST, r, Z); |
| r->type = l->type; |
| n->right = r; |
| } |
| n->type = l->type; |
| break; |
| |
| case OAS: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| typeext(l->type, r); |
| if(tcompat(n, l->type, r->type, tasign)) |
| goto bad; |
| constas(n, l->type, r->type); |
| if(!sametype(l->type, r->type)) { |
| r = new1(OCAST, r, Z); |
| r->type = l->type; |
| n->right = r; |
| } |
| n->type = l->type; |
| break; |
| |
| case OASADD: |
| case OASSUB: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| typeext1(l->type, r); |
| if(tcompat(n, l->type, r->type, tasadd)) |
| goto bad; |
| constas(n, l->type, r->type); |
| t = l->type; |
| arith(n, 0); |
| while(n->left->op == OCAST) |
| n->left = n->left->left; |
| if(!sametype(t, n->type) && !mixedasop(t, n->type)) { |
| r = new1(OCAST, n->right, Z); |
| r->type = t; |
| n->right = r; |
| n->type = t; |
| } |
| break; |
| |
| case OASMUL: |
| case OASLMUL: |
| case OASDIV: |
| case OASLDIV: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| typeext1(l->type, r); |
| if(tcompat(n, l->type, r->type, tmul)) |
| goto bad; |
| constas(n, l->type, r->type); |
| t = l->type; |
| arith(n, 0); |
| while(n->left->op == OCAST) |
| n->left = n->left->left; |
| if(!sametype(t, n->type) && !mixedasop(t, n->type)) { |
| r = new1(OCAST, n->right, Z); |
| r->type = t; |
| n->right = r; |
| n->type = t; |
| } |
| if(typeu[n->type->etype]) { |
| if(n->op == OASDIV) |
| n->op = OASLDIV; |
| if(n->op == OASMUL) |
| n->op = OASLMUL; |
| } |
| break; |
| |
| case OASLSHR: |
| case OASASHR: |
| case OASASHL: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| n->type = l->type; |
| if(typeu[n->type->etype]) { |
| if(n->op == OASASHR) |
| n->op = OASLSHR; |
| } |
| break; |
| |
| case OASMOD: |
| case OASLMOD: |
| case OASOR: |
| case OASAND: |
| case OASXOR: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| t = l->type; |
| arith(n, 0); |
| while(n->left->op == OCAST) |
| n->left = n->left->left; |
| if(!sametype(t, n->type) && !mixedasop(t, n->type)) { |
| r = new1(OCAST, n->right, Z); |
| r->type = t; |
| n->right = r; |
| n->type = t; |
| } |
| if(typeu[n->type->etype]) { |
| if(n->op == OASMOD) |
| n->op = OASLMOD; |
| } |
| break; |
| |
| case OPREINC: |
| case OPREDEC: |
| case OPOSTINC: |
| case OPOSTDEC: |
| if(tcom(l)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, types[TINT], tadd)) |
| goto bad; |
| n->type = l->type; |
| if(n->type->etype == TIND) |
| if(n->type->link->width < 1) |
| diag(n, "inc/dec of a void pointer"); |
| break; |
| |
| case OEQ: |
| case ONE: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| typeext(l->type, r); |
| typeext(r->type, l); |
| if(tcompat(n, l->type, r->type, trel)) |
| goto bad; |
| arith(n, 0); |
| n->type = types[TINT]; |
| break; |
| |
| case OLT: |
| case OGE: |
| case OGT: |
| case OLE: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| typeext1(l->type, r); |
| typeext1(r->type, l); |
| if(tcompat(n, l->type, r->type, trel)) |
| goto bad; |
| arith(n, 0); |
| if(typeu[n->type->etype]) |
| n->op = logrel[relindex(n->op)]; |
| n->type = types[TINT]; |
| break; |
| |
| case OCOND: |
| o = tcom(l); |
| o |= tcom(r->left); |
| if(o | tcom(r->right)) |
| goto bad; |
| if(r->right->type->etype == TIND && vconst(r->left) == 0) { |
| r->left->type = r->right->type; |
| r->left->vconst = 0; |
| } |
| if(r->left->type->etype == TIND && vconst(r->right) == 0) { |
| r->right->type = r->left->type; |
| r->right->vconst = 0; |
| } |
| if(sametype(r->right->type, r->left->type)) { |
| r->type = r->right->type; |
| n->type = r->type; |
| break; |
| } |
| if(tcompat(r, r->left->type, r->right->type, trel)) |
| goto bad; |
| arith(r, 0); |
| n->type = r->type; |
| break; |
| |
| case OADD: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tadd)) |
| goto bad; |
| arith(n, 1); |
| break; |
| |
| case OSUB: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tsub)) |
| goto bad; |
| arith(n, 1); |
| break; |
| |
| case OMUL: |
| case OLMUL: |
| case ODIV: |
| case OLDIV: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tmul)) |
| goto bad; |
| arith(n, 1); |
| if(typeu[n->type->etype]) { |
| if(n->op == ODIV) |
| n->op = OLDIV; |
| if(n->op == OMUL) |
| n->op = OLMUL; |
| } |
| break; |
| |
| case OLSHR: |
| case OASHL: |
| case OASHR: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| n->right = Z; |
| arith(n, 1); |
| n->right = new1(OCAST, r, Z); |
| n->right->type = types[TINT]; |
| if(typeu[n->type->etype]) |
| if(n->op == OASHR) |
| n->op = OLSHR; |
| break; |
| |
| case OAND: |
| case OOR: |
| case OXOR: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| arith(n, 1); |
| break; |
| |
| case OMOD: |
| case OLMOD: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| arith(n, 1); |
| if(typeu[n->type->etype]) |
| n->op = OLMOD; |
| break; |
| |
| case OPOS: |
| if(tcom(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| |
| r = l; |
| l = new(OCONST, Z, Z); |
| l->vconst = 0; |
| l->type = types[TINT]; |
| n->op = OADD; |
| n->right = r; |
| n->left = l; |
| |
| if(tcom(l)) |
| goto bad; |
| if(tcompat(n, l->type, r->type, tsub)) |
| goto bad; |
| arith(n, 1); |
| break; |
| |
| case ONEG: |
| if(tcom(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| |
| if(!machcap(n)) { |
| r = l; |
| l = new(OCONST, Z, Z); |
| l->vconst = 0; |
| l->type = types[TINT]; |
| n->op = OSUB; |
| n->right = r; |
| n->left = l; |
| |
| if(tcom(l)) |
| goto bad; |
| if(tcompat(n, l->type, r->type, tsub)) |
| goto bad; |
| } |
| arith(n, 1); |
| break; |
| |
| case OCOM: |
| if(tcom(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| |
| if(!machcap(n)) { |
| r = l; |
| l = new(OCONST, Z, Z); |
| l->vconst = -1; |
| l->type = types[TINT]; |
| n->op = OXOR; |
| n->right = r; |
| n->left = l; |
| |
| if(tcom(l)) |
| goto bad; |
| if(tcompat(n, l->type, r->type, tand)) |
| goto bad; |
| } |
| arith(n, 1); |
| break; |
| |
| case ONOT: |
| if(tcom(l)) |
| goto bad; |
| if(isfunct(n)) |
| break; |
| if(tcompat(n, T, l->type, tnot)) |
| goto bad; |
| n->type = types[TINT]; |
| break; |
| |
| case OANDAND: |
| case OOROR: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| if(tcompat(n, T, l->type, tnot) | |
| tcompat(n, T, r->type, tnot)) |
| goto bad; |
| n->type = types[TINT]; |
| break; |
| |
| case OCOMMA: |
| o = tcom(l); |
| if(o | tcom(r)) |
| goto bad; |
| n->type = r->type; |
| break; |
| |
| |
| case OSIGN: /* extension signof(type) returns a hash */ |
| if(l != Z) { |
| if(l->op != OSTRING && l->op != OLSTRING) |
| if(tcomo(l, 0)) |
| goto bad; |
| if(l->op == OBIT) { |
| diag(n, "signof bitfield"); |
| goto bad; |
| } |
| n->type = l->type; |
| } |
| if(n->type == T) |
| goto bad; |
| if(n->type->width < 0) { |
| diag(n, "signof undefined type"); |
| goto bad; |
| } |
| n->op = OCONST; |
| n->left = Z; |
| n->right = Z; |
| n->vconst = convvtox(signature(n->type), TULONG); |
| n->type = types[TULONG]; |
| break; |
| |
| case OSIZE: |
| if(l != Z) { |
| if(l->op != OSTRING && l->op != OLSTRING) |
| if(tcomo(l, 0)) |
| goto bad; |
| if(l->op == OBIT) { |
| diag(n, "sizeof bitfield"); |
| goto bad; |
| } |
| n->type = l->type; |
| } |
| if(n->type == T) |
| goto bad; |
| if(n->type->width <= 0) { |
| diag(n, "sizeof undefined type"); |
| goto bad; |
| } |
| if(n->type->etype == TFUNC) { |
| diag(n, "sizeof function"); |
| goto bad; |
| } |
| n->op = OCONST; |
| n->left = Z; |
| n->right = Z; |
| n->vconst = convvtox(n->type->width, TINT); |
| n->type = types[TINT]; |
| break; |
| |
| case OFUNC: |
| o = tcomo(l, 0); |
| if(o) |
| goto bad; |
| if(l->type->etype == TIND && l->type->link->etype == TFUNC) { |
| l = new1(OIND, l, Z); |
| l->type = l->left->type->link; |
| n->left = l; |
| } |
| if(tcompat(n, T, l->type, tfunct)) |
| goto bad; |
| if(o | tcoma(l, r, l->type->down, 1)) |
| goto bad; |
| n->type = l->type->link; |
| if(!debug['B']) |
| if(l->type->down == T || l->type->down->etype == TOLD) { |
| nerrors--; |
| diag(n, "function args not checked: %F", l); |
| } |
| dpcheck(n); |
| break; |
| |
| case ONAME: |
| if(n->type == T) { |
| diag(n, "name not declared: %F", n); |
| goto bad; |
| } |
| if(n->type->etype == TENUM) { |
| n->op = OCONST; |
| n->type = n->sym->tenum; |
| if(!typefd[n->type->etype]) |
| n->vconst = n->sym->vconst; |
| else |
| n->fconst = n->sym->fconst; |
| break; |
| } |
| n->addable = 1; |
| if(n->class == CEXREG) { |
| n->op = OREGISTER; |
| // on 386 or amd64, "extern register" generates |
| // memory references relative to the |
| // gs or fs segment. |
| if(thechar == '8' || thechar == '6') // [sic] |
| n->op = OEXREG; |
| n->reg = n->sym->offset; |
| n->xoffset = 0; |
| break; |
| } |
| break; |
| |
| case OLSTRING: |
| if(n->type->link != types[TRUNE]) { |
| o = outstring(0, 0); |
| while(o & 3) { |
| outlstring(&zer, sizeof(TRune)); |
| o = outlstring(0, 0); |
| } |
| } |
| n->op = ONAME; |
| n->xoffset = outlstring(n->rstring, n->type->width); |
| n->addable = 1; |
| break; |
| |
| case OSTRING: |
| if(n->type->link != types[TCHAR]) { |
| o = outstring(0, 0); |
| while(o & 3) { |
| outstring("", 1); |
| o = outstring(0, 0); |
| } |
| } |
| n->op = ONAME; |
| n->xoffset = outstring(n->cstring, n->type->width); |
| n->addable = 1; |
| break; |
| |
| case OCONST: |
| break; |
| |
| case ODOT: |
| if(tcom(l)) |
| goto bad; |
| if(tcompat(n, T, l->type, tdot)) |
| goto bad; |
| if(tcomd(n)) |
| goto bad; |
| break; |
| |
| case OADDR: |
| if(tcomo(l, ADDROP)) |
| goto bad; |
| if(tlvalue(l)) |
| goto bad; |
| if(l->type->nbits) { |
| diag(n, "address of a bit field"); |
| goto bad; |
| } |
| if(l->op == OREGISTER) { |
| diag(n, "address of a register"); |
| goto bad; |
| } |
| n->type = typ(TIND, l->type); |
| n->type->width = types[TIND]->width; |
| break; |
| |
| case OIND: |
| if(tcom(l)) |
| goto bad; |
| if(tcompat(n, T, l->type, tindir)) |
| goto bad; |
| n->type = l->type->link; |
| n->addable = 1; |
| break; |
| |
| case OSTRUCT: |
| if(tcomx(n)) |
| goto bad; |
| break; |
| } |
| t = n->type; |
| if(t == T) |
| goto bad; |
| if(t->width < 0) { |
| snap(t); |
| if(t->width < 0) { |
| if(typesu[t->etype] && t->tag) |
| diag(n, "structure not fully declared %s", t->tag->name); |
| else |
| diag(n, "structure not fully declared"); |
| goto bad; |
| } |
| } |
| if(typeaf[t->etype]) { |
| if(f & ADDROF) |
| goto addaddr; |
| if(f & ADDROP) |
| warn(n, "address of array/func ignored"); |
| } |
| return 0; |
| |
| addaddr: |
| if(tlvalue(n)) |
| goto bad; |
| l = new1(OXXX, Z, Z); |
| *l = *n; |
| n->op = OADDR; |
| if(l->type->etype == TARRAY) |
| l->type = l->type->link; |
| n->left = l; |
| n->right = Z; |
| n->addable = 0; |
| n->type = typ(TIND, l->type); |
| n->type->width = types[TIND]->width; |
| return 0; |
| |
| bad: |
| n->type = T; |
| return 1; |
| } |
| |
| int |
| tcoma(Node *l, Node *n, Type *t, int f) |
| { |
| Node *n1; |
| int o; |
| |
| if(t != T) |
| if(t->etype == TOLD || t->etype == TDOT) /* .../old in prototype */ |
| t = T; |
| if(n == Z) { |
| if(t != T && !sametype(t, types[TVOID])) { |
| diag(n, "not enough function arguments: %F", l); |
| return 1; |
| } |
| return 0; |
| } |
| if(n->op == OLIST) { |
| o = tcoma(l, n->left, t, 0); |
| if(t != T) { |
| t = t->down; |
| if(t == T) |
| t = types[TVOID]; |
| } |
| return o | tcoma(l, n->right, t, 1); |
| } |
| if(f && t != T) |
| tcoma(l, Z, t->down, 0); |
| if(tcom(n) || tcompat(n, T, n->type, targ)) |
| return 1; |
| if(sametype(t, types[TVOID])) { |
| diag(n, "too many function arguments: %F", l); |
| return 1; |
| } |
| if(t != T) { |
| typeext(t, n); |
| if(stcompat(nodproto, t, n->type, tasign)) { |
| diag(l, "argument prototype mismatch \"%T\" for \"%T\": %F", |
| n->type, t, l); |
| return 1; |
| } |
| // switch(t->etype) { |
| // case TCHAR: |
| // case TSHORT: |
| // t = types[TINT]; |
| // break; |
| // |
| // case TUCHAR: |
| // case TUSHORT: |
| // t = types[TUINT]; |
| // break; |
| // } |
| } else { |
| switch(n->type->etype) { |
| case TCHAR: |
| case TSHORT: |
| t = types[TINT]; |
| break; |
| |
| case TUCHAR: |
| case TUSHORT: |
| t = types[TUINT]; |
| break; |
| |
| case TFLOAT: |
| t = types[TDOUBLE]; |
| } |
| } |
| |
| if(t != T && !sametype(t, n->type)) { |
| n1 = new1(OXXX, Z, Z); |
| *n1 = *n; |
| n->op = OCAST; |
| n->left = n1; |
| n->right = Z; |
| n->type = t; |
| n->addable = 0; |
| } |
| return 0; |
| } |
| |
| int |
| tcomd(Node *n) |
| { |
| Type *t; |
| int32 o; |
| |
| o = 0; |
| t = dotsearch(n->sym, n->left->type->link, n, &o); |
| if(t == T) { |
| diag(n, "not a member of struct/union: %F", n); |
| return 1; |
| } |
| makedot(n, t, o); |
| return 0; |
| } |
| |
| int |
| tcomx(Node *n) |
| { |
| Type *t; |
| Node *l, *r, **ar, **al; |
| int e; |
| |
| e = 0; |
| if(n->type->etype != TSTRUCT) { |
| diag(n, "constructor must be a structure"); |
| return 1; |
| } |
| l = invert(n->left); |
| n->left = l; |
| al = &n->left; |
| for(t = n->type->link; t != T; t = t->down) { |
| if(l == Z) { |
| diag(n, "constructor list too short"); |
| return 1; |
| } |
| if(l->op == OLIST) { |
| r = l->left; |
| ar = &l->left; |
| al = &l->right; |
| l = l->right; |
| } else { |
| r = l; |
| ar = al; |
| l = Z; |
| } |
| if(tcom(r)) |
| e++; |
| typeext(t, r); |
| if(tcompat(n, t, r->type, tasign)) |
| e++; |
| constas(n, t, r->type); |
| if(!e && !sametype(t, r->type)) { |
| r = new1(OCAST, r, Z); |
| r->type = t; |
| *ar = r; |
| } |
| } |
| if(l != Z) { |
| diag(n, "constructor list too long"); |
| return 1; |
| } |
| return e; |
| } |
| |
| int |
| tlvalue(Node *n) |
| { |
| |
| if(!n->addable) { |
| diag(n, "not an l-value"); |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* |
| * general rewrite |
| * (IND(ADDR x)) ==> x |
| * (ADDR(IND x)) ==> x |
| * remove some zero operands |
| * remove no op casts |
| * evaluate constants |
| */ |
| void |
| ccom(Node *n) |
| { |
| Node *l, *r; |
| int t; |
| |
| loop: |
| if(n == Z) |
| return; |
| l = n->left; |
| r = n->right; |
| switch(n->op) { |
| |
| case OAS: |
| case OASXOR: |
| case OASAND: |
| case OASOR: |
| case OASMOD: |
| case OASLMOD: |
| case OASLSHR: |
| case OASASHR: |
| case OASASHL: |
| case OASDIV: |
| case OASLDIV: |
| case OASMUL: |
| case OASLMUL: |
| case OASSUB: |
| case OASADD: |
| ccom(l); |
| ccom(r); |
| if(n->op == OASLSHR || n->op == OASASHR || n->op == OASASHL) |
| if(r->op == OCONST) { |
| t = n->type->width * 8; /* bits per byte */ |
| if(r->vconst >= t || r->vconst < 0) |
| warn(n, "stupid shift: %lld", r->vconst); |
| } |
| break; |
| |
| case OCAST: |
| ccom(l); |
| if(l->op == OCONST) { |
| evconst(n); |
| if(n->op == OCONST) |
| break; |
| } |
| if(nocast(l->type, n->type)) { |
| l->type = n->type; |
| *n = *l; |
| } |
| break; |
| |
| case OCOND: |
| ccom(l); |
| ccom(r); |
| if(l->op == OCONST) |
| if(vconst(l) == 0) |
| *n = *r->right; |
| else |
| *n = *r->left; |
| break; |
| |
| case OREGISTER: |
| case OINDREG: |
| case OCONST: |
| case ONAME: |
| break; |
| |
| case OADDR: |
| ccom(l); |
| l->etype = TVOID; |
| if(l->op == OIND) { |
| l->left->type = n->type; |
| *n = *l->left; |
| break; |
| } |
| goto common; |
| |
| case OIND: |
| ccom(l); |
| if(l->op == OADDR) { |
| l->left->type = n->type; |
| *n = *l->left; |
| break; |
| } |
| goto common; |
| |
| case OEQ: |
| case ONE: |
| |
| case OLE: |
| case OGE: |
| case OLT: |
| case OGT: |
| |
| case OLS: |
| case OHS: |
| case OLO: |
| case OHI: |
| ccom(l); |
| ccom(r); |
| if(compar(n, 0) || compar(n, 1)) |
| break; |
| relcon(l, r); |
| relcon(r, l); |
| goto common; |
| |
| case OASHR: |
| case OASHL: |
| case OLSHR: |
| ccom(l); |
| if(vconst(l) == 0 && !side(r)) { |
| *n = *l; |
| break; |
| } |
| ccom(r); |
| if(vconst(r) == 0) { |
| *n = *l; |
| break; |
| } |
| if(r->op == OCONST) { |
| t = n->type->width * 8; /* bits per byte */ |
| if(r->vconst >= t || r->vconst <= -t) |
| warn(n, "stupid shift: %lld", r->vconst); |
| } |
| goto common; |
| |
| case OMUL: |
| case OLMUL: |
| ccom(l); |
| t = vconst(l); |
| if(t == 0 && !side(r)) { |
| *n = *l; |
| break; |
| } |
| if(t == 1) { |
| *n = *r; |
| goto loop; |
| } |
| ccom(r); |
| t = vconst(r); |
| if(t == 0 && !side(l)) { |
| *n = *r; |
| break; |
| } |
| if(t == 1) { |
| *n = *l; |
| break; |
| } |
| goto common; |
| |
| case ODIV: |
| case OLDIV: |
| ccom(l); |
| if(vconst(l) == 0 && !side(r)) { |
| *n = *l; |
| break; |
| } |
| ccom(r); |
| t = vconst(r); |
| if(t == 0) { |
| diag(n, "divide check"); |
| *n = *r; |
| break; |
| } |
| if(t == 1) { |
| *n = *l; |
| break; |
| } |
| goto common; |
| |
| case OSUB: |
| ccom(r); |
| if(r->op == OCONST) { |
| if(typefd[r->type->etype]) { |
| n->op = OADD; |
| r->fconst = -r->fconst; |
| goto loop; |
| } else { |
| n->op = OADD; |
| r->vconst = -r->vconst; |
| goto loop; |
| } |
| } |
| ccom(l); |
| goto common; |
| |
| case OXOR: |
| case OOR: |
| case OADD: |
| ccom(l); |
| if(vconst(l) == 0) { |
| *n = *r; |
| goto loop; |
| } |
| ccom(r); |
| if(vconst(r) == 0) { |
| *n = *l; |
| break; |
| } |
| goto commute; |
| |
| case OAND: |
| ccom(l); |
| ccom(r); |
| if(vconst(l) == 0 && !side(r)) { |
| *n = *l; |
| break; |
| } |
| if(vconst(r) == 0 && !side(l)) { |
| *n = *r; |
| break; |
| } |
| |
| commute: |
| /* look for commutative constant */ |
| if(r->op == OCONST) { |
| if(l->op == n->op) { |
| if(l->left->op == OCONST) { |
| n->right = l->right; |
| l->right = r; |
| goto loop; |
| } |
| if(l->right->op == OCONST) { |
| n->right = l->left; |
| l->left = r; |
| goto loop; |
| } |
| } |
| } |
| if(l->op == OCONST) { |
| if(r->op == n->op) { |
| if(r->left->op == OCONST) { |
| n->left = r->right; |
| r->right = l; |
| goto loop; |
| } |
| if(r->right->op == OCONST) { |
| n->left = r->left; |
| r->left = l; |
| goto loop; |
| } |
| } |
| } |
| goto common; |
| |
| case OANDAND: |
| ccom(l); |
| if(vconst(l) == 0) { |
| *n = *l; |
| break; |
| } |
| ccom(r); |
| goto common; |
| |
| case OOROR: |
| ccom(l); |
| if(l->op == OCONST && l->vconst != 0) { |
| *n = *l; |
| n->vconst = 1; |
| break; |
| } |
| ccom(r); |
| goto common; |
| |
| default: |
| if(l != Z) |
| ccom(l); |
| if(r != Z) |
| ccom(r); |
| common: |
| if(l != Z) |
| if(l->op != OCONST) |
| break; |
| if(r != Z) |
| if(r->op != OCONST) |
| break; |
| evconst(n); |
| } |
| } |
| |
| /* OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */ |
| static char *cmps[12] = |
| { |
| "==", "!=", "<=", "<=", "<", "<", ">=", ">=", ">", ">", |
| }; |
| |
| /* 128-bit numbers */ |
| typedef struct Big Big; |
| struct Big |
| { |
| vlong a; |
| uvlong b; |
| }; |
| static int |
| cmp(Big x, Big y) |
| { |
| if(x.a != y.a){ |
| if(x.a < y.a) |
| return -1; |
| return 1; |
| } |
| if(x.b != y.b){ |
| if(x.b < y.b) |
| return -1; |
| return 1; |
| } |
| return 0; |
| } |
| static Big |
| add(Big x, int y) |
| { |
| uvlong ob; |
| |
| ob = x.b; |
| x.b += y; |
| if(y > 0 && x.b < ob) |
| x.a++; |
| if(y < 0 && x.b > ob) |
| x.a--; |
| return x; |
| } |
| |
| Big |
| big(vlong a, uvlong b) |
| { |
| Big x; |
| |
| x.a = a; |
| x.b = b; |
| return x; |
| } |
| |
| int |
| compar(Node *n, int reverse) |
| { |
| Big lo, hi, x; |
| int op; |
| char xbuf[40], cmpbuf[50]; |
| Node *l, *r; |
| Type *lt, *rt; |
| |
| /* |
| * The point of this function is to diagnose comparisons |
| * that can never be true or that look misleading because |
| * of the `usual arithmetic conversions'. As an example |
| * of the latter, if x is a ulong, then if(x <= -1) really means |
| * if(x <= 0xFFFFFFFF), while if(x <= -1LL) really means |
| * what it says (but 8c compiles it wrong anyway). |
| */ |
| |
| if(reverse){ |
| r = n->left; |
| l = n->right; |
| op = comrel[relindex(n->op)]; |
| }else{ |
| l = n->left; |
| r = n->right; |
| op = n->op; |
| } |
| |
| /* |
| * Skip over left casts to find out the original expression range. |
| */ |
| while(l->op == OCAST) |
| l = l->left; |
| if(l->op == OCONST) |
| return 0; |
| lt = l->type; |
| if(l->op == ONAME && l->sym->type){ |
| lt = l->sym->type; |
| if(lt->etype == TARRAY) |
| lt = lt->link; |
| } |
| if(lt == T) |
| return 0; |
| if(lt->etype == TXXX || lt->etype > TUVLONG) |
| return 0; |
| |
| /* |
| * Skip over the right casts to find the on-screen value. |
| */ |
| if(r->op != OCONST) |
| return 0; |
| while(r->oldop == OCAST && !r->xcast) |
| r = r->left; |
| rt = r->type; |
| if(rt == T) |
| return 0; |
| |
| x.b = r->vconst; |
| x.a = 0; |
| if((rt->etype&1) && r->vconst < 0) /* signed negative */ |
| x.a = ~0ULL; |
| |
| if((lt->etype&1)==0){ |
| /* unsigned */ |
| lo = big(0, 0); |
| if(lt->width == 8) |
| hi = big(0, ~0ULL); |
| else |
| hi = big(0, (1ULL<<(l->type->width*8))-1); |
| }else{ |
| lo = big(~0ULL, -(1ULL<<(l->type->width*8-1))); |
| hi = big(0, (1ULL<<(l->type->width*8-1))-1); |
| } |
| |
| switch(op){ |
| case OLT: |
| case OLO: |
| case OGE: |
| case OHS: |
| if(cmp(x, lo) <= 0) |
| goto useless; |
| if(cmp(x, add(hi, 1)) >= 0) |
| goto useless; |
| break; |
| case OLE: |
| case OLS: |
| case OGT: |
| case OHI: |
| if(cmp(x, add(lo, -1)) <= 0) |
| goto useless; |
| if(cmp(x, hi) >= 0) |
| goto useless; |
| break; |
| case OEQ: |
| case ONE: |
| /* |
| * Don't warn about comparisons if the expression |
| * is as wide as the value: the compiler-supplied casts |
| * will make both outcomes possible. |
| */ |
| if(lt->width >= rt->width && debug['w'] < 2) |
| return 0; |
| if(cmp(x, lo) < 0 || cmp(x, hi) > 0) |
| goto useless; |
| break; |
| } |
| return 0; |
| |
| useless: |
| if((x.a==0 && x.b<=9) || (x.a==~0LL && x.b >= -9ULL)) |
| snprint(xbuf, sizeof xbuf, "%lld", x.b); |
| else if(x.a == 0) |
| snprint(xbuf, sizeof xbuf, "%#llux", x.b); |
| else |
| snprint(xbuf, sizeof xbuf, "%#llx", x.b); |
| if(reverse) |
| snprint(cmpbuf, sizeof cmpbuf, "%s %s %T", |
| xbuf, cmps[relindex(n->op)], lt); |
| else |
| snprint(cmpbuf, sizeof cmpbuf, "%T %s %s", |
| lt, cmps[relindex(n->op)], xbuf); |
| warn(n, "useless or misleading comparison: %s", cmpbuf); |
| return 0; |
| } |
| |