/** * Perform constant folding. * * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/optimize.d, _optimize.d) * Documentation: https://dlang.org/phobos/dmd_optimize.html * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/optimize.d */ module dmd.optimize; import core.stdc.stdio; import dmd.astenums; import dmd.constfold; import dmd.ctfeexpr; import dmd.dclass; import dmd.declaration; import dmd.dsymbol; import dmd.dsymbolsem; import dmd.errors; import dmd.expression; import dmd.expressionsem; import dmd.globals; import dmd.init; import dmd.location; import dmd.mtype; import dmd.printast; import dmd.root.ctfloat; import dmd.sideeffect; import dmd.tokens; import dmd.visitor; /************************************* * If variable has a const initializer, * return that initializer. * Returns: * initializer if there is one, * null if not, * ErrorExp if error */ Expression expandVar(int result, VarDeclaration v) { //printf("expandVar(result = %d, v = %p, %s)\n", result, v, v ? v.toChars() : "null"); /******** * Params: * e = initializer expression */ Expression initializerReturn(Expression e) { if (e.type != v.type) { e = e.castTo(null, v.type); } v.inuse++; e = e.optimize(result); v.inuse--; //if (e) printf("\te = %p, %s, e.type = %d, %s\n", e, e.toChars(), e.type.ty, e.type.toChars()); return e; } static Expression nullReturn() { return null; } static Expression errorReturn() { return ErrorExp.get(); } if (!v) return nullReturn(); if (!v.originalType && v.semanticRun < PASS.semanticdone) // semantic() not yet run v.dsymbolSemantic(null); if (v.type && (v.isConst() || v.isImmutable() || v.storage_class & STC.manifest)) { Type tb = v.type.toBasetype(); if (v.storage_class & STC.manifest || tb.isscalar() || ((result & WANTexpand) && (tb.ty != Tsarray && tb.ty != Tstruct))) { if (v._init) { if (v.inuse) { if (v.storage_class & STC.manifest) { v.error("recursive initialization of constant"); return errorReturn(); } return nullReturn(); } Expression ei = v.getConstInitializer(); if (!ei) { if (v.storage_class & STC.manifest) { v.error("enum cannot be initialized with `%s`", v._init.toChars()); return errorReturn(); } return nullReturn(); } if (ei.op == EXP.construct || ei.op == EXP.blit) { AssignExp ae = cast(AssignExp)ei; ei = ae.e2; if (ei.isConst() == 1) { } else if (ei.op == EXP.string_) { // https://issues.dlang.org/show_bug.cgi?id=14459 // Do 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) return nullReturn(); } else return nullReturn(); if (ei.type == v.type) { // const variable initialized with const expression } else if (ei.implicitConvTo(v.type) >= MATCH.constant) { // const var initialized with non-const expression ei = ei.implicitCastTo(null, v.type); ei = ei.expressionSemantic(null); } else return nullReturn(); } else if (!(v.storage_class & STC.manifest) && ei.isConst() != 1 && ei.op != EXP.string_ && ei.op != EXP.address) { return nullReturn(); } if (!ei.type) { return nullReturn(); } else { // Should remove the copy() operation by // making all mods to expressions copy-on-write return initializerReturn(ei.copy()); } } else { // v does not have an initializer version (all) { return nullReturn(); } else { // BUG: what if const is initialized in constructor? auto e = v.type.defaultInit(); e.loc = e1.loc; return initializerReturn(e); } } assert(0); } } return nullReturn(); } private 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 (auto ve = e1.isVarExp()) { 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 == EXP.comma && e.isCommaExp().e1.isDeclarationExp()) 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; } /*** * 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. * Params: * lengthVar = variable declaration for the `.length` property * arr = String, ArrayLiteral, or of TypeSArray */ package void setLengthVarIfKnown(VarDeclaration lengthVar, Expression arr) { if (!lengthVar) return; if (lengthVar._init && !lengthVar._init.isVoidInitializer()) return; // we have previously calculated the length dinteger_t len; if (auto se = arr.isStringExp()) len = se.len; else if (auto ale = arr.isArrayLiteralExp()) len = ale.elements.length; else { auto tsa = arr.type.toBasetype().isTypeSArray(); if (!tsa) return; // we don't know the length yet len = tsa.dim.toInteger(); } Expression dollar = new IntegerExp(Loc.initial, len, Type.tsize_t); lengthVar._init = new ExpInitializer(Loc.initial, dollar); lengthVar.storage_class |= STC.static_ | STC.const_; } /*** * Same as above, but determines the length from 'type'. * Params: * lengthVar = variable declaration for the `.length` property * type = TypeSArray */ package void setLengthVarIfKnown(VarDeclaration lengthVar, Type type) { if (!lengthVar) return; if (lengthVar._init && !lengthVar._init.isVoidInitializer()) return; // we have previously calculated the length auto tsa = type.toBasetype().isTypeSArray(); if (!tsa) return; // we don't know the length yet const len = tsa.dim.toInteger(); Expression dollar = new IntegerExp(Loc.initial, len, Type.tsize_t); lengthVar._init = new ExpInitializer(Loc.initial, dollar); lengthVar.storage_class |= STC.static_ | STC.const_; } /********************************* * Constant fold an Expression. * Params: * e = expression to const fold; this may get modified in-place * result = WANTvalue, WANTexpand, or both * keepLvalue = `e` is an lvalue, and keep it as an lvalue since it is * an argument to a `ref` or `out` parameter, or the operand of `&` operator * Returns: * Constant folded version of `e` */ Expression Expression_optimize(Expression e, int result, bool keepLvalue) { //printf("Expression_optimize() e: %s result: %d keepLvalue %d\n", e.toChars(), result, keepLvalue); Expression ret = e; void error() { ret = ErrorExp.get(); } /* Returns: true if error */ bool expOptimize(ref Expression e, int flags, bool keepLvalue = false) { if (!e) return false; Expression ex = Expression_optimize(e, flags, keepLvalue); if (ex.op == EXP.error) { 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, bool keepLhsLvalue = false) { return expOptimize(e.e1, flags, keepLhsLvalue) | expOptimize(e.e2, flags); } void visitExp(Expression e) { //printf("Expression::optimize(result = x%x) %s\n", result, e.toChars()); } void visitVar(VarExp e) { VarDeclaration v = e.var.isVarDeclaration(); if (!(keepLvalue && v && !(v.storage_class & STC.manifest))) ret = fromConstInitializer(result, e); // if unoptimized, try to optimize the dtor expression // (e.g., might be a LogicalExp with constant lhs) if (ret == e && v && v.edtor) { // prevent infinite recursion (`.~this()`) if (!v.inuse) { v.inuse++; expOptimize(v.edtor, WANTvalue); v.inuse--; } } } void visitTuple(TupleExp e) { expOptimize(e.e0, WANTvalue); foreach (ref ex; (*e.exps)[]) { expOptimize(ex, WANTvalue); } } void visitArrayLiteral(ArrayLiteralExp e) { if (e.elements) { expOptimize(e.basis, result & WANTexpand); foreach (ref ex; (*e.elements)[]) { expOptimize(ex, result & WANTexpand); } } } void visitAssocArrayLiteral(AssocArrayLiteralExp e) { assert(e.keys.length == e.values.length); foreach (i, ref ekey; (*e.keys)[]) { expOptimize(ekey, result & WANTexpand); expOptimize((*e.values)[i], result & WANTexpand); } } void visitStructLiteral(StructLiteralExp e) { if (e.stageflags & stageOptimize) return; int old = e.stageflags; e.stageflags |= stageOptimize; if (e.elements) { foreach (ref ex; (*e.elements)[]) { expOptimize(ex, result & WANTexpand); } } e.stageflags = old; } void visitUna(UnaExp e) { //printf("UnaExp::optimize() %s\n", e.toChars()); if (unaOptimize(e, result)) return; } void visitNeg(NegExp e) { if (unaOptimize(e, result)) return; if (e.e1.isConst() == 1) { ret = Neg(e.type, e.e1).copy(); } } void visitCom(ComExp e) { if (unaOptimize(e, result)) return; if (e.e1.isConst() == 1) { ret = Com(e.type, e.e1).copy(); } } void visitNop(NotExp e) { if (unaOptimize(e, result)) return; if (e.e1.isConst() == 1) { ret = Not(e.type, e.e1).copy(); } } void visitSymOff(SymOffExp e) { assert(e.var); } void visitAddr(AddrExp e) { //printf("AddrExp::optimize(result = %d, keepLvalue = %d) %s\n", result, keepLvalue, e.toChars()); /* Rewrite &(a,b) as (a,&b) */ if (auto ce = e.e1.isCommaExp()) { auto 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; // error return // Convert &*ex to ex if (auto pe = e.e1.isPtrExp()) { Expression ex = pe.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 (auto ve = e.e1.isVarExp()) { if (!ve.var.isReference() && !ve.var.isImportedSymbol()) { ret = new SymOffExp(e.loc, ve.var, 0, ve.hasOverloads); ret.type = e.type; return; } } if (e.e1.isDotVarExp()) { /****************************** * Run down the left side of the a.b.c expression to determine the * leftmost variable being addressed (`a`), and accumulate the offsets of the `.b` and `.c`. * Params: * e = the DotVarExp or VarExp * var = set to the VarExp at the end, or null if doesn't end in VarExp * eint = set to the IntegerExp at the end, or null if doesn't end in IntegerExp * offset = accumulation of all the .var offsets encountered * Returns: true on error */ static bool getVarAndOffset(Expression e, out VarDeclaration var, out IntegerExp eint, ref uint offset) { if (e.type.size() == SIZE_INVALID) // trigger computation of v.offset return true; if (auto dve = e.isDotVarExp()) { auto v = dve.var.isVarDeclaration(); if (!v || !v.isField() || v.isBitFieldDeclaration()) return false; if (getVarAndOffset(dve.e1, var, eint, offset)) return true; offset += v.offset; } else if (auto ve = e.isVarExp()) { if (!ve.var.isReference() && !ve.var.isImportedSymbol() && ve.var.isDataseg() && ve.var.isCsymbol()) { var = ve.var.isVarDeclaration(); } } else if (auto ep = e.isPtrExp()) { if (auto ei = ep.e1.isIntegerExp()) { eint = ei; } else if (auto se = ep.e1.isSymOffExp()) { if (!se.var.isReference() && !se.var.isImportedSymbol() && se.var.isDataseg()) { var = se.var.isVarDeclaration(); offset += se.offset; } } } else if (auto ei = e.isIndexExp()) { if (auto ve = ei.e1.isVarExp()) { if (!ve.var.isReference() && !ve.var.isImportedSymbol() && ve.var.isDataseg() && ve.var.isCsymbol()) { if (auto ie = ei.e2.isIntegerExp()) { var = ve.var.isVarDeclaration(); offset += ie.toInteger() * ve.type.toBasetype().nextOf().size(); } } } } return false; } uint offset; VarDeclaration var; IntegerExp eint; if (getVarAndOffset(e.e1, var, eint, offset)) { ret = ErrorExp.get(); return; } if (var) { ret = new SymOffExp(e.loc, var, offset, false); ret.type = e.type; return; } if (eint) { ret = new IntegerExp(e.loc, eint.toInteger() + offset, e.type); return; } } else if (auto ae = e.e1.isIndexExp()) { if (ae.e2.isIntegerExp() && ae.e1.isIndexExp()) { /* Rewrite `(a[i])[index]` to `(&a[i]) + index*size` */ sinteger_t index = ae.e2.toInteger(); auto ae1 = ae.e1.isIndexExp(); // ae1 is a[i] if (auto ts = ae1.type.isTypeSArray()) { 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(); } import core.checkedint : mulu; bool overflow; const offset = mulu(index, ts.nextOf().size(e.loc), overflow); // offset = index*size if (overflow) { e.error("array offset overflow"); return error(); } Expression ex = new AddrExp(ae1.loc, ae1); // &a[i] ex.type = ae1.type.pointerTo(); Expression add = new AddExp(ae.loc, ex, new IntegerExp(ae.e2.loc, offset, ae.e2.type)); add.type = e.type; ret = Expression_optimize(add, result, keepLvalue); return; } } // Convert &array[n] to &array+n if (ae.e2.isIntegerExp() && ae.e1.isVarExp()) { sinteger_t index = ae.e2.toInteger(); VarExp ve = ae.e1.isVarExp(); if (ve.type.isTypeSArray() && !ve.var.isImportedSymbol()) { TypeSArray ts = ve.type.isTypeSArray(); sinteger_t dim = ts.dim.toInteger(); if (index < 0 || index >= dim) { /* 0 for C static arrays means size is unknown, no need to check, * and address one past the end is OK, too */ if (!((dim == 0 || dim == index) && ve.var.isCsymbol())) { e.error("array index %lld is out of bounds `[0..%lld]`", index, dim); return error(); } } import core.checkedint : mulu; bool overflow; const 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; } } // Convert &((a.b)[index]) to (&a.b)+index*elementsize else if (ae.e2.isIntegerExp() && ae.e1.isDotVarExp()) { sinteger_t index = ae.e2.toInteger(); DotVarExp ve = ae.e1.isDotVarExp(); if (ve.type.isTypeSArray() && ve.var.isField() && ve.e1.isPtrExp()) { TypeSArray ts = ve.type.isTypeSArray(); sinteger_t dim = ts.dim.toInteger(); if (index < 0 || index >= dim) { /* 0 for C static arrays means size is unknown, no need to check, * and address one past the end is OK, too */ if (!((dim == 0 || dim == index) && ve.var.isCsymbol())) { e.error("array index %lld is out of bounds `[0..%lld]`", index, dim); return error(); } } import core.checkedint : mulu; bool overflow; const offset = mulu(index, ts.nextOf().size(e.loc), overflow); // index*elementsize if (overflow) { e.error("array offset overflow"); return error(); } auto pe = new AddrExp(e.loc, ve); pe.type = e.type; ret = new AddExp(e.loc, pe, new IntegerExp(e.loc, offset, Type.tsize_t)); ret.type = e.type; return; } } } } void visitPtr(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 (auto ey = e.e1.isAddrExp()) { Expression ex = ey.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 == EXP.add) { Expression ex = Ptr(e.type, e.e1).copy(); if (!CTFEExp.isCantExp(ex)) { ret = ex; return; } } if (auto se = e.e1.isSymOffExp()) { VarDeclaration v = se.var.isVarDeclaration(); Expression ex = expandVar(result, v); if (ex && ex.isStructLiteralExp()) { StructLiteralExp sle = ex.isStructLiteralExp(); ex = sle.getField(e.type, cast(uint)se.offset); if (ex && !CTFEExp.isCantExp(ex)) { ret = ex; return; } } } } void visitDotVar(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 (auto ve = ex.isVarExp()) { VarDeclaration v = ve.var.isVarDeclaration(); ex = expandVar(result, v); } if (ex && ex.isStructLiteralExp()) { StructLiteralExp sle = ex.isStructLiteralExp(); VarDeclaration vf = e.var.isVarDeclaration(); if (vf && !vf.overlapped) { /* https://issues.dlang.org/show_bug.cgi?id=13021 * Prevent optimization if vf has overlapped fields. */ ex = sle.getField(e.type, vf.offset); if (ex && !CTFEExp.isCantExp(ex)) { ret = ex; return; } } } } void visitNew(NewExp e) { expOptimize(e.thisexp, WANTvalue); // Optimize parameters if (e.arguments) { foreach (ref arg; (*e.arguments)[]) { expOptimize(arg, WANTvalue); } } } void visitCall(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 (auto td = t1.isTypeDelegate()) t1 = td.next; // t1 can apparently be void for __ArrayDtor(T) calls if (auto tf = t1.isTypeFunction()) { foreach (i, ref arg; (*e.arguments)[]) { Parameter p = tf.parameterList[i]; bool keep = p && p.isReference(); expOptimize(arg, WANTvalue, keep); } } } } void visitCast(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); const op1 = e.e1.op; Expression e1old = e.e1; if (expOptimize(e.e1, result, keepLvalue)) return; if (!keepLvalue) e.e1 = fromConstInitializer(result, e.e1); if (e.e1 == e1old && e.e1.op == EXP.arrayLiteral && 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 == EXP.string_ || e.e1.op == EXP.arrayLiteral) && (e.type.ty == Tpointer || e.type.ty == Tarray)) { const esz = e.type.nextOf().size(e.loc); const e1sz = e.e1.type.toBasetype().nextOf().size(e.e1.loc); if (esz == SIZE_INVALID || e1sz == SIZE_INVALID) return error(); if (e1sz == esz) { // https://issues.dlang.org/show_bug.cgi?id=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; } } // Returning e.e1 with changing its type void returnE_e1() { ret = (e1old == e.e1 ? e.e1.copy() : e.e1); ret.type = e.type; } if (e.e1.op == EXP.structLiteral && e.e1.type.implicitConvTo(e.type) >= MATCH.constant) { //printf(" returning2 %s\n", e.e1.toChars()); return returnE_e1(); } /* The first test here is to prevent infinite loops */ if (op1 != EXP.arrayLiteral && e.e1.op == EXP.arrayLiteral) { ret = e.e1.castTo(null, e.to); return; } if (e.e1.op == EXP.null_ && (e.type.ty == Tpointer || e.type.ty == Tclass || e.type.ty == Tarray)) { //printf(" returning3 %s\n", e.e1.toChars()); return returnE_e1(); } if (e.type.ty == Tclass && e.e1.type.ty == Tclass) { import dmd.astenums : Sizeok; // See if we can remove an unnecessary cast ClassDeclaration cdfrom = e.e1.type.isClassHandle(); ClassDeclaration cdto = e.type.isClassHandle(); if (cdfrom.errors || cdto.errors) return error(); if (cdto == ClassDeclaration.object && !cdfrom.isInterfaceDeclaration()) return returnE_e1(); // 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 if (cdfrom.size(e.loc) == SIZE_INVALID) return error(); assert(cdfrom.sizeok == Sizeok.done); assert(cdto.sizeok == Sizeok.done || !cdto.isBaseOf(cdfrom, null)); int offset; if (cdto.isBaseOf(cdfrom, &offset) && offset == 0) { //printf(" returning4 %s\n", e.e1.toChars()); return returnE_e1(); } } if (e.e1.type.mutableOf().unSharedOf().equals(e.to.mutableOf().unSharedOf())) { //printf(" returning5 %s\n", e.e1.toChars()); return returnE_e1(); } if (e.e1.isConst()) { if (e.e1.op == EXP.symbolOffset) { if (e.type.toBasetype().ty != Tsarray) { const esz = e.type.size(e.loc); const e1sz = e.e1.type.size(e.e1.loc); if (esz == SIZE_INVALID || e1sz == SIZE_INVALID) return error(); if (esz == e1sz) return returnE_e1(); } 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 visitBinAssign(BinAssignExp e) { //printf("BinAssignExp::optimize(result = %d) %s\n", result, e.toChars()); if (binOptimize(e, result, /*keepLhsLvalue*/ true)) return; if (e.op == EXP.leftShiftAssign || e.op == EXP.rightShiftAssign || e.op == EXP.unsignedRightShiftAssign) { if (e.e2.isConst() == 1) { sinteger_t i2 = e.e2.toInteger(); uinteger_t sz = e.e1.type.size(e.e1.loc); assert(sz != SIZE_INVALID); sz *= 8; if (i2 < 0 || i2 >= sz) { e.error("shift assign by %lld is outside the range `0..%llu`", i2, cast(ulong)sz - 1); return error(); } } } } void visitBin(BinExp e) { //printf("BinExp::optimize(result = %d) %s\n", result, e.toChars()); const keepLhsLvalue = e.op == EXP.construct || e.op == EXP.blit || e.op == EXP.assign || e.op == EXP.plusPlus || e.op == EXP.minusMinus || e.op == EXP.prePlusPlus || e.op == EXP.preMinusMinus; binOptimize(e, result, keepLhsLvalue); } void visitAdd(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 == EXP.symbolOffset && e.e2.op == EXP.symbolOffset) return; ret = Add(e.loc, e.type, e.e1, e.e2).copy(); } } void visitMin(MinExp e) { //printf("MinExp::optimize(%s)\n", e.toChars()); if (binOptimize(e, result)) return; if (e.e1.isConst() && e.e2.isConst()) { if (e.e2.op == EXP.symbolOffset) return; ret = Min(e.loc, e.type, e.e1, e.e2).copy(); } } void visitMul(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 visitDiv(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 visitMod(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(); } } extern (D) void shift_optimize(BinExp e, UnionExp function(const ref Loc, Type, Expression, Expression) shift) { if (binOptimize(e, result)) return; if (e.e2.isConst() == 1) { sinteger_t i2 = e.e2.toInteger(); uinteger_t sz = e.e1.type.size(e.e1.loc); assert(sz != SIZE_INVALID); sz *= 8; if (i2 < 0 || i2 >= sz) { e.error("shift by %lld is outside the range `0..%llu`", i2, cast(ulong)sz - 1); return error(); } if (e.e1.isConst() == 1) ret = (*shift)(e.loc, e.type, e.e1, e.e2).copy(); } } void visitShl(ShlExp e) { //printf("ShlExp::optimize(result = %d) %s\n", result, e.toChars()); shift_optimize(e, &Shl); } void visitShr(ShrExp e) { //printf("ShrExp::optimize(result = %d) %s\n", result, e.toChars()); shift_optimize(e, &Shr); } void visitUshr(UshrExp e) { //printf("UshrExp::optimize(result = %d) %s\n", result, toChars()); shift_optimize(e, &Ushr); } void visitAnd(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 visitOr(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 visitXor(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 visitPow(PowExp e) { if (binOptimize(e, result)) return; // All negative integral powers are illegal. if (e.e1.type.isintegral() && (e.e2.op == EXP.int64) && cast(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 == EXP.float64 && e.e2.toReal() == real_t(cast(sinteger_t)e.e2.toReal())) { // This only applies to floating point, or positive integral powers. if (e.e1.type.isfloating() || cast(sinteger_t)e.e2.toInteger() >= 0) 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; } } } void visitComma(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 == EXP.error) return; if (!e.e1 || e.e1.op == EXP.int64 || e.e1.op == EXP.float64 || !hasSideEffect(e.e1)) { ret = e.e2; if (ret) ret.type = e.type; } //printf("-CommaExp::optimize(result = %d) %s\n", result, e.e.toChars()); } void visitArrayLength(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 (auto ve = e.e1.isVarExp()) { VarDeclaration v = ve.var.isVarDeclaration(); if (v && (v.storage_class & STC.static_) && (v.storage_class & STC.immutable_) && v._init) { if (Expression ci = v.getConstInitializer()) e.e1 = ci; } } if (e.e1.op == EXP.string_ || e.e1.op == EXP.arrayLiteral || e.e1.op == EXP.assocArrayLiteral || e.e1.type.toBasetype().ty == Tsarray || e.e1.op == EXP.null_) { ret = ArrayLength(e.type, e.e1).copy(); } } void visitEqual(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 == EXP.error) { ret = e1; return; } if (e2.op == EXP.error) { ret = e2; return; } ret = Equal(e.op, e.loc, e.type, e1, e2).copy(); if (CTFEExp.isCantExp(ret)) ret = e; } void visitIdentity(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 == EXP.null_ && e.e2.op == EXP.null_)) { ret = Identity(e.op, e.loc, e.type, e.e1, e.e2).copy(); if (CTFEExp.isCantExp(ret)) ret = e; } } void visitIndex(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; // Don't optimize to an array literal element directly in case an lvalue is requested if (keepLvalue && ex.op == EXP.arrayLiteral) return; ret = Index(e.type, ex, e.e2, e.indexIsInBounds).copy(); if (CTFEExp.isCantExp(ret) || (!ret.isErrorExp() && keepLvalue && !ret.isLvalue())) ret = e; } void visitSlice(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 == EXP.string_) { // 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 == EXP.error) return; ret = Slice(e.type, e.e1, e.lwr, e.upr).copy(); if (CTFEExp.isCantExp(ret)) ret = e; } // https://issues.dlang.org/show_bug.cgi?id=14649 // 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 == EXP.string_) { e.e1 = ret; e.lwr = null; e.upr = null; ret = e; } //printf("-SliceExp::optimize() %s\n", ret.toChars()); } void visitLogical(LogicalExp e) { //printf("LogicalExp::optimize(%d) %s\n", result, e.toChars()); if (expOptimize(e.e1, WANTvalue)) return; const oror = e.op == EXP.orOr; if (e.e1.toBool().hasValue(oror)) { // Replace with (e1, oror) ret = IntegerExp.createBool(oror); 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 = Expression_optimize(ret, result, false); return; } expOptimize(e.e2, WANTvalue); if (e.e1.isConst()) { const e1Opt = e.e1.toBool(); if (e.e2.isConst()) { bool n1 = e1Opt.get(); bool n2 = e.e2.toBool().get(); ret = new IntegerExp(e.loc, oror ? (n1 || n2) : (n1 && n2), e.type); } else if (e1Opt.hasValue(!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 visitCmp(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 visitCat(CatExp e) { //printf("CatExp::optimize(%d) %s\n", result, e.toChars()); if (binOptimize(e, result)) return; if (auto ce1 = e.e1.isCatExp()) { // https://issues.dlang.org/show_bug.cgi?id=12798 // optimize ((expr ~ str1) ~ str2) scope CatExp cex = new CatExp(e.loc, ce1.e2, e.e2); cex.type = e.type; Expression ex = Expression_optimize(cex, result, false); if (ex != cex) { e.e1 = ce1.e1; e.e2 = ex; } } // optimize "str"[] -> "str" if (auto se1 = e.e1.isSliceExp()) { if (se1.e1.op == EXP.string_ && !se1.lwr) e.e1 = se1.e1; } if (auto se2 = e.e2.isSliceExp()) { if (se2.e1.op == EXP.string_ && !se2.lwr) e.e2 = se2.e1; } ret = Cat(e.loc, e.type, e.e1, e.e2).copy(); if (CTFEExp.isCantExp(ret)) ret = e; } void visitCond(CondExp e) { if (expOptimize(e.econd, WANTvalue)) return; const opt = e.econd.toBool(); if (opt.hasValue(true)) ret = Expression_optimize(e.e1, result, keepLvalue); else if (opt.hasValue(false)) ret = Expression_optimize(e.e2, result, keepLvalue); else { expOptimize(e.e1, result, keepLvalue); expOptimize(e.e2, result, keepLvalue); } } // Optimize the expression until it can no longer be simplified. size_t b; while (1) { if (b++ == global.recursionLimit) { e.error("infinite loop while optimizing expression"); fatal(); } auto ex = ret; switch (ex.op) { case EXP.variable: visitVar(ex.isVarExp()); break; case EXP.tuple: visitTuple(ex.isTupleExp()); break; case EXP.arrayLiteral: visitArrayLiteral(ex.isArrayLiteralExp()); break; case EXP.assocArrayLiteral: visitAssocArrayLiteral(ex.isAssocArrayLiteralExp()); break; case EXP.structLiteral: visitStructLiteral(ex.isStructLiteralExp()); break; case EXP.import_: case EXP.assert_: case EXP.dotIdentifier: case EXP.dotTemplateDeclaration: case EXP.dotTemplateInstance: case EXP.delegate_: case EXP.dotType: case EXP.uadd: case EXP.delete_: case EXP.vector: case EXP.vectorArray: case EXP.array: case EXP.delegatePointer: case EXP.delegateFunctionPointer: case EXP.preMinusMinus: case EXP.prePlusPlus: visitUna(cast(UnaExp)ex); break; case EXP.negate: visitNeg(ex.isNegExp()); break; case EXP.tilde: visitCom(ex.isComExp()); break; case EXP.not: visitNop(ex.isNotExp()); break; case EXP.symbolOffset: visitSymOff(ex.isSymOffExp()); break; case EXP.address: visitAddr(ex.isAddrExp()); break; case EXP.star: visitPtr(ex.isPtrExp()); break; case EXP.dotVariable: visitDotVar(ex.isDotVarExp()); break; case EXP.new_: visitNew(ex.isNewExp()); break; case EXP.call: visitCall(ex.isCallExp()); break; case EXP.cast_: visitCast(ex.isCastExp()); break; case EXP.addAssign: case EXP.minAssign: case EXP.mulAssign: case EXP.divAssign: case EXP.modAssign: case EXP.andAssign: case EXP.orAssign: case EXP.xorAssign: case EXP.powAssign: case EXP.leftShiftAssign: case EXP.rightShiftAssign: case EXP.unsignedRightShiftAssign: case EXP.concatenateElemAssign: case EXP.concatenateDcharAssign: case EXP.concatenateAssign: visitBinAssign(ex.isBinAssignExp()); break; case EXP.minusMinus: case EXP.plusPlus: case EXP.assign: case EXP.construct: case EXP.blit: case EXP.in_: case EXP.remove: case EXP.dot: visitBin(cast(BinExp)ex); break; case EXP.add: visitAdd(ex.isAddExp()); break; case EXP.min: visitMin(ex.isMinExp()); break; case EXP.mul: visitMul(ex.isMulExp()); break; case EXP.div: visitDiv(ex.isDivExp()); break; case EXP.mod: visitMod(ex.isModExp()); break; case EXP.leftShift: visitShl(ex.isShlExp()); break; case EXP.rightShift: visitShr(ex.isShrExp()); break; case EXP.unsignedRightShift: visitUshr(ex.isUshrExp()); break; case EXP.and: visitAnd(ex.isAndExp()); break; case EXP.or: visitOr(ex.isOrExp()); break; case EXP.xor: visitXor(ex.isXorExp()); break; case EXP.pow: visitPow(ex.isPowExp()); break; case EXP.comma: visitComma(ex.isCommaExp()); break; case EXP.arrayLength: visitArrayLength(ex.isArrayLengthExp()); break; case EXP.notEqual: case EXP.equal: visitEqual(ex.isEqualExp()); break; case EXP.notIdentity: case EXP.identity: visitIdentity(ex.isIdentityExp()); break; case EXP.index: visitIndex(ex.isIndexExp()); break; case EXP.slice: visitSlice(ex.isSliceExp()); break; case EXP.andAnd: case EXP.orOr: visitLogical(ex.isLogicalExp()); break; case EXP.lessThan: case EXP.lessOrEqual: case EXP.greaterThan: case EXP.greaterOrEqual: visitCmp(cast(CmpExp)ex); break; case EXP.concatenate: visitCat(ex.isCatExp()); break; case EXP.question: visitCond(ex.isCondExp()); break; default: visitExp(ex); break; } if (ex == ret) break; } return ret; }