EXAMPLE 08 • image-filter.cpp

WebAssembly: Debugging C++ via Scopes & the Wasm Debug Proxy

A hand-assembled wasm module with a scopes source map: inlined C++ helpers, register reuse, structs in linear memory, i64 values and a wasm trap, all shown as authored C++.

Wasm Source Map Positions (line 0, column = module byte offset)Binding Expressions over V8's Wasm Debug Proxy ($var0, memories[0], stack[0], $func)Struct Reconstruction from Linear Memory (DataView / Uint8Array)SubRangeBinding[] for a Reused Wasm Local ($var3 -> 4 values)3-Level Inlining + 2 Call Sites of clampLevel (callSite)Hidden Compiler Stub (legalstub$adjustImage, isHidden: true)Nested Block Scopes & Strength-Reduced Loop Index (i -> $var4 - $var3)

OPEN CHROME DEVTOOLS (F12) FIRST, THEN TRIGGER:

Ready. Click "Run & Pause in Debugger" with DevTools open.

How This Example Works

Nothing in the scopes proposal is JavaScript-specific. Source maps for WebAssembly use a single generated line (0) and the module byte offset as the column, and binding expressions are evaluated with Debugger.evaluateOnCallFrame on the wasm frame. There, V8 exposes a debug proxy with the wasm state: locals $var0… as { type, value }, the linear memory memories[0] (or $memory, named after its export), functions such as $_Z11adjustPixeliii, and the value stack stack[0]…

image-filter.wasm is a hand-assembled module whose authored source is image-filter.cpp. The bindings describe what an optimizing C++ compiler did: clampLevel and applyContrast are inlined into adjustPixel, with clampLevel inlined at two call sites. One wasm local ($var3) holds four different C++ values over time. The loop index i exists only as a pointer difference, and Image* is decoded from linear memory into an object with a live Uint8Array of pixels. The int64_t checksum shows up as a BigInt, and an Emscripten legalstub$adjustImage wrapper is hidden. The JS glue (bundle.js) is not source-mapped.

This is the experimental example: it only works if DevTools applies scopes to wasm call frames, so expect the most rough edges here.

What to Try & Verify in DevTools

Pause in C++ via emscripten_debugger() Call Stack

Try:Click "Run & Pause in Debugger". DevTools pauses at debugger; in the JS glue (bundle.js), which implements emscripten_debugger(). Press Step out (Shift+F11) once.

Authored location: Paused on line 49 of image-filter.cpp (if (i == 2) emscripten_debugger();), not in the wasm disassembly.
Call Stack: adjustImage (image-filter.cpp) → callAdjustImage → window.runExample08 (bundle.js). The Emscripten wrapper legalstub$adjustImage between them is not shown (hidden range).
No raw names: No $var… locals and no Expression (value stack) scope from raw wasm debugging.

Inspect C++ Variables Reconstructed from Wasm State Scope View

Try:Look at the Scope pane for the adjustImage frame, and expand image and image.pixels.

Block scopes: pixel: 2066 (an address) and adjusted: 255; in the enclosing for block, i: 2 (computed as $var4 - $var3 because the compiler turned i into a pointer).
Function scope: brightness: 30, contrastPct: 150, pixelCount: 4, checksum: 457n (an int64_t shows up as a BigInt).
Struct from linear memory: image is {width: 2, height: 2, pixels: Uint8Array(4) [41, 161, 255, 250]}. The first 3 pixels are already adjusted.
Module scope: kMaxLevel: 255 (constant), g_imagesProcessed: 0 and g_lastAverage: 0 (read from linear memory; higher on later runs), clampLevel/applyContrast/averageLevel <unavailable> (always inlined), adjustPixel/adjustImage are functions.

Break Inside an Inlined Helper with Two Call Sites Conditional Breakpoints

Try:Set a conditional breakpoint on line 19 (if (level > kMaxLevel) ... in clampLevel) with condition level > kMaxLevel, then resume (F8). Resume once more after the first hit.

1st hit (call site 1): Call Stack clampLevel → adjustPixel (line 31) → adjustImage (line 46). level: 280 (250 + 30).
2nd hit (call site 2): clampLevel → applyContrast (line 26) → adjustPixel (line 32) → adjustImage. level: 318.
Mixed frames: clampLevel and applyContrast are virtual (inlined) frames, while adjustPixel and adjustImage are two real wasm frames.

Try:At the 2nd hit, select the applyContrast frame and then the adjustPixel frame in the Call Stack.

applyContrast: level: 255, contrastPct: 150, centered: 127, scaled: 190. The wasm local $var3 currently holds scaled + 128, so level and centered are reconstructed from $var0/$var1.
adjustPixel: level: 250, brightness: 30, contrastPct: 150, brightened: 255 (reconstructed), result: <unavailable>.
Value stack binding: Remove the breakpoints, set one on line 33 (return result;) and resume. result should be 255, read from the wasm value stack (stack[0]).

Step Through Inlined C++ Code Logical Stepping

Try:Remove all breakpoints, click Run again, step out of the JS glue and use Step over (F10) until you reach line 46. Then use Step into (F11) repeatedly.

Step into enters adjustPixel (a real wasm call) and then the inlined clampLevel/applyContrast frames, which appear and disappear in the Call Stack.
Step over on a line that calls an inlined helper (e.g. int32_t brightened = ...) does not stop inside the helper.
Step out of an inlined frame lands back in the caller's line.

Symbolized Stack Trace for a Wasm Trap Error Stack Traces

Try:Remove all breakpoints, resume, and click Trap: Divide by Zero. It runs adjustImage on an empty 0×0 image, so the inlined averageLevel divides by zero.

Console: RuntimeError: divide by zero with stack averageLevel (line 37) → adjustImage (line 51) → callAdjustImage → window.logStackExample08 (bundle.js).
Hidden and raw frames: legalstub$adjustImage is not shown. The page readout shows the raw err.stack with wasm-function[3]:0x… frames.
Pause on exceptions: Enable Pause on caught exceptions and click the button again. DevTools pauses on line 37 with sum: 0n and count: 0. In adjustImage, image is {width: 0, height: 0, pixels: Uint8Array(0)}.

Other things to try

Evaluate raw wasm names like $var3, $memory, memories, locals or stack in the Console. Do they still work next to the authored names?
Hover image, checksum or pixel in image-filter.cpp for popovers, and check the inline value hints.
Right-click the Call Stack › Copy stack trace while paused in the inlined clampLevel.
Set a logpoint on line 48 logging i, adjusted, checksum.
Open image-filter.wasm itself in the Sources panel (disassembly) and compare the byte offsets with tab 2.
Add image as a Watch expression and step through the loop to watch image.pixels change.

Not sure if it's a DevTools bug? Tab 4. Decoded Scopes shows what the source map actually encodes.

Try in the Console While Paused

While paused, select a frame and evaluate these in the Console (Esc opens the drawer) using the authored names:

image.pixels[i]

Expected Result: 255 (adjustImage frame, first pause)

image is decoded from linear memory with a live Uint8Array for pixels, and i is $var4.value - $var3.value. Close to C++'s image->pixels[i].

Number(checksum) / (i + 1)

Expected Result: 152.33333333333334 (adjustImage frame, first pause)

checksum is an int64_t (wasm i64), so its binding produces a BigInt (457n) that has to be converted before mixing it with numbers.

adjustPixel(200, brightness, contrastPct)

Expected Result: 255

adjustPixel is bound to the wasm function $_Z11adjustPixeliii, so the Console calls into wasm while paused.

{ level, centered, scaled }

Expected Result: { level: 255, centered: 127, scaled: 190 } (applyContrast frame, 2nd conditional breakpoint hit)

All three values come from different sub-range bindings: a reconstruction from $var0/$var1 and arithmetic on the reused $var3.

        
        // Authored C++: image-filter.cpp
      
        // Pretend build: em++ -O2 -gsource-map -sWASM_BIGINT=0 image-filter.cpp
      
        #include <cstdint>
      
        #include <emscripten.h>
      
        struct Image {
      
          int32_t width;
      
          int32_t height;
      
          uint8_t* pixels;  // 8-bit grayscale, row-major
      
        };
      
        constexpr int32_t kMaxLevel = 255;
      
        int32_t g_imagesProcessed = 0;
      
        int32_t g_lastAverage = 0;
      
        static inline int32_t clampLevel(int32_t level) {
      
          if (level < 0) return 0;
      
          if (level > kMaxLevel) return kMaxLevel;
      
          return level;
      
        }
      
        static inline int32_t applyContrast(int32_t level, int32_t contrastPct) {
      
          int32_t centered = level - 128;
      
          int32_t scaled = centered * contrastPct / 100;
      
          return clampLevel(scaled + 128);
      
        }
      
        __attribute__((noinline))
      
        int32_t adjustPixel(int32_t level, int32_t brightness, int32_t contrastPct) {
      
          int32_t brightened = clampLevel(level + brightness);
      
          int32_t result = applyContrast(brightened, contrastPct);
      
          return result;
      
        }
      
        static inline int32_t averageLevel(int64_t sum, int32_t count) {
      
          return static_cast<int32_t>(sum / count);  // Traps in wasm if count == 0!
      
        }
      
        extern "C" EMSCRIPTEN_KEEPALIVE
      
        int64_t adjustImage(Image* image, int32_t brightness, int32_t contrastPct) {
      
          const int32_t pixelCount = image->width * image->height;
      
          int64_t checksum = 0;
      
          for (int32_t i = 0; i < pixelCount; ++i) {
      
            uint8_t* pixel = &image->pixels[i];
      
            const int32_t adjusted = adjustPixel(*pixel, brightness, contrastPct);
      
            *pixel = static_cast<uint8_t>(adjusted);
      
            checksum += adjusted;
      
            if (i == 2) emscripten_debugger();  // Pause once, mid-image.
      
          }
      
          g_lastAverage = averageLevel(checksum, pixelCount);
      
          ++g_imagesProcessed;
      
          return checksum;
      
        }

        
               (module
      
                 (import "env" "emscripten_debugger" (func $emscripten_debugger (;0;)))
      
                 (import "env" "setTempRet0" (func $setTempRet0 (;1;) (param i32)))
      
                 (memory (;0;) 1)
      
                 (export "memory" (memory 0))
      
                 (export "adjustImage" (func $legalstub$adjustImage))
      
        0x079    (func $_Z11adjustPixeliii (;2;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i32)
      
                   (local $var3 i32)
      
                   ;; brightened = clampLevel(level + brightness)
      
        0x07c      local.get $var0
      
        0x07e      local.get $var1
      
        0x080      i32.add
      
        0x081      local.tee $var3
      
                   ;; inlined clampLevel(level + brightness)
      
        0x083      i32.const 0
      
        0x085      local.get $var3
      
        0x087      i32.const 0
      
        0x089      i32.gt_s
      
        0x08a      select
      
        0x08b      local.tee $var3
      
        0x08d      i32.const 255
      
        0x090      local.get $var3
      
        0x092      i32.const 255
      
        0x095      i32.lt_s
      
        0x096      select
      
        0x097      local.set $var3
      
                   ;; inlined applyContrast(brightened, contrastPct)
      
        0x099      local.get $var3
      
        0x09b      i32.const 128
      
        0x09e      i32.sub
      
        0x09f      local.get $var2
      
        0x0a1      i32.mul
      
        0x0a2      i32.const 100
      
        0x0a5      i32.div_s
      
        0x0a6      i32.const 128
      
        0x0a9      i32.add
      
        0x0aa      local.tee $var3
      
                   ;; inlined clampLevel(scaled + 128)
      
        0x0ac      i32.const 0
      
        0x0ae      local.get $var3
      
        0x0b0      i32.const 0
      
        0x0b2      i32.gt_s
      
        0x0b3      select
      
        0x0b4      local.tee $var3
      
        0x0b6      i32.const 255
      
        0x0b9      local.get $var3
      
        0x0bb      i32.const 255
      
        0x0be      i32.lt_s
      
        0x0bf      select
      
                   ;; return result;  (result is on the wasm value stack)
      
        0x0c0      end
      
        0x0c3    (func $adjustImage (;3;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i64)
      
                   (local $var3 i32)
      
                   (local $var4 i32)
      
                   (local $var5 i32)
      
                   (local $var6 i64)
      
                   (local $var7 i32)
      
                   ;; pixels = image->pixels; end = pixels + image->width * image->height
      
        0x0ca      local.get $var0
      
        0x0cc      i32.load offset=8
      
        0x0cf      local.tee $var3
      
        0x0d1      local.get $var0
      
        0x0d3      i32.load
      
        0x0d6      local.get $var0
      
        0x0d8      i32.load offset=4
      
        0x0db      i32.mul
      
        0x0dc      i32.add
      
        0x0dd      local.set $var5
      
                   ;; for (int32_t i = 0; i < pixelCount; ++i)  -- i is strength-reduced into a pointer
      
        0x0df      block
      
        0x0e1        local.get $var3
      
        0x0e3        local.get $var5
      
        0x0e5        i32.ge_u
      
        0x0e6        br_if 0
      
        0x0e8        local.get $var3
      
        0x0ea        local.set $var4
      
        0x0ec        loop
      
        0x0ee          local.get $var4
      
        0x0f0          i32.load8_u
      
        0x0f3          local.get $var1
      
        0x0f5          local.get $var2
      
        0x0f7          call $_Z11adjustPixeliii
      
        0x0f9          local.set $var7
      
        0x0fb          local.get $var4
      
        0x0fd          local.get $var7
      
        0x0ff          i32.store8
      
        0x102          local.get $var6
      
        0x104          local.get $var7
      
        0x106          i64.extend_i32_s
      
        0x107          i64.add
      
        0x108          local.set $var6
      
        0x10a          local.get $var4
      
        0x10c          local.get $var3
      
        0x10e          i32.sub
      
        0x10f          i32.const 2
      
        0x111          i32.eq
      
        0x112          if
      
        0x114            call $emscripten_debugger
      
        0x116          end
      
        0x117          local.get $var4
      
        0x119          i32.const 1
      
        0x11b          i32.add
      
        0x11c          local.tee $var4
      
        0x11e          local.get $var5
      
        0x120          i32.lt_u
      
        0x121          br_if 0
      
        0x123        end
      
        0x124      end
      
                   ;; g_lastAverage = averageLevel(checksum, pixelCount)
      
        0x125      i32.const 0
      
        0x127      local.get $var6
      
        0x129      local.get $var5
      
        0x12b      local.get $var3
      
        0x12d      i32.sub
      
        0x12e      i64.extend_i32_s
      
                   ;; inlined averageLevel(): traps with 'divide by zero' if count == 0
      
        0x12f      i64.div_s
      
        0x130      i64.store32 offset=1028
      
        0x134      i32.const 0
      
        0x136      i32.const 0
      
        0x138      i32.load offset=1024
      
        0x13c      i32.const 1
      
        0x13e      i32.add
      
        0x13f      i32.store offset=1024
      
        0x143      local.get $var6
      
        0x145      end
      
        0x147    (func $legalstub$adjustImage (;4;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i32)
      
                   (local $var3 i64)
      
        0x14a      local.get $var0
      
        0x14c      local.get $var1
      
        0x14e      local.get $var2
      
        0x150      call $adjustImage
      
        0x152      local.tee $var3
      
        0x154      i64.const 32
      
        0x156      i64.shr_u
      
        0x157      i32.wrap_i64
      
        0x158      call $setTempRet0
      
        0x15a      local.get $var3
      
        0x15c      i32.wrap_i64
      
        0x15d      end
      
               )

        
        // Every position is { line: 0, column: <byte offset in image-filter.wasm> }.
      
        // wasm.at(func, label) returns the module offset of a labelled instruction.
      
        // Binding expressions run on the wasm frame via V8's wasm debug proxy:
      
        // $var<N> (locals, as { type, value }), memories[0], $<funcName>, stack[N], ...
      
        const builder = new SafeScopeInfoBuilder();
      
        // 1. Original Scopes: image-filter.cpp
      
        builder
      
          .startSource()
      
          .startScope(0, 0, {
      
            kind: "Module",
      
            key: "module",
      
            variables: ["kMaxLevel", "g_imagesProcessed", "g_lastAverage", "clampLevel",
      
                        "applyContrast", "adjustPixel", "averageLevel", "adjustImage"],
      
          })
      
          .startScope(/* clampLevel( */ { kind: "Function", name: "clampLevel", isStackFrame: true,
      
            key: "clampLevel", variables: ["level"] }).endScope(/* } */)
      
          .startScope(/* applyContrast( */ { kind: "Function", name: "applyContrast", isStackFrame: true,
      
            key: "applyContrast", variables: ["level", "contrastPct", "centered", "scaled"] }).endScope()
      
          .startScope(/* adjustPixel( */ { kind: "Function", name: "adjustPixel", isStackFrame: true,
      
            key: "adjustPixel", variables: ["level", "brightness", "contrastPct", "brightened", "result"] })
      
          .endScope()
      
          .startScope(/* averageLevel( */ { kind: "Function", name: "averageLevel", isStackFrame: true,
      
            key: "averageLevel", variables: ["sum", "count"] }).endScope()
      
          .startScope(/* adjustImage( */ { kind: "Function", name: "adjustImage", isStackFrame: true,
      
            key: "adjustImage", variables: ["image", "brightness", "contrastPct", "pixelCount", "checksum"] })
      
            .startScope(/* for ( */ { kind: "Block", key: "for", variables: ["i"] })
      
              .startScope(/* { */ { kind: "Block", key: "forBody", variables: ["pixel", "adjusted"] })
      
              .endScope(/* } */)
      
            .endScope(/* } */)
      
          .endScope()
      
          .endScope()
      
          .endSource();
      
        // 2. Generated Ranges: byte offsets in image-filter.wasm
      
        // sub(start, [from, value?], ...) builds a SubRangeBinding[] over [start, ...).
      
        builder
      
          .startRange(0, 0, {
      
            scopeKey: "module",
      
            values: [
      
              "255",                                    // kMaxLevel: constant-folded
      
              "new DataView(memories[0].buffer).getInt32(1024, true)",   // C++ globals live in linear memory
      
              "new DataView(memories[0].buffer).getInt32(1028, true)",
      
              null, null,                               // clampLevel, applyContrast: always inlined
      
              "$_Z11adjustPixeliii",                     // the wasm function (mangled name)
      
              null,                                     // averageLevel: always inlined
      
              "$adjustImage",
      
            ],
      
          })
      
          // ---- wasm function $_Z11adjustPixeliii ----
      
          .startRange(0, wasm.bodyStart("_Z11adjustPixeliii"), {
      
            scopeKey: "adjustPixel",
      
            isStackFrame: true,
      
            values: [
      
              "$var0.value", "$var1.value", "$var2.value",
      
              // brightened: $var3 is reused, so reconstruct once it is overwritten.
      
              sub(fnStart, [at("centered"), "$var3.value"],
      
                           [at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255)"]),
      
              // result: only exists on the wasm value stack right before returning.
      
              sub(fnStart, [at("return"), "stack[0].value"]),
      
            ],
      
          })
      
            .startRange(0, at("clamp1.lt0"), {
      
              scopeKey: "clampLevel", isStackFrame: false,
      
              callSite: /* clampLevel(level + brightness) */,
      
              values: ["$var0.value + $var1.value"],
      
            })
      
            .endRange(0, at("clamp1.end"))
      
            .startRange(0, at("centered"), {
      
              scopeKey: "applyContrast", isStackFrame: false,
      
              callSite: /* applyContrast(brightened, contrastPct) */,
      
              values: [
      
                sub(at("centered"), ["$var3.value"], [at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255)"]),
      
                "$var2.value",
      
                sub(at("centered"), [at("scaled"), "$var3.value - 128"],
      
                                    [at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255) - 128"]),
      
                sub(at("centered"), [at("contrastReturn"), "stack[0].value"],         // value stack!
      
                                    [at("scaledPlus128Tee"), "stack[0].value - 128"],
      
                                    [at("clamp2.lt0"), "$var3.value - 128"],
      
                                    [at("clamp2.afterTee")]),                         // clobbered
      
              ],
      
            })
      
              .startRange(0, at("clamp2.lt0"), {
      
                scopeKey: "clampLevel", isStackFrame: false,   // 2nd call site, same OriginalScope
      
                callSite: /* clampLevel(scaled + 128) */,
      
                values: [sub(at("clamp2.lt0"), ["$var3.value"], [at("clamp2.afterTee")])],
      
              })
      
              .endRange(0, at("return"))
      
            .endRange(0, at("return"))
      
          .endRange(0, wasm.bodyEnd("_Z11adjustPixeliii"))
      
          // ---- wasm function $adjustImage ----
      
          .startRange(0, wasm.bodyStart("adjustImage"), {
      
            scopeKey: "adjustImage",
      
            isStackFrame: true,
      
            values: [
      
              "(() => { const m = new DataView(memories[0].buffer), p = $var0.value, w = m.getInt32(p, true), h = m.getInt32(p + 4, true); return { width: w, height: h, pixels: new Uint8Array(m.buffer, m.getUint32(p + 8, true), w * h) }; })()",
      
              "$var1.value", "$var2.value",
      
              sub(fnStart, [at("for"), "$var5.value - $var3.value"]),  // pixelCount
      
              "$var6.value",                                         // checksum: i64 -> BigInt
      
            ],
      
          })
      
            .startRange(0, at("for"), {
      
              scopeKey: "for",
      
              values: [sub(at("for"), [at("loop"), "$var4.value - $var3.value"])],  // i (strength-reduced)
      
            })
      
              .startRange(0, at("body"), {
      
                scopeKey: "forBody",
      
                values: ["$var4.value", sub(at("body"), [at("store"), "$var7.value"])],
      
              })
      
              .endRange(0, at("increment"))
      
            .endRange(0, at("forEnd"))
      
            .startRange(0, at("divide"), {
      
              scopeKey: "averageLevel", isStackFrame: false,
      
              callSite: /* averageLevel(checksum, pixelCount) */,
      
              values: ["$var6.value", "$var5.value - $var3.value"],
      
            })
      
            .endRange(0, at("storeAverage"))
      
          .endRange(0, wasm.bodyEnd("adjustImage"))
      
          // ---- Emscripten-generated $legalstub$adjustImage: no authored code, hidden ----
      
          .startRange(0, wasm.bodyStart("legalstub$adjustImage"), { isStackFrame: true, isHidden: true })
      
          .endRange(0, wasm.bodyEnd("legalstub$adjustImage"))
      
          .endRange(0, wasm.end);

Decoded OriginalScope Tree (image-filter.cpp)
      Module
      (anonymous)
      [0:0 → 54:0)
      
    
variables: [kMaxLevel, g_imagesProcessed, g_lastAverage, clampLevel, applyContrast, adjustPixel, averageLevel, adjustImage]

      Function
      clampLevel
      [16:32 → 20:1)
      isStackFrame
    
variables: [level]

      Function
      applyContrast
      [22:35 → 26:1)
      isStackFrame
    
variables: [level, contrastPct, centered, scaled]

      Function
      adjustPixel
      [29:19 → 33:1)
      isStackFrame
    
variables: [level, brightness, contrastPct, brightened, result]

      Function
      averageLevel
      [35:34 → 37:1)
      isStackFrame
    
variables: [sum, count]

      Function
      adjustImage
      [40:19 → 53:1)
      isStackFrame
    
variables: [image, brightness, contrastPct, pixelCount, checksum]

      Block
      (anonymous)
      [43:6 → 49:3)
      
    
variables: [i]

      Block
      (anonymous)
      [43:43 → 49:3)
      
    
variables: [pixel, adjusted]
Decoded GeneratedRange & Binding Tree (image-filter.wasm)
      Range [0x0 → 0x1eb)
      → Module
      isStackFrame: false
      
      
    

          bindings: kMaxLevel → 255, g_imagesProcessed → new DataView(memories[0].buffer).getInt32(1024, true), g_lastAverage → new DataView(memories[0].buffer).getInt32(1028, true), clampLevel → <unavailable>, applyContrast → <unavailable>, adjustPixel → $_Z11adjustPixeliii, averageLevel → <unavailable>, adjustImage → $adjustImage
        

      Range [0x79 → 0xc1)
      → Function(adjustPixel)
      isStackFrame
      
      
    

          bindings: level → $var0.value, brightness → $var1.value, contrastPct → $var2.value, brightened → SubRanges([0x79-0x99]: unavailable | [0x99-0xac]: $var3.value | [0xac-0xc1]: Math.min(Math.max($var0.value + $var1.value, 0), 255)), result → SubRanges([0x79-0xc0]: unavailable | [0xc0-0xc1]: stack[0].value)
        

      Range [0x83 → 0x97)
      → Function(clampLevel)
      isStackFrame: false
      
      callSite @ 31:24
    

          bindings: level → $var0.value + $var1.value
        

      Range [0x99 → 0xc0)
      → Function(applyContrast)
      isStackFrame: false
      
      callSite @ 32:20
    

          bindings: level → SubRanges([0x99-0xac]: $var3.value | [0xac-0xc0]: Math.min(Math.max($var0.value + $var1.value, 0), 255)), contrastPct → $var2.value, centered → SubRanges([0x99-0x9f]: unavailable | [0x9f-0xac]: $var3.value - 128 | [0xac-0xc0]: Math.min(Math.max($var0.value + $var1.value, 0), 255) - 128), scaled → SubRanges([0x99-0xa6]: unavailable | [0xa6-0xaa]: stack[0].value | [0xaa-0xac]: stack[0].value - 128 | [0xac-0xb6]: $var3.value - 128 | [0xb6-0xc0]: unavailable)
        

      Range [0xac → 0xc0)
      → Function(clampLevel)
      isStackFrame: false
      
      callSite @ 26:10
    

          bindings: level → SubRanges([0xac-0xb6]: $var3.value | [0xb6-0xc0]: unavailable)
        

      Range [0xc3 → 0x146)
      → Function(adjustImage)
      isStackFrame
      
      
    

          bindings: image → (() => { const m = new DataView(memories[0].buffer), p = $var0.value, w = m.getInt32(p, true), h = m.getInt32(p + 4, true); return { width: w, height: h, pixels: new Uint8Array(m.buffer, m.getUint32(p + 8, true), w * h) }; })(), brightness → $var1.value, contrastPct → $var2.value, pixelCount → SubRanges([0xc3-0xdf]: unavailable | [0xdf-0x146]: $var5.value - $var3.value), checksum → $var6.value
        

      Range [0xdf → 0x125)
      → Block
      isStackFrame: false
      
      
    

          bindings: i → SubRanges([0xdf-0xec]: unavailable | [0xec-0x125]: $var4.value - $var3.value)
        

      Range [0xee → 0x117)
      → Block
      isStackFrame: false
      
      
    

          bindings: pixel → $var4.value, adjusted → SubRanges([0xee-0xfb]: unavailable | [0xfb-0x117]: $var7.value)
        

      Range [0x12f → 0x130)
      → Function(averageLevel)
      isStackFrame: false
      
      callSite @ 51:19
    

          bindings: sum → $var6.value, count → $var5.value - $var3.value
        

      Range [0x147 → 0x15e)
      → unmapped range
      isStackFrame
      isHidden: true
      
    

              Raw Source Map JSON (image-filter.wasm.map)
              {
  "version": 3,
  "file": "image-filter.wasm",
  "sources": [
    "image-filter.cpp"
  ],
  "sourcesContent": [
    "// Authored C++: image-filter.cpp\n// Pretend build: em++ -O2 -gsource-map -sWASM_BIGINT=0 image-filter.cpp\n#include <cstdint>\n#include <emscripten.h>\n\nstruct Image {\n  int32_t width;\n  int32_t height;\n  uint8_t* pixels;  // 8-bit grayscale, row-major\n};\n\nconstexpr int32_t kMaxLevel = 255;\n\nint32_t g_imagesProcessed = 0;\nint32_t g_lastAverage = 0;\n\nstatic inline int32_t clampLevel(int32_t level) {\n  if (level < 0) return 0;\n  if (level > kMaxLevel) return kMaxLevel;\n  return level;\n}\n\nstatic inline int32_t applyContrast(int32_t level, int32_t contrastPct) {\n  int32_t centered = level - 128;\n  int32_t scaled = centered * contrastPct / 100;\n  return clampLevel(scaled + 128);\n}\n\n__attribute__((noinline))\nint32_t adjustPixel(int32_t level, int32_t brightness, int32_t contrastPct) {\n  int32_t brightened = clampLevel(level + brightness);\n  int32_t result = applyContrast(brightened, contrastPct);\n  return result;\n}\n\nstatic inline int32_t averageLevel(int64_t sum, int32_t count) {\n  return static_cast<int32_t>(sum / count);  // Traps in wasm if count == 0!\n}\n\nextern \"C\" EMSCRIPTEN_KEEPALIVE\nint64_t adjustImage(Image* image, int32_t brightness, int32_t contrastPct) {\n  const int32_t pixelCount = image->width * image->height;\n  int64_t checksum = 0;\n  for (int32_t i = 0; i < pixelCount; ++i) {\n    uint8_t* pixel = &image->pixels[i];\n    const int32_t adjusted = adjustPixel(*pixel, brightness, contrastPct);\n    *pixel = static_cast<uint8_t>(adjusted);\n    checksum += adjusted;\n    if (i == 2) emscripten_debugger();  // Pause once, mid-image.\n  }\n  g_lastAverage = averageLevel(checksum, pixelCount);\n  ++g_imagesProcessed;\n  return checksum;\n}\n"
  ],
  "names": [
    "brightened",
    "centered",
    "scaled",
    "pixelCount",
    "i",
    "pixel",
    "adjusted",
    "adjustPixel",
    "checksum",
    "g_lastAverage",
    "Module",
    "kMaxLevel",
    "g_imagesProcessed",
    "clampLevel",
    "applyContrast",
    "averageLevel",
    "adjustImage",
    "Function",
    "level",
    "contrastPct",
    "brightness",
    "result",
    "sum",
    "count",
    "image",
    "Block",
    "255",
    "new DataView(memories[0].buffer).getInt32(1024, true)",
    "new DataView(memories[0].buffer).getInt32(1028, true)",
    "$_Z11adjustPixeliii",
    "$adjustImage",
    "$var0.value",
    "$var1.value",
    "$var2.value",
    "$var3.value",
    "Math.min(Math.max($var0.value + $var1.value, 0), 255)",
    "stack[0].value",
    "$var0.value + $var1.value",
    "$var3.value - 128",
    "Math.min(Math.max($var0.value + $var1.value, 0), 255) - 128",
    "stack[0].value - 128",
    "(() => { const m = new DataView(memories[0].buffer), p = $var0.value, w = m.getInt32(p, true), h = m.getInt32(p + 4, true); return { width: w, height: h, pixels: new Uint8Array(m.buffer, m.getUint32(p + 8, true), w * h) }; })()",
    "$var6.value",
    "$var5.value - $var3.value",
    "$var4.value - $var3.value",
    "$var4.value",
    "$var7.value"
  ],
  "mappings": "4HA8BEA,OAbA,QACA,YAYAA,EAPAC,MACAC,OACA,MARA,QACA,YAcA,UASAC,uBAEoB,OAAfC,MACHC,EACAC,OAAyBC,IACzB,OACAC,QACA,UAAY,GALsB,OAAhB,OAOpBC,UAdA,CAcAA,IACA,eACA,O",
  "scopes": [
    "BCAAU,DWCHICPQC,BHQgBaO,DE,CEB,BHCjBCA,DAClBC,CEB,BHDTPA,DgBEDnBqB,CEB,BHCiBQA,DCC,CCB,BHDTCA,DCJDhBK,BCDGQ,DJ,BCAlBA,DCC,CGD,CAA,CEB,CBA"
  ],
  "ranges": [
    "ECAAA,GbcdAAeAf,EG5DAG,GgBhBiBAA,HDAgBjBATkB,HEAnClB,ECKAF,GmB,IAeX,FU,ECCAC,GjBiBAA,HAATkB,HCAGnBANoB,HDANlBAEpBACnBAKA,IAfT,ECTAD,GjB,HAAKA,IAZJ,FU,FA,FB,EGCAI,GqBhBiBArB,HDAcsB,ECcAC,GA,HAANtB,ECPAC,GuBA,HBANvB,FpB,FO,ECKAH,GrBsB,IAyBS,FB,FW,EMB,FX,FtE"
  ]
}
            

        
        // bundle.js: hand-written, Emscripten-style JS glue for image-filter.wasm.
      
        // This file is NOT source-mapped. The source map with "scopes" belongs to
      
        // image-filter.wasm (see its "sourceMappingURL" custom section).
      
        (function() {
      
          "use strict";
      
          const G_IMAGES_PROCESSED = 1024; // &g_imagesProcessed
      
          const G_LAST_AVERAGE = 1028; // &g_lastAverage
      
          const IMAGE_PTR = 2048; // Image { width, height, pixels }
      
          const PIXELS_PTR = 2064;
      
          const EMPTY_IMAGE_PTR = 2096; // Image { 0, 0, pixels }
      
          const SAMPLE_PIXELS = [40, 120, 200, 250];
      
          let instance = null;
      
          let tempRet0 = 0;
      
          const imports = {
      
            env: {
      
              // Like in Emscripten, emscripten_debugger() is a JS library function.
      
              emscripten_debugger: function() {
      
                debugger; // Step out (Shift+F11) to continue in image-filter.cpp.
      
              },
      
              // Receives the high 32 bits of i64 results from legalstub$adjustImage.
      
              setTempRet0: function(value) {
      
                tempRet0 = value;
      
              },
      
            },
      
          };
      
          WebAssembly.instantiateStreaming(fetch("./image-filter.wasm"), imports).then(
      
            function(result) {
      
              instance = result.instance;
      
            },
      
            function(err) {
      
              console.error("Failed to instantiate image-filter.wasm", err);
      
            },
      
          );
      
          function wasmExports() {
      
            if (!instance) throw new Error("image-filter.wasm is still loading, try again.");
      
            return instance.exports;
      
          }
      
          function writeImage(ptr, width, height, pixelsPtr, pixels) {
      
            const memory = wasmExports().memory;
      
            const view = new DataView(memory.buffer);
      
            view.setInt32(ptr, width, true);
      
            view.setInt32(ptr + 4, height, true);
      
            view.setUint32(ptr + 8, pixelsPtr, true);
      
            new Uint8Array(memory.buffer, pixelsPtr, pixels.length).set(pixels);
      
          }
      
          function callAdjustImage(imagePtr) {
      
            const low = wasmExports().adjustImage(imagePtr, 30, 150);
      
            return tempRet0 * 2 ** 32 + (low >>> 0);
      
          }
      
          window.runExample08 = function() {
      
            writeImage(IMAGE_PTR, 2, 2, PIXELS_PTR, SAMPLE_PIXELS);
      
            const checksum = callAdjustImage(IMAGE_PTR);
      
            const memory = wasmExports().memory;
      
            const view = new DataView(memory.buffer);
      
            return {
      
              checksum: checksum,
      
              pixels: Array.from(new Uint8Array(memory.buffer, PIXELS_PTR, SAMPLE_PIXELS.length)),
      
              lastAverage: view.getInt32(G_LAST_AVERAGE, true),
      
              imagesProcessed: view.getInt32(G_IMAGES_PROCESSED, true),
      
            };
      
          };
      
          window.logStackExample08 = function() {
      
            writeImage(EMPTY_IMAGE_PTR, 0, 0, PIXELS_PTR, []);
      
            try {
      
              callAdjustImage(EMPTY_IMAGE_PTR);
      
              return "Unexpectedly, no trap.";
      
            } catch (err) {
      
              console.error(err);
      
              return String(err.stack);
      
            }
      
          };
      
        })();

1	// Authored C++: image-filter.cpp
2	// Pretend build: em++ -O2 -gsource-map -sWASM_BIGINT=0 image-filter.cpp
3	#include <cstdint>
4	#include <emscripten.h>
5
6	struct Image {
7	int32_t width;
8	int32_t height;
9	uint8_t* pixels; // 8-bit grayscale, row-major
10	};
11
12	constexpr int32_t kMaxLevel = 255;
13
14	int32_t g_imagesProcessed = 0;
15	int32_t g_lastAverage = 0;
16
17	static inline int32_t clampLevel(int32_t level) {
18	if (level < 0) return 0;
19	if (level > kMaxLevel) return kMaxLevel;
20	return level;
21	}
22
23	static inline int32_t applyContrast(int32_t level, int32_t contrastPct) {
24	int32_t centered = level - 128;
25	int32_t scaled = centered * contrastPct / 100;
26	return clampLevel(scaled + 128);
27	}
28
29	__attribute__((noinline))
30	int32_t adjustPixel(int32_t level, int32_t brightness, int32_t contrastPct) {
31	int32_t brightened = clampLevel(level + brightness);
32	int32_t result = applyContrast(brightened, contrastPct);
33	return result;
34	}
35
36	static inline int32_t averageLevel(int64_t sum, int32_t count) {
37	return static_cast<int32_t>(sum / count); // Traps in wasm if count == 0!
38	}
39
40	extern "C" EMSCRIPTEN_KEEPALIVE
41	int64_t adjustImage(Image* image, int32_t brightness, int32_t contrastPct) {
42	const int32_t pixelCount = image->width * image->height;
43	int64_t checksum = 0;
44	for (int32_t i = 0; i < pixelCount; ++i) {
45	uint8_t* pixel = &image->pixels[i];
46	const int32_t adjusted = adjustPixel(*pixel, brightness, contrastPct);
47	*pixel = static_cast<uint8_t>(adjusted);
48	checksum += adjusted;
49	if (i == 2) emscripten_debugger(); // Pause once, mid-image.
50	}
51	g_lastAverage = averageLevel(checksum, pixelCount);
52	++g_imagesProcessed;
53	return checksum;
54	}

1	(module
2	(import "env" "emscripten_debugger" (func $emscripten_debugger (;0;)))
3	(import "env" "setTempRet0" (func $setTempRet0 (;1;) (param i32)))
4	(memory (;0;) 1)
5	(export "memory" (memory 0))
6	(export "adjustImage" (func $legalstub$adjustImage))
7
8	0x079 (func $_Z11adjustPixeliii (;2;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i32)
9	(local $var3 i32)
10	;; brightened = clampLevel(level + brightness)
11	0x07c local.get $var0
12	0x07e local.get $var1
13	0x080 i32.add
14	0x081 local.tee $var3
15	;; inlined clampLevel(level + brightness)
16	0x083 i32.const 0
17	0x085 local.get $var3
18	0x087 i32.const 0
19	0x089 i32.gt_s
20	0x08a select
21	0x08b local.tee $var3
22	0x08d i32.const 255
23	0x090 local.get $var3
24	0x092 i32.const 255
25	0x095 i32.lt_s
26	0x096 select
27	0x097 local.set $var3
28	;; inlined applyContrast(brightened, contrastPct)
29	0x099 local.get $var3
30	0x09b i32.const 128
31	0x09e i32.sub
32	0x09f local.get $var2
33	0x0a1 i32.mul
34	0x0a2 i32.const 100
35	0x0a5 i32.div_s
36	0x0a6 i32.const 128
37	0x0a9 i32.add
38	0x0aa local.tee $var3
39	;; inlined clampLevel(scaled + 128)
40	0x0ac i32.const 0
41	0x0ae local.get $var3
42	0x0b0 i32.const 0
43	0x0b2 i32.gt_s
44	0x0b3 select
45	0x0b4 local.tee $var3
46	0x0b6 i32.const 255
47	0x0b9 local.get $var3
48	0x0bb i32.const 255
49	0x0be i32.lt_s
50	0x0bf select
51	;; return result; (result is on the wasm value stack)
52	0x0c0 end
53
54	0x0c3 (func $adjustImage (;3;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i64)
55	(local $var3 i32)
56	(local $var4 i32)
57	(local $var5 i32)
58	(local $var6 i64)
59	(local $var7 i32)
60	;; pixels = image->pixels; end = pixels + image->width * image->height
61	0x0ca local.get $var0
62	0x0cc i32.load offset=8
63	0x0cf local.tee $var3
64	0x0d1 local.get $var0
65	0x0d3 i32.load
66	0x0d6 local.get $var0
67	0x0d8 i32.load offset=4
68	0x0db i32.mul
69	0x0dc i32.add
70	0x0dd local.set $var5
71	;; for (int32_t i = 0; i < pixelCount; ++i) -- i is strength-reduced into a pointer
72	0x0df block
73	0x0e1 local.get $var3
74	0x0e3 local.get $var5
75	0x0e5 i32.ge_u
76	0x0e6 br_if 0
77	0x0e8 local.get $var3
78	0x0ea local.set $var4
79	0x0ec loop
80	0x0ee local.get $var4
81	0x0f0 i32.load8_u
82	0x0f3 local.get $var1
83	0x0f5 local.get $var2
84	0x0f7 call $_Z11adjustPixeliii
85	0x0f9 local.set $var7
86	0x0fb local.get $var4
87	0x0fd local.get $var7
88	0x0ff i32.store8
89	0x102 local.get $var6
90	0x104 local.get $var7
91	0x106 i64.extend_i32_s
92	0x107 i64.add
93	0x108 local.set $var6
94	0x10a local.get $var4
95	0x10c local.get $var3
96	0x10e i32.sub
97	0x10f i32.const 2
98	0x111 i32.eq
99	0x112 if
100	0x114 call $emscripten_debugger
101	0x116 end
102	0x117 local.get $var4
103	0x119 i32.const 1
104	0x11b i32.add
105	0x11c local.tee $var4
106	0x11e local.get $var5
107	0x120 i32.lt_u
108	0x121 br_if 0
109	0x123 end
110	0x124 end
111	;; g_lastAverage = averageLevel(checksum, pixelCount)
112	0x125 i32.const 0
113	0x127 local.get $var6
114	0x129 local.get $var5
115	0x12b local.get $var3
116	0x12d i32.sub
117	0x12e i64.extend_i32_s
118	;; inlined averageLevel(): traps with 'divide by zero' if count == 0
119	0x12f i64.div_s
120	0x130 i64.store32 offset=1028
121	0x134 i32.const 0
122	0x136 i32.const 0
123	0x138 i32.load offset=1024
124	0x13c i32.const 1
125	0x13e i32.add
126	0x13f i32.store offset=1024
127	0x143 local.get $var6
128	0x145 end
129
130	0x147 (func $legalstub$adjustImage (;4;) (param $var0 i32) (param $var1 i32) (param $var2 i32) (result i32)
131	(local $var3 i64)
132	0x14a local.get $var0
133	0x14c local.get $var1
134	0x14e local.get $var2
135	0x150 call $adjustImage
136	0x152 local.tee $var3
137	0x154 i64.const 32
138	0x156 i64.shr_u
139	0x157 i32.wrap_i64
140	0x158 call $setTempRet0
141	0x15a local.get $var3
142	0x15c i32.wrap_i64
143	0x15d end
144	)

1	// Every position is { line: 0, column: <byte offset in image-filter.wasm> }.
2	// wasm.at(func, label) returns the module offset of a labelled instruction.
3	// Binding expressions run on the wasm frame via V8's wasm debug proxy:
4	// $var<N> (locals, as { type, value }), memories[0], $<funcName>, stack[N], ...
5	const builder = new SafeScopeInfoBuilder();
6
7	// 1. Original Scopes: image-filter.cpp
8	builder
9	.startSource()
10	.startScope(0, 0, {
11	kind: "Module",
12	key: "module",
13	variables: ["kMaxLevel", "g_imagesProcessed", "g_lastAverage", "clampLevel",
14	"applyContrast", "adjustPixel", "averageLevel", "adjustImage"],
15	})
16	.startScope(/* clampLevel( */ { kind: "Function", name: "clampLevel", isStackFrame: true,
17	key: "clampLevel", variables: ["level"] }).endScope(/* } */)
18	.startScope(/* applyContrast( */ { kind: "Function", name: "applyContrast", isStackFrame: true,
19	key: "applyContrast", variables: ["level", "contrastPct", "centered", "scaled"] }).endScope()
20	.startScope(/* adjustPixel( */ { kind: "Function", name: "adjustPixel", isStackFrame: true,
21	key: "adjustPixel", variables: ["level", "brightness", "contrastPct", "brightened", "result"] })
22	.endScope()
23	.startScope(/* averageLevel( */ { kind: "Function", name: "averageLevel", isStackFrame: true,
24	key: "averageLevel", variables: ["sum", "count"] }).endScope()
25	.startScope(/* adjustImage( */ { kind: "Function", name: "adjustImage", isStackFrame: true,
26	key: "adjustImage", variables: ["image", "brightness", "contrastPct", "pixelCount", "checksum"] })
27	.startScope(/* for ( */ { kind: "Block", key: "for", variables: ["i"] })
28	.startScope(/* { */ { kind: "Block", key: "forBody", variables: ["pixel", "adjusted"] })
29	.endScope(/* } */)
30	.endScope(/* } */)
31	.endScope()
32	.endScope()
33	.endSource();
34
35	// 2. Generated Ranges: byte offsets in image-filter.wasm
36	// sub(start, [from, value?], ...) builds a SubRangeBinding[] over [start, ...).
37	builder
38	.startRange(0, 0, {
39	scopeKey: "module",
40	values: [
41	"255", // kMaxLevel: constant-folded
42	"new DataView(memories[0].buffer).getInt32(1024, true)", // C++ globals live in linear memory
43	"new DataView(memories[0].buffer).getInt32(1028, true)",
44	null, null, // clampLevel, applyContrast: always inlined
45	"$_Z11adjustPixeliii", // the wasm function (mangled name)
46	null, // averageLevel: always inlined
47	"$adjustImage",
48	],
49	})
50	// ---- wasm function $_Z11adjustPixeliii ----
51	.startRange(0, wasm.bodyStart("_Z11adjustPixeliii"), {
52	scopeKey: "adjustPixel",
53	isStackFrame: true,
54	values: [
55	"$var0.value", "$var1.value", "$var2.value",
56	// brightened: $var3 is reused, so reconstruct once it is overwritten.
57	sub(fnStart, [at("centered"), "$var3.value"],
58	[at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255)"]),
59	// result: only exists on the wasm value stack right before returning.
60	sub(fnStart, [at("return"), "stack[0].value"]),
61	],
62	})
63	.startRange(0, at("clamp1.lt0"), {
64	scopeKey: "clampLevel", isStackFrame: false,
65	callSite: /* clampLevel(level + brightness) */,
66	values: ["$var0.value + $var1.value"],
67	})
68	.endRange(0, at("clamp1.end"))
69	.startRange(0, at("centered"), {
70	scopeKey: "applyContrast", isStackFrame: false,
71	callSite: /* applyContrast(brightened, contrastPct) */,
72	values: [
73	sub(at("centered"), ["$var3.value"], [at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255)"]),
74	"$var2.value",
75	sub(at("centered"), [at("scaled"), "$var3.value - 128"],
76	[at("clamp2.lt0"), "Math.min(Math.max($var0.value + $var1.value, 0), 255) - 128"]),
77	sub(at("centered"), [at("contrastReturn"), "stack[0].value"], // value stack!
78	[at("scaledPlus128Tee"), "stack[0].value - 128"],
79	[at("clamp2.lt0"), "$var3.value - 128"],
80	[at("clamp2.afterTee")]), // clobbered
81	],
82	})
83	.startRange(0, at("clamp2.lt0"), {
84	scopeKey: "clampLevel", isStackFrame: false, // 2nd call site, same OriginalScope
85	callSite: /* clampLevel(scaled + 128) */,
86	values: [sub(at("clamp2.lt0"), ["$var3.value"], [at("clamp2.afterTee")])],
87	})
88	.endRange(0, at("return"))
89	.endRange(0, at("return"))
90	.endRange(0, wasm.bodyEnd("_Z11adjustPixeliii"))
91	// ---- wasm function $adjustImage ----
92	.startRange(0, wasm.bodyStart("adjustImage"), {
93	scopeKey: "adjustImage",
94	isStackFrame: true,
95	values: [
96	"(() => { const m = new DataView(memories[0].buffer), p = $var0.value, w = m.getInt32(p, true), h = m.getInt32(p + 4, true); return { width: w, height: h, pixels: new Uint8Array(m.buffer, m.getUint32(p + 8, true), w * h) }; })()",
97	"$var1.value", "$var2.value",
98	sub(fnStart, [at("for"), "$var5.value - $var3.value"]), // pixelCount
99	"$var6.value", // checksum: i64 -> BigInt
100	],
101	})
102	.startRange(0, at("for"), {
103	scopeKey: "for",
104	values: [sub(at("for"), [at("loop"), "$var4.value - $var3.value"])], // i (strength-reduced)
105	})
106	.startRange(0, at("body"), {
107	scopeKey: "forBody",
108	values: ["$var4.value", sub(at("body"), [at("store"), "$var7.value"])],
109	})
110	.endRange(0, at("increment"))
111	.endRange(0, at("forEnd"))
112	.startRange(0, at("divide"), {
113	scopeKey: "averageLevel", isStackFrame: false,
114	callSite: /* averageLevel(checksum, pixelCount) */,
115	values: ["$var6.value", "$var5.value - $var3.value"],
116	})
117	.endRange(0, at("storeAverage"))
118	.endRange(0, wasm.bodyEnd("adjustImage"))
119	// ---- Emscripten-generated $legalstub$adjustImage: no authored code, hidden ----
120	.startRange(0, wasm.bodyStart("legalstub$adjustImage"), { isStackFrame: true, isHidden: true })
121	.endRange(0, wasm.bodyEnd("legalstub$adjustImage"))
122	.endRange(0, wasm.end);

1	// bundle.js: hand-written, Emscripten-style JS glue for image-filter.wasm.
2	// This file is NOT source-mapped. The source map with "scopes" belongs to
3	// image-filter.wasm (see its "sourceMappingURL" custom section).
4	(function() {
5	"use strict";
6	const G_IMAGES_PROCESSED = 1024; // &g_imagesProcessed
7	const G_LAST_AVERAGE = 1028; // &g_lastAverage
8	const IMAGE_PTR = 2048; // Image { width, height, pixels }
9	const PIXELS_PTR = 2064;
10	const EMPTY_IMAGE_PTR = 2096; // Image { 0, 0, pixels }
11	const SAMPLE_PIXELS = [40, 120, 200, 250];
12
13	let instance = null;
14	let tempRet0 = 0;
15
16	const imports = {
17	env: {
18	// Like in Emscripten, emscripten_debugger() is a JS library function.
19	emscripten_debugger: function() {
20	debugger; // Step out (Shift+F11) to continue in image-filter.cpp.
21	},
22	// Receives the high 32 bits of i64 results from legalstub$adjustImage.
23	setTempRet0: function(value) {
24	tempRet0 = value;
25	},
26	},
27	};
28
29	WebAssembly.instantiateStreaming(fetch("./image-filter.wasm"), imports).then(
30	function(result) {
31	instance = result.instance;
32	},
33	function(err) {
34	console.error("Failed to instantiate image-filter.wasm", err);
35	},
36	);
37
38	function wasmExports() {
39	if (!instance) throw new Error("image-filter.wasm is still loading, try again.");
40	return instance.exports;
41	}
42
43	function writeImage(ptr, width, height, pixelsPtr, pixels) {
44	const memory = wasmExports().memory;
45	const view = new DataView(memory.buffer);
46	view.setInt32(ptr, width, true);
47	view.setInt32(ptr + 4, height, true);
48	view.setUint32(ptr + 8, pixelsPtr, true);
49	new Uint8Array(memory.buffer, pixelsPtr, pixels.length).set(pixels);
50	}
51
52	function callAdjustImage(imagePtr) {
53	const low = wasmExports().adjustImage(imagePtr, 30, 150);
54	return tempRet0 * 2 ** 32 + (low >>> 0);
55	}
56
57	window.runExample08 = function() {
58	writeImage(IMAGE_PTR, 2, 2, PIXELS_PTR, SAMPLE_PIXELS);
59	const checksum = callAdjustImage(IMAGE_PTR);
60	const memory = wasmExports().memory;
61	const view = new DataView(memory.buffer);
62	return {
63	checksum: checksum,
64	pixels: Array.from(new Uint8Array(memory.buffer, PIXELS_PTR, SAMPLE_PIXELS.length)),
65	lastAverage: view.getInt32(G_LAST_AVERAGE, true),
66	imagesProcessed: view.getInt32(G_IMAGES_PROCESSED, true),
67	};
68	};
69
70	window.logStackExample08 = function() {
71	writeImage(EMPTY_IMAGE_PTR, 0, 0, PIXELS_PTR, []);
72	try {
73	callAdjustImage(EMPTY_IMAGE_PTR);
74	return "Unexpectedly, no trap.";
75	} catch (err) {
76	console.error(err);
77	return String(err.stack);
78	}
79	};
80	})();