WebAssembly (WASM) for High Performance Apps · Leçon

Déboguer des modules WebAssembly

Utilisez les outils de développement des navigateurs et d’autres techniques de débogage pour examiner et dépanner vos applications WASM.

Déboguer des modules WebAssembly est une leçon WebAssembly (WASM) for High Performance Apps gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage WebAssembly (WASM) for High Performance Apps, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours WebAssembly (WASM) for High Performance Apps comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Debugging WASM: An Overview

Ever wondered how to peek inside your WebAssembly code while it runs? Debugging WASM lets you find and fix issues in your high-performance modules.

It's a bit different from debugging pure JavaScript, but modern browser developer tools offer powerful capabilities to help you out.

Browser DevTools: Sources Tab

Your browser's developer tools are your best friend for WASM debugging. In Chrome, open DevTools (F12 or Cmd+Option+I).

Navigate to the Sources tab.
Look for your WASM module in the file tree, often under wasm:// or similar.
Without source maps, you'll see raw WebAssembly text format – which is very hard to read!

Source Maps: From WASM to Source

Debugging raw WebAssembly text is incredibly tough! Source maps are special files that link the compiled WASM code back to your original C, C++, or Rust source code.

When present, your browser can display your original source files, allowing you to debug them directly, just like JavaScript.

Rust & wasm-pack Source Maps

When compiling Rust to WASM, tools like wasm-pack can automatically generate source maps. The key is to compile in debug mode.

A simple Rust function that adds one to a number:

// src/lib.rs
#[no_mangle]
pub extern "C" fn add_one(num: i32) -> i32 {
    // This function adds 1 to the input number.
    // It will be exported from the WASM module.
    num + 1
}

Loading WASM & Source Maps

Let's see how a browser loads a WASM module. When compiled with source maps (e.g., wasm-pack build --target web --dev), the browser uses them to show your original Rust/C/C++ files in the Sources tab.

Here's how JavaScript loads a tiny, conceptual WASM module:

async function loadAndRunWasm() {
  // This is a conceptual WASM binary for 'add(a, b) => a + b'
  const wasmCode = new Uint8Array([
    0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x07, 0x01, 0x60,
    0x02, 0x7f, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x07, 0x01,
    0x03, 0x61, 0x64, 0x64, 0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20,
    0x00, 0x20, 0x01, 0x6a, 0x0b
  ]);

  const wasmModule = await WebAssembly.instantiate(wasmCode, {});
  const add = wasmModule.instance.exports.add;
  console.log("WASM add(5, 7):", add(5, 7)); // Expected: 12
}
loadAndRunWasm();

Pausing Execution with Breakpoints

Just like JavaScript, you can set breakpoints directly in your original C/C++/Rust source files shown in the Sources tab of your browser's DevTools.

Click on the line number in the gutter where you want to pause execution.
When your WASM code executes that line, the browser will pause, letting you inspect variables and the call stack.

Inspect Variables, Memory & Stack

When execution pauses at a breakpoint, you gain powerful insights:

Scope pane: View local variables and function arguments, often with their original names if source maps are good.
Memory Inspector: Use the dedicated 'Memory' tab or right-click a memory address to inspect WASM's linear memory buffer.
Call Stack pane: See the sequence of function calls that led to the current point, including both JavaScript and WASM frames.

Step-by-Step Execution

Once paused at a breakpoint, use the debugger controls to navigate your code line by line:

Step Over (F10): Execute the current line and move to the next.
Step Into (F11): Dive into a function call on the current line.
Step Out (Shift+F11): Finish executing the current function and return to where it was called.
Resume (F8): Continue execution until the next breakpoint or the program ends.

Debugging JS-WASM Interaction

Often, bugs occur at the boundary where JavaScript calls WASM functions or vice-versa. Set breakpoints in both your JavaScript and WASM code.

You can step seamlessly between JS and WASM execution frames in the DevTools call stack, making it easy to trace data flow and identify issues in the interop layer.

Debugging Knowledge Check

Test your understanding of WebAssembly debugging!

Debugging WASM: Recap

Today, you learned how to leverage browser developer tools to debug your WebAssembly applications. We covered:

Using source maps to see original source code.
Setting breakpoints and stepping through execution.
Inspecting variables, memory, and the call stack.
Debugging interactions between JavaScript and WASM.

Mastering these techniques is crucial for building robust and performant WASM applications. Keep practicing!

Questions Fréquemment Posées

La leçon « Déboguer des modules WebAssembly » est-elle gratuite ?

Oui — le texte complet de « Déboguer des modules WebAssembly » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours WebAssembly (WASM) for High Performance Apps, passe à CoddyKit PRO. Le cours WebAssembly (WASM) for High Performance Apps comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Déboguer des modules WebAssembly » ?

Utilisez les outils de développement des navigateurs et d’autres techniques de débogage pour examiner et dépanner vos applications WASM. Tu pratiques WebAssembly (WASM) for High Performance Apps avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer WebAssembly (WASM) for High Performance Apps ?

Aucune expérience préalable n'est requise. WebAssembly (WASM) for High Performance Apps sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Déboguer des modules WebAssembly » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon WebAssembly (WASM) for High Performance Apps ?

Oui. Chaque leçon WebAssembly (WASM) for High Performance Apps inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Évaluer les performances de WASM
Optimiser le code Rust pour WASM
Déboguer des modules WebAssembly
SIMD et multithreading pour un débit maximal

← Retour à WebAssembly (WASM) for High Performance Apps