Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 6 additions & 1 deletion crates/perry-codegen/src/expr/index.rs
Original file line number Diff line number Diff line change
Expand Up @@ -345,9 +345,14 @@ pub(crate) fn lower_index_set_fast(
"js_typed_feedback_record_fallback_call",
&[(I64, feedback_site_id)],
);
// Strict `arr[i] = v`: a frozen array's element is non-writable and a
// non-extensible array rejects a new index, so route to the throwing
// variant. (The inline fast/medium paths above are only reached for
// arrays with a proven dense-numeric layout, which excludes frozen /
// sealed / non-extensible arrays — those always fall to this call.)
let new_handle = blk.call(
I64,
"js_array_set_f64_extend",
"js_array_set_f64_extend_strict",
&[(I64, &arr_handle), (I32, &idx_i32), (DOUBLE, val_double)],
);
let new_box = nanbox_pointer_inline(blk, &new_handle);
Expand Down
5 changes: 4 additions & 1 deletion crates/perry-codegen/src/expr/property_set.rs
Original file line number Diff line number Diff line change
Expand Up @@ -194,8 +194,11 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
let blk = ctx.block();
let arr_bits = blk.bitcast_double_to_i64(&arr_box);
let arr_handle = blk.and(I64, &arr_bits, POINTER_MASK_I64);
// `arr.length = v` is a strict `Set(O,"length",v,true)`: a frozen
// array's `length` is non-writable, so route to the throwing
// variant instead of the silent internal helper.
blk.call_void(
"js_array_set_length",
"js_array_set_length_strict",
&[(I64, &arr_handle), (DOUBLE, &val_double)],
);
return Ok(val_double);
Expand Down
2 changes: 2 additions & 0 deletions crates/perry-codegen/src/runtime_decls/arrays.rs
Original file line number Diff line number Diff line change
Expand Up @@ -51,6 +51,7 @@ pub fn declare_phase_b_arrays(module: &mut LlModule) {
// Extending variant: returns a possibly-realloc'd pointer that the
// caller must write back to the local slot.
module.declare_function("js_array_set_f64_extend", I64, &[I64, I32, DOUBLE]);
module.declare_function("js_array_set_f64_extend_strict", I64, &[I64, I32, DOUBLE]);
module.declare_function("js_array_fill_f64_const_extend", I64, &[I64, I32, DOUBLE]);
module.declare_function("js_array_fill_f64_iota_extend", I64, &[I64, I32]);
module.declare_function("js_array_fill_f64_const_len_extend", I64, &[I64, DOUBLE]);
Expand Down Expand Up @@ -135,6 +136,7 @@ pub fn declare_phase_b_arrays(module: &mut LlModule) {
module.declare_function("js_array_delete", I32, &[I64, I32]);
// Closes #304: `arr.length = N` truncate / extend.
module.declare_function("js_array_set_length", VOID, &[I64, DOUBLE]);
module.declare_function("js_array_set_length_strict", VOID, &[I64, DOUBLE]);
// Array.from() — js_array_clone handles arrays, Sets, and Maps.
module.declare_function("js_array_clone", I64, &[I64]);
// #2773: Array.from(source) — throws TypeError for nullish sources, keeps
Expand Down
140 changes: 140 additions & 0 deletions crates/perry-runtime/src/array/indexing.rs
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,31 @@ const MAX_DENSE_ARRAY_GROW_LENGTH: u32 = 1_000_000;
/// benchmark for 6 hours (Regression Check, v0.5.1129–v0.5.1150).
const DENSE_ARRAY_GAP_LIMIT: u32 = 1024;

/// A strict-mode element write (`arr[i] = v`) to a **frozen** array's existing
/// index is `[[Set]]` on a non-writable data property with `Throw = true`
/// (ECMA-262 §10.4.2.4 → OrdinarySetWithOwnDescriptor step 2.b.i), so it must
/// throw a **TypeError** rather than silently no-op. Perry compiles everything
/// strict, so the codegen `arr[i] = v` fast paths — which call these
/// `js_array_set_f64*` helpers directly — carry the strict-`Set` contract.
/// Matches V8's message. (test262 built-ins/Array element-write-on-frozen.)
#[cold]
fn throw_frozen_array_index_write(index: u32) -> ! {
crate::collection_iter::throw_type_error(&format!(
"Cannot assign to read only property '{index}' of object '[object Array]'"
));
}

/// A strict-mode write that would *add* a new index to a non-extensible
/// (frozen / sealed / preventExtensions'd) array — `arr[i] = v` with
/// `i >= length` — is `CreateDataProperty` on a non-extensible object with
/// `Throw = true`, so it must throw a **TypeError**. Matches V8's message.
#[cold]
fn throw_array_not_extensible_add(index: u32) -> ! {
crate::collection_iter::throw_type_error(&format!(
"Cannot add property {index}, object is not extensible"
));
}

/// Lazily-memoized address of the `Array.prototype` array, and a sticky flag
/// recording whether anyone has installed an indexed property on it. An
/// out-of-bounds element read on an ordinary array must fall through to
Expand Down Expand Up @@ -830,6 +855,61 @@ pub extern "C" fn js_array_set_f64(arr: *mut ArrayHeader, index: u32, value: f64
}
}

/// Strict-mode `arr[i] = v` — the user-visible element assignment, i.e.
/// `Set(O, ToString(i), v, true)` (PutValue with `Throw = true`). On a frozen
/// array this must throw a **TypeError** instead of silently no-oping: writing
/// an existing index is a read-only violation; adding a new index (or writing
/// any index of a sealed / preventExtensions'd array past its length) is a
/// not-extensible violation.
///
/// Kept separate from `js_array_set_f64_extend` so the *internal* callers of the
/// latter — `Object.defineProperty(arr, i, …)` (which uses it as a raw
/// `[[DefineOwnProperty]]` slot-writer after clearing attrs),
/// `polymorphic_index`, and freshly-allocated runtime arrays — retain their
/// silent, non-throwing contract. Only the `arr[i] = v` assignment codegen
/// (`index_set` / `index` / `field_set_by_name`) routes here.
/// test262 built-ins/Array element/add on frozen|sealed|non-extensible.
/// Strict-mode guard for a would-be `arr[index] = v` element write: throws the
/// spec `Set`-with-`Throw` TypeError when `arr` is frozen (existing index →
/// read-only) or non-extensible and the index is new (→ not-extensible). No-op
/// for writable slots, buffers, and typed arrays (which own their store
/// semantics). Shared by the strict element-write entry points.
#[inline]
pub(crate) fn array_strict_index_write_guard(arr: *mut ArrayHeader, index: u32) {
let clean = clean_arr_ptr_mut(arr);
if clean.is_null()
|| crate::buffer::is_registered_buffer(clean as usize)
|| crate::typedarray::lookup_typed_array_kind(clean as usize).is_some()
{
return;
}
let flags = array_object_flags(clean);
let length = unsafe { (*clean).length };
if index < length {
// Existing index: only a *frozen* array's data is non-writable; a
// sealed / non-extensible array still permits overwriting it.
if flags & crate::gc::OBJ_FLAG_FROZEN != 0 {
throw_frozen_array_index_write(index);
}
} else if flags
& (crate::gc::OBJ_FLAG_FROZEN | crate::gc::OBJ_FLAG_SEALED | crate::gc::OBJ_FLAG_NO_EXTEND)
!= 0
{
// New index on a non-extensible array: cannot add the property.
throw_array_not_extensible_add(index);
}
}
Comment on lines +878 to +901

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Inspect how non-writable index/length descriptors are represented and whether
# any other layer would throw for a strict write on a non-frozen array.
rg -nP 'OBJ_FLAG_ARRAY_DESCRIPTORS|get_property_attrs|writable\(\)' crates/perry-runtime/src/array/indexing.rs -C2
rg -nP 'fn (freeze|seal|prevent_extensions|define_property)' crates/perry-runtime/src -C3

Repository: PerryTS/perry

Length of output: 5118


🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Inspect the strict index-write guard and the descriptor-aware setter around it.
sed -n '850,910p' crates/perry-runtime/src/array/indexing.rs
echo '---'
sed -n '720,760p' crates/perry-runtime/src/array/indexing.rs
echo '---'
sed -n '960,1010p' crates/perry-runtime/src/array/indexing.rs

# Find the strict-write call sites and any strict-mode throwing helpers for array writes.
rg -n "array_strict_index_write_guard|throw_frozen_array_index_write|throw_array_not_extensible_add|strict" crates/perry-runtime/src/array/indexing.rs crates/perry-runtime/src -C3

Repository: PerryTS/perry

Length of output: 50370


Handle descriptor-backed non-writable array writes in the strict path
array_strict_index_write_guard only throws for frozen/sealed/non-extensible arrays, but js_array_set_f64_extend still returns silently for OBJ_FLAG_ARRAY_DESCRIPTORS slots with !attrs.writable() and for a non-writable length. That makes strict arr[i] = v no-op instead of TypeError on descriptor-backed arrays.

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/perry-runtime/src/array/indexing.rs` around lines 878 - 901, The
strict write guard in array_strict_index_write_guard only checks
frozen/sealed/non-extensible flags, but descriptor-backed arrays can still
reject writes when a slot is non-writable or when length is non-writable. Update
the strict array assignment path in js_array_set_f64_extend so that
OBJ_FLAG_ARRAY_DESCRIPTORS elements with !attrs.writable() and non-writable
length both trigger the appropriate TypeError instead of returning silently,
matching the existing strict behavior for array index writes.


#[no_mangle]
pub extern "C" fn js_array_set_f64_extend_strict(
arr: *mut ArrayHeader,
index: u32,
value: f64,
) -> *mut ArrayHeader {
array_strict_index_write_guard(arr, index);
js_array_set_f64_extend(arr, index, value)
}

/// Set an element in an array by index, extending the array if needed
/// Returns the (possibly reallocated) array pointer
/// This mimics JavaScript's arr[i] = value behavior
Expand Down Expand Up @@ -1485,3 +1565,63 @@ pub extern "C" fn js_array_set_index_or_string(
}
arr
}

/// Strict-mode `arr[key] = v` (dynamic index-or-string key) — `Set` with
/// `Throw = true`. For a canonical numeric index this enforces the frozen /
/// non-extensible guard (throwing a TypeError) before delegating; non-index
/// keys fall through to the ordinary path unchanged. This is the assignment
/// entry point behind `js_typed_feedback_array_set_index_or_string`; the plain
/// `js_array_set_index_or_string` keeps its silent contract for any internal
/// caller. test262 built-ins/Array element-write-on-frozen (string/dynamic key).
#[no_mangle]
pub extern "C" fn js_array_set_index_or_string_strict(
arr: *mut ArrayHeader,
idx: f64,
value: f64,
) -> *mut ArrayHeader {
if !arr.is_null() {
// Resolve the canonical array-index interpretation of the key (mirrors
// the numeric branch of `js_array_set_index_or_string`), and guard it.
// A string key that spells an index (`"0"`) also targets the element
// store, so ToString it and re-parse.
let index = canonical_index_of_set_key(idx);
if let Some(i) = index {
array_strict_index_write_guard(arr, i);
}
}
js_array_set_index_or_string(arr, idx, value)
}

/// The canonical array index (`0..2^32-1`) a dynamic `arr[key] = v` key targets,
/// or `None` for a non-index key. Numbers use the array-index boundary; string
/// keys are parsed via their ToString so `arr["3"]` on a frozen array throws
/// like `arr[3]`.
fn canonical_index_of_set_key(idx: f64) -> Option<u32> {
let bits = idx.to_bits();
let top16 = bits >> 48;
// Heap string / SSO key: parse the string as a canonical index.
if top16 == 0x7FFF || top16 == 0x7FF9 {
let s = crate::value::js_get_string_pointer_unified(idx) as *const crate::StringHeader;
if s.is_null() {
return None;
}
let len = unsafe { (*s).byte_len as usize };
let data = unsafe { (s as *const u8).add(std::mem::size_of::<crate::StringHeader>()) };
let bytes = unsafe { std::slice::from_raw_parts(data, len) };
let name = std::str::from_utf8(bytes).ok()?;
return crate::object::canonical_array_index(name);
}
// Numeric key.
let n = if (bits & crate::value::TAG_MASK) == crate::value::INT32_TAG {
crate::value::JSValue::from_bits(bits).as_int32() as f64
} else if !(0x7FF8..=0x7FFF).contains(&top16) {
idx
} else {
return None;
};
if n.is_finite() && n.trunc() == n && n >= 0.0 && n < u32::MAX as f64 {
Some(n as u32)
} else {
None
}
}
7 changes: 4 additions & 3 deletions crates/perry-runtime/src/array/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -79,8 +79,8 @@ pub use self::indexing::{
js_array_get_element, js_array_get_element_f64, js_array_get_f64, js_array_get_f64_unchecked,
js_array_get_index_or_string, js_array_get_length, js_array_length,
js_array_numeric_get_f64_unboxed, js_array_numeric_set_f64_unboxed, js_array_set_f64,
js_array_set_f64_extend, js_array_set_f64_unchecked, js_array_set_index_or_string,
js_array_set_string_key,
js_array_set_f64_extend, js_array_set_f64_extend_strict, js_array_set_f64_unchecked,
js_array_set_index_or_string, js_array_set_index_or_string_strict, js_array_set_string_key,
};
pub use self::is_array::js_array_is_array;
pub(crate) use self::iter_methods::throw_reduce_of_empty;
Expand Down Expand Up @@ -119,7 +119,8 @@ pub(crate) use self::push_pop::guard_writable_length;
pub use self::push_pop::{
js_array_delete, js_array_grow, js_array_numeric_push_f64_unboxed, js_array_pop_f64,
js_array_push_f64, js_array_push_hole, js_array_push_spread_f64, js_array_set_length,
js_array_shift_f64, js_array_unshift_f64, js_array_unshift_jsvalue, js_array_unshift_variadic,
js_array_set_length_strict, js_array_shift_f64, js_array_unshift_f64, js_array_unshift_jsvalue,
js_array_unshift_variadic,
};
pub use self::reduce_right::js_array_reduce_right;
pub use self::search::{
Expand Down
26 changes: 26 additions & 0 deletions crates/perry-runtime/src/array/push_pop.rs
Original file line number Diff line number Diff line change
Expand Up @@ -380,6 +380,32 @@ pub extern "C" fn js_array_pop_f64(arr: *mut ArrayHeader) -> f64 {
/// JSValue). The JS ArraySetLength path coerces it with `Number(...)`, then
/// rejects NaN, negative, fractional, infinite, and >uint32 lengths with
/// `RangeError: Invalid array length`.
/// `arr.length = v` as the user-visible assignment — `Set(O, "length", v, true)`
/// (PutValue with `Throw = true`, ECMA-262 §13.15.2). A frozen array's `length`
/// is a non-writable data property, so the write must throw a **TypeError**
/// rather than silently no-op — even when `v` equals the current length or is an
/// invalid length (V8 rejects the non-writable write before coercing the value,
/// so a frozen `arr.length = -1` is a TypeError, not a RangeError; hence the
/// guard precedes `array_length_from_property_value_or_throw`).
///
/// This throwing variant is separate from `js_array_set_length` so the *internal*
/// callers of the latter (`Object.defineProperty(arr, "length", …)`,
/// array-object length coercion, stream/url bookkeeping) keep their silent,
/// non-throwing `[[DefineOwnProperty]]`/no-Throw contract. Only the assignment
/// codegen paths (`field_set_by_name` / `property_set` / proxy `PutValue`) route
/// here. test262 built-ins/Array length-write-on-frozen.
#[no_mangle]
pub extern "C" fn js_array_set_length_strict(arr: *mut ArrayHeader, new_length: f64) {
let arr = clean_arr_ptr_mut(arr);
if arr.is_null() {
return;
}
if unsafe { array_object_flags(arr) } & crate::gc::OBJ_FLAG_FROZEN != 0 {
throw_non_writable_length();
}
js_array_set_length(arr, new_length);
}
Comment on lines +398 to +407

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Map the relevant file and locate the array-length setters and callers.
git ls-files crates/perry-runtime/src/array/push_pop.rs \
             crates/perry-runtime/src/property_set.rs \
             crates/perry-runtime/src/field_set_by_name.rs \
             crates/perry-runtime/src/put_value.rs

echo '--- outline: push_pop.rs ---'
ast-grep outline crates/perry-runtime/src/array/push_pop.rs --view expanded || true

echo '--- search for length setter functions and descriptor checks ---'
rg -n "js_array_set_length|OBJ_FLAG_ARRAY_DESCRIPTORS|get_property_attrs\\(|throw_non_writable_length|writable\\(" \
  crates/perry-runtime/src/array/push_pop.rs \
  crates/perry-runtime/src/property_set.rs \
  crates/perry-runtime/src/field_set_by_name.rs \
  crates/perry-runtime/src/put_value.rs

echo '--- relevant slices from push_pop.rs ---'
sed -n '300,470p' crates/perry-runtime/src/array/push_pop.rs

echo '--- relevant caller slices ---'
sed -n '1,260p' crates/perry-runtime/src/property_set.rs
sed -n '1,260p' crates/perry-runtime/src/field_set_by_name.rs
sed -n '1,260p' crates/perry-runtime/src/put_value.rs

Repository: PerryTS/perry

Length of output: 3993


🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- relevant slice: push_pop.rs ---'
sed -n '1,80p' crates/perry-runtime/src/array/push_pop.rs
sed -n '380,450p' crates/perry-runtime/src/array/push_pop.rs

echo '--- locate caller files ---'
git ls-files | rg '(^|/)(property_set|field_set_by_name|put_value)\.(rs|ts|js)$|(^|/)put_value\.rs$|(^|/)property_set\.rs$|(^|/)field_set_by_name\.rs$'

echo '--- search for js_array_set_length_strict call sites ---'
rg -n "js_array_set_length_strict|js_array_set_length\\(" crates/perry-runtime/src

echo '--- search for non-writable length guards ---'
rg -n "array_length_is_non_writable|guard_writable_length|throw_non_writable_length|get_property_attrs\\(arr as usize, \"length\"" crates/perry-runtime/src

Repository: PerryTS/perry

Length of output: 10889


🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- field_set_by_name.rs around strict length writes ---'
sed -n '560,640p' crates/perry-runtime/src/object/field_set_by_name.rs

echo '--- proxy/put_value.rs around strict length writes ---'
sed -n '160,220p' crates/perry-runtime/src/proxy/put_value.rs

echo '--- object/native_call_method/common_methods.rs around length guard usage ---'
sed -n '760,810p' crates/perry-runtime/src/object/native_call_method/common_methods.rs

echo '--- object/native_call_method/handle_methods.rs around length guard usage ---'
sed -n '340,385p' crates/perry-runtime/src/object/native_call_method/handle_methods.rs

Repository: PerryTS/perry

Length of output: 11923


js_array_set_length_strict should also throw for non-writable length

js_array_set_length already has a silent no-op path for Object.defineProperty(arr, "length", { writable: false }), but the strict wrapper only checks OBJ_FLAG_FROZEN. That leaves strict arr.length = v able to no-op instead of throwing TypeError. field_set_by_name.rs and proxy/put_value.rs both route strict length assignment through this helper, so this is the right place to mirror the existing array_length_is_non_writable guard.

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/perry-runtime/src/array/push_pop.rs` around lines 398 - 407,
`js_array_set_length_strict` only checks `OBJ_FLAG_FROZEN`, so strict `length`
assignment can still silently no-op when the array’s length property is
non-writable. Update this helper to also detect the non-writable length case
using the same `array_length_is_non_writable` guard used by
`js_array_set_length`, and call `throw_non_writable_length()` before delegating
to `js_array_set_length`. Keep the behavior aligned for callers like
`field_set_by_name` and `proxy/put_value` that route strict length writes
through `js_array_set_length_strict`.


#[no_mangle]
pub extern "C" fn js_array_set_length(arr: *mut ArrayHeader, new_length: f64) {
let arr = clean_arr_ptr_mut(arr);
Expand Down
13 changes: 10 additions & 3 deletions crates/perry-runtime/src/object/field_set_by_name.rs
Original file line number Diff line number Diff line change
Expand Up @@ -577,7 +577,12 @@ pub extern "C" fn js_object_set_field_by_name(
let gc_header =
(obj as *const u8).sub(crate::gc::GC_HEADER_SIZE) as *const crate::gc::GcHeader;
if (*gc_header).obj_type == crate::gc::GC_TYPE_ARRAY {
crate::array::js_array_set_length(obj as *mut crate::array::ArrayHeader, value);
// Assignment (`arr.length = v`) is a strict `Set` with
// `Throw = true`: throw on a frozen array's non-writable length.
crate::array::js_array_set_length_strict(
obj as *mut crate::array::ArrayHeader,
value,
);
return;
}
}
Expand Down Expand Up @@ -614,11 +619,13 @@ pub extern "C" fn js_object_set_field_by_name(
};
let arr = obj as *mut crate::array::ArrayHeader;
if name == "length" {
crate::array::js_array_set_length(arr, value);
// Strict `Set(arr, "length", v, true)` — throw on frozen.
crate::array::js_array_set_length_strict(arr, value);
return;
}
if let Some(index) = super::canonical_array_index(name) {
crate::array::js_array_set_f64_extend(arr, index, value);
// Strict `Set(arr, i, v, true)` — throw on frozen/non-extensible.
crate::array::js_array_set_f64_extend_strict(arr, index, value);
return;
}
// Own-accessor short-circuit — an Array can carry a named accessor
Expand Down
9 changes: 8 additions & 1 deletion crates/perry-runtime/src/proxy/put_value.rs
Original file line number Diff line number Diff line change
Expand Up @@ -188,7 +188,14 @@ pub extern "C" fn js_put_value_set(
}
if target.to_bits() == receiver.to_bits() && key_is_length(property_key) {
if let Some(arr) = array_ptr_from_value(target) {
crate::array::js_array_set_length(arr, value);
// PutValue(`arr.length = v`) is `Set(O, "length", v, Throw)`. In
// strict mode a frozen array's non-writable `length` makes the
// write throw a TypeError instead of silently no-oping.
if strict != 0 {
crate::array::js_array_set_length_strict(arr, value);
} else {
crate::array::js_array_set_length(arr, value);
}
return value;
}
}
Expand Down
9 changes: 7 additions & 2 deletions crates/perry-runtime/src/typed_feedback.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1782,7 +1782,10 @@ pub extern "C" fn js_typed_feedback_array_set_f64_extend(
if !pass {
record_fallback_call(site_id);
}
crate::array::js_array_set_f64_extend(arr, index, value)
// This wrapper is only emitted for the source-level `arr[i] = v` assignment,
// so it carries strict `Set`-with-`Throw` semantics: a frozen array's element
// is non-writable and a non-extensible array rejects a new index → TypeError.
crate::array::js_array_set_f64_extend_strict(arr, index, value)
}

#[no_mangle]
Expand Down Expand Up @@ -2029,7 +2032,9 @@ pub extern "C" fn js_typed_feedback_array_set_index_or_string(
} else {
record_guard_pass(site_id);
}
crate::array::js_array_set_index_or_string(arr, idx, value)
// Assignment-site wrapper → strict `Set` with `Throw = true` (frozen /
// non-extensible array element write throws a TypeError).
crate::array::js_array_set_index_or_string_strict(arr, idx, value)
}

#[no_mangle]
Expand Down
Loading