pxt-core 13.2.2 → 13.2.3

package/built/pxtcompiler.js

@@ -1138,6 +1138,10 @@ ${baseLabel}_nochk:
             }
             emitFieldAccess(e, store = false) {
                 let info = e.data;
+                if (!store && this.shouldSpecializeCheckedFieldLoad(info)) {
+                    this.emitCheckedFieldLoad(info);
+                    return;
+                }
                 let pref = store ? "st" : "ld";
                 let lbl = pref + "fld_" + info.classInfo.id + "_" + info.name;
                 if (info.needsCheck && !pxtc.target.switches.skipClassCheck) {
@@ -1156,6 +1160,32 @@ ${baseLabel}_nochk:
                     this.write(`ldr r0, [r0, ${xoff}]`);
                 return;
             }
+            checkedFieldAccessCountKey(info) {
+                return `${info.classInfo.id}:${info.name}:get`;
+            }
+            shouldSpecializeCheckedFieldLoad(info) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                if (pxtc.target.switches.skipClassCheck || !info.needsCheck)
+                    return false;
+                return (this.bin.checkedFieldAccessCounts[this.checkedFieldAccessCountKey(info)] || 0) >= 5;
+            }
+            emitCheckedFieldLoad(info) {
+                const helperKey = "ldfldchk_" + info.classInfo.id + "_" + info.name;
+                const helper = this.ensureLabelledHelper(helperKey, () => {
+                    this.write(this.t.helper_prologue());
+                    this.emitInstanceOf(info.classInfo, "validate");
+                    let off = info.idx * 4 + 4;
+                    let xoff = "#" + off;
+                    if (off > 124) {
+                        this.write(this.t.emit_int(off, "r3"));
+                        xoff = "r3";
+                    }
+                    this.write(`ldr r0, [r0, ${xoff}]`);
+                    this.write(this.t.helper_epilogue());
+                });
+                this.write(this.t.call_lbl(helper, false, this.stackAlignmentNeeded(0)));
+            }
             writeFailBranch() {
                 this.write(`.fail:`);
                 this.write(`mov r1, lr`);
@@ -1376,12 +1406,50 @@ ${baseLabel}_nochk:
             }
             emitIfaceCall(procid, numargs, getset = "") {
                 pxtc.U.assert(procid.ifaceIndex > 0);
-                this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
-                this.emitLabelledHelper("ifacecall" + numargs + "_" + getset, () => {
+                const helperKey = "ifacecall" + numargs + "_" + getset;
+                const helper = this.ensureLabelledHelper(helperKey, () => {
                     this.write(`ldr r0, [sp, #0] ; ld-this`);
                     this.loadVTable();
                     this.ifaceCallCore(numargs, getset);
                 });
+                if (this.shouldSpecializeIfaceCall(procid.ifaceIndex, numargs, getset)) {
+                    const thunkKey = helperKey + "_i" + procid.ifaceIndex;
+                    this.emitLabelledHelper(thunkKey, () => {
+                        this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
+                        this.write(`ldlit r7, ${helper}@fn`);
+                        this.write(`bx r7`);
+                    });
+                }
+                else {
+                    this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
+                    this.write(this.t.call_lbl(helper));
+                }
+            }
+            ifaceCallCountKey(ifaceIndex, numargs, getset) {
+                return `${ifaceIndex}:${numargs}:${getset || "call"}`;
+            }
+            // Count-driven specialization decisions (this method and the related
+            // shouldSpecializeCheckedFieldLoad / shouldSpecializeMapSetByFieldId) assume:
+            //  - bin.finalPass is true, AND
+            //  - the count maps were populated during the same final-pass emit()
+            //    call that builds the IR this asm walk consumes.
+            // This is currently true because the frontend populates counts during IR
+            // generation and the backend reads them only during the subsequent asm walk.
+            // Any future change that interleaves IR generation with asm emission would
+            // silently regress these to "always false".
+            //
+            // Threshold of 3 is the break-even point for the labelled-thunk pattern:
+            // each shared call site saves ~4 bytes vs an inline call, and the thunk
+            // itself costs ~12 bytes. At 3 callers, savings break even with thunk cost.
+            shouldSpecializeIfaceCall(ifaceIndex, numargs, getset) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                const count = this.bin.ifaceCallCounts[this.ifaceCallCountKey(ifaceIndex, numargs, getset)] || 0;
+                if (getset == "get" && numargs == 1)
+                    return count >= 3;
+                if (getset == "set" || !getset)
+                    return count >= 3;
+                return false;
             }
             // vtable in r3; clobber r2
             checkSubtype(info, failLbl = ".fail", r2 = "r2") {
@@ -1479,6 +1547,8 @@ ${baseLabel}_nochk:
             }
             emitRtCall(topExpr, genCall = null) {
                 let name = topExpr.data;
+                const mapSetFieldId = this.mapSetByFieldId(topExpr);
+                const specializeMapSetFieldId = mapSetFieldId !== undefined && this.shouldSpecializeMapSetByFieldId(mapSetFieldId);
                 if (name == "pxt::beginTry") {
                     return this.emitBeginTry(topExpr);
                 }
@@ -1491,6 +1561,8 @@ ${baseLabel}_nochk:
                     isRef: (maskInfo.refMask & (1 << i)) != 0,
                     conv: convs.find(c => c.argIdx == i)
                 }));
+                if (specializeMapSetFieldId)
+                    allArgs = allArgs.filter(a => a.idx != 1);
                 pxtc.U.assert(allArgs.length <= 4);
                 let seenUpdate = false;
                 for (let a of pxtc.U.reversed(allArgs)) {
@@ -1593,33 +1665,69 @@ ${baseLabel}_nochk:
                     genCall();
                 }
                 else {
-                    if (name != "langsupp::ignore")
+                    if (specializeMapSetFieldId)
+                        this.emitMapSetByFieldIdCall(mapSetFieldId);
+                    else if (name != "langsupp::ignore")
                         this.alignedCall(name, "", 0, true);
                 }
                 if (clearStack) {
                     this.clearArgs(complexArgs.filter(a => !a.isRef).map(a => a.expr), complexArgs.filter(a => a.isRef).map(a => a.expr));
                 }
             }
+            mapSetByFieldId(topExpr) {
+                if (topExpr.data != "pxtrt::mapSet" || topExpr.args.length != 3)
+                    return undefined;
+                const fieldId = topExpr.args[1];
+                if (fieldId.exprKind != pxtc.ir.EK.NumberLiteral || typeof fieldId.data != "number")
+                    return undefined;
+                return fieldId.data;
+            }
+            shouldSpecializeMapSetByFieldId(fieldId) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                return (this.bin.mapSetByFieldIdCounts[fieldId + ""] || 0) >= 3;
+            }
+            emitMapSetByFieldIdCall(fieldId) {
+                const helper = this.ensureLabelledHelper("mapset_i" + fieldId, () => {
+                    this.write(this.t.helper_prologue());
+                    this.write(this.t.emit_int(fieldId, "r1"));
+                    this.write(this.t.callCPP("pxtrt::mapSet"));
+                    this.write(this.t.helper_epilogue());
+                });
+                this.write(this.t.call_lbl(helper, false, this.stackAlignmentNeeded(0)));
+            }
             alignedCall(name, cmt = "", off = 0, saveStack = false) {
                 if (pxtc.U.startsWith(name, "_cmp_") || pxtc.U.startsWith(name, "_pxt_"))
                     saveStack = false;
                 this.write(this.t.call_lbl(name, saveStack, this.stackAlignmentNeeded(off)) + cmt);
             }
-            emitLabelledHelper(lbl, generate) {
+            // Lazily emit a deduped helper body and return its label.
+            // Use this when you want to BRANCH to (or reference) the helper without
+            // emitting a `bl` at the current cursor -- e.g. when wrapping the call in
+            // a thunk, or storing the label for later use.
+            ensureLabelledHelper(lbl, generate) {
                 if (!this.labelledHelpers[lbl]) {
                     let outp = this.redirectOutput(generate);
-                    this.emitHelper(outp, lbl);
-                    this.labelledHelpers[lbl] = this.bin.codeHelpers[outp];
-                }
-                else {
-                    this.write(this.t.call_lbl(this.labelledHelpers[lbl]));
+                    this.labelledHelpers[lbl] = this.helperLabel(outp, lbl);
                 }
+                return this.labelledHelpers[lbl];
             }
-            emitHelper(asm, baseName = "hlp") {
+            // Ensure a deduped helper exists and emit a `bl` to it at the cursor.
+            // Use this for the common case of "factor this sequence into a helper and call it here".
+            emitLabelledHelper(lbl, generate) {
+                const helper = this.ensureLabelledHelper(lbl, generate);
+                this.write(this.t.call_lbl(helper));
+                return helper;
+            }
+            helperLabel(asm, baseName = "hlp") {
                 if (!this.bin.codeHelpers[asm]) {
                     let len = Object.keys(this.bin.codeHelpers).length;
                     this.bin.codeHelpers[asm] = `_${baseName}_${len}`;
                 }
+                return this.bin.codeHelpers[asm];
+            }
+            emitHelper(asm, baseName = "hlp") {
+                this.helperLabel(asm, baseName);
                 this.write(this.t.call_lbl(this.bin.codeHelpers[asm]));
             }
             pushToExprStack(a) {
@@ -1656,48 +1764,85 @@ ${baseLabel}_nochk:
                     }
                 }
             }
-            emitFieldMethods() {
-                for (let op of ["get", "set"]) {
-                    this.write(`
+            emitFieldMethod(op) {
+                this.write(`
                 ${this.helperObject(op)}
                 .section code
                 _pxt_map_${op}:
                 `);
-                    this.loadVTable("r4");
-                    this.checkSubtype(this.builtInClassNo(pxt.BuiltInType.RefMap), ".notmap", "r4");
-                    this.write(this.t.callCPPPush(op == "set" ? "pxtrt::mapSetByString" : "pxtrt::mapGetByString"));
-                    this.write(".notmap:");
-                    let numargs = op == "set" ? 2 : 1;
-                    let hasAlign = false;
-                    this.write("mov r4, r3 ; save VT");
-                    if (op == "set") {
-                        if (pxtc.target.stackAlign) {
-                            hasAlign = true;
-                            this.write("push {lr} ; align");
-                        }
-                        this.write(`
+                this.loadVTable("r4");
+                this.checkSubtype(this.builtInClassNo(pxt.BuiltInType.RefMap), ".notmap", "r4");
+                this.write(this.t.callCPPPush(op == "set" ? "pxtrt::mapSetByString" : "pxtrt::mapGetByString"));
+                this.write(".notmap:");
+                let numargs = op == "set" ? 2 : 1;
+                let hasAlign = false;
+                this.write("mov r4, r3 ; save VT");
+                if (op == "set") {
+                    if (pxtc.target.stackAlign) {
+                        hasAlign = true;
+                        this.write("push {lr} ; align");
+                    }
+                    this.write(`
                             push {r0, r2, lr}
                             mov r0, r1
                         `);
-                    }
-                    else {
-                        this.write(`
+                }
+                else {
+                    this.write(`
                             push {r0, lr}
                             mov r0, r1
                         `);
-                    }
-                    this.write(`
+                }
+                this.write(`
                     bl pxtrt::lookupMapKey
                     mov r1, r0 ; put key index in r1
                     ldr r0, [sp, #0] ; restore obj pointer
                     mov r3, r4 ; restore vt
                     bl .dowork
                 `);
-                    this.write(this.t.pop_locals(numargs + (hasAlign ? 1 : 0)));
-                    this.write("pop {pc}");
-                    this.write(".dowork:");
-                    this.ifaceCallCore(numargs, op, true);
-                }
+                this.write(this.t.pop_locals(numargs + (hasAlign ? 1 : 0)));
+                this.write("pop {pc}");
+                this.write(".dowork:");
+                this.ifaceCallCore(numargs, op, true);
+            }
+            emitStringMapSetMethod() {
+                // Fast path for the well-typed "map with string index signature" case.
+                // - tagged-int / null receivers: unrecoverable, panic with failedCast (matches the
+                //   pre-optimization mapSetGeneric path, which also can't proceed on these).
+                // - non-RefMap pointer receivers: tail-call _pxt_map_set, which handles
+                //   non-map objects via interface dispatch. Preserves back-compat for code that
+                //   casts non-map objects to a string-index-signature type.
+                //
+                // Emitted only when the final-pass IR selected mapSetByStringOnly
+                // (never under `noIfaceSpec`): unreferenced helper text costs image
+                // space in every program otherwise.
+                if (!this.bin.usesMapSetByStringOnly)
+                    return;
+                this.write(`
+                ${this.helperObject("set string map")}
+                .section code
+                _pxt_map_set_by_string:
+                    lsls r4, r0, #30
+                    bne .badtype
+                    cmp r0, #0
+                    beq .badtype
+                    ldr r3, [r0, #0]
+                `);
+                this.write(`
+                ldrh r4, [r3, #8]
+                cmp r4, #${pxt.BuiltInType.RefMap}
+                bne .fallback
+            `);
+                this.write(this.t.callCPPPush("pxtrt::mapSetByString"));
+                this.write(`
+                .fallback:
+                    b _pxt_map_set
+                .badtype:
+                    mov r1, lr
+                    mov r7, sp
+                    str r7, [r6, #4]
+                    bl pxt::failedCast
+            `);
             }
             emitArrayMethod(op, isBuffer) {
                 this.write(`
@@ -1783,6 +1928,12 @@ ${baseLabel}_nochk:
                     this.emitArrayMethod(op, false);
                 }
             }
+            emitFieldMethods() {
+                for (let op of ["get", "set"]) {
+                    this.emitFieldMethod(op);
+                }
+                this.emitStringMapSetMethod();
+            }
             emitLambdaTrampoline() {
                 let r3 = pxtc.target.stackAlign ? "r3," : "";
                 this.write(`
@@ -2130,6 +2281,12 @@ ${baseLabel}_nochk:
                     this.write(`.short 0, 0 ; no captured vars`);
                     this.write(`.word ${this.proc.label()}_args@fn`);
                 }
+                if (this.proc.useExactIfaceWrapper) {
+                    this.write(`${this.proc.label()}_iface:`);
+                    this.write(`b ${this.proc.label()}_nochk`);
+                    if (!this.proc.info.usedAsValue)
+                        return;
+                }
                 this.write(`${this.proc.label()}_args:`);
                 let numargs = this.proc.args.length;
                 if (numargs == 0)
@@ -2898,6 +3055,17 @@ var ts;
             "pxt::fromInt": "_numops_fromInt",
             "pxt::switch_eq": "_pxt_switch_eq",
         };
+        // Boolean conversion fast paths, kept out of inlineArithmetic so the
+        // `noBoolLower` flag can drop the group (redirects and helper bodies alike).
+        const inlineBoolOps = {
+            "pxt::fromBool": "_pxt_fromBool",
+            "numops::toBool": "_numops_toBool",
+            "numops::toBoolDecr": "_numops_toBoolDecr",
+            "Boolean_::bang": "_pxt_boolean_bang",
+        };
+        function boolLowerEnabled() {
+            return !pxtc.target.switches.noBoolLower;
+        }
         // snippets for ARM Thumb assembly
         class ThumbSnippets extends pxtc.AssemblerSnippets {
             stackAligned() {
@@ -3005,6 +3173,8 @@ ${lbl}:`;
             }
             call_lbl(lbl, saveStack, stackAlign) {
                 let o = pxtc.U.lookup(inlineArithmetic, lbl);
+                if (!o && boolLowerEnabled())
+                    o = pxtc.U.lookup(inlineBoolOps, lbl);
                 if (o) {
                     lbl = o;
                     saveStack = false;
@@ -3176,6 +3346,99 @@ _numops_fromInt:
     blx lr
 .over2:
     ${this.callCPPPush("pxt::fromInt")}
+`;
+                // skipped under `noBoolLower` flag: unreferenced helper text still costs image space
+                if (boolLowerEnabled())
+                    r += `
+; Tag a raw 0/1 truth value into a boolean object (taggedTrue/taggedFalse).
+; Inverse of the toBool fast paths below; matches C++ pxt::fromBool.
+_pxt_fromBool:
+    @scope _pxt_fromBool
+    cmp r0, #0
+    beq .false
+.true:
+    movs r0, #${pxtc.taggedTrue}
+    blx lr
+.false:
+    movs r0, #${pxtc.taggedFalse}
+    blx lr
+
+; Logical NOT of a raw 0/1 truth value -> raw 0/1 (matches C++ bool bang(bool)).
+; Callers pass an already-tested condition, so this is raw-in / raw-out; value
+; context (x = !y) wraps the result with fromBool to re-tag it.
+_pxt_boolean_bang:
+    @scope _pxt_boolean_bang
+    cmp r0, #0
+    beq .true
+.false:
+    movs r0, #0
+    blx lr
+.true:
+    movs r0, #1
+    blx lr
+
+; Fast-path truthiness test: tagged value in r0 -> raw 0/1 in r0.
+; Value encodings (see taggedSpecialValue in emitter.ts): tagged int = (n<<1)|1
+; (low bit set); special tags = (n<<2)|2 with undefined=0, null, false, NaN,
+; true; heap objects have low 2 bits 00.
+; Only non-pointer values are decided inline here; any heap object is handed to
+; the C++ helper at .boxed (which also handles boxed numbers/strings like 0.0
+; and ""). INVARIANT: the falsy set below must match C++ numops::toBool exactly
+; -- if a new falsy tagged value is ever added, it must be added here too, or it
+; will fall through to .true.
+_numops_toBool:
+    @scope _numops_toBool
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${pxtc.taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${pxtc.taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${pxtc.taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:                  ; remaining specials (e.g. true) are truthy
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBool")}
+
+; Same truthiness classification as _numops_toBool (see comments above), but
+; this variant also consumes (ref-decrements) its argument. Only heap objects
+; are ref-counted, and those go through the C++ fallback which does the decr;
+; the inline non-pointer paths carry no refcount, so they need none.
+_numops_toBoolDecr:
+    @scope _numops_toBoolDecr
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${pxtc.taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${pxtc.taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${pxtc.taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBoolDecr")}
 `;
                 for (let op of Object.keys(pxtc.thumbCmpMap)) {
                     op = op.replace(/.*::/, "");
@@ -3200,9 +3463,10 @@ _cmp_${op}:
                     // the cmp isn't really needed, given how toBoolDecr() is compiled,
                     // but better not rely on it
                     // Also, cmp isn't needed when ref-counting (it ends with movs r0, r4)
+                    const toBoolDecr = boolLowerEnabled() ? "_numops_toBoolDecr" : "numops::toBoolDecr";
                     r += boxedOp(`
                         bl numops::${op}
-                        bl numops::toBoolDecr
+                        bl ${toBoolDecr}
                         cmp r0, #0`);
                 }
                 // switch(x){case k:} compiles to equality tests via pxt::switch_eq.
@@ -8648,6 +8912,7 @@ var ts;
                     this.classInfo = null;
                     this.perfCounterName = null;
                     this.perfCounterNo = 0;
+                    this.useExactIfaceWrapper = false;
                     this.body = [];
                     this.lblNo = 0;
                     this.action = null;
@@ -8665,6 +8930,11 @@ var ts;
                 isGetter() {
                     return this.action && this.action.kind == ts.SyntaxKind.GetAccessor;
                 }
+                // Returns the proc's "_args" entry label -- the full arg-shuffling
+                // wrapper. Use this for any vtable-style reference where the caller
+                // cannot guarantee the wrapper-skip preconditions (numargs >= proc.args.length).
+                // For iface-table entries that CAN accept the optimization, the consumer
+                // (hexfile.ts) inspects useExactIfaceWrapper directly and picks _iface instead.
                 vtLabel() {
                     return this.label() + (pxtc.isStackMachine() ? "" : "_args");
                 }
@@ -9207,6 +9477,11 @@ var ts;
                 argsFmt: ["T", "T", "S", "T"],
                 value: 0
             },
+            "pxtrt::mapSetByStringOnly": {
+                name: "_pxt_map_set_by_string",
+                argsFmt: ["T", "T", "S", "T"],
+                value: 0
+            },
         };
         let EK = pxtc.ir.EK;
         pxtc.SK = ts.SyntaxKind;
@@ -9940,6 +10215,87 @@ var ts;
             bin.breakpoints = opts.breakpoints;
             bin.name = opts.name;
             bin.target = opts.target;
+            function ifaceCallKindCounts(ifaceIndex, getset) {
+                const suffix = ":" + (getset || "call");
+                return Object.keys(bin.ifaceCallCounts)
+                    .filter(k => pxtc.U.startsWith(k, ifaceIndex + ":") && pxtc.U.endsWith(k, suffix))
+                    .map(k => ({
+                    numargs: parseInt(k.split(":")[1]),
+                    count: bin.ifaceCallCounts[k]
+                }));
+            }
+            // Decides whether `proc` (an iface-dispatched method) can safely skip the
+            // arg-shuffling _args wrapper and have its iface vtable entry point directly
+            // at _nochk. Safe iff every call site that targets this (ifaceIndex, getset)
+            // bucket passes at least `proc.args.length` arguments -- that's exactly the
+            // condition the wrapper would short-circuit on (`cmp r4, #numargs; bge _nochk`).
+            //
+            // Notes:
+            // - The counts are a per-(ifaceIndex, getset) projection, not per-proc. In a
+            //   polymorphic iface bucket each proc is evaluated independently; eligibility
+            //   ends up cascading to the proc with the largest args.length in the bucket.
+            // - toString is excluded because hexfile.ts:~841 wires toString's vtable
+            //   slot to `vtLabel()` (i.e. _args). The fixed-slot dispatch through that
+            //   vtable entry has no arg-count guarantees, so the wrapper is required.
+            //   Skipping it for a toString proc would dangle the _args reference.
+            //   Any future fixed-slot vtable consumer that uses vtLabel() must add a
+            //   matching exclusion here.
+            // - dynamicIfaceCalls disqualifies any ifaceIndex ever dispatched without a
+            //   known decl (line ~2503). Those callers don't go through the counted path.
+            // - The "no get calls in a non-get bucket" check is conservative: a "get"
+            //   syntax call has args.length == 1 which could under-feed a multi-arg call
+            //   target sharing the bucket.
+            function canUseExactIfaceWrapper(proc, ifaceIndex, getset) {
+                if (!isThumb() || !proc || !proc.info.usedAsIface || proc.args.length == 0)
+                    return false;
+                if (proc.action && isToString(proc.action))
+                    return false;
+                if (bin.dynamicIfaceCalls[ifaceIndex + ""])
+                    return false;
+                if (!getset && ifaceCallKindCounts(ifaceIndex, "get").length)
+                    return false;
+                const counts = ifaceCallKindCounts(ifaceIndex, getset);
+                return counts.every(c => c.numargs >= proc.args.length);
+            }
+            // Must run AFTER the final-pass emit(rootFunction) has populated
+            // bin.ifaceCallCounts and bin.dynamicIfaceCalls, and BEFORE
+            // hexfile.ts emits iface vtables (which read useExactIfaceWrapper to
+            // pick _iface vs _args per entry) and backbase.ts emits proc wrappers
+            // (which read useExactIfaceWrapper to decide whether to emit _iface).
+            function markExactIfaceWrappers() {
+                bin.procs.forEach(p => p.useExactIfaceWrapper = false);
+                if (!isThumb() || pxtc.target.switches.noIfaceSpec)
+                    return;
+                const eligible = {};
+                const seen = {};
+                const note = (proc, ifaceIndex, getset) => {
+                    if (!proc || proc.args.length == 0)
+                        return;
+                    const key = proc.seqNo + "";
+                    seen[key] = true;
+                    if (eligible[key] === undefined)
+                        eligible[key] = true;
+                    if (!canUseExactIfaceWrapper(proc, ifaceIndex, getset))
+                        eligible[key] = false;
+                };
+                for (const info of bin.usedClassInfos) {
+                    if (!info.itable)
+                        continue;
+                    for (const entry of info.itable) {
+                        if (entry.proc)
+                            note(entry.proc, entry.idx, entry.proc.isGetter() ? "get" : "");
+                        if (entry.setProc)
+                            note(entry.setProc, entry.idx, "set");
+                    }
+                }
+                for (const proc of bin.procs) {
+                    const key = proc.seqNo + "";
+                    proc.useExactIfaceWrapper = !!seen[key] && !!eligible[key];
+                }
+            }
+            function emitEscapedExpression(expr, reason) {
+                return emitExpr(expr);
+            }
             function reset() {
                 bin.reset();
                 proc = null;
@@ -10020,7 +10376,13 @@ var ts;
             reset();
             needsUsingInfo = false;
             bin.finalPass = true;
+            bin.ifaceCallCounts = {};
+            bin.mapSetByFieldIdCounts = {};
+            bin.checkedFieldAccessCounts = {};
+            bin.dynamicIfaceCalls = {};
+            bin.usesMapSetByStringOnly = false;
             emit(rootFunction);
+            markExactIfaceWrappers();
             pxtc.U.assert(usedWorkList.length == 0);
             res.configData = [];
             for (let k of Object.keys(configEntries)) {
@@ -10710,7 +11072,7 @@ ${lbl}: .short 0xffff
                 let coll = pxtc.ir.shared(pxtc.ir.rtcall("Array_::mk", []));
                 for (let elt of node.elements) {
                     let mask = isRefCountedExpr(elt) ? (1 << 1) : 0;
-                    proc.emitExpr(pxtc.ir.rtcall("Array_::push", [coll, emitExpr(elt)], mask));
+                    proc.emitExpr(pxtc.ir.rtcall("Array_::push", [coll, emitEscapedExpression(elt, "arrayElement")], mask));
                 }
                 if (node.elements.length > 0)
                     // Make sure there is at least one use of the array, so it doesn't get GC-ed away in the last push.
@@ -10752,8 +11114,11 @@ ${lbl}: .short 0xffff
                         if (isRefCountedExpr(p.initializer))
                             mask |= 1 << 2;
                     }
+                    const nativeFieldId = pxtc.target.isNative ? getIfaceMemberId(keyName) : undefined;
+                    if (nativeFieldId !== undefined)
+                        bin.mapSetByFieldIdCounts[nativeFieldId + ""] = (bin.mapSetByFieldIdCounts[nativeFieldId + ""] || 0) + 1;
                     const fieldId = pxtc.target.isNative
-                        ? pxtc.ir.numlit(getIfaceMemberId(keyName))
+                        ? pxtc.ir.numlit(nativeFieldId)
                         : pxtc.ir.ptrlit(null, JSON.stringify(keyName));
                     const args = [
                         expr,
@@ -10813,6 +11178,9 @@ ${lbl}: .short 0xffff
                             return emitShim(fld, decl, [node.expression]);
                         }
                         else {
+                            if (idx.needsCheck && !pxtc.target.switches.skipClassCheck) {
+                                bin.checkedFieldAccessCounts[checkedFieldAccessCountKey(idx)] = (bin.checkedFieldAccessCounts[checkedFieldAccessCountKey(idx)] || 0) + 1;
+                            }
                             return pxtc.ir.op(EK.FieldAccess, [emitExpr(node.expression)], idx);
                         }
                     }
@@ -10866,7 +11234,17 @@ ${lbl}: .short 0xffff
                     indexer = assign ? attrs.indexerSet : attrs.indexerGet;
                 }
                 if (!indexer && (t.flags & (ts.TypeFlags.Any | ts.TypeFlags.StructuredOrTypeVariable))) {
-                    indexer = assign ? "pxtrt::mapSetGeneric" : "pxtrt::mapGetGeneric";
+                    const hasIndexSignature = !!checker.getIndexTypeOfType(t, ts.IndexKind.String) || !!checker.getIndexTypeOfType(t, ts.IndexKind.Number);
+                    // Native-only: mapSetByStringOnly resolves to the _pxt_map_set_by_string
+                    // thumb helper. The JS backend has no such runtime entry, so the generic
+                    // setter is the only valid choice there.
+                    const mapOnlySet = !pxtc.target.switches.noIfaceSpec && pxtc.target.isNative
+                        && !!assign && !(t.flags & ts.TypeFlags.Any) && hasIndexSignature;
+                    if (mapOnlySet)
+                        bin.usesMapSetByStringOnly = true;
+                    indexer = assign
+                        ? (mapOnlySet ? "pxtrt::mapSetByStringOnly" : "pxtrt::mapSetGeneric")
+                        : "pxtrt::mapGetGeneric";
                     stringOk = true;
                 }
                 if (indexer) {
@@ -11203,7 +11581,7 @@ ${lbl}: .short 0xffff
                         lst.push(tracked);
                 }
                 function emitPlain() {
-                    let r = mkProcCall(decl, node, args.map((x) => emitExpr(x)));
+                    let r = mkProcCall(decl, node, args.map(x => emitEscapedExpression(x, "callArgument")));
                     let pp = r.data;
                     if (args[0] && pp.proc && pp.proc.classInfo)
                         pp.isThis = args[0].kind == pxtc.SK.ThisKeyword;
@@ -11230,7 +11608,7 @@ ${lbl}: .short 0xffff
                         baseCtor = p.ctor;
                     if (!baseCtor && bin.finalPass)
                         throw userError(9280, lf("super() call requires an explicit constructor in base class"));
-                    let ctorArgs = args.map((x) => emitExpr(x));
+                    let ctorArgs = args.map((x) => emitEscapedExpression(x, "callArgument"));
                     ctorArgs.unshift(emitThis(funcExpr));
                     return mkProcCallCore(baseCtor, node, ctorArgs);
                 }
@@ -11246,9 +11624,11 @@ ${lbl}: .short 0xffff
                         // TODO in VT accessor/field/method -> different
                         pxtc.U.assert(funcExpr.kind == pxtc.SK.PropertyAccessExpression);
                         const fieldName = funcExpr.name.text;
+                        const ifaceIndex = getIfaceMemberId(fieldName, true);
+                        bin.dynamicIfaceCalls[ifaceIndex + ""] = true;
                         // completely dynamic dispatch
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
-                            ifaceIndex: getIfaceMemberId(fieldName, true),
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
+                            ifaceIndex,
                             callLocationIndex: markCallLocation(node),
                             noArgs
                         });
@@ -11272,7 +11652,7 @@ ${lbl}: .short 0xffff
                             pxtc.U.assert(false);
                         }
                         pxtc.U.assert(!bin.finalPass || info.virtualIndex != null, "!bin.finalPass || info.virtualIndex != null");
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
                             classInfo: info.parentClassInfo,
                             virtualIndex: info.virtualIndex,
                             noArgs,
@@ -11312,9 +11692,15 @@ ${lbl}: .short 0xffff
                         return emitPlain();
                     }
                     else if (needsVCall || pxtc.target.switches.slowMethods || !forceMethod) {
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
-                            ifaceIndex: getIfaceMemberId(getName(decl), true),
-                            isSet: noArgs && args.length == 2,
+                        const ifaceIndex = getIfaceMemberId(getName(decl), true);
+                        const isSet = noArgs && args.length == 2;
+                        const callKind = isSet ? "set" : noArgs ? "get" : "call";
+                        const helperGetSet = callKind == "call" ? "" : callKind;
+                        const countKey = `${ifaceIndex}:${args.length}:${helperGetSet || "call"}`;
+                        bin.ifaceCallCounts[countKey] = (bin.ifaceCallCounts[countKey] || 0) + 1;
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
+                            ifaceIndex,
+                            isSet,
                             callLocationIndex: markCallLocation(node),
                             noArgs
                         });
@@ -11333,7 +11719,7 @@ ${lbl}: .short 0xffff
                 // here's where we will recurse to generate funcExpr
                 args.unshift(funcExpr);
                 pxtc.U.assert(!noArgs);
-                return mkMethodCall(args.map(x => emitExpr(x)), {
+                return mkMethodCall(args.map(x => emitEscapedExpression(x, "callArgument")), {
                     virtualIndex: -1,
                     callLocationIndex: markCallLocation(node),
                     noArgs
@@ -11429,6 +11815,8 @@ ${lbl}: .short 0xffff
                 }
             }
             function getCtor(decl) {
+                if (!decl.members)
+                    return null;
                 return decl.members.filter(m => m.kind == pxtc.SK.Constructor)[0];
             }
             function isIfaceMemberUsed(name) {
@@ -11476,7 +11864,7 @@ ${lbl}: .short 0xffff
                         // let sig = checker.getResolvedSignature(node)
                         // TODO: can we have overloeads?
                         addDefaultParametersAndTypeCheck(checker.getResolvedSignature(node), args, ctorAttrs);
-                        let compiled = args.map((x) => emitExpr(x));
+                        let compiled = args.map((x) => emitEscapedExpression(x, "callArgument"));
                         if (ctorAttrs.shim) {
                             // TODO need to deal with refMask and tagged ints here
                             // we drop 'obj' variable
@@ -11865,7 +12253,7 @@ ${lbl}: .short 0xffff
                 for (let f of initalizedFields) {
                     let idx = fieldIndexCore(proc.classInfo, getFieldInfo(proc.classInfo, getName(f)), false);
                     let trg2 = pxtc.ir.op(EK.FieldAccess, [emitLocalLoad(info.thisParameter)], idx);
-                    proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitExpr(f.initializer)]));
+                    proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitEscapedExpression(f.initializer, "initializer")]));
                 }
                 flushHoistedFunctionDefinitions();
                 if (node.body.kind == pxtc.SK.Block) {
@@ -12083,9 +12471,12 @@ ${lbl}: .short 0xffff
                     isRef: true,
                     shimName: attrs.shim,
                     classInfo: info,
-                    needsCheck
+                    needsCheck,
                 };
             }
+            function checkedFieldAccessCountKey(info) {
+                return `${info.classInfo.id}:${info.name}:get`;
+            }
             function fieldIndex(pacc) {
                 const tp = typeOf(pacc.expression);
                 if (isPossiblyGenericClassType(tp)) {
@@ -12116,7 +12507,7 @@ ${lbl}: .short 0xffff
                     if (decl && (isGlobal || isVar(decl) || isParameter(decl))) {
                         let l = lookupCell(decl);
                         recordUse(decl, true);
-                        proc.emitExpr(l.storeByRef(emitExpr(src)));
+                        proc.emitExpr(l.storeByRef(emitEscapedExpression(src, "assignment")));
                     }
                     else {
                         unhandled(trg, lf("bad target identifier"), 9248);
@@ -12132,7 +12523,10 @@ ${lbl}: .short 0xffff
                         }
                         proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
                     }
-                    else if (decl && (decl.kind == pxtc.SK.PropertySignature || decl.kind == pxtc.SK.PropertyAssignment || isSlowField(decl))) {
+                    else if (decl && (decl.kind == pxtc.SK.PropertySignature || decl.kind == pxtc.SK.PropertyAssignment)) {
+                        proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
+                    }
+                    else if (decl && isSlowField(decl)) {
                         proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
                     }
                     else {
@@ -12148,7 +12542,7 @@ ${lbl}: .short 0xffff
                                 }
                             }
                             let trg2 = emitExpr(trg);
-                            proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitExpr(src)]));
+                            proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitEscapedExpression(src, "assignment")]));
                             break;
                         }
                     }
@@ -12559,7 +12953,7 @@ ${lbl}: .short 0xffff
                 let mask = getMask(args);
                 let convInfos = [];
                 let args2 = args.map((a, i) => {
-                    let r = emitExpr(a);
+                    let r = emitEscapedExpression(a, "runtimeCallArgument");
                     if (!needsNumberConversions())
                         return r;
                     let f = fmt[i + 1];
@@ -12897,6 +13291,43 @@ ${lbl}: .short 0xffff
                 emitExprAsStmt(node.expression);
             }
             function emitCondition(expr, inner = null) {
+                // with `noBoolLower` flag, the generic paths below handle every condition
+                const boolLower = !pxtc.target.switches.noBoolLower;
+                // Lower `&&` / `||` used as a condition into short-circuiting jumps
+                // that yield 0/1 directly, instead of boxing the intermediate
+                // booleans and converting them back with a runtime helper.
+                if (boolLower && !inner && !isStackMachine() && expr.kind == pxtc.SK.BinaryExpression) {
+                    const binary = expr;
+                    const op = binary.operatorToken.kind;
+                    if (op == pxtc.SK.AmpersandAmpersandToken || op == pxtc.SK.BarBarToken) {
+                        const shortCircuitLabel = proc.mkLabel("lazycond");
+                        const doneLabel = proc.mkLabel("lazycondfin");
+                        if (op == pxtc.SK.AmpersandAmpersandToken) {
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), pxtc.ir.JmpMode.IfZero);
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), pxtc.ir.JmpMode.IfZero);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(1), pxtc.ir.JmpMode.Always);
+                            proc.emitLbl(shortCircuitLabel);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(0), pxtc.ir.JmpMode.Always);
+                        }
+                        else {
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), pxtc.ir.JmpMode.IfNotZero);
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), pxtc.ir.JmpMode.IfNotZero);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(0), pxtc.ir.JmpMode.Always);
+                            proc.emitLbl(shortCircuitLabel);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(1), pxtc.ir.JmpMode.Always);
+                        }
+                        proc.emitLbl(doneLabel);
+                        return captureJmpValue();
+                    }
+                }
+                // Lower `!expr` used as a condition by negating the operand's
+                // condition directly, avoiding a boxed boolean just to invert it.
+                if (boolLower && !inner && !isStackMachine() && expr.kind == pxtc.SK.PrefixUnaryExpression) {
+                    const unary = expr;
+                    if (unary.operator == pxtc.SK.ExclamationToken) {
+                        return pxtc.ir.rtcall("Boolean_::bang", [emitCondition(unary.operand)]);
+                    }
+                }
                 if (!inner && isThumb() && expr.kind == pxtc.SK.BinaryExpression) {
                     let be = expr;
                     let mapped = pxtc.U.lookup(pxtc.thumbCmpMap, simpleInstruction(be, be.operatorToken.kind));
@@ -13348,7 +13779,10 @@ ${lbl}: .short 0xffff
                         }
                     }
                     typeCheckSubtoSup(node.initializer, node);
-                    proc.emitExpr(loc.storeByRef(emitExpr(node.initializer)));
+                    const initializerExpr = isGlobalVar(node)
+                        ? emitEscapedExpression(node.initializer, "initializer")
+                        : emitExpr(node.initializer);
+                    proc.emitExpr(loc.storeByRef(initializerExpr));
                     currJres = null;
                     proc.stackEmpty();
                 }
@@ -13373,8 +13807,17 @@ ${lbl}: .short 0xffff
                     exres = pxtc.ir.op(EK.FieldAccess, [objRef], fieldIndexCore(info, getFieldInfo(info, fieldName)));
                 }
                 else {
+                    // Dynamic field access on a non-class-typed receiver (any, structural type,
+                    // etc). The call site supplies exactly 1 arg (the receiver) but the target
+                    // proc resolved via iface dispatch may be a method that expects more --
+                    // the _args wrapper is what normally fills in the missing args. Flag this
+                    // ifaceIndex so canUseExactIfaceWrapper disqualifies the wrapper-skip
+                    // optimization for any proc reachable here. Mirrors the dynamic-method-call
+                    // path above.
+                    const ifaceIndex = getIfaceMemberId(fieldName, true);
+                    bin.dynamicIfaceCalls[ifaceIndex + ""] = true;
                     exres = mkMethodCall([objRef], {
-                        ifaceIndex: getIfaceMemberId(fieldName, true),
+                        ifaceIndex,
                         callLocationIndex: markCallLocation(node),
                         noArgs: true
                     });
@@ -13757,6 +14200,11 @@ ${lbl}: .short 0xffff
                 this.usedChars = new Uint32Array(0x10000 / 32);
                 this.explicitlyUsedIfaceMembers = {};
                 this.ifaceMemberMap = {};
+                this.ifaceCallCounts = {};
+                this.mapSetByFieldIdCounts = {};
+                this.checkedFieldAccessCounts = {};
+                this.dynamicIfaceCalls = {};
+                this.usesMapSetByStringOnly = false;
                 this.strings = {};
                 this.hexlits = {};
                 this.doubles = {};
@@ -16207,9 +16655,9 @@ ${lbl}: ${snippets.obj_header("pxt::number_vt")}
             uint32_t ifaceHashMult;
             PVoid methods[2 or 4];
             */
-            const ifaceInfo = computeHashMultiplier(info.itable.map(e => e.idx));
-            //if (info.itable.length == 0)
-            //    ifaceInfo.mult = 0
+            const ifaceInfo = info.itable.length
+                ? computeHashMultiplier(info.itable.map(e => e.idx))
+                : { mult: 0, mapping: new Uint16Array(0), size: 0 };
             let ptrSz = pxtc.target.shortPointers ? ".short" : ".word";
             let s = `
         .object ${info.id}_VT
@@ -16243,6 +16691,11 @@ ${info.id}_IfaceVT:
 `;
             const descSize = 8;
             const zeroOffset = ifaceInfo.mapping.length * 2;
+            // Iface table is the one consumer that can elect the wrapper-skip
+            // optimization. Procs with useExactIfaceWrapper get pointed at _iface
+            // (which `b _nochk`); everyone else gets the usual _args wrapper entry.
+            // canUseExactIfaceWrapper guarantees this is safe for the elected procs.
+            const procIfaceLabel = (p) => (p.useExactIfaceWrapper ? p.label() + "_iface" : p.vtLabel()) + "@fn";
             let descs = "";
             let offset = zeroOffset;
             let offsets = {};
@@ -16250,11 +16703,11 @@ ${info.id}_IfaceVT:
                 offsets[e.idx + ""] = offset;
                 const desc = !e.proc ? 0 : e.proc.isGetter() ? 1 : 2;
                 descs += `  .short ${e.idx}, ${desc} ; ${e.name}\n`;
-                descs += `  .word ${e.proc ? e.proc.vtLabel() + "@fn" : e.info}\n`;
+                descs += `  .word ${e.proc ? procIfaceLabel(e.proc) : e.info}\n`;
                 offset += descSize;
                 if (e.setProc) {
                     descs += `  .short ${e.idx}, 0 ; set ${e.name}\n`;
-                    descs += `  .word ${e.setProc.vtLabel()}@fn\n`;
+                    descs += `  .word ${procIfaceLabel(e.setProc)}\n`;
                     offset += descSize;
                 }
             }
@@ -16267,7 +16720,9 @@ ${info.id}_IfaceVT:
                     bin.itFullEntries++;
             }
             // offsets are relative to the position in the array
-            s += "  .short " + pxtc.U.toArray(map).map((e, i) => (offsets[e + ""] || zeroOffset) - (i * 2)).join(", ") + "\n";
+            const hashOffsets = pxtc.U.toArray(map).map((e, i) => (offsets[e + ""] || zeroOffset) - (i * 2));
+            if (hashOffsets.length)
+                s += "  .short " + hashOffsets.join(", ") + "\n";
             s += descs;
             s += "\n";
             return s;