pxt-common-packages 9.3.7 → 9.3.11

package/libs/color/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P133931(s) {
+function _main___P133949(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___134172 = (undefined);
-    globals._pollEventQueue___134185 = (undefined);
+    globals._intervals___134190 = (undefined);
+    globals._pollEventQueue___134203 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P133931.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
-_main___P133931.continuations = [  ]
+_main___P133949.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
+_main___P133949.continuations = [  ]
 
-function _main___P133931_mk(s) {
+function _main___P133949_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P133931, depth: s.depth + 1,
+        parent: s, fn: _main___P133949, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P133931_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P133931
+return _main___P133949
 })

package/libs/core---esp32/pxt.h

@@ -41,7 +41,9 @@ typedef Buffer Sound;
 typedef struct worker *worker_t;
 worker_t worker_alloc(const char *id, uint32_t stack_size);
 int worker_run(worker_t w, TaskFunction_t fn, void *arg);
+int worker_run_wait(worker_t w, TaskFunction_t fn, void *arg);
 void worker_set_idle(worker_t w, TaskFunction_t fn, void *arg);
+extern worker_t fg_worker;
 
 void memInfo();
 

package/libs/core---esp32/usb.cpp

@@ -240,41 +240,66 @@ int HF2::handlePkt(int sz) {
     return sendResponse(0);
 }
 
-void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend) {
-    if (!connected)
-        return;
+struct BufferEntry {
+    unsigned size;
+    uint8_t flag;
+    uint8_t data[0];
+};
 
-    uint32_t buf[64 / 4]; // aligned
+static void send_buffer_core(void *ent_) {
+    auto ent = (BufferEntry *)ent_;
 
-    if (prepend + 1)
-        size += 4;
+    uint32_t buf[64 / 4]; // aligned
+    auto size = ent->size;
+    auto data = ent->data;
 
-    while (connected && size > 0) {
+    while (hf2.connected && size > 0) {
         memset(buf + 1, 0, 60);
         int s = 63;
         if (size <= 63) {
             s = size;
-            buf[0] = flag;
+            buf[0] = ent->flag;
         } else {
-            buf[0] = flag == HF2_FLAG_CMDPKT_LAST ? HF2_FLAG_CMDPKT_BODY : flag;
+            buf[0] = ent->flag == HF2_FLAG_CMDPKT_LAST ? HF2_FLAG_CMDPKT_BODY : ent->flag;
         }
         buf[0] |= s;
         uint8_t *dst = (uint8_t *)buf;
         dst++;
-        if (prepend + 1) {
-            memcpy(dst, &prepend, 4);
-            prepend = -1;
-            dst += 4;
-            s -= 4;
-            size -= 4;
-        }
         memcpy(dst, data, s);
-        data = (const uint8_t *)data + s;
+        data = data + s;
         size -= s;
 
-        tinyusb_cdcacm_write_queue(TINYUSB_CDC_ACM_0, (uint8_t *)buf, sizeof(buf));
+        if (tinyusb_cdcacm_write_queue(TINYUSB_CDC_ACM_0, (uint8_t *)buf, sizeof(buf)) <
+            sizeof(buf))
+            DMESG("CDC write fail");
         // tinyusb_cdcacm_write_flush(TINYUSB_CDC_ACM_0, 0); - prints warnings
     }
+
+    xfree(ent);
+}
+
+void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend) {
+    if (!connected)
+        return;
+
+    if (prepend + 1)
+        size += 4;
+
+    auto ent = (BufferEntry *)xmalloc(sizeof(BufferEntry) + size);
+    ent->size = size;
+    ent->flag = flag;
+    auto dst = ent->data;
+
+    if (prepend + 1) {
+        memcpy(dst, &prepend, 4);
+        dst += 4;
+        size -= 4;
+    }
+
+    memcpy(dst, data, size);
+
+    if (worker_run_wait(fg_worker, send_buffer_core, ent))
+        DMESG("HF2 queue full");
 }
 
 int HF2::sendEvent(uint32_t evId, const void *data, int size) {

package/libs/core---esp32/worker.cpp

@@ -48,4 +48,12 @@ int worker_run(worker_t w, TaskFunction_t fn, void *arg) {
     return -1;
 }
 
+int worker_run_wait(worker_t w, TaskFunction_t fn, void *arg) {
+    qitem_t evt = {fn, arg};
+    if (xQueueSend(w->queue, &evt, 100) == pdPASS)
+        return 0;
+    return -1;
+}
+
+
 }

package/libs/core---vm/vm.cpp

@@ -147,6 +147,78 @@ static inline void runAction(FiberContext *ctx, RefAction *ra) {
     ctx->pc = actionPC(ra);
 }
 
+static const uint8_t *find_src_map() {
+    const uint32_t *p = (const uint32_t *)((uint32_t)vmImg->dataEnd & ~0xf);
+    const uint32_t *endP = p + 128;
+    while (p < endP) {
+        if (p[0] == 0x4d435253 && p[1] == 0x2d4e1588 && p[2] == 0x719986aa)
+            return (const uint8_t *)p;
+        p += 4;
+    }
+    DMESG("source map not found; dataEnd=%p", vmImg->dataEnd);
+    return NULL;
+}
+
+static const uint8_t *decode_num(const uint8_t *p, int *dst) {
+    auto v = *p++;
+    if (v < 0xf0) {
+        *dst = v;
+        return p;
+    }
+    auto sz = v & 0x07;
+    int r = 0;
+    for (int i = 0; i < sz; ++i) {
+        r |= *p++ << (i * 8);
+    }
+    if (v & 0x08)
+        r = -r;
+    *dst = r;
+    return p;
+}
+
+static const uint8_t *dump_pc_one(int addr, int off, const uint8_t *fn) {
+    if (!fn)
+        return NULL;
+    auto p = fn;
+    while (*p)
+        p++;
+    p++;
+    int prevLn = 0, prevOff = 0;
+    while (*p != 0xff) {
+        int a, b, c;
+        p = decode_num(p, &a);
+        p = decode_num(p, &b);
+        p = decode_num(p, &c);
+        prevLn += a;
+        b <<= 1;
+        prevOff += b;
+        c <<= 1;
+
+        int startA = prevOff;
+        int endA = startA + c;
+        if (startA <= addr + off && addr + off <= endA) {
+            DMESG(" PC:%x %s(%d)", addr, fn, prevLn);
+            return NULL;
+        }
+    }
+    return p + 1;
+}
+
+static void dump_pc(int addr, const uint8_t *srcmap) {
+    if (srcmap) {
+        auto p = srcmap + 16;
+        for (;;) {
+            auto a = dump_pc_one(addr, -2, p);
+            if (!a || !dump_pc_one(addr, -4, p) || !dump_pc_one(addr, 0, p))
+                return;
+            p = a;
+            if (*p == 0)
+                break;
+        }
+    }
+    DMESG(" PC:%x", addr);
+}
+
 void vm_stack_trace() {
     auto ctx = currentFiber;
     if (!ctx)
@@ -154,12 +226,13 @@ void vm_stack_trace() {
     DMESG("stack trace (programHash:%d):", programHash());
     auto end = vmImg->stackTop;
     auto ptr = ctx->sp;
-    DMESG(" PC:%x", (ctx->pc - ctx->imgbase) << 1);
+    auto srcmap = find_src_map();
+    dump_pc((ctx->pc - ctx->imgbase) << 1, srcmap);
     int max = 30;
     while (ptr < end && max) {
         auto v = (uintptr_t)*ptr++;
         if (VM_IS_ENCODED_PC(v)) {
-            DMESG(" PC:%x", VM_DECODE_PC(v) << 1);
+            dump_pc(VM_DECODE_PC(v) << 1, srcmap);
             max--;
         }
     }
@@ -218,18 +291,21 @@ void op_callind(FiberContext *ctx, unsigned arg) {
 void op_ret(FiberContext *ctx, unsigned arg) {
     SPLIT_ARG(retNumArgs, numTmps);
 
-    // check if we're leaving a function that still has open try blocks
-    // (this results from invalid code generation)
-    if (ctx->tryFrame && ctx->tryFrame->registers[0] == (uintptr_t)ctx->currAction) {
-        DMESG("try frame %p left on return", ctx->tryFrame);
-        target_panic(PANIC_VM_ERROR);
-    }
-
     POP(numTmps);
     auto retaddr = (intptr_t)POPVAL();
     ctx->currAction = (RefAction *)POPVAL();
     POP(retNumArgs);
 
+    // check if we're leaving a function that still has open try blocks
+    // (this results from invalid code generation)
+    if (ctx->tryFrame &&
+        ctx->tryFrame->registers[2] < (uint8_t *)ctx->sp - (uint8_t *)vmImg->stackBase) {
+        DMESG("try frame %p left on return %d/%d", ctx->tryFrame, ctx->tryFrame->registers[2],
+              (uint8_t *)ctx->sp - (uint8_t *)vmImg->stackBase);
+        vm_stack_trace();
+        target_panic(PANIC_VM_ERROR);
+    }
+
     if (retaddr == (intptr_t)TAG_STACK_BOTTOM) {
         ctx->pc = NULL;
     } else {