fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-04-26 15:32:16 +00:00
Code Issues Projects Releases Wiki Activity

Add bounds checks to DataView and fix some lint issues

Browse Source
This commit is contained in:
dcodeIO 2018-11-12 09:11:04 +01:00
parent 1882679807
commit 84ffa91db9
5 changed files with 4541 additions and 3046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
std/assembly/dataview.ts
View File

@ -1,129 +1,185 @@
import { HEADER_SIZE } from "./internal/arraybuffer"; import {
HEADER_SIZE,
MAX_BLENGTH
} from "./internal/arraybuffer";
export class DataView { export class DataView {
constructor( constructor(
readonly buffer: ArrayBuffer, readonly buffer: ArrayBuffer,
readonly byteOffset: i32 = 0, readonly byteOffset: i32 = 0,
readonly byteLength: i32 = i32.MIN_VALUE, readonly byteLength: i32 = i32.MIN_VALUE // FIXME
) { ) {
if (byteLength === i32.MIN_VALUE) byteLength = buffer.byteLength - byteOffset; if (byteLength === i32.MIN_VALUE) byteLength = buffer.byteLength - byteOffset; // FIXME
if (<u32>byteOffset > <u32>MAX_BLENGTH) throw new RangeError("Invalid byteOffset");
if (byteOffset < 0) throw new RangeError("byteOffset cannot be negative"); if (<u32>byteLength > <u32>MAX_BLENGTH) throw new RangeError("Invalid byteLength");
if (byteLength < 0) throw new RangeError("byteLength cannot be negative"); if (byteOffset + byteLength > buffer.byteLength) throw new RangeError("Invalid length");
if (byteOffset + byteLength > buffer.byteLength) throw new RangeError("Length out of range of buffer");
} }
@inline
getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 { getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 {
var result: u32 = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 4, this.byteLength);
return reinterpret<f32>(littleEndian ? result : bswap<u32>(result)); return littleEndian
? load<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
: reinterpret<f32>(
bswap<u32>(
load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
)
);
} }
@inline
getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 { getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 {
var result: u64 = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 8, this.byteLength);
return reinterpret<f64>(littleEndian ? result : bswap<u64>(result)); return littleEndian
? load<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
: reinterpret<f64>(
bswap(
load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
)
);
} }
@inline
getInt8(byteOffset: i32): i8 { getInt8(byteOffset: i32): i8 {
checkOffset(byteOffset, 1, this.byteLength);
return load<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); return load<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
} }
@inline
getInt16(byteOffset: i32, littleEndian: boolean = false): i16 { getInt16(byteOffset: i32, littleEndian: boolean = false): i16 {
checkOffset(byteOffset, 2, this.byteLength);
var result: i16 = load<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var result: i16 = load<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<i16>(result); return littleEndian ? result : bswap<i16>(result);
} }
@inline
getInt32(byteOffset: i32, littleEndian: boolean = false): i32 { getInt32(byteOffset: i32, littleEndian: boolean = false): i32 {
var result: i32 = load<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 4, this.byteLength);
var result = load<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<i32>(result); return littleEndian ? result : bswap<i32>(result);
} }
@inline
getUint8(byteOffset: i32): u8 { getUint8(byteOffset: i32): u8 {
checkOffset(byteOffset, 1, this.byteLength);
return load<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); return load<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
} }
@inline
getUint16(byteOffset: i32, littleEndian: boolean = false): u16 { getUint16(byteOffset: i32, littleEndian: boolean = false): u16 {
checkOffset(byteOffset, 2, this.byteLength);
var result: u16 = load<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var result: u16 = load<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<u16>(result); return littleEndian ? result : bswap<u16>(result);
} }
@inline
getUint32(byteOffset: i32, littleEndian: boolean = false): u32 { getUint32(byteOffset: i32, littleEndian: boolean = false): u32 {
var result: u32 = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 4, this.byteLength);
var result = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<u32>(result); return littleEndian ? result : bswap<u32>(result);
} }
@inline
setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void { setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void {
var input: f32 = littleEndian ? value : reinterpret<f32>(bswap<u32>(reinterpret<u32>(value))); checkOffset(byteOffset, 4, this.byteLength);
store<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, input, HEADER_SIZE); if (littleEndian) {
store<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} else {
store<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
bswap(
reinterpret<u32>(value)
),
HEADER_SIZE
);
}
} }
@inline
setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void { setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void {
var input: f64 = littleEndian ? value : reinterpret<f64>(bswap<u64>(reinterpret<u64>(value))); checkOffset(byteOffset, 8, this.byteLength);
store<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, input, HEADER_SIZE); if (littleEndian) {
store<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} else {
store<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
bswap(
reinterpret<u64>(value)
),
HEADER_SIZE
);
}
} }
@inline
setInt8(byteOffset: i32, value: i8): void { setInt8(byteOffset: i32, value: i8): void {
checkOffset(byteOffset, 1, this.byteLength);
store<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); store<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} }
@inline
setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void { setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void {
store<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i16>(value), HEADER_SIZE); checkOffset(byteOffset, 2, this.byteLength);
store<i16>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
@inline
setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void { setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void {
store<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i32>(value), HEADER_SIZE); checkOffset(byteOffset, 4, this.byteLength);
store<i32>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
@inline
setUint8(byteOffset: i32, value: u8): void { setUint8(byteOffset: i32, value: u8): void {
checkOffset(byteOffset, 1, this.byteLength);
store<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); store<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} }
@inline
setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void { setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void {
store<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u16>(value), HEADER_SIZE); checkOffset(byteOffset, 2, this.byteLength);
store<u16>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
@inline
setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void { setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void {
store<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u32>(value), HEADER_SIZE); checkOffset(byteOffset, 4, this.byteLength);
store<u32>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
/** // Non-standard additions that make sense in WebAssembly, but won't work in JS:
* Non-standard additions that makes sense in WebAssembly, but won't work in JS
*/
@inline
getInt64(byteOffset: i32, littleEndian: boolean = false): i64 { getInt64(byteOffset: i32, littleEndian: boolean = false): i64 {
var result: i64 = load<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 8, this.byteLength);
return littleEndian ? result : bswap<i64>(result); var result = load<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap(result);
} }
@inline
getUint64(byteOffset: i32, littleEndian: boolean = false): u64 { getUint64(byteOffset: i32, littleEndian: boolean = false): u64 {
var result: u64 = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); checkOffset(byteOffset, 8, this.byteLength);
return littleEndian ? result : bswap<u64>(result); var result = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap(result);
} }
@inline
setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void { setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void {
store<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i64>(value), HEADER_SIZE); checkOffset(byteOffset, 8, this.byteLength);
store<i64>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
@inline
setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void { setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void {
store<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u64>(value), HEADER_SIZE); checkOffset(byteOffset, 8, this.byteLength);
store<u64>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
} }
} }
@inline function checkOffset(byteOffset: i32, n: i32, byteLength: i32): void {
// n and byteLength must be known to be in bounds
if (<u32>byteOffset > <u32>MAX_BLENGTH || byteOffset + n > byteLength) throw new Error("Offset out of bounds");
}

2
tests/compiler.js
View File

@ -184,7 +184,7 @@ tests.forEach(filename => {
console.log(colorsUtil.red(" abort: " + getString(msg) + " at " + getString(file) + ":" + line + ":" + column)); console.log(colorsUtil.red(" abort: " + getString(msg) + " at " + getString(file) + ":" + line + ":" + column));
}, },
trace: function(msg, n) { trace: function(msg, n) {
console.log(" " + getString(msg) + (n ? " " : "") + Array.prototype.slice.call(arguments, 2, 2 + n).join(", ")); console.log(" trace: " + getString(msg) + (n ? " " : "") + Array.prototype.slice.call(arguments, 2, 2 + n).join(", "));
}, },
externalFunction: function() { }, externalFunction: function() { },
externalConstant: 1 externalConstant: 1

2651
tests/compiler/std/dataview.optimized.wat Normal file
View File

File diff suppressed because it is too large Load Diff

80
tests/compiler/std/dataview.ts
View File

@ -65,8 +65,8 @@ assert(view.getInt32(2, false) === 1486848613);
assert(view.getInt32(3, false) === -1618844349); assert(view.getInt32(3, false) === -1618844349);
assert(view.getInt32(4, false) === -2107292833); assert(view.getInt32(4, false) === -2107292833);
assert(view.getInt64(0, true) === 6864441868736323830) assert(view.getInt64(0, true) === 6864441868736323830);
assert(view.getInt64(0, false) === -657428103485373601) assert(view.getInt64(0, false) === -657428103485373601);
assert(view.getUint8(0) === 246); assert(view.getUint8(0) === 246);
assert(view.getUint8(1) === 224); assert(view.getUint8(1) === 224);
@ -105,59 +105,59 @@ assert(view.getUint32(2, false) === 1486848613);
assert(view.getUint32(3, false) === 2676122947); assert(view.getUint32(3, false) === 2676122947);
assert(view.getUint32(4, false) === 2187674463); assert(view.getUint32(4, false) === 2187674463);
assert(view.getUint64(0, true) === 6864441868736323830) assert(view.getUint64(0, true) === 6864441868736323830);
assert(view.getUint64(0, false) === 17789315970224178015) assert(view.getUint64(0, false) === 17789315970224178015);
view.setFloat32(0, 1.5976661625240943e-18, true) view.setFloat32(0, 1.5976661625240943e-18, true);
assert(view.getFloat32(0, true) === 1.5976661625240943e-18) assert(view.getFloat32(0, true) === 1.5976661625240943e-18);
view.setFloat32(0, 1.9762819733816963e+21, false) view.setFloat32(0, 1.9762819733816963e+21, false);
assert(view.getFloat32(0, false) === 1.9762819733816963e+21) assert(view.getFloat32(0, false) === 1.9762819733816963e+21);
view.setFloat64(0, -1.094252199637739e+148, true) view.setFloat64(0, -1.094252199637739e+148, true);
assert(view.getFloat64(0, true) === -1.094252199637739e+148) assert(view.getFloat64(0, true) === -1.094252199637739e+148);
view.setFloat64(0, 6.022586634778589e-103, false) view.setFloat64(0, 6.022586634778589e-103, false);
assert(view.getFloat64(0, false) === 6.022586634778589e-103) assert(view.getFloat64(0, false) === 6.022586634778589e-103);
view.setInt8(0, 108) view.setInt8(0, 108);
assert(view.getInt8(0) === 108) assert(view.getInt8(0) === 108);
view.setInt16(0, -13360, true) view.setInt16(0, -13360, true);
assert(view.getInt16(0, true) === -13360) assert(view.getInt16(0, true) === -13360);
view.setInt16(0, 14689, false) view.setInt16(0, 14689, false);
assert(view.getInt16(0, false) === 14689) assert(view.getInt16(0, false) === 14689);
view.setInt32(0, 1204680201, true) view.setInt32(0, 1204680201, true);
assert(view.getInt32(0, true) === 1204680201) assert(view.getInt32(0, true) === 1204680201);
view.setInt32(0, 660673230, false) view.setInt32(0, 660673230, false);
assert(view.getInt32(0, false) === 660673230) assert(view.getInt32(0, false) === 660673230);
view.setInt64(0, -3290739641816099749, true) view.setInt64(0, -3290739641816099749, true);
assert(view.getInt64(0, true) === -3290739641816099749) assert(view.getInt64(0, true) === -3290739641816099749);
view.setInt64(0, 8178932412950708047, false) view.setInt64(0, 8178932412950708047, false);
assert(view.getInt64(0, false) === 8178932412950708047) assert(view.getInt64(0, false) === 8178932412950708047);
view.setUint8(0, 238) view.setUint8(0, 238);
assert(view.getUint8(0) === 238) assert(view.getUint8(0) === 238);
view.setUint16(0, 58856, true) view.setUint16(0, 58856, true);
assert(view.getUint16(0, true) === 58856) assert(view.getUint16(0, true) === 58856);
view.setUint16(0, 60400, false) view.setUint16(0, 60400, false);
assert(view.getUint16(0, false) === 60400) assert(view.getUint16(0, false) === 60400);
view.setUint32(0, 3448161552, true) view.setUint32(0, 3448161552, true);
assert(view.getUint32(0, true) === 3448161552) assert(view.getUint32(0, true) === 3448161552);
view.setUint32(0, 2784175665, false) view.setUint32(0, 2784175665, false);
assert(view.getUint32(0, false) === 2784175665) assert(view.getUint32(0, false) === 2784175665);
view.setUint64(0, 2334704782995986958, true) view.setUint64(0, 2334704782995986958, true);
assert(view.getUint64(0, true) === 2334704782995986958) assert(view.getUint64(0, true) === 2334704782995986958);
view.setUint64(0, 11323557176419695287, false) view.setUint64(0, 11323557176419695287, false);
assert(view.getUint64(0, false) === 11323557176419695287) assert(view.getUint64(0, false) === 11323557176419695287);

4698
tests/compiler/std/dataview.untouched.wat
View File

File diff suppressed because it is too large Load Diff