wasmparser 0.257.0

/* Copyright 2026 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//! Logical offsets into the input wasm file are strictly limited to fit into
//! an integer of type [u64]. Data in each chunk is addressed through an offset
//! into an `[u8]` slice, which uses `usize`-addressing.
//!
//! This module contains functionality to bridge the gap.

// An (not necessarily exhaustive) list of properties we use of `u64` in relation
// to usize:
// - u64::MAX as an upper bound and sometimes invalid offset
// - 0u64 as the starting offset
// - we can add and subtract small offsets to recalculate the original position
//   in some error paths, where saving the position directly would clutter registers.

// An memory offset into some chunk of bytes occurs at some specified logical
// offset in the file. We currently use `usize` to represent memory offsets.
// TODO: on platforms where usize::BITS > u64::BITS (currently almost no-where),
// we could use u64 directly instead of usize to represent memory offsets.

use crate::Error;

/// Return the largest memory offset that can be added to `offset` without going
/// past `max_offset` or overflowing.
pub fn max_data_len(offset: u64, max_offset: u64) -> usize {
    let mut max_logical = max_offset - offset;
    if u64::BITS > usize::BITS {
        max_logical = max_logical.min(usize::MAX as u64)
    }
    // we now know that max_logical fits into a usize
    max_logical as usize
}

#[cold]
pub fn panic_too_many_bytes(offset: u64, len: usize, max_len: usize) -> ! {
    panic!(
        "Content too large to parse. Got {len}, expected at most {max_len} bytes at offset 0x{offset:x}."
    )
}
pub fn err_too_many_bytes(offset: u64, len: usize, max_len: usize) -> Error {
    format_err!(
        offset,
        "Content too large to parse. Got {len}, expected at most {max_len} bytes."
    )
}