Compare `873921b ... +15 ... fe4b650`

            {
                getregs(cdb,retregs);
                genregs(cdb,0x19,reg,reg);     // SBB reg,reg
                if (rex)
                    code_orrex(cdb.last(), rex);
                if (rex || flag & REX_W)
                    code_orrex(cdb.last(), REX_W);
                if (flag)
                { }                                         // cdcond() will handle it
                else if (jop == JNC)

@@ -1,12 +1,12 @@

/**
 * Compiler implementation of the
 * $(LINK2 http://www.dlang.org, D programming language).
 * Top level code for the code generator.
 *
 * Copyright:   Copyright (C) 1985-1998 by Symantec
 *              Copyright (C) 2000-2020 by The D Language Foundation, All Rights Reserved
 * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
 * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/cgcod.d, backend/cgcod.d)
 * Documentation:  https://dlang.org/phobos/dmd_backend_cgcod.html
 * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/backend/cgcod.d
 */


@@ -754,7 +754,7 @@

    bool pushalloc = false;
    tym_t tyf = funcsym_p.ty();
    tym_t tym = tybasic(tyf);
    uint farfunc = tyfarfunc(tym);
    const farfunc = tyfarfunc(tym) != 0;

    // Special Intel 64 bit ABI prolog setup for variadic functions
    Symbol *sv64 = null;                        // set to __va_argsave

@@ -1051,7 +1051,7 @@

    }
    else if (needframe)                 // if variables or parameters
    {
        prolog_frame(cdbx, farfunc, &xlocalsize, &enter, &cfa_offset);
        prolog_frame(cdbx, farfunc, xlocalsize, enter, cfa_offset);
        hasframe = 1;
    }


@@ -1135,7 +1135,7 @@

            }

            uint regsaved;
            prolog_trace(cdbx, farfunc != 0, &regsaved);
            prolog_trace(cdbx, farfunc, &regsaved);

            if (spalign)
                cod3_stackadj(cdbx, -spalign);

@@ -7,6 +7,7 @@

 * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
 * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/cod3.d, backend/cod3.d)
 * Documentation:  https://dlang.org/phobos/dmd_backend_cod3.html
 * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/backend/cod3.d
 */


@@ -3177,28 +3178,27 @@


/**********************************************
 * Set up frame register.
 * Input:
 *      *xlocalsize     amount of local variables
 * Output:
 *      *enter          set to true if ENTER instruction can be used, false otherwise
 *      *xlocalsize     amount to be subtracted from stack pointer
 *      *cfa_offset     the frame pointer's offset from the CFA
 * Params:
 *      cdb        = write generated code here
 *      farfunc    = true if a far function
 *      enter      = set to true if ENTER instruction can be used, false otherwise
 *      xlocalsize = amount of local variables, set to amount to be subtracted from stack pointer
 *      cfa_offset = set to frame pointer's offset from the CFA
 * Returns:
 *      generated code
 */

void prolog_frame(ref CodeBuilder cdb, uint farfunc, uint* xlocalsize, bool* enter, int* cfa_offset)
void prolog_frame(ref CodeBuilder cdb, bool farfunc, ref uint xlocalsize, out bool enter, out int cfa_offset)
{
    //printf("prolog_frame\n");
    *cfa_offset = 0;
    cfa_offset = 0;

    if (0 && config.exe == EX_WIN64)
    {
        // PUSH RBP
        // LEA RBP,0[RSP]
        cdb. gen1(0x50 + BP);
        cdb.genc1(LEA,(REX_W<<16) | (modregrm(0,4,SP)<<8) | modregrm(2,BP,4),FLconst,0);
        *enter = false;
        enter = false;
        return;
    }


@@ -3208,7 +3208,7 @@

        config.exe & (EX_LINUX | EX_LINUX64 | EX_OSX | EX_OSX64 | EX_FREEBSD | EX_FREEBSD64 | EX_DRAGONFLYBSD64 | EX_SOLARIS | EX_SOLARIS64 | EX_WIN64) ||
        !localsize ||
        config.flags & CFGstack ||
        (*xlocalsize >= 0x1000 && config.exe & EX_flat) ||
        (xlocalsize >= 0x1000 && config.exe & EX_flat) ||
        localsize >= 0x10000 ||
        (NTEXCEPTIONS == 2 &&
         (usednteh & (NTEH_try | NTEH_except | NTEHcpp | EHcleanup | EHtry | NTEHpassthru) && (config.ehmethod == EHmethod.EH_WIN32 && !(funcsym_p.Sfunc.Fflags3 & Feh_none) || config.ehmethod == EHmethod.EH_SEH))) ||

@@ -3230,7 +3230,7 @@

            nteh_prolog(cdb);
            int sz = nteh_contextsym_size();
            assert(sz != 0);        // should be 5*4, not 0
            *xlocalsize -= sz;      // sz is already subtracted from ESP
            xlocalsize -= sz;      // sz is already subtracted from ESP
                                    // by nteh_prolog()
        }
}

@@ -3246,12 +3246,12 @@

             * which is why the offset of BP is set to 8
             */
            dwarf_CFA_set_reg_offset(BP, off);        // CFA is now 0[EBP]
            *cfa_offset = off;  // remember the difference between the CFA and the frame pointer
            cfa_offset = off;  // remember the difference between the CFA and the frame pointer
        }
        *enter = false;              /* do not use ENTER instruction */
        enter = false;              /* do not use ENTER instruction */
    }
    else
        *enter = true;
        enter = true;
}

/**********************************************

@@ -3328,7 +3328,7 @@

    {
        if (enter)
        {   // ENTER xlocalsize,0
            cdb.genc(0xC8,0,FLconst,xlocalsize,FLconst,cast(targ_uns) 0);
            cdb.genc(ENTER,0,FLconst,xlocalsize,FLconst,cast(targ_uns) 0);
            assert(!(config.fulltypes == CVDWARF_C || config.fulltypes == CVDWARF_D)); // didn't emit Dwarf data
        }
        else if (xlocalsize == REGSIZE && config.flags4 & CFG4optimized)

@@ -4232,7 +4232,7 @@

                else if (config.target_cpu >= TARGET_80286 &&
                    !(config.target_cpu >= TARGET_80386 && config.flags4 & CFG4speed)
                   )
                    cdbx.gen1(0xC9);           // LEAVE
                    cdbx.gen1(LEAVE);          // LEAVE
                else if (0 && xlocalsize == REGSIZE && Alloca.size == 0 && I32)
                {   // This doesn't work - I should figure out why
                    mfuncreg &= ~mask(regx);

@@ -4310,7 +4310,7 @@

4310	4310		if (cr.Iop == 0x81 && cr.Irm == modregrm(3,0,SP)) // if ADD SP,imm
4311	4311		{
4312	4312		if (
4313		-	c.Iop == 0xC9 \|\| // LEAVE
	4313	+	c.Iop == LEAVE \|\| // LEAVE
4314	4314		(c.Iop == 0x8B && c.Irm == modregrm(3,SP,BP)) \|\| // MOV SP,BP
4315	4315		(c.Iop == LEA && c.Irm == modregrm(1,SP,6)) // LEA SP,-imm[BP]
4316	4316		)

@@ -6822,7 +6822,7 @@

        }
        else
        {
            if (op == 0xC8)
            if (op == ENTER)
                do16bit(&ggen, cast(FL)c.IFL1,&c.IEV1,0);
        }
        flags &= CFseg | CFoff | CFselfrel;

@@ -2293,8 +2293,6 @@

    regm_t psw = *pretregs & mPSW;               /* save PSW bit                 */
    const op1 = e1.Eoper;
    uint sz1 = tysize(e1.Ety);
    uint rex = (I64 && sz1 == 8) ? REX_W : 0;
    uint grex = rex << 16;
    uint jop = jmpopcode(e1);

    uint jop1 = jmpopcode(e21);

@@ -2341,6 +2339,10 @@

        e22.Eoper == OPconst
       )
    {
        uint sz = tysize(e.Ety);
        uint rex = (I64 && sz == 8) ? REX_W : 0;
        uint grex = rex << 16;

        regm_t retregs;
        targ_size_t v1,v2;


@@ -2357,7 +2359,7 @@

                retregs = BYTEREGS;
        }

        cdcmp_flag = 1;
        cdcmp_flag = 1 | rex;
        v1 = cast(targ_size_t)e21.EV.Vllong;
        v2 = cast(targ_size_t)e22.EV.Vllong;
        if (jop == JNC)

@@ -214,17 +214,13 @@


__gshared CtfeGlobals ctfeGlobals;

enum CtfeGoal : int
enum CTFEGoal : int
{
    ctfeNeedRvalue,     // Must return an Rvalue (== CTFE value)
    ctfeNeedLvalue,     // Must return an Lvalue (== CTFE reference)
    ctfeNeedNothing,    // The return value is not required
    RValue,     /// Must return an Rvalue (== CTFE value)
    LValue,     /// Must return an Lvalue (== CTFE reference)
    Nothing,    /// The return value is not required
}

alias ctfeNeedRvalue = CtfeGoal.ctfeNeedRvalue;
alias ctfeNeedLvalue = CtfeGoal.ctfeNeedLvalue;
alias ctfeNeedNothing = CtfeGoal.ctfeNeedNothing;

//debug = LOG;
//debug = LOGASSIGN;
//debug = LOGCOMPILE;

@@ -471,7 +467,7 @@

                return CTFEExp.cantexp;
            }
            // Convert all reference arguments into lvalue references
            earg = interpretRegion(earg, istate, ctfeNeedLvalue);
            earg = interpretRegion(earg, istate, CTFEGoal.LValue);
            if (CTFEExp.isCantExp(earg))
                return earg;
        }

@@ -551,7 +547,7 @@

        VarDeclaration v = (*fd.parameters)[i];
        debug (LOG)
        {
            printf("arg[%d] = %s\n", i, earg.toChars());
            printf("arg[%zu] = %s\n", i, earg.toChars());
        }
        ctfeGlobals.stack.push(v);


@@ -595,12 +591,12 @@

        }
        debug (LOG)
        {
            printf("interpreted arg[%d] = %s\n", i, earg.toChars());
            printf("interpreted arg[%zu] = %s\n", i, earg.toChars());
            showCtfeExpr(earg);
        }
        debug (LOGASSIGN)
        {
            printf("interpreted arg[%d] = %s\n", i, earg.toChars());
            printf("interpreted arg[%zu] = %s\n", i, earg.toChars());
            showCtfeExpr(earg);
        }
    }

@@ -715,11 +711,11 @@

    alias visit = Visitor.visit;
public:
    InterState* istate;
    CtfeGoal goal;
    CTFEGoal goal;
    Expression result;
    UnionExp* pue;              // storage for `result`

    extern (D) this(UnionExp* pue, InterState* istate, CtfeGoal goal)
    extern (D) this(UnionExp* pue, InterState* istate, CTFEGoal goal)
    {
        this.pue = pue;
        this.istate = istate;

@@ -786,7 +782,7 @@

        if (s.exp && s.exp.hasCode)
            incUsageCtfe(istate, s.loc);

        Expression e = interpret(pue, s.exp, istate, ctfeNeedNothing);
        Expression e = interpret(pue, s.exp, istate, CTFEGoal.Nothing);
        if (exceptionOrCant(e))
            return;
    }

@@ -1004,7 +1000,7 @@

         */
        if (tf.isref)
        {
            result = interpret(pue, s.exp, istate, ctfeNeedLvalue);
            result = interpret(pue, s.exp, istate, CTFEGoal.LValue);
            return;
        }
        if (tf.next && tf.next.ty == Tdelegate && istate.fd.closureVars.dim > 0)

@@ -1223,7 +1219,7 @@

            UnionExp uei = void;
            if (s.increment)
                incUsageCtfe(istate, s.increment.loc);
            e = interpret(&uei, s.increment, istate, ctfeNeedNothing);
            e = interpret(&uei, s.increment, istate, CTFEGoal.Nothing);
            if (exceptionOrCant(e))
                return;
        }

@@ -1723,7 +1719,7 @@

        {
            printf("%s ThisExp::interpret() %s\n", e.loc.toChars(), e.toChars());
        }
        if (goal == ctfeNeedLvalue)
        if (goal == CTFEGoal.LValue)
        {
            // We might end up here with istate being zero
            // https://issues.dlang.org/show_bug.cgi?id=16382

@@ -1972,7 +1968,7 @@

                return;
            }
        }
        auto er = interpret(e.e1, istate, ctfeNeedLvalue);
        auto er = interpret(e.e1, istate, CTFEGoal.LValue);
        if (auto ve = er.isVarExp())
            if (ve.var == istate.fd.vthis)
                er = interpret(er, istate);

@@ -2020,7 +2016,7 @@

        }
    }

    static Expression getVarExp(const ref Loc loc, InterState* istate, Declaration d, CtfeGoal goal)
    static Expression getVarExp(const ref Loc loc, InterState* istate, Declaration d, CTFEGoal goal)
    {
        Expression e = CTFEExp.cantexp;
        if (VarDeclaration v = d.isVarDeclaration())

@@ -2128,7 +2124,7 @@

                    errorSupplemental(vie.var.loc, "`%s` was uninitialized and used before set", vie.var.toChars());
                    return CTFEExp.cantexp;
                }
                if (goal != ctfeNeedLvalue && (v.isRef() || v.isOut()))
                if (goal != CTFEGoal.LValue && (v.isRef() || v.isOut()))
                    e = interpret(e, istate, goal);
            }
            if (!e)

@@ -2163,37 +2159,39 @@

            return;
        }

        if (goal == ctfeNeedLvalue)
        if (goal == CTFEGoal.LValue)
        {
            VarDeclaration v = e.var.isVarDeclaration();
            if (v && !v.isDataseg() && !v.isCTFE() && !istate)
            {
                e.error("variable `%s` cannot be read at compile time", v.toChars());
                result = CTFEExp.cantexp;
                return;
            }
            if (v && !hasValue(v))
            if (auto v = e.var.isVarDeclaration())
            {
                if (!v.isCTFE() && v.isDataseg())
                    e.error("static variable `%s` cannot be read at compile time", v.toChars());
                else // CTFE initiated from inside a function
                if (!v.isDataseg() && !v.isCTFE() && !istate)
                {
                    e.error("variable `%s` cannot be read at compile time", v.toChars());
                result = CTFEExp.cantexp;
                return;
            }

            if (v && (v.storage_class & (STC.out_ | STC.ref_)) && hasValue(v))
            {
                // Strip off the nest of ref variables
                Expression ev = getValue(v);
                if (ev.op == TOK.variable ||
                    ev.op == TOK.index ||
                    ev.op == TOK.slice ||
                    ev.op == TOK.dotVariable)
                    result = CTFEExp.cantexp;
                    return;
                }
                if (!hasValue(v))
                {
                    result = interpret(pue, ev, istate, goal);
                    if (!v.isCTFE() && v.isDataseg())
                        e.error("static variable `%s` cannot be read at compile time", v.toChars());
                    else // CTFE initiated from inside a function
                        e.error("variable `%s` cannot be read at compile time", v.toChars());
                    result = CTFEExp.cantexp;
                    return;
                }

                if (v.storage_class & (STC.out_ | STC.ref_))
                {
                    // Strip off the nest of ref variables
                    Expression ev = getValue(v);
                    if (ev.op == TOK.variable ||
                        ev.op == TOK.index ||
                        ev.op == TOK.slice ||
                        ev.op == TOK.dotVariable)
                    {
                        result = interpret(pue, ev, istate, goal);
                        return;
                    }
                }
            }
            result = e;
            return;

@@ -2380,7 +2378,7 @@

        {
            printf("%s TupleExp::interpret() %s\n", e.loc.toChars(), e.toChars());
        }
        if (exceptionOrCant(interpretRegion(e.e0, istate, ctfeNeedNothing)))
        if (exceptionOrCant(interpretRegion(e.e0, istate, CTFEGoal.Nothing)))
            return;

        auto expsx = e.exps;

@@ -2391,7 +2389,7 @@

                return;

            // A tuple of assignments can contain void (Bug 5676).
            if (goal == ctfeNeedNothing)
            if (goal == CTFEGoal.Nothing)
                continue;
            if (ex.op == TOK.voidExpression)
            {

@@ -2732,7 +2730,7 @@

            return;
        }

        Expression epre = interpret(pue, e.argprefix, istate, ctfeNeedNothing);
        Expression epre = interpret(pue, e.argprefix, istate, CTFEGoal.Nothing);
        if (exceptionOrCant(epre))
            return;


@@ -3255,7 +3253,7 @@

        {
            assert(!fp);

            Expression newval = interpretRegion(e.e2, istate, ctfeNeedLvalue);
            Expression newval = interpretRegion(e.e2, istate, CTFEGoal.LValue);
            if (exceptionOrCant(newval))
                return;


@@ -3264,7 +3262,7 @@


            // Get the value to return. Note that 'newval' is an Lvalue,
            // so if we need an Rvalue, we have to interpret again.
            if (goal == ctfeNeedRvalue)
            if (goal == CTFEGoal.RValue)
                result = interpretRegion(newval, istate);
            else
                result = e1; // VarExp is a CTFE reference

@@ -3399,7 +3397,7 @@

                }

                // We must set to aggregate with newaae
                e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
                e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
                if (exceptionOrCant(e1))
                    return;
                e1 = assignToLvalue(e, e1, newaae);

@@ -3441,7 +3439,7 @@

        else
        {
        L1:
            e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
            e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
            if (exceptionOrCant(e1))
                return;


@@ -3587,7 +3585,7 @@

                result = CTFEExp.cantexp;
                return;
            }
            e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
            e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
            if (exceptionOrCant(e1))
                return;


@@ -3614,7 +3612,7 @@

                newval = pue.copy();

            // Determine the return value
            if (goal == ctfeNeedLvalue) // https://issues.dlang.org/show_bug.cgi?id=14371
            if (goal == CTFEGoal.LValue) // https://issues.dlang.org/show_bug.cgi?id=14371
                result = e1;
            else
            {

@@ -3649,7 +3647,7 @@

                return;
            if (auto se = e.e1.isSliceExp())
            {
                Expression e1x = interpretRegion(se.e1, istate, ctfeNeedLvalue);
                Expression e1x = interpretRegion(se.e1, istate, CTFEGoal.LValue);
                if (auto dve = e1x.isDotVarExp())
                {
                    auto ex = dve.e1;

@@ -3872,7 +3870,7 @@

     *
     * Returns TOK.cantExpression on failure. If there are no errors,
     * it returns aggregate[low..upp], except that as an optimisation,
     * if goal == ctfeNeedNothing, it will return NULL
     * if goal == CTFEGoal.Nothing, it will return NULL
     */
    private Expression interpretAssignToSlice(UnionExp* pue, BinExp e, Expression e1, Expression newval, bool isBlockAssignment)
    {

@@ -4042,7 +4040,7 @@

            {
                existingSE.setCodeUnit(cast(size_t)(i + firstIndex), value);
            }
            if (goal == ctfeNeedNothing)
            if (goal == CTFEGoal.Nothing)
                return null; // avoid creating an unused literal
            auto retslice = ctfeEmplaceExp!SliceExp(e.loc, existingSE,
                        ctfeEmplaceExp!IntegerExp(e.loc, firstIndex, Type.tsize_t),

@@ -4248,7 +4246,7 @@

            if (Expression ex = rb.assignTo(existingAE, cast(size_t)lowerbound, cast(size_t)upperbound))
                return ex;

            if (goal == ctfeNeedNothing)
            if (goal == CTFEGoal.Nothing)
                return null; // avoid creating an unused literal
            auto retslice = ctfeEmplaceExp!SliceExp(e.loc, existingAE,
                ctfeEmplaceExp!IntegerExp(e.loc, firstIndex, Type.tsize_t),

@@ -4591,7 +4589,7 @@

        }
        incUsageCtfe(istate, e.e2.loc);

        if (goal != ctfeNeedNothing)
        if (goal != CTFEGoal.Nothing)
        {
            if (e.type.equals(Type.tbool))
                result = IntegerExp.createBool(res);

@@ -4696,7 +4694,7 @@


                // printf("2 ea = %s, %s %s\n", ea.type.toChars(), Token.toChars(ea.op), ea.toChars());
                if (ea.op == TOK.variable || ea.op == TOK.symbolOffset)
                    result = getVarExp(e.loc, istate, (cast(SymbolExp)ea).var, ctfeNeedRvalue);
                    result = getVarExp(e.loc, istate, (cast(SymbolExp)ea).var, CTFEGoal.RValue);
                else if (auto ae = ea.isAddrExp())
                    result = interpretRegion(ae.e1, istate);


@@ -4836,7 +4834,7 @@

            return;
        if (!exceptionOrCantInterpret(result))
        {
            if (goal != ctfeNeedLvalue) // Peel off CTFE reference if it's unnecessary
            if (goal != CTFEGoal.LValue) // Peel off CTFE reference if it's unnecessary
            {
                if (result == pue.exp())
                    result = pue.copy();

@@ -4910,7 +4908,7 @@

        else
        {
            UnionExp ue = void;
            auto e1 = interpret(&ue, e.e1, istate, ctfeNeedNothing);
            auto e1 = interpret(&ue, e.e1, istate, CTFEGoal.Nothing);
            if (exceptionOrCant(e1))
                return endTempStackFrame();
        }

@@ -5232,7 +5230,7 @@

            }
            if (agg.op == TOK.arrayLiteral || agg.op == TOK.string_)
            {
                if (goal == ctfeNeedLvalue)
                if (goal == CTFEGoal.LValue)
                {
                    // if we need a reference, IndexExp shouldn't be interpreting
                    // the expression to a value, it should stay as a reference

@@ -5262,7 +5260,7 @@

                return;
            if (e1.op == TOK.null_)
            {
                if (goal == ctfeNeedLvalue && e1.type.ty == Taarray && e.modifiable)
                if (goal == CTFEGoal.LValue && e1.type.ty == Taarray && e.modifiable)
                {
                    assert(0); // does not reach here?
                }

@@ -5274,7 +5272,7 @@

            if (exceptionOrCant(e2))
                return;

            if (goal == ctfeNeedLvalue)
            if (goal == CTFEGoal.LValue)
            {
                // Pointer or reference of a scalar type
                if (e1 == e.e1 && e2 == e.e2)

@@ -5308,7 +5306,7 @@

            return;
        }

        if (goal == ctfeNeedLvalue)
        if (goal == CTFEGoal.LValue)
        {
            Expression e2 = ctfeEmplaceExp!IntegerExp(e.e2.loc, indexToAccess, Type.tsize_t);
            emplaceExp!(IndexExp)(pue, e.loc, agg, e2);

@@ -5409,14 +5407,14 @@

            return;
        }

        CtfeGoal goal1 = ctfeNeedRvalue;
        if (goal == ctfeNeedLvalue)
        CTFEGoal goal1 = CTFEGoal.RValue;
        if (goal == CTFEGoal.LValue)
        {
            if (e.e1.type.toBasetype().ty == Tsarray)
                if (auto ve = e.e1.isVarExp())
                    if (auto vd = ve.var.isVarDeclaration())
                        if (vd.storage_class & STC.ref_)
                            goal1 = ctfeNeedLvalue;
                            goal1 = CTFEGoal.LValue;
        }
        Expression e1 = interpret(e.e1, istate, goal1);
        if (exceptionOrCant(e1))

@@ -5995,7 +5993,7 @@

            if (soe1.offset == 0 && soe1.var.isVarDeclaration() && isFloatIntPaint(e.type, soe1.var.type))
            {
                // *(cast(int*)&v), where v is a float variable
                result = paintFloatInt(pue, getVarExp(e.loc, istate, soe1.var, ctfeNeedRvalue), e.type);
                result = paintFloatInt(pue, getVarExp(e.loc, istate, soe1.var, CTFEGoal.RValue), e.type);
                return;
            }


@@ -6176,7 +6174,7 @@

        if ((*se.elements)[i] is null)
            (*se.elements)[i] = voidInitLiteral(e.type, v).copy();

        if (goal == ctfeNeedLvalue)
        if (goal == CTFEGoal.LValue)
        {
            // just return the (simplified) dotvar expression as a CTFE reference
            if (e.e1 == ex)

@@ -6297,19 +6295,19 @@

 *    resulting expression
 */

Expression interpret(UnionExp* pue, Expression e, InterState* istate, CtfeGoal goal = ctfeNeedRvalue)
Expression interpret(UnionExp* pue, Expression e, InterState* istate, CTFEGoal goal = CTFEGoal.RValue)
{
    if (!e)
        return null;
    scope Interpreter v = new Interpreter(pue, istate, goal);
    e.accept(v);
    Expression ex = v.result;
    assert(goal == ctfeNeedNothing || ex !is null);
    assert(goal == CTFEGoal.Nothing || ex !is null);
    return ex;
}

///
Expression interpret(Expression e, InterState* istate, CtfeGoal goal = ctfeNeedRvalue)
Expression interpret(Expression e, InterState* istate, CTFEGoal goal = CTFEGoal.RValue)
{
    UnionExp ue = void;
    auto result = interpret(&ue, e, istate, goal);

@@ -6327,7 +6325,7 @@

 * Returns:
 *    resulting expression
 */
Expression interpretRegion(Expression e, InterState* istate, CtfeGoal goal = ctfeNeedRvalue)
Expression interpretRegion(Expression e, InterState* istate, CTFEGoal goal = CTFEGoal.RValue)
{
    UnionExp ue = void;
    auto result = interpret(&ue, e, istate, goal);

@@ -6366,7 +6364,7 @@

{
    if (!s)
        return null;
    scope Interpreter v = new Interpreter(pue, istate, ctfeNeedNothing);
    scope Interpreter v = new Interpreter(pue, istate, CTFEGoal.Nothing);
    s.accept(v);
    return v.result;
}

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Learn more Showing 5 files with coverage changes found.

Changes in src/dmd/backend/gflow.d

-3

→

Loading file...

Changes in src/dmd/backend/cod2.d

-2

→

Loading file...

Changes in src/dmd/backend/cod3.d

New

Loading file...

Changes in src/dmd/dinterpret.d

-1

→

+12

Loading file...

Changes in src/dmd/backend/code_x86.d

→

Loading file...

77.200% 87.804% ø

Merge pull request #11542 from MartinNowak/merge_stable

dlang-bot

fe4b650

CI Passed

+14

77.197% 98.113% ø

Merge pull request #11544 from Geod24/ctfe-refactor

dlang-bot

b646a5f

CI Passed

-1

77.198% ø +0.001%

Interpret: Fix printf format string in versioned out log statements

Geod24

f66508a

CI Passed

-1

77.197% 100.000% +<.001%

fix Issue 10966 - Optimizer generates wrong code with try-catch

Unknown

1da8a5e

CI Passed

Hiding 3 contexual commits

77.197% ø ø

mars1.d: consolidate divide tests together

Unknown

b2f1a37

CI Passed

77.197% ø +<.001%

Merge pull request #11534 from MoonlightSentinel/move-build.d

dlang-bot

fa4f32e

CI Passed

-1030

-1367

+337

77.686% ø ø

Github Actions: Drop testing for LLVM < v6.0.0

Geod24

ec370e2

CI Passed

77.686% 100.000% +<.001%

fix Issue 20162 - Sign Extension for ?: optimization done wrong

Unknown

18c930d

CI Passed

77.686% 66.666% ø

add out parameters to prolog_frame()

Unknown

89fa2d6

CI Passed

77.686% 57.142% ø

small changes to prolog_frame() to improve clarity

Unknown

187a7fb

CI Passed

+1030

+1367

-337

77.197% ø -0.490%

Improve CodeCov upload

MoonlightSentinel

54ce9fc

CI Passed

Hiding 1 contexual commits

-1030

-1367

+337

77.686% ø ø

Bump host compiler for Azure Win64

MoonlightSentinel

ae95799

CI Passed

+1013

+1350

-337

77.200% 0.000% -0.486%

fixup for ErrorExp singleton

Unknown

873921b

CI Passed

Files		•	•	•	Coverage
src/dmd	ø	ø	ø	ø	77.200%
Project Totals (203 files)	115,872	89,454	0	26,418	77.200%

3140	3140		{
3141	3141		getregs(cdb,retregs);
3142	3142		genregs(cdb,0x19,reg,reg); // SBB reg,reg
3143		-	if (rex)
3144		-	code_orrex(cdb.last(), rex);
	3143	+	if (rex \|\| flag & REX_W)
	3144	+	code_orrex(cdb.last(), REX_W);
3145	3145		if (flag)
3146	3146		{ } // cdcond() will handle it
3147	3147		else if (jop == JNC)

754	754		bool pushalloc = false;
755	755		tym_t tyf = funcsym_p.ty();
756	756		tym_t tym = tybasic(tyf);
757		-	uint farfunc = tyfarfunc(tym);
	757	+	const farfunc = tyfarfunc(tym) != 0;
758	758
759	759		// Special Intel 64 bit ABI prolog setup for variadic functions
760	760		Symbol *sv64 = null; // set to __va_argsave

1051	1051		}
1052	1052		else if (needframe) // if variables or parameters
1053	1053		{
1054		-	prolog_frame(cdbx, farfunc, &xlocalsize, &enter, &cfa_offset);
	1054	+	prolog_frame(cdbx, farfunc, xlocalsize, enter, cfa_offset);
1055	1055		hasframe = 1;
1056	1056		}
1057	1057

1135	1135		}
1136	1136
1137	1137		uint regsaved;
1138		-	prolog_trace(cdbx, farfunc != 0, &regsaved);
	1138	+	prolog_trace(cdbx, farfunc, &regsaved);
1139	1139
1140	1140		if (spalign)
1141	1141		cod3_stackadj(cdbx, -spalign);

3177	3178
3178	3179		/**********************************************
3179	3180		* Set up frame register.
3180		-	* Input:
3181		-	* *xlocalsize amount of local variables
3182		-	* Output:
3183		-	* *enter set to true if ENTER instruction can be used, false otherwise
3184		-	* *xlocalsize amount to be subtracted from stack pointer
3185		-	* *cfa_offset the frame pointer's offset from the CFA
	3181	+	* Params:
	3182	+	* cdb = write generated code here
	3183	+	* farfunc = true if a far function
	3184	+	* enter = set to true if ENTER instruction can be used, false otherwise
	3185	+	* xlocalsize = amount of local variables, set to amount to be subtracted from stack pointer
	3186	+	* cfa_offset = set to frame pointer's offset from the CFA
3186	3187		* Returns:
3187	3188		* generated code
3188	3189		*/
3189		-
3190		-	void prolog_frame(ref CodeBuilder cdb, uint farfunc, uint* xlocalsize, bool* enter, int* cfa_offset)
	3190	+	void prolog_frame(ref CodeBuilder cdb, bool farfunc, ref uint xlocalsize, out bool enter, out int cfa_offset)
3191	3191		{
3192	3192		//printf("prolog_frame\n");
3193		-	*cfa_offset = 0;
	3193	+	cfa_offset = 0;
3194	3194
3195	3195		if (0 && config.exe == EX_WIN64)
3196	3196		{
3197	3197		// PUSH RBP
3198	3198		// LEA RBP,0[RSP]
3199	3199		cdb. gen1(0x50 + BP);
3200	3200		cdb.genc1(LEA,(REX_W<<16) \| (modregrm(0,4,SP)<<8) \| modregrm(2,BP,4),FLconst,0);
3201		-	*enter = false;
	3201	+	enter = false;
3202	3202		return;
3203	3203		}
3204	3204

Compare `873921b ... +15 ... fe4b650`

No flags found

Show failed CI and contexual commits `c`

17 Commits

1	1		/**
2		-	* Compiler implementation of the
3		-	* $(LINK2 http://www.dlang.org, D programming language).
	2	+	* Top level code for the code generator.
4	3		*
5	4		* Copyright: Copyright (C) 1985-1998 by Symantec
6	5		* Copyright (C) 2000-2020 by The D Language Foundation, All Rights Reserved
7	6		* Authors: $(LINK2 http://www.digitalmars.com, Walter Bright)
8	7		* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
9	8		* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/cgcod.d, backend/cgcod.d)
	9	+	* Documentation: https://dlang.org/phobos/dmd_backend_cgcod.html
10	10		* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/backend/cgcod.d
11	11		*/
12	12

3208	3208		config.exe & (EX_LINUX \| EX_LINUX64 \| EX_OSX \| EX_OSX64 \| EX_FREEBSD \| EX_FREEBSD64 \| EX_DRAGONFLYBSD64 \| EX_SOLARIS \| EX_SOLARIS64 \| EX_WIN64) \|\|
3209	3209		!localsize \|\|
3210	3210		config.flags & CFGstack \|\|
3211		-	(*xlocalsize >= 0x1000 && config.exe & EX_flat) \|\|
	3211	+	(xlocalsize >= 0x1000 && config.exe & EX_flat) \|\|
3212	3212		localsize >= 0x10000 \|\|
3213	3213		(NTEXCEPTIONS == 2 &&
3214	3214		(usednteh & (NTEH_try \| NTEH_except \| NTEHcpp \| EHcleanup \| EHtry \| NTEHpassthru) && (config.ehmethod == EHmethod.EH_WIN32 && !(funcsym_p.Sfunc.Fflags3 & Feh_none) \|\| config.ehmethod == EHmethod.EH_SEH))) \|\|

3230	3230		nteh_prolog(cdb);
3231	3231		int sz = nteh_contextsym_size();
3232	3232		assert(sz != 0); // should be 5*4, not 0
3233		-	*xlocalsize -= sz; // sz is already subtracted from ESP
	3233	+	xlocalsize -= sz; // sz is already subtracted from ESP
3234	3234		// by nteh_prolog()
3235	3235		}
3236	3236		}

3246	3246		* which is why the offset of BP is set to 8
3247	3247		*/
3248	3248		dwarf_CFA_set_reg_offset(BP, off); // CFA is now 0[EBP]
3249		-	*cfa_offset = off; // remember the difference between the CFA and the frame pointer
	3249	+	cfa_offset = off; // remember the difference between the CFA and the frame pointer
3250	3250		}
3251		-	enter = false; / do not use ENTER instruction */
	3251	+	enter = false; /* do not use ENTER instruction */
3252	3252		}
3253	3253		else
3254		-	*enter = true;
	3254	+	enter = true;
3255	3255		}
3256	3256
3257	3257		/**********************************************

3328	3328		{
3329	3329		if (enter)
3330	3330		{ // ENTER xlocalsize,0
3331		-	cdb.genc(0xC8,0,FLconst,xlocalsize,FLconst,cast(targ_uns) 0);
	3331	+	cdb.genc(ENTER,0,FLconst,xlocalsize,FLconst,cast(targ_uns) 0);
3332	3332		assert(!(config.fulltypes == CVDWARF_C \|\| config.fulltypes == CVDWARF_D)); // didn't emit Dwarf data
3333	3333		}
3334	3334		else if (xlocalsize == REGSIZE && config.flags4 & CFG4optimized)

4232	4232		else if (config.target_cpu >= TARGET_80286 &&
4233	4233		!(config.target_cpu >= TARGET_80386 && config.flags4 & CFG4speed)
4234	4234		)
4235		-	cdbx.gen1(0xC9); // LEAVE
	4235	+	cdbx.gen1(LEAVE); // LEAVE
4236	4236		else if (0 && xlocalsize == REGSIZE && Alloca.size == 0 && I32)
4237	4237		{ // This doesn't work - I should figure out why
4238	4238		mfuncreg &= ~mask(regx);

6822	6822		}
6823	6823		else
6824	6824		{
6825		-	if (op == 0xC8)
	6825	+	if (op == ENTER)
6826	6826		do16bit(&ggen, cast(FL)c.IFL1,&c.IEV1,0);
6827	6827		}
6828	6828		flags &= CFseg \| CFoff \| CFselfrel;

2293	2293		regm_t psw = pretregs & mPSW; / save PSW bit */
2294	2294		const op1 = e1.Eoper;
2295	2295		uint sz1 = tysize(e1.Ety);
2296		-	uint rex = (I64 && sz1 == 8) ? REX_W : 0;
2297		-	uint grex = rex << 16;
2298	2296		uint jop = jmpopcode(e1);
2299	2297
2300	2298		uint jop1 = jmpopcode(e21);

2341	2339		e22.Eoper == OPconst
2342	2340		)
2343	2341		{
	2342	+	uint sz = tysize(e.Ety);
	2343	+	uint rex = (I64 && sz == 8) ? REX_W : 0;
	2344	+	uint grex = rex << 16;
	2345	+
2344	2346		regm_t retregs;
2345	2347		targ_size_t v1,v2;
2346	2348

2357	2359		retregs = BYTEREGS;
2358	2360		}
2359	2361
2360		-	cdcmp_flag = 1;
	2362	+	cdcmp_flag = 1 \| rex;
2361	2363		v1 = cast(targ_size_t)e21.EV.Vllong;
2362	2364		v2 = cast(targ_size_t)e22.EV.Vllong;
2363	2365		if (jop == JNC)

551	547		VarDeclaration v = (*fd.parameters)[i];
552	548		debug (LOG)
553	549		{
554		-	printf("arg[%d] = %s\n", i, earg.toChars());
	550	+	printf("arg[%zu] = %s\n", i, earg.toChars());
555	551		}
556	552		ctfeGlobals.stack.push(v);
557	553

595	591		}
596	592		debug (LOG)
597	593		{
598		-	printf("interpreted arg[%d] = %s\n", i, earg.toChars());
	594	+	printf("interpreted arg[%zu] = %s\n", i, earg.toChars());
599	595		showCtfeExpr(earg);
600	596		}
601	597		debug (LOGASSIGN)
602	598		{
603		-	printf("interpreted arg[%d] = %s\n", i, earg.toChars());
	599	+	printf("interpreted arg[%zu] = %s\n", i, earg.toChars());
604	600		showCtfeExpr(earg);
605	601		}
606	602		}

3441	3439		else
3442	3440		{
3443	3441		L1:
3444		-	e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
	3442	+	e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
3445	3443		if (exceptionOrCant(e1))
3446	3444		return;
3447	3445

3587	3585		result = CTFEExp.cantexp;
3588	3586		return;
3589	3587		}
3590		-	e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
	3588	+	e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
3591	3589		if (exceptionOrCant(e1))
3592	3590		return;
3593	3591

214	214
215	215		__gshared CtfeGlobals ctfeGlobals;
216	216
217		-	enum CtfeGoal : int
	217	+	enum CTFEGoal : int
218	218		{
219		-	ctfeNeedRvalue, // Must return an Rvalue (== CTFE value)
220		-	ctfeNeedLvalue, // Must return an Lvalue (== CTFE reference)
221		-	ctfeNeedNothing, // The return value is not required
	219	+	RValue, /// Must return an Rvalue (== CTFE value)
	220	+	LValue, /// Must return an Lvalue (== CTFE reference)
	221	+	Nothing, /// The return value is not required
222	222		}
223	223
224		-	alias ctfeNeedRvalue = CtfeGoal.ctfeNeedRvalue;
225		-	alias ctfeNeedLvalue = CtfeGoal.ctfeNeedLvalue;
226		-	alias ctfeNeedNothing = CtfeGoal.ctfeNeedNothing;
227		-
228	224		//debug = LOG;
229	225		//debug = LOGASSIGN;
230	226		//debug = LOGCOMPILE;

471	467		return CTFEExp.cantexp;
472	468		}
473	469		// Convert all reference arguments into lvalue references
474		-	earg = interpretRegion(earg, istate, ctfeNeedLvalue);
	470	+	earg = interpretRegion(earg, istate, CTFEGoal.LValue);
475	471		if (CTFEExp.isCantExp(earg))
476	472		return earg;
477	473		}

715	711		alias visit = Visitor.visit;
716	712		public:
717	713		InterState* istate;
718		-	CtfeGoal goal;
	714	+	CTFEGoal goal;
719	715		Expression result;
720	716		UnionExp* pue; // storage for `result`
721	717
722		-	extern (D) this(UnionExp* pue, InterState* istate, CtfeGoal goal)
	718	+	extern (D) this(UnionExp* pue, InterState* istate, CTFEGoal goal)
723	719		{
724	720		this.pue = pue;
725	721		this.istate = istate;

786	782		if (s.exp && s.exp.hasCode)
787	783		incUsageCtfe(istate, s.loc);
788	784
789		-	Expression e = interpret(pue, s.exp, istate, ctfeNeedNothing);
	785	+	Expression e = interpret(pue, s.exp, istate, CTFEGoal.Nothing);
790	786		if (exceptionOrCant(e))
791	787		return;
792	788		}

1004	1000		*/
1005	1001		if (tf.isref)
1006	1002		{
1007		-	result = interpret(pue, s.exp, istate, ctfeNeedLvalue);
	1003	+	result = interpret(pue, s.exp, istate, CTFEGoal.LValue);
1008	1004		return;
1009	1005		}
1010	1006		if (tf.next && tf.next.ty == Tdelegate && istate.fd.closureVars.dim > 0)

1223	1219		UnionExp uei = void;
1224	1220		if (s.increment)
1225	1221		incUsageCtfe(istate, s.increment.loc);
1226		-	e = interpret(&uei, s.increment, istate, ctfeNeedNothing);
	1222	+	e = interpret(&uei, s.increment, istate, CTFEGoal.Nothing);
1227	1223		if (exceptionOrCant(e))
1228	1224		return;
1229	1225		}

1723	1719		{
1724	1720		printf("%s ThisExp::interpret() %s\n", e.loc.toChars(), e.toChars());
1725	1721		}
1726		-	if (goal == ctfeNeedLvalue)
	1722	+	if (goal == CTFEGoal.LValue)
1727	1723		{
1728	1724		// We might end up here with istate being zero
1729	1725		// https://issues.dlang.org/show_bug.cgi?id=16382

1972	1968		return;
1973	1969		}
1974	1970		}
1975		-	auto er = interpret(e.e1, istate, ctfeNeedLvalue);
	1971	+	auto er = interpret(e.e1, istate, CTFEGoal.LValue);
1976	1972		if (auto ve = er.isVarExp())
1977	1973		if (ve.var == istate.fd.vthis)
1978	1974		er = interpret(er, istate);

2020	2016		}
2021	2017		}
2022	2018
2023		-	static Expression getVarExp(const ref Loc loc, InterState* istate, Declaration d, CtfeGoal goal)
	2019	+	static Expression getVarExp(const ref Loc loc, InterState* istate, Declaration d, CTFEGoal goal)
2024	2020		{
2025	2021		Expression e = CTFEExp.cantexp;
2026	2022		if (VarDeclaration v = d.isVarDeclaration())

2128	2124		errorSupplemental(vie.var.loc, "`%s` was uninitialized and used before set", vie.var.toChars());
2129	2125		return CTFEExp.cantexp;
2130	2126		}
2131		-	if (goal != ctfeNeedLvalue && (v.isRef() \|\| v.isOut()))
	2127	+	if (goal != CTFEGoal.LValue && (v.isRef() \|\| v.isOut()))
2132	2128		e = interpret(e, istate, goal);
2133	2129		}
2134	2130		if (!e)

Compare 873921b ... +15 ... fe4b650

No flags found

Show failed CI and contexual commits c 17 Commits

Compare `873921b ... +15 ... fe4b650`

Show failed CI and contexual commits `c`

17 Commits

2163	2159		return;
2164	2160		}
2165	2161
2166		-	if (goal == ctfeNeedLvalue)
	2162	+	if (goal == CTFEGoal.LValue)
2167	2163		{
2168		-	VarDeclaration v = e.var.isVarDeclaration();
2169		-	if (v && !v.isDataseg() && !v.isCTFE() && !istate)
2170		-	{
2171		-	e.error("variable `%s` cannot be read at compile time", v.toChars());
2172		-	result = CTFEExp.cantexp;
2173		-	return;
2174		-	}
2175		-	if (v && !hasValue(v))
	2164	+	if (auto v = e.var.isVarDeclaration())
2176	2165		{
2177		-	if (!v.isCTFE() && v.isDataseg())
2178		-	e.error("static variable `%s` cannot be read at compile time", v.toChars());
2179		-	else // CTFE initiated from inside a function
	2166	+	if (!v.isDataseg() && !v.isCTFE() && !istate)
	2167	+	{
2180	2168		e.error("variable `%s` cannot be read at compile time", v.toChars());
2181		-	result = CTFEExp.cantexp;
2182		-	return;
2183		-	}
2184		-
2185		-	if (v && (v.storage_class & (STC.out_ \| STC.ref_)) && hasValue(v))
2186		-	{
2187		-	// Strip off the nest of ref variables
2188		-	Expression ev = getValue(v);
2189		-	if (ev.op == TOK.variable \|\|
2190		-	ev.op == TOK.index \|\|
2191		-	ev.op == TOK.slice \|\|
2192		-	ev.op == TOK.dotVariable)
	2169	+	result = CTFEExp.cantexp;
	2170	+	return;
	2171	+	}
	2172	+	if (!hasValue(v))
2193	2173		{
2194		-	result = interpret(pue, ev, istate, goal);
	2174	+	if (!v.isCTFE() && v.isDataseg())
	2175	+	e.error("static variable `%s` cannot be read at compile time", v.toChars());
	2176	+	else // CTFE initiated from inside a function
	2177	+	e.error("variable `%s` cannot be read at compile time", v.toChars());
	2178	+	result = CTFEExp.cantexp;
2195	2179		return;
2196	2180		}
	2181	+
	2182	+	if (v.storage_class & (STC.out_ \| STC.ref_))
	2183	+	{
	2184	+	// Strip off the nest of ref variables
	2185	+	Expression ev = getValue(v);
	2186	+	if (ev.op == TOK.variable \|\|
	2187	+	ev.op == TOK.index \|\|
	2188	+	ev.op == TOK.slice \|\|
	2189	+	ev.op == TOK.dotVariable)
	2190	+	{
	2191	+	result = interpret(pue, ev, istate, goal);
	2192	+	return;
	2193	+	}
	2194	+	}
2197	2195		}
2198	2196		result = e;
2199	2197		return;

2380	2378		{
2381	2379		printf("%s TupleExp::interpret() %s\n", e.loc.toChars(), e.toChars());
2382	2380		}
2383		-	if (exceptionOrCant(interpretRegion(e.e0, istate, ctfeNeedNothing)))
	2381	+	if (exceptionOrCant(interpretRegion(e.e0, istate, CTFEGoal.Nothing)))
2384	2382		return;
2385	2383
2386	2384		auto expsx = e.exps;

2391	2389		return;
2392	2390
2393	2391		// A tuple of assignments can contain void (Bug 5676).
2394		-	if (goal == ctfeNeedNothing)
	2392	+	if (goal == CTFEGoal.Nothing)
2395	2393		continue;
2396	2394		if (ex.op == TOK.voidExpression)
2397	2395		{

2732	2730		return;
2733	2731		}
2734	2732
2735		-	Expression epre = interpret(pue, e.argprefix, istate, ctfeNeedNothing);
	2733	+	Expression epre = interpret(pue, e.argprefix, istate, CTFEGoal.Nothing);
2736	2734		if (exceptionOrCant(epre))
2737	2735		return;
2738	2736

3264	3262
3265	3263		// Get the value to return. Note that 'newval' is an Lvalue,
3266	3264		// so if we need an Rvalue, we have to interpret again.
3267		-	if (goal == ctfeNeedRvalue)
	3265	+	if (goal == CTFEGoal.RValue)
3268	3266		result = interpretRegion(newval, istate);
3269	3267		else
3270	3268		result = e1; // VarExp is a CTFE reference

3399	3397		}
3400	3398
3401	3399		// We must set to aggregate with newaae
3402		-	e1 = interpretRegion(e1, istate, ctfeNeedLvalue);
	3400	+	e1 = interpretRegion(e1, istate, CTFEGoal.LValue);
3403	3401		if (exceptionOrCant(e1))
3404	3402		return;
3405	3403		e1 = assignToLvalue(e, e1, newaae);

3614	3612		newval = pue.copy();
3615	3613
3616	3614		// Determine the return value
3617		-	if (goal == ctfeNeedLvalue) // https://issues.dlang.org/show_bug.cgi?id=14371
	3615	+	if (goal == CTFEGoal.LValue) // https://issues.dlang.org/show_bug.cgi?id=14371
3618	3616		result = e1;
3619	3617		else
3620	3618		{

3649	3647		return;
3650	3648		if (auto se = e.e1.isSliceExp())
3651	3649		{
3652		-	Expression e1x = interpretRegion(se.e1, istate, ctfeNeedLvalue);
	3650	+	Expression e1x = interpretRegion(se.e1, istate, CTFEGoal.LValue);
3653	3651		if (auto dve = e1x.isDotVarExp())
3654	3652		{
3655	3653		auto ex = dve.e1;

3872	3870		*
3873	3871		* Returns TOK.cantExpression on failure. If there are no errors,
3874	3872		* it returns aggregate[low..upp], except that as an optimisation,
3875		-	* if goal == ctfeNeedNothing, it will return NULL
	3873	+	* if goal == CTFEGoal.Nothing, it will return NULL
3876	3874		*/
3877	3875		private Expression interpretAssignToSlice(UnionExp* pue, BinExp e, Expression e1, Expression newval, bool isBlockAssignment)
3878	3876		{

4042	4040		{
4043	4041		existingSE.setCodeUnit(cast(size_t)(i + firstIndex), value);
4044	4042		}
4045		-	if (goal == ctfeNeedNothing)
	4043	+	if (goal == CTFEGoal.Nothing)
4046	4044		return null; // avoid creating an unused literal
4047	4045		auto retslice = ctfeEmplaceExp!SliceExp(e.loc, existingSE,
4048	4046		ctfeEmplaceExp!IntegerExp(e.loc, firstIndex, Type.tsize_t),