| |
| /* Compiler implementation of the D programming language |
| * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved |
| * written by Walter Bright |
| * http://www.digitalmars.com |
| * Distributed under the Boost Software License, Version 1.0 |
| * http://www.boost.org/LICENSE_1_0.txt |
| * https://github.com/D-Programming-Language/dmd/blob/master/src/optimize.c |
| */ |
| |
| #include "root/dsystem.h" |
| |
| #include "root/checkedint.h" |
| #include "lexer.h" |
| #include "mtype.h" |
| #include "expression.h" |
| #include "declaration.h" |
| #include "aggregate.h" |
| #include "init.h" |
| #include "enum.h" |
| #include "ctfe.h" |
| #include "errors.h" |
| |
| /************************************* |
| * If variable has a const initializer, |
| * return that initializer. |
| */ |
| |
| Expression *expandVar(int result, VarDeclaration *v) |
| { |
| //printf("expandVar(result = %d, v = %p, %s)\n", result, v, v ? v->toChars() : "null"); |
| |
| Expression *e = NULL; |
| if (!v) |
| return e; |
| if (!v->originalType && v->semanticRun < PASSsemanticdone) // semantic() not yet run |
| dsymbolSemantic(v, NULL); |
| |
| if (v->isConst() || v->isImmutable() || v->storage_class & STCmanifest) |
| { |
| if (!v->type) |
| { |
| return e; |
| } |
| Type *tb = v->type->toBasetype(); |
| if (v->storage_class & STCmanifest || |
| v->type->toBasetype()->isscalar() || |
| ((result & WANTexpand) && (tb->ty != Tsarray && tb->ty != Tstruct)) |
| ) |
| { |
| if (v->_init) |
| { |
| if (v->inuse) |
| { |
| if (v->storage_class & STCmanifest) |
| { |
| v->error("recursive initialization of constant"); |
| goto Lerror; |
| } |
| goto L1; |
| } |
| Expression *ei = v->getConstInitializer(); |
| if (!ei) |
| { |
| if (v->storage_class & STCmanifest) |
| { |
| v->error("enum cannot be initialized with %s", v->_init->toChars()); |
| goto Lerror; |
| } |
| goto L1; |
| } |
| if (ei->op == TOKconstruct || ei->op == TOKblit) |
| { |
| AssignExp *ae = (AssignExp *)ei; |
| ei = ae->e2; |
| if (ei->isConst() == 1) |
| { |
| } |
| else if (ei->op == TOKstring) |
| { |
| // Bugzilla 14459: We should not constfold the string literal |
| // if it's typed as a C string, because the value expansion |
| // will drop the pointer identity. |
| if (!(result & WANTexpand) && ei->type->toBasetype()->ty == Tpointer) |
| goto L1; |
| } |
| else |
| goto L1; |
| |
| if (ei->type == v->type) |
| { |
| // const variable initialized with const expression |
| } |
| else if (ei->implicitConvTo(v->type) >= MATCHconst) |
| { |
| // const var initialized with non-const expression |
| ei = ei->implicitCastTo(NULL, v->type); |
| ei = expressionSemantic(ei, NULL); |
| } |
| else |
| goto L1; |
| } |
| else if (!(v->storage_class & STCmanifest) && |
| ei->isConst() != 1 && ei->op != TOKstring && |
| ei->op != TOKaddress) |
| { |
| goto L1; |
| } |
| if (!ei->type) |
| { |
| goto L1; |
| } |
| else |
| { |
| // Should remove the copy() operation by |
| // making all mods to expressions copy-on-write |
| e = ei->copy(); |
| } |
| } |
| else |
| { |
| goto L1; |
| } |
| if (e->type != v->type) |
| { |
| e = e->castTo(NULL, v->type); |
| } |
| v->inuse++; |
| e = e->optimize(result); |
| v->inuse--; |
| } |
| } |
| L1: |
| //if (e) printf("\te = %p, %s, e->type = %d, %s\n", e, e->toChars(), e->type->ty, e->type->toChars()); |
| return e; |
| |
| Lerror: |
| return new ErrorExp(); |
| } |
| |
| |
| Expression *fromConstInitializer(int result, Expression *e1) |
| { |
| //printf("fromConstInitializer(result = %x, %s)\n", result, e1->toChars()); |
| //static int xx; if (xx++ == 10) assert(0); |
| Expression *e = e1; |
| if (e1->op == TOKvar) |
| { |
| VarExp *ve = (VarExp *)e1; |
| VarDeclaration *v = ve->var->isVarDeclaration(); |
| e = expandVar(result, v); |
| if (e) |
| { |
| // If it is a comma expression involving a declaration, we mustn't |
| // perform a copy -- we'd get two declarations of the same variable. |
| // See bugzilla 4465. |
| if (e->op == TOKcomma && ((CommaExp *)e)->e1->op == TOKdeclaration) |
| e = e1; |
| else |
| |
| if (e->type != e1->type && e1->type && e1->type->ty != Tident) |
| { |
| // Type 'paint' operation |
| e = e->copy(); |
| e->type = e1->type; |
| } |
| e->loc = e1->loc; |
| } |
| else |
| { |
| e = e1; |
| } |
| } |
| return e; |
| } |
| |
| Expression *Expression_optimize(Expression *e, int result, bool keepLvalue) |
| { |
| class OptimizeVisitor : public Visitor |
| { |
| public: |
| int result; |
| bool keepLvalue; |
| Expression *ret; |
| |
| OptimizeVisitor(int result, bool keepLvalue) |
| : result(result), keepLvalue(keepLvalue) |
| { |
| } |
| |
| void error() |
| { |
| ret = new ErrorExp(); |
| } |
| |
| bool expOptimize(Expression *&e, int flags, bool keepLvalue = false) |
| { |
| if (!e) |
| return false; |
| Expression *ex = e->optimize(flags, keepLvalue); |
| if (ex->op == TOKerror) |
| { |
| ret = ex; // store error result |
| return true; |
| } |
| else |
| { |
| e = ex; // modify original |
| return false; |
| } |
| } |
| |
| bool unaOptimize(UnaExp *e, int flags) |
| { |
| return expOptimize(e->e1, flags); |
| } |
| |
| bool binOptimize(BinExp *e, int flags) |
| { |
| expOptimize(e->e1, flags); |
| expOptimize(e->e2, flags); |
| return ret->op == TOKerror; |
| } |
| |
| void visit(Expression *) |
| { |
| //printf("Expression::optimize(result = x%x) %s\n", result, e->toChars()); |
| } |
| |
| void visit(VarExp *e) |
| { |
| if (keepLvalue) |
| { |
| VarDeclaration *v = e->var->isVarDeclaration(); |
| if (v && !(v->storage_class & STCmanifest)) |
| return; |
| } |
| ret = fromConstInitializer(result, e); |
| } |
| |
| void visit(TupleExp *e) |
| { |
| expOptimize(e->e0, WANTvalue); |
| for (size_t i = 0; i < e->exps->length; i++) |
| { |
| expOptimize((*e->exps)[i], WANTvalue); |
| } |
| } |
| |
| void visit(ArrayLiteralExp *e) |
| { |
| if (e->elements) |
| { |
| expOptimize(e->basis, result & WANTexpand); |
| for (size_t i = 0; i < e->elements->length; i++) |
| { |
| expOptimize((*e->elements)[i], result & WANTexpand); |
| } |
| } |
| } |
| |
| void visit(AssocArrayLiteralExp *e) |
| { |
| assert(e->keys->length == e->values->length); |
| for (size_t i = 0; i < e->keys->length; i++) |
| { |
| expOptimize((*e->keys)[i], result & WANTexpand); |
| expOptimize((*e->values)[i], result & WANTexpand); |
| } |
| } |
| |
| void visit(StructLiteralExp *e) |
| { |
| if (e->stageflags & stageOptimize) return; |
| int old = e->stageflags; |
| e->stageflags |= stageOptimize; |
| if (e->elements) |
| { |
| for (size_t i = 0; i < e->elements->length; i++) |
| { |
| expOptimize((*e->elements)[i], result & WANTexpand); |
| } |
| } |
| e->stageflags = old; |
| } |
| |
| void visit(UnaExp *e) |
| { |
| //printf("UnaExp::optimize() %s\n", e->toChars()); |
| if (unaOptimize(e, result)) |
| return; |
| } |
| |
| void visit(NegExp *e) |
| { |
| if (unaOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1) |
| { |
| ret = Neg(e->type, e->e1).copy(); |
| } |
| } |
| |
| void visit(ComExp *e) |
| { |
| if (unaOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1) |
| { |
| ret = Com(e->type, e->e1).copy(); |
| } |
| } |
| |
| void visit(NotExp *e) |
| { |
| if (unaOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1) |
| { |
| ret = Not(e->type, e->e1).copy(); |
| } |
| } |
| |
| void visit(SymOffExp *e) |
| { |
| assert(e->var); |
| } |
| |
| void visit(AddrExp *e) |
| { |
| //printf("AddrExp::optimize(result = %d) %s\n", result, e->toChars()); |
| |
| /* Rewrite &(a,b) as (a,&b) |
| */ |
| if (e->e1->op == TOKcomma) |
| { |
| CommaExp *ce = (CommaExp *)e->e1; |
| AddrExp *ae = new AddrExp(e->loc, ce->e2, e->type); |
| ret = new CommaExp(ce->loc, ce->e1, ae); |
| ret->type = e->type; |
| return; |
| } |
| |
| // Keep lvalue-ness |
| if (expOptimize(e->e1, result, true)) |
| return; |
| |
| // Convert &*ex to ex |
| if (e->e1->op == TOKstar) |
| { |
| Expression *ex = ((PtrExp *)e->e1)->e1; |
| if (e->type->equals(ex->type)) |
| ret = ex; |
| else if (e->type->toBasetype()->equivalent(ex->type->toBasetype())) |
| { |
| ret = ex->copy(); |
| ret->type = e->type; |
| } |
| return; |
| } |
| if (e->e1->op == TOKvar) |
| { |
| VarExp *ve = (VarExp *)e->e1; |
| if (!ve->var->isOut() && !ve->var->isRef() && |
| !ve->var->isImportedSymbol()) |
| { |
| ret = new SymOffExp(e->loc, ve->var, 0, ve->hasOverloads); |
| ret->type = e->type; |
| return; |
| } |
| } |
| if (e->e1->op == TOKindex) |
| { |
| // Convert &array[n] to &array+n |
| IndexExp *ae = (IndexExp *)e->e1; |
| |
| if (ae->e2->op == TOKint64 && ae->e1->op == TOKvar) |
| { |
| sinteger_t index = ae->e2->toInteger(); |
| VarExp *ve = (VarExp *)ae->e1; |
| if (ve->type->ty == Tsarray |
| && !ve->var->isImportedSymbol()) |
| { |
| TypeSArray *ts = (TypeSArray *)ve->type; |
| sinteger_t dim = ts->dim->toInteger(); |
| if (index < 0 || index >= dim) |
| { |
| e->error("array index %lld is out of bounds [0..%lld]", index, dim); |
| return error(); |
| } |
| |
| bool overflow = false; |
| const d_uns64 offset = mulu(index, ts->nextOf()->size(e->loc), overflow); |
| if (overflow) |
| { |
| e->error("array offset overflow"); |
| return error(); |
| } |
| |
| ret = new SymOffExp(e->loc, ve->var, offset); |
| ret->type = e->type; |
| return; |
| } |
| } |
| } |
| } |
| |
| void visit(PtrExp *e) |
| { |
| //printf("PtrExp::optimize(result = x%x) %s\n", result, e->toChars()); |
| if (expOptimize(e->e1, result)) |
| return; |
| // Convert *&ex to ex |
| // But only if there is no type punning involved |
| if (e->e1->op == TOKaddress) |
| { |
| Expression *ex = ((AddrExp *)e->e1)->e1; |
| if (e->type->equals(ex->type)) |
| ret = ex; |
| else if (e->type->toBasetype()->equivalent(ex->type->toBasetype())) |
| { |
| ret = ex->copy(); |
| ret->type = e->type; |
| } |
| } |
| if (keepLvalue) |
| return; |
| |
| // Constant fold *(&structliteral + offset) |
| if (e->e1->op == TOKadd) |
| { |
| Expression *ex = Ptr(e->type, e->e1).copy(); |
| if (!CTFEExp::isCantExp(ex)) |
| { |
| ret = ex; |
| return; |
| } |
| } |
| |
| if (e->e1->op == TOKsymoff) |
| { |
| SymOffExp *se = (SymOffExp *)e->e1; |
| VarDeclaration *v = se->var->isVarDeclaration(); |
| Expression *ex = expandVar(result, v); |
| if (ex && ex->op == TOKstructliteral) |
| { |
| StructLiteralExp *sle = (StructLiteralExp *)ex; |
| ex = sle->getField(e->type, (unsigned)se->offset); |
| if (ex && !CTFEExp::isCantExp(ex)) |
| { |
| ret = ex; |
| return; |
| } |
| } |
| } |
| } |
| |
| void visit(DotVarExp *e) |
| { |
| //printf("DotVarExp::optimize(result = x%x) %s\n", result, e->toChars()); |
| if (expOptimize(e->e1, result)) |
| return; |
| if (keepLvalue) |
| return; |
| |
| Expression *ex = e->e1; |
| |
| if (ex->op == TOKvar) |
| { |
| VarExp *ve = (VarExp *)ex; |
| VarDeclaration *v = ve->var->isVarDeclaration(); |
| ex = expandVar(result, v); |
| } |
| |
| if (ex && ex->op == TOKstructliteral) |
| { |
| StructLiteralExp *sle = (StructLiteralExp *)ex; |
| VarDeclaration *vf = e->var->isVarDeclaration(); |
| if (vf && !vf->overlapped) |
| { |
| /* Bugzilla 13021: Prevent optimization if vf has overlapped fields. |
| */ |
| ex = sle->getField(e->type, vf->offset); |
| if (ex && !CTFEExp::isCantExp(ex)) |
| { |
| ret = ex; |
| return; |
| } |
| } |
| } |
| } |
| |
| void visit(NewExp *e) |
| { |
| expOptimize(e->thisexp, WANTvalue); |
| |
| // Optimize parameters |
| if (e->newargs) |
| { |
| for (size_t i = 0; i < e->newargs->length; i++) |
| { |
| expOptimize((*e->newargs)[i], WANTvalue); |
| } |
| } |
| |
| if (e->arguments) |
| { |
| for (size_t i = 0; i < e->arguments->length; i++) |
| { |
| expOptimize((*e->arguments)[i], WANTvalue); |
| } |
| } |
| } |
| |
| void visit(CallExp *e) |
| { |
| //printf("CallExp::optimize(result = %d) %s\n", result, e->toChars()); |
| |
| // Optimize parameters with keeping lvalue-ness |
| if (expOptimize(e->e1, result)) |
| return; |
| if (e->arguments) |
| { |
| Type *t1 = e->e1->type->toBasetype(); |
| if (t1->ty == Tdelegate) t1 = t1->nextOf(); |
| assert(t1->ty == Tfunction); |
| TypeFunction *tf = (TypeFunction *)t1; |
| for (size_t i = 0; i < e->arguments->length; i++) |
| { |
| Parameter *p = tf->parameterList[i]; |
| bool keep = p && (p->storageClass & (STCref | STCout)) != 0; |
| expOptimize((*e->arguments)[i], WANTvalue, keep); |
| } |
| } |
| } |
| |
| void visit(CastExp *e) |
| { |
| //printf("CastExp::optimize(result = %d) %s\n", result, e->toChars()); |
| //printf("from %s to %s\n", e->type->toChars(), e->to->toChars()); |
| //printf("from %s\n", e->type->toChars()); |
| //printf("e1->type %s\n", e->e1->type->toChars()); |
| //printf("type = %p\n", e->type); |
| assert(e->type); |
| TOK op1 = e->e1->op; |
| |
| Expression *e1old = e->e1; |
| if (expOptimize(e->e1, result)) |
| return; |
| e->e1 = fromConstInitializer(result, e->e1); |
| |
| if (e->e1 == e1old && |
| e->e1->op == TOKarrayliteral && |
| e->type->toBasetype()->ty == Tpointer && |
| e->e1->type->toBasetype()->ty != Tsarray) |
| { |
| // Casting this will result in the same expression, and |
| // infinite loop because of Expression::implicitCastTo() |
| return; // no change |
| } |
| |
| if ((e->e1->op == TOKstring || e->e1->op == TOKarrayliteral) && |
| (e->type->ty == Tpointer || e->type->ty == Tarray)) |
| { |
| const d_uns64 esz = e->type->nextOf()->size(e->loc); |
| const d_uns64 e1sz = e->e1->type->toBasetype()->nextOf()->size(e->e1->loc); |
| if (esz == SIZE_INVALID || e1sz == SIZE_INVALID) |
| return error(); |
| |
| if (e1sz == esz) |
| { |
| // Bugzilla 12937: If target type is void array, trying to paint |
| // e->e1 with that type will cause infinite recursive optimization. |
| if (e->type->nextOf()->ty == Tvoid) |
| return; |
| |
| ret = e->e1->castTo(NULL, e->type); |
| //printf(" returning1 %s\n", ret->toChars()); |
| return; |
| } |
| } |
| |
| if (e->e1->op == TOKstructliteral && |
| e->e1->type->implicitConvTo(e->type) >= MATCHconst) |
| { |
| //printf(" returning2 %s\n", e->e1->toChars()); |
| L1: // Returning e1 with changing its type |
| ret = (e1old == e->e1 ? e->e1->copy() : e->e1); |
| ret->type = e->type; |
| return; |
| } |
| |
| /* The first test here is to prevent infinite loops |
| */ |
| if (op1 != TOKarrayliteral && e->e1->op == TOKarrayliteral) |
| { |
| ret = e->e1->castTo(NULL, e->to); |
| return; |
| } |
| if (e->e1->op == TOKnull && |
| (e->type->ty == Tpointer || e->type->ty == Tclass || e->type->ty == Tarray)) |
| { |
| //printf(" returning3 %s\n", e->e1->toChars()); |
| goto L1; |
| } |
| |
| if (e->type->ty == Tclass && e->e1->type->ty == Tclass) |
| { |
| // See if we can remove an unnecessary cast |
| ClassDeclaration *cdfrom = e->e1->type->isClassHandle(); |
| ClassDeclaration *cdto = e->type->isClassHandle(); |
| if (cdto == ClassDeclaration::object && !cdfrom->isInterfaceDeclaration()) |
| goto L1; // can always convert a class to Object |
| // Need to determine correct offset before optimizing away the cast. |
| // https://issues.dlang.org/show_bug.cgi?id=16980 |
| cdfrom->size(e->loc); |
| assert(cdfrom->sizeok == SIZEOKdone); |
| assert(cdto->sizeok == SIZEOKdone || !cdto->isBaseOf(cdfrom, NULL)); |
| int offset; |
| if (cdto->isBaseOf(cdfrom, &offset) && offset == 0) |
| { |
| //printf(" returning4 %s\n", e->e1->toChars()); |
| goto L1; |
| } |
| } |
| |
| // We can convert 'head const' to mutable |
| if (e->to->mutableOf()->constOf()->equals(e->e1->type->mutableOf()->constOf())) |
| { |
| //printf(" returning5 %s\n", e->e1->toChars()); |
| goto L1; |
| } |
| |
| if (e->e1->isConst()) |
| { |
| if (e->e1->op == TOKsymoff) |
| { |
| if (e->type->toBasetype()->ty != Tsarray) |
| { |
| const d_uns64 esz = e->type->size(e->loc); |
| const d_uns64 e1sz = e->e1->type->size(e->e1->loc); |
| if (esz == SIZE_INVALID || |
| e1sz == SIZE_INVALID) |
| return error(); |
| |
| if (esz == e1sz) |
| goto L1; |
| } |
| return; |
| } |
| if (e->to->toBasetype()->ty != Tvoid) |
| { |
| if (e->e1->type->equals(e->type) && e->type->equals(e->to)) |
| ret = e->e1; |
| else |
| ret = Cast(e->loc, e->type, e->to, e->e1).copy(); |
| } |
| } |
| //printf(" returning6 %s\n", ret->toChars()); |
| } |
| |
| void visit(BinExp *e) |
| { |
| //printf("BinExp::optimize(result = %d) %s\n", result, e->toChars()); |
| // don't replace const variable with its initializer in e1 |
| bool e2only = (e->op == TOKconstruct || e->op == TOKblit); |
| if (e2only ? expOptimize(e->e2, result) : binOptimize(e, result)) |
| return; |
| |
| if (e->op == TOKshlass || e->op == TOKshrass || e->op == TOKushrass) |
| { |
| if (e->e2->isConst() == 1) |
| { |
| sinteger_t i2 = e->e2->toInteger(); |
| d_uns64 sz = e->e1->type->size(e->e1->loc); |
| assert(sz != SIZE_INVALID); |
| sz *= 8; |
| if (i2 < 0 || (d_uns64)i2 >= sz) |
| { |
| e->error("shift assign by %lld is outside the range 0..%llu", i2, (ulonglong)sz - 1); |
| return error(); |
| } |
| } |
| } |
| } |
| |
| void visit(AddExp *e) |
| { |
| //printf("AddExp::optimize(%s)\n", e->toChars()); |
| |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() && e->e2->isConst()) |
| { |
| if (e->e1->op == TOKsymoff && e->e2->op == TOKsymoff) |
| return; |
| ret = Add(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void visit(MinExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() && e->e2->isConst()) |
| { |
| if (e->e2->op == TOKsymoff) |
| return; |
| ret = Min(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void visit(MulExp *e) |
| { |
| //printf("MulExp::optimize(result = %d) %s\n", result, e->toChars()); |
| |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| { |
| ret = Mul(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void visit(DivExp *e) |
| { |
| //printf("DivExp::optimize(%s)\n", e->toChars()); |
| |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| { |
| ret = Div(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void visit(ModExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| { |
| ret = Mod(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void shift_optimize(BinExp *e, UnionExp (*shift)(Loc, Type *, Expression *, Expression *)) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e2->isConst() == 1) |
| { |
| sinteger_t i2 = e->e2->toInteger(); |
| d_uns64 sz = e->e1->type->size(); |
| assert(sz != SIZE_INVALID); |
| sz *= 8; |
| if (i2 < 0 || (d_uns64)i2 >= sz) |
| { |
| e->error("shift by %lld is outside the range 0..%llu", i2, (ulonglong)sz - 1); |
| return error(); |
| } |
| if (e->e1->isConst() == 1) |
| ret = (*shift)(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| } |
| |
| void visit(ShlExp *e) |
| { |
| //printf("ShlExp::optimize(result = %d) %s\n", result, e->toChars()); |
| shift_optimize(e, &Shl); |
| } |
| |
| void visit(ShrExp *e) |
| { |
| //printf("ShrExp::optimize(result = %d) %s\n", result, e->toChars()); |
| shift_optimize(e, &Shr); |
| } |
| |
| void visit(UshrExp *e) |
| { |
| //printf("UshrExp::optimize(result = %d) %s\n", result, toChars()); |
| shift_optimize(e, &Ushr); |
| } |
| |
| void visit(AndExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| ret = And(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| |
| void visit(OrExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| ret = Or(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| |
| void visit(XorExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| ret = Xor(e->loc, e->type, e->e1, e->e2).copy(); |
| } |
| |
| void visit(PowExp *e) |
| { |
| if (binOptimize(e, result)) |
| return; |
| |
| // Replace 1 ^^ x or 1.0^^x by (x, 1) |
| if ((e->e1->op == TOKint64 && e->e1->toInteger() == 1) || |
| (e->e1->op == TOKfloat64 && e->e1->toReal() == CTFloat::one)) |
| { |
| ret = new CommaExp(e->loc, e->e2, e->e1); |
| ret->type = e->type; |
| return; |
| } |
| |
| // Replace -1 ^^ x by (x&1) ? -1 : 1, where x is integral |
| if (e->e2->type->isintegral() && e->e1->op == TOKint64 && (sinteger_t)e->e1->toInteger() == -1L) |
| { |
| ret = new AndExp(e->loc, e->e2, new IntegerExp(e->loc, 1, e->e2->type)); |
| ret->type = e->e2->type; |
| ret = new CondExp(e->loc, ret, new IntegerExp(e->loc, -1L, e->type), new IntegerExp(e->loc, 1L, e->type)); |
| ret->type = e->type; |
| return; |
| } |
| |
| // Replace x ^^ 0 or x^^0.0 by (x, 1) |
| if ((e->e2->op == TOKint64 && e->e2->toInteger() == 0) || |
| (e->e2->op == TOKfloat64 && e->e2->toReal() == CTFloat::zero)) |
| { |
| if (e->e1->type->isintegral()) |
| ret = new IntegerExp(e->loc, 1, e->e1->type); |
| else |
| ret = new RealExp(e->loc, CTFloat::one, e->e1->type); |
| |
| ret = new CommaExp(e->loc, e->e1, ret); |
| ret->type = e->type; |
| return; |
| } |
| |
| // Replace x ^^ 1 or x^^1.0 by (x) |
| if ((e->e2->op == TOKint64 && e->e2->toInteger() == 1) || |
| (e->e2->op == TOKfloat64 && e->e2->toReal() == CTFloat::one)) |
| { |
| ret = e->e1; |
| return; |
| } |
| |
| // Replace x ^^ -1.0 by (1.0 / x) |
| if ((e->e2->op == TOKfloat64 && e->e2->toReal() == CTFloat::minusone)) |
| { |
| ret = new DivExp(e->loc, new RealExp(e->loc, CTFloat::one, e->e2->type), e->e1); |
| ret->type = e->type; |
| return; |
| } |
| |
| // All other negative integral powers are illegal |
| if ((e->e1->type->isintegral()) && (e->e2->op == TOKint64) && (sinteger_t)e->e2->toInteger() < 0) |
| { |
| e->error("cannot raise %s to a negative integer power. Did you mean (cast(real)%s)^^%s ?", |
| e->e1->type->toBasetype()->toChars(), e->e1->toChars(), e->e2->toChars()); |
| return error(); |
| } |
| |
| // If e2 *could* have been an integer, make it one. |
| if (e->e2->op == TOKfloat64 && (e->e2->toReal() == ldouble((sinteger_t)e->e2->toReal()))) |
| e->e2 = new IntegerExp(e->loc, e->e2->toInteger(), Type::tint64); |
| |
| if (e->e1->isConst() == 1 && e->e2->isConst() == 1) |
| { |
| Expression *ex = Pow(e->loc, e->type, e->e1, e->e2).copy(); |
| if (!CTFEExp::isCantExp(ex)) |
| { |
| ret = ex; |
| return; |
| } |
| } |
| |
| // (2 ^^ n) ^^ p -> 1 << n * p |
| if (e->e1->op == TOKint64 && e->e1->toInteger() > 0 && |
| !((e->e1->toInteger() - 1) & e->e1->toInteger()) && |
| e->e2->type->isintegral() && e->e2->type->isunsigned()) |
| { |
| dinteger_t i = e->e1->toInteger(); |
| dinteger_t mul = 1; |
| while ((i >>= 1) > 1) |
| mul++; |
| Expression *shift = new MulExp(e->loc, e->e2, new IntegerExp(e->loc, mul, e->e2->type)); |
| shift->type = e->e2->type; |
| shift = shift->castTo(NULL, Type::tshiftcnt); |
| ret = new ShlExp(e->loc, new IntegerExp(e->loc, 1, e->e1->type), shift); |
| ret->type = e->type; |
| return; |
| } |
| } |
| |
| void visit(CommaExp *e) |
| { |
| //printf("CommaExp::optimize(result = %d) %s\n", result, e->toChars()); |
| // Comma needs special treatment, because it may |
| // contain compiler-generated declarations. We can interpret them, but |
| // otherwise we must NOT attempt to constant-fold them. |
| // In particular, if the comma returns a temporary variable, it needs |
| // to be an lvalue (this is particularly important for struct constructors) |
| |
| expOptimize(e->e1, WANTvalue); |
| expOptimize(e->e2, result, keepLvalue); |
| if (ret->op == TOKerror) |
| return; |
| |
| if (!e->e1 || e->e1->op == TOKint64 || e->e1->op == TOKfloat64 || !hasSideEffect(e->e1)) |
| { |
| ret = e->e2; |
| if (ret) |
| ret->type = e->type; |
| } |
| |
| //printf("-CommaExp::optimize(result = %d) %s\n", result, e->e->toChars()); |
| } |
| |
| void visit(ArrayLengthExp *e) |
| { |
| //printf("ArrayLengthExp::optimize(result = %d) %s\n", result, e->toChars()); |
| |
| if (unaOptimize(e, WANTexpand)) |
| return; |
| |
| // CTFE interpret static immutable arrays (to get better diagnostics) |
| if (e->e1->op == TOKvar) |
| { |
| VarDeclaration *v = ((VarExp *)e->e1)->var->isVarDeclaration(); |
| if (v && (v->storage_class & STCstatic) && (v->storage_class & STCimmutable) && v->_init) |
| { |
| if (Expression *ci = v->getConstInitializer()) |
| e->e1 = ci; |
| } |
| } |
| |
| if (e->e1->op == TOKstring || e->e1->op == TOKarrayliteral || e->e1->op == TOKassocarrayliteral || |
| e->e1->type->toBasetype()->ty == Tsarray) |
| { |
| ret = ArrayLength(e->type, e->e1).copy(); |
| } |
| } |
| |
| void visit(EqualExp *e) |
| { |
| //printf("EqualExp::optimize(result = %x) %s\n", result, e->toChars()); |
| if (binOptimize(e, WANTvalue)) |
| return; |
| |
| Expression *e1 = fromConstInitializer(result, e->e1); |
| Expression *e2 = fromConstInitializer(result, e->e2); |
| if (e1->op == TOKerror) |
| { |
| ret = e1; |
| return; |
| } |
| if (e2->op == TOKerror) |
| { |
| ret = e2; |
| return; |
| } |
| |
| ret = Equal(e->op, e->loc, e->type, e1, e2).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| |
| void visit(IdentityExp *e) |
| { |
| //printf("IdentityExp::optimize(result = %d) %s\n", result, e->toChars()); |
| |
| if (binOptimize(e, WANTvalue)) |
| return; |
| |
| if ((e->e1->isConst() && e->e2->isConst()) || |
| (e->e1->op == TOKnull && e->e2->op == TOKnull) |
| ) |
| { |
| ret = Identity(e->op, e->loc, e->type, e->e1, e->e2).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| } |
| |
| /* It is possible for constant folding to change an array expression of |
| * unknown length, into one where the length is known. |
| * If the expression 'arr' is a literal, set lengthVar to be its length. |
| */ |
| static void setLengthVarIfKnown(VarDeclaration *lengthVar, Expression *arr) |
| { |
| if (!lengthVar) |
| return; |
| if (lengthVar->_init && !lengthVar->_init->isVoidInitializer()) |
| return; // we have previously calculated the length |
| size_t len; |
| if (arr->op == TOKstring) |
| len = ((StringExp *)arr)->len; |
| else if (arr->op == TOKarrayliteral) |
| len = ((ArrayLiteralExp *)arr)->elements->length; |
| else |
| { |
| Type *t = arr->type->toBasetype(); |
| if (t->ty == Tsarray) |
| len = (size_t)((TypeSArray *)t)->dim->toInteger(); |
| else |
| return; // we don't know the length yet |
| } |
| |
| Expression *dollar = new IntegerExp(Loc(), len, Type::tsize_t); |
| lengthVar->_init = new ExpInitializer(Loc(), dollar); |
| lengthVar->storage_class |= STCstatic | STCconst; |
| } |
| |
| void visit(IndexExp *e) |
| { |
| //printf("IndexExp::optimize(result = %d) %s\n", result, e->toChars()); |
| if (expOptimize(e->e1, result & WANTexpand)) |
| return; |
| |
| Expression *ex = fromConstInitializer(result, e->e1); |
| |
| // We might know $ now |
| setLengthVarIfKnown(e->lengthVar, ex); |
| |
| if (expOptimize(e->e2, WANTvalue)) |
| return; |
| if (keepLvalue) |
| return; |
| ret = Index(e->type, ex, e->e2).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| |
| void visit(SliceExp *e) |
| { |
| //printf("SliceExp::optimize(result = %d) %s\n", result, e->toChars()); |
| if (expOptimize(e->e1, result & WANTexpand)) |
| return; |
| if (!e->lwr) |
| { |
| if (e->e1->op == TOKstring) |
| { |
| // Convert slice of string literal into dynamic array |
| Type *t = e->e1->type->toBasetype(); |
| if (Type *tn = t->nextOf()) |
| ret = e->e1->castTo(NULL, tn->arrayOf()); |
| } |
| } |
| else |
| { |
| e->e1 = fromConstInitializer(result, e->e1); |
| // We might know $ now |
| setLengthVarIfKnown(e->lengthVar, e->e1); |
| expOptimize(e->lwr, WANTvalue); |
| expOptimize(e->upr, WANTvalue); |
| if (ret->op == TOKerror) |
| return; |
| ret = Slice(e->type, e->e1, e->lwr, e->upr).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| |
| // Bugzilla 14649: We need to leave the slice form so it might be |
| // a part of array operation. |
| // Assume that the backend codegen will handle the form `e[]` |
| // as an equal to `e` itself. |
| if (ret->op == TOKstring) |
| { |
| e->e1 = ret; |
| e->lwr = NULL; |
| e->upr = NULL; |
| ret = e; |
| } |
| //printf("-SliceExp::optimize() %s\n", ret->toChars()); |
| } |
| |
| void visit(LogicalExp *e) |
| { |
| //printf("LogicalExp::optimize(%d) %s\n", result, e->toChars()); |
| if (expOptimize(e->e1, WANTvalue)) |
| return; |
| const bool oror = e->op == TOKoror; |
| if (e->e1->isBool(oror)) |
| { |
| // Replace with (e1, oror) |
| ret = new IntegerExp(e->loc, oror, Type::tbool); |
| ret = Expression::combine(e->e1, ret); |
| if (e->type->toBasetype()->ty == Tvoid) |
| { |
| ret = new CastExp(e->loc, ret, Type::tvoid); |
| ret->type = e->type; |
| } |
| ret = ret->optimize(result); |
| return; |
| } |
| |
| if (expOptimize(e->e2, WANTvalue)) |
| return; |
| |
| if (e->e1->isConst()) |
| { |
| if (e->e2->isConst()) |
| { |
| bool n1 = e->e1->isBool(true); |
| bool n2 = e->e2->isBool(true); |
| ret = new IntegerExp(e->loc, oror ? (n1 || n2) : (n1 && n2), e->type); |
| } |
| else if (e->e1->isBool(!oror)) |
| { |
| if (e->type->toBasetype()->ty == Tvoid) |
| ret = e->e2; |
| else |
| { |
| ret = new CastExp(e->loc, e->e2, e->type); |
| ret->type = e->type; |
| } |
| } |
| } |
| } |
| |
| void visit(CmpExp *e) |
| { |
| //printf("CmpExp::optimize() %s\n", e->toChars()); |
| if (binOptimize(e, WANTvalue)) |
| return; |
| |
| Expression *e1 = fromConstInitializer(result, e->e1); |
| Expression *e2 = fromConstInitializer(result, e->e2); |
| |
| ret = Cmp(e->op, e->loc, e->type, e1, e2).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| |
| void visit(CatExp *e) |
| { |
| //printf("CatExp::optimize(%d) %s\n", result, e->toChars()); |
| |
| if (binOptimize(e, result)) |
| return; |
| |
| if (e->e1->op == TOKcat) |
| { |
| // Bugzilla 12798: optimize ((expr ~ str1) ~ str2) |
| CatExp *ce1 = (CatExp *)e->e1; |
| CatExp cex(e->loc, ce1->e2, e->e2); |
| cex.type = e->type; |
| Expression *ex = cex.optimize(result); |
| if (ex != &cex) |
| { |
| e->e1 = ce1->e1; |
| e->e2 = ex; |
| } |
| } |
| |
| // optimize "str"[] -> "str" |
| if (e->e1->op == TOKslice) |
| { |
| SliceExp *se1 = (SliceExp *)e->e1; |
| if (se1->e1->op == TOKstring && !se1->lwr) |
| e->e1 = se1->e1; |
| } |
| if (e->e2->op == TOKslice) |
| { |
| SliceExp *se2 = (SliceExp *)e->e2; |
| if (se2->e1->op == TOKstring && !se2->lwr) |
| e->e2 = se2->e1; |
| } |
| |
| ret = Cat(e->type, e->e1, e->e2).copy(); |
| if (CTFEExp::isCantExp(ret)) |
| ret = e; |
| } |
| |
| void visit(CondExp *e) |
| { |
| if (expOptimize(e->econd, WANTvalue)) |
| return; |
| if (e->econd->isBool(true)) |
| ret = e->e1->optimize(result, keepLvalue); |
| else if (e->econd->isBool(false)) |
| ret = e->e2->optimize(result, keepLvalue); |
| else |
| { |
| expOptimize(e->e1, result, keepLvalue); |
| expOptimize(e->e2, result, keepLvalue); |
| } |
| } |
| }; |
| |
| OptimizeVisitor v(result, keepLvalue); |
| Expression *ex = NULL; |
| v.ret = e; |
| |
| // Optimize the expression until it can no longer be simplified. |
| size_t b = 0; |
| while (1) |
| { |
| if (b++ == global.recursionLimit) |
| { |
| e->error("infinite loop while optimizing expression"); |
| fatal(); |
| } |
| ex = v.ret; |
| ex->accept(&v); |
| if (ex == v.ret) |
| break; |
| } |
| return ex; |
| } |
