anchor.diff:  
     @override
     void visitTryFinally(TryFinally node) {
  -    // We lower a [TryFinally] to three nested blocks, and we emit the finalizer
  -    // up to three times. Once in a catch, to handle the case where the try
  +    // We lower a [TryFinally] to a number of nested blocks, depending on how
  +    // many different code paths we have that run the finally block.
  +    //
  +    // We emit the finalizer once in a catch, to handle the case where the try
       // throws. Once outside of the catch, to handle the case where the try does
  -    // not throw. Finally, if there is a return within the try block, then we
  -    // emit the finalizer one more time along with logic to continue walking up
  -    // the stack.
  +    // not throw. If there is a return within the try block, then we emit the
  +    // finalizer one more time along with logic to continue walking up the
  +    // stack.
  +    //
  +    // A `break L` can run more than one finalizer, and each of those
  +    // finalizers will need to be run in a different `try` block. So for each
  +    // wrapping label we generate a block to run the finalizer on `break` and
  +    // then branch to the right Wasm block to either run the next finalizer or
  +    // break.
  +
  +    // The block for the try-finally statement. Used as `br` target in normal
  +    // execution after the finalizer (no throws, returns, or breaks).
       w.Label tryFinallyBlock = b.block();
  -    w.Label finalizerBlock = b.block();
  -    finalizers.add(TryBlockFinalizer(finalizerBlock));
  +
  +    // Create one block for each wrapping label
  +    for (final labelBlocks in breakFinalizers.values) {
  +      labelBlocks.add(b.block());
  +    }
  +
  +    // Continuation of this block runs the finalizer and returns (or jumps to
  +    // the next finalizer block). Used as `br` target on `return`.
  +    w.Label returnFinalizerBlock = b.block();
  +    returnFinalizers.add(TryBlockFinalizer(returnFinalizerBlock));
  +
       w.Label tryBlock = b.try_();
       visitStatement(node.body);
  -    bool mustHandleReturn = finalizers.removeLast().mustHandleReturn;
  -    b.br(tryBlock);
  +    final bool mustHandleReturn =
  +        returnFinalizers.removeLast().mustHandleReturn;
       b.catch_(translator.exceptionTag);
  +
  +    // `break` statements in the current finalizer and the rest will not run
  +    // the current finalizer, update the `break` targets
  +    final removedBreakTargets = <LabeledStatement, w.Label>{};
  +    for (final breakFinalizerEntry in breakFinalizers.entries) {
  +      removedBreakTargets[breakFinalizerEntry.key] =
  +          breakFinalizerEntry.value.removeLast();
  +    }
  +
  +    // Run finalizer on exception
       visitStatement(node.finalizer);
       b.rethrow_(tryBlock);
       b.end(); // end tryBlock.
  +
  +    // Run finalizer on normal execution (no breaks, throws, or returns)
       visitStatement(node.finalizer);
       b.br(tryFinallyBlock);
  -    b.end(); // end finalizerBlock.
  +    b.end(); // end returnFinalizerBlock.
  +
  +    // Run finalizer on `return`
       if (mustHandleReturn) {
         visitStatement(node.finalizer);
  -      if (finalizers.isNotEmpty) {
  -        b.br(finalizers.last.label);
  +      if (returnFinalizers.isNotEmpty) {
  +        b.br(returnFinalizers.last.label);
         } else {
           if (returnValueLocal != null) {
             b.local_get(returnValueLocal!);
  
positive.code:     // as the stack unwinds. When we get to the top of the finalizer stack, we
      // will handle the return using [returnValueLocal] if this function returns
      // a value.
      if (finalizers.isNotEmpty) {
        for (TryBlockFinalizer finalizer in finalizers) {
          finalizer.mustHandleReturn = true;
        }
        if (returnType != voidMarker) {
  
negative.code:         returnValueLocal ??= addLocal(returnType.withNullability(true));
          b.local_set(returnValueLocal!);
        }
        b.br(returnFinalizers.last.label);
      } else {
        _returnFromFunction();
      }
  