Skip to content

Commit 5c7e8d4

Browse files
dcodeIOdcodeIO
authored
Update Binaryen and other dependencies (#1224)
1 parent 51ba4a2 commit 5c7e8d4

File tree

277 files changed

+6600
-7112
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

277 files changed

+6600
-7112
lines changed

Diff for: ‎package-lock.json

+154-167
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

Diff for: ‎package.json

+4-4
Original file line numberDiff line numberDiff line change
@@ -21,23 +21,23 @@
2121
"url": "https://github.com/AssemblyScript/assemblyscript/issues"
2222
},
2323
"dependencies": {
24-
"binaryen": "91.0.0-nightly.20200310",
24+
"binaryen": "91.0.0-nightly.20200414",
2525
"long": "^4.0.0",
2626
"source-map-support": "^0.5.16",
2727
"ts-node": "^6.2.0"
2828
},
2929
"devDependencies": {
30-
"@types/node": "^13.9.1",
30+
"@types/node": "^13.11.1",
3131
"browser-process-hrtime": "^1.0.0",
3232
"diff": "^4.0.2",
3333
"glob": "^7.1.6",
3434
"physical-cpu-count": "^2.0.0",
3535
"source-map-support": "^0.5.16",
36-
"ts-loader": "^6.2.1",
36+
"ts-loader": "^6.2.2",
3737
"ts-node": "^6.2.0",
3838
"tslint": "^5.20.1",
3939
"typescript": "^3.8.3",
40-
"webpack": "^4.42.0",
40+
"webpack": "^4.42.1",
4141
"webpack-cli": "^3.3.11"
4242
},
4343
"main": "index.js",

Diff for: ‎scripts/update-constants.js

+1-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ const srcfile = path.join(__dirname, "..", "src", "module.ts");
88
var src = fs.readFileSync(srcfile, "utf8");
99

1010
binaryen.ready.then(() => {
11-
src = src.replace(/enum (\w+) \{([^}]*)\}/g, function($0) {
11+
src = src.replace(/(?:enum|namespace) (\w+) \{([^}]*)\}/g, function($0) {
1212
return $0.replace(/(\w+)[ ]+=[ ]+([^,;\n]+)/g, function($0, key, val) {
1313
var match = val.match(/\b(_Binaryen\w+)\b/);
1414
if (match) {

Diff for: ‎src/builtins.ts

+119-5
Original file line numberDiff line numberDiff line change
@@ -346,6 +346,7 @@ export namespace BuiltinNames {
346346
export const v128_bitselect = "~lib/builtins/v128.bitselect";
347347
export const v128_any_true = "~lib/builtins/v128.any_true";
348348
export const v128_all_true = "~lib/builtins/v128.all_true";
349+
export const v128_bitmask = "~lib/builtins/v128.bitmask";
349350
export const v128_min = "~lib/builtins/v128.min";
350351
export const v128_max = "~lib/builtins/v128.max";
351352
export const v128_dot = "~lib/builtins/v128.dot";
@@ -385,6 +386,7 @@ export namespace BuiltinNames {
385386
export const i8x16_max_s = "~lib/builtins/i8x16.max_s";
386387
export const i8x16_max_u = "~lib/builtins/i8x16.max_u";
387388
export const i8x16_avgr_u = "~lib/builtins/i8x16.avgr_u";
389+
export const i8x16_abs = "~lib/builtins/i8x16.abs";
388390
export const i8x16_neg = "~lib/builtins/i8x16.neg";
389391
export const i8x16_add_saturate_s = "~lib/builtins/i8x16.add_saturate_s";
390392
export const i8x16_add_saturate_u = "~lib/builtins/i8x16.add_saturate_u";
@@ -395,6 +397,7 @@ export namespace BuiltinNames {
395397
export const i8x16_shr_u = "~lib/builtins/i8x16.shr_u";
396398
export const i8x16_any_true = "~lib/builtins/i8x16.any_true";
397399
export const i8x16_all_true = "~lib/builtins/i8x16.all_true";
400+
export const i8x16_bitmask = "~lib/builtins/i8x16.bitmask";
398401
export const i8x16_eq = "~lib/builtins/i8x16.eq";
399402
export const i8x16_ne = "~lib/builtins/i8x16.ne";
400403
export const i8x16_lt_s = "~lib/builtins/i8x16.lt_s";
@@ -420,6 +423,7 @@ export namespace BuiltinNames {
420423
export const i16x8_max_s = "~lib/builtins/i16x8.max_s";
421424
export const i16x8_max_u = "~lib/builtins/i16x8.max_u";
422425
export const i16x8_avgr_u = "~lib/builtins/i16x8.avgr_u";
426+
export const i16x8_abs = "~lib/builtins/i16x8.abs";
423427
export const i16x8_neg = "~lib/builtins/i16x8.neg";
424428
export const i16x8_add_saturate_s = "~lib/builtins/i16x8.add_saturate_s";
425429
export const i16x8_add_saturate_u = "~lib/builtins/i16x8.add_saturate_u";
@@ -430,6 +434,7 @@ export namespace BuiltinNames {
430434
export const i16x8_shr_u = "~lib/builtins/i16x8.shr_u";
431435
export const i16x8_any_true = "~lib/builtins/i16x8.any_true";
432436
export const i16x8_all_true = "~lib/builtins/i16x8.all_true";
437+
export const i16x8_bitmask = "~lib/builtins/i16x8.bitmask";
433438
export const i16x8_eq = "~lib/builtins/i16x8.eq";
434439
export const i16x8_ne = "~lib/builtins/i16x8.ne";
435440
export const i16x8_lt_s = "~lib/builtins/i16x8.lt_s";
@@ -460,12 +465,14 @@ export namespace BuiltinNames {
460465
export const i32x4_max_s = "~lib/builtins/i32x4.max_s";
461466
export const i32x4_max_u = "~lib/builtins/i32x4.max_u";
462467
export const i32x4_dot_i16x8_s = "~lib/builtins/i32x4.dot_i16x8_s";
468+
export const i32x4_abs = "~lib/builtins/i32x4.abs";
463469
export const i32x4_neg = "~lib/builtins/i32x4.neg";
464470
export const i32x4_shl = "~lib/builtins/i32x4.shl";
465471
export const i32x4_shr_s = "~lib/builtins/i32x4.shr_s";
466472
export const i32x4_shr_u = "~lib/builtins/i32x4.shr_u";
467473
export const i32x4_any_true = "~lib/builtins/i32x4.any_true";
468474
export const i32x4_all_true = "~lib/builtins/i32x4.all_true";
475+
export const i32x4_bitmask = "~lib/builtins/i32x4.bitmask";
469476
export const i32x4_eq = "~lib/builtins/i32x4.eq";
470477
export const i32x4_ne = "~lib/builtins/i32x4.ne";
471478
export const i32x4_lt_s = "~lib/builtins/i32x4.lt_s";
@@ -2600,8 +2607,8 @@ function builtin_assert(ctx: BuiltinContext): ExpressionRef {
26002607

26012608
// if the assertion can be proven statically, omit it
26022609
if (getExpressionId(arg0 = module.precomputeExpression(arg0)) == ExpressionId.Const) {
2603-
switch (getExpressionType(arg0)) {
2604-
case NativeType.I32: {
2610+
switch (<u32>getExpressionType(arg0)) {
2611+
case <u32>NativeType.I32: {
26052612
if (getConstValueI32(arg0) != 0) {
26062613
if (contextualType == Type.void) {
26072614
compiler.currentType = Type.void;
@@ -2611,7 +2618,7 @@ function builtin_assert(ctx: BuiltinContext): ExpressionRef {
26112618
}
26122619
break;
26132620
}
2614-
case NativeType.I64: {
2621+
case <u32>NativeType.I64: {
26152622
if (getConstValueI64Low(arg0) != 0 || getConstValueI64High(arg0) != 0) {
26162623
if (contextualType == Type.void) {
26172624
compiler.currentType = Type.void;
@@ -2621,7 +2628,7 @@ function builtin_assert(ctx: BuiltinContext): ExpressionRef {
26212628
}
26222629
break;
26232630
}
2624-
case NativeType.F32: {
2631+
case <u32>NativeType.F32: {
26252632
if (getConstValueF32(arg0) != 0) {
26262633
if (contextualType == Type.void) {
26272634
compiler.currentType = Type.void;
@@ -2631,7 +2638,7 @@ function builtin_assert(ctx: BuiltinContext): ExpressionRef {
26312638
}
26322639
break;
26332640
}
2634-
case NativeType.F64: {
2641+
case <u32>NativeType.F64: {
26352642
if (getConstValueF64(arg0) != 0) {
26362643
if (contextualType == Type.void) {
26372644
compiler.currentType = Type.void;
@@ -4398,6 +4405,20 @@ function builtin_v128_abs(ctx: BuiltinContext): ExpressionRef {
43984405
var arg0 = compiler.compileExpression(operands[0], Type.v128, Constraints.CONV_IMPLICIT);
43994406
if (!type.is(TypeFlags.REFERENCE)) {
44004407
switch (type.kind) {
4408+
case TypeKind.I8: return module.unary(UnaryOp.AbsI8x16, arg0);
4409+
case TypeKind.I16: return module.unary(UnaryOp.AbsI16x8, arg0);
4410+
case TypeKind.ISIZE: {
4411+
if (compiler.options.isWasm64) break;
4412+
// fall-through
4413+
}
4414+
case TypeKind.I32: return module.unary(UnaryOp.AbsI32x4, arg0);
4415+
case TypeKind.USIZE: {
4416+
if (compiler.options.isWasm64) break;
4417+
// fall-through
4418+
}
4419+
case TypeKind.U8:
4420+
case TypeKind.U16:
4421+
case TypeKind.U32: return arg0;
44014422
case TypeKind.F32: return module.unary(UnaryOp.AbsF32x4, arg0);
44024423
case TypeKind.F64: return module.unary(UnaryOp.AbsF64x2, arg0);
44034424
}
@@ -4844,6 +4865,45 @@ function builtin_v128_all_true(ctx: BuiltinContext): ExpressionRef {
48444865
}
48454866
builtins.set(BuiltinNames.v128_all_true, builtin_v128_all_true);
48464867

4868+
// v128.bitmask<T!>(a: v128) -> i32
4869+
function builtin_v128_bitmask(ctx: BuiltinContext): ExpressionRef {
4870+
var compiler = ctx.compiler;
4871+
var module = compiler.module;
4872+
if (
4873+
checkFeatureEnabled(ctx, Feature.SIMD) |
4874+
checkTypeRequired(ctx) |
4875+
checkArgsRequired(ctx, 1)
4876+
) {
4877+
compiler.currentType = Type.i32;
4878+
return module.unreachable();
4879+
}
4880+
var operands = ctx.operands;
4881+
var type = ctx.typeArguments![0];
4882+
var arg0 = compiler.compileExpression(operands[0], Type.v128, Constraints.CONV_IMPLICIT);
4883+
compiler.currentType = Type.i32;
4884+
if (!type.is(TypeFlags.REFERENCE)) {
4885+
switch (type.kind) {
4886+
case TypeKind.I8:
4887+
case TypeKind.U8: return module.unary(UnaryOp.BitmaskI8x16, arg0);
4888+
case TypeKind.I16:
4889+
case TypeKind.U16: return module.unary(UnaryOp.BitmaskI16x8, arg0);
4890+
case TypeKind.ISIZE:
4891+
case TypeKind.USIZE: {
4892+
if (compiler.options.isWasm64) break;
4893+
// fall-through
4894+
}
4895+
case TypeKind.I32:
4896+
case TypeKind.U32: return module.unary(UnaryOp.BitmaskI32x4, arg0);
4897+
}
4898+
}
4899+
compiler.error(
4900+
DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,
4901+
ctx.reportNode.typeArgumentsRange, "v128.bitmask", type.toString()
4902+
);
4903+
return module.unreachable();
4904+
}
4905+
builtins.set(BuiltinNames.v128_bitmask, builtin_v128_bitmask);
4906+
48474907
// v128.qfma<T!>(a: v128, b: v128, c: v128) -> v128
48484908
function builtin_v128_qfma(ctx: BuiltinContext): ExpressionRef {
48494909
var compiler = ctx.compiler;
@@ -6225,6 +6285,15 @@ function builtin_i8x16_avgr_u(ctx: BuiltinContext): ExpressionRef {
62256285
}
62266286
builtins.set(BuiltinNames.i8x16_avgr_u, builtin_i8x16_avgr_u);
62276287

6288+
// i8x16.abs -> v128.abs<i8>
6289+
function builtin_i8x16_abs(ctx: BuiltinContext): ExpressionRef {
6290+
checkTypeAbsent(ctx);
6291+
ctx.typeArguments = [ Type.i8 ];
6292+
ctx.contextualType = Type.v128;
6293+
return builtin_v128_abs(ctx);
6294+
}
6295+
builtins.set(BuiltinNames.i8x16_abs, builtin_i8x16_abs);
6296+
62286297
// i8x16.neg -> v128.neg<i8>
62296298
function builtin_i8x16_neg(ctx: BuiltinContext): ExpressionRef {
62306299
checkTypeAbsent(ctx);
@@ -6315,6 +6384,15 @@ function builtin_i8x16_all_true(ctx: BuiltinContext): ExpressionRef {
63156384
}
63166385
builtins.set(BuiltinNames.i8x16_all_true, builtin_i8x16_all_true);
63176386

6387+
// i8x16.bitmask -> v128.bitmask<i8>
6388+
function builtin_i8x16_bitmask(ctx: BuiltinContext): ExpressionRef {
6389+
checkTypeAbsent(ctx);
6390+
ctx.typeArguments = [ Type.i8 ];
6391+
ctx.contextualType = Type.i32;
6392+
return builtin_v128_bitmask(ctx);
6393+
}
6394+
builtins.set(BuiltinNames.i8x16_bitmask, builtin_i8x16_bitmask);
6395+
63186396
// i8x16.eq -> v128.eq<i8>
63196397
function builtin_i8x16_eq(ctx: BuiltinContext): ExpressionRef {
63206398
checkTypeAbsent(ctx);
@@ -6531,6 +6609,15 @@ function builtin_i16x8_avgr_u(ctx: BuiltinContext): ExpressionRef {
65316609
}
65326610
builtins.set(BuiltinNames.i16x8_avgr_u, builtin_i16x8_avgr_u);
65336611

6612+
// i16x8.abs -> v128.abs<i16>
6613+
function builtin_i16x8_abs(ctx: BuiltinContext): ExpressionRef {
6614+
checkTypeAbsent(ctx);
6615+
ctx.typeArguments = [ Type.i16 ];
6616+
ctx.contextualType = Type.v128;
6617+
return builtin_v128_abs(ctx);
6618+
}
6619+
builtins.set(BuiltinNames.i16x8_abs, builtin_i16x8_abs);
6620+
65346621
// i16x8.neg -> v128.neg<i16>
65356622
function builtin_i16x8_neg(ctx: BuiltinContext): ExpressionRef {
65366623
checkTypeAbsent(ctx);
@@ -6621,6 +6708,15 @@ function builtin_i16x8_all_true(ctx: BuiltinContext): ExpressionRef {
66216708
}
66226709
builtins.set(BuiltinNames.i16x8_all_true, builtin_i16x8_all_true);
66236710

6711+
// i16x8.bitmask -> v128.bitmask<i16>
6712+
function builtin_i16x8_bitmask(ctx: BuiltinContext): ExpressionRef {
6713+
checkTypeAbsent(ctx);
6714+
ctx.typeArguments = [ Type.i16 ];
6715+
ctx.contextualType = Type.i32;
6716+
return builtin_v128_bitmask(ctx);
6717+
}
6718+
builtins.set(BuiltinNames.i16x8_bitmask, builtin_i16x8_bitmask);
6719+
66246720
// i16x8.eq -> v128.eq<i16>
66256721
function builtin_i16x8_eq(ctx: BuiltinContext): ExpressionRef {
66266722
checkTypeAbsent(ctx);
@@ -6882,6 +6978,15 @@ function builtin_i32x4_dot_i16x8_s(ctx: BuiltinContext): ExpressionRef {
68826978
}
68836979
builtins.set(BuiltinNames.i32x4_dot_i16x8_s, builtin_i32x4_dot_i16x8_s);
68846980

6981+
// i32x4.abs -> v128.abs<i32>
6982+
function builtin_i32x4_abs(ctx: BuiltinContext): ExpressionRef {
6983+
checkTypeAbsent(ctx);
6984+
ctx.typeArguments = [ Type.i32 ];
6985+
ctx.contextualType = Type.v128;
6986+
return builtin_v128_abs(ctx);
6987+
}
6988+
builtins.set(BuiltinNames.i32x4_abs, builtin_i32x4_abs);
6989+
68856990
// i32x4.neg -> v128.neg<i32>
68866991
function builtin_i32x4_neg(ctx: BuiltinContext): ExpressionRef {
68876992
checkTypeAbsent(ctx);
@@ -6936,6 +7041,15 @@ function builtin_i32x4_all_true(ctx: BuiltinContext): ExpressionRef {
69367041
}
69377042
builtins.set(BuiltinNames.i32x4_all_true, builtin_i32x4_all_true);
69387043

7044+
// i32x4.bitmask -> v128.bitmask<i32>
7045+
function builtin_i32x4_bitmask(ctx: BuiltinContext): ExpressionRef {
7046+
checkTypeAbsent(ctx);
7047+
ctx.typeArguments = [ Type.i32 ];
7048+
ctx.contextualType = Type.i32;
7049+
return builtin_v128_bitmask(ctx);
7050+
}
7051+
builtins.set(BuiltinNames.i32x4_bitmask, builtin_i32x4_bitmask);
7052+
69397053
// i32x4.eq -> v128.eq<i32>
69407054
function builtin_i32x4_eq(ctx: BuiltinContext): ExpressionRef {
69417055
checkTypeAbsent(ctx);

Diff for: ‎src/compiler.ts

+15-15
Original file line numberDiff line numberDiff line change
@@ -1084,26 +1084,26 @@ export class Compiler extends DiagnosticEmitter {
10841084
} else {
10851085
assert(getExpressionId(initExpr) == ExpressionId.Const);
10861086
let exprType = getExpressionType(initExpr);
1087-
switch (exprType) {
1088-
case NativeType.I32: {
1087+
switch (<u32>exprType) {
1088+
case <u32>NativeType.I32: {
10891089
global.constantValueKind = ConstantValueKind.INTEGER;
10901090
global.constantIntegerValue = i64_new(getConstValueI32(initExpr), 0);
10911091
break;
10921092
}
1093-
case NativeType.I64: {
1093+
case <u32>NativeType.I64: {
10941094
global.constantValueKind = ConstantValueKind.INTEGER;
10951095
global.constantIntegerValue = i64_new(
10961096
getConstValueI64Low(initExpr),
10971097
getConstValueI64High(initExpr)
10981098
);
10991099
break;
11001100
}
1101-
case NativeType.F32: {
1101+
case <u32>NativeType.F32: {
11021102
global.constantValueKind = ConstantValueKind.FLOAT;
11031103
global.constantFloatValue = getConstValueF32(initExpr);
11041104
break;
11051105
}
1106-
case NativeType.F64: {
1106+
case <u32>NativeType.F64: {
11071107
global.constantValueKind = ConstantValueKind.FLOAT;
11081108
global.constantFloatValue = getConstValueF64(initExpr);
11091109
break;
@@ -1731,8 +1731,8 @@ export class Compiler extends DiagnosticEmitter {
17311731
program.writeRuntimeHeader(buf, 0, id, byteLength);
17321732
var pos = runtimeHeaderSize;
17331733
var nativeType = elementType.toNativeType();
1734-
switch (nativeType) {
1735-
case NativeType.I32: {
1734+
switch (<u32>nativeType) {
1735+
case <u32>NativeType.I32: {
17361736
switch (byteSize) {
17371737
case 1: {
17381738
for (let i = 0; i < length; ++i) {
@@ -1768,7 +1768,7 @@ export class Compiler extends DiagnosticEmitter {
17681768
}
17691769
break;
17701770
}
1771-
case NativeType.I64: {
1771+
case <u32>NativeType.I64: {
17721772
for (let i = 0; i < length; ++i) {
17731773
let value = values[i];
17741774
assert(getExpressionType(value) == nativeType);
@@ -1778,7 +1778,7 @@ export class Compiler extends DiagnosticEmitter {
17781778
}
17791779
break;
17801780
}
1781-
case NativeType.F32: {
1781+
case <u32>NativeType.F32: {
17821782
for (let i = 0; i < length; ++i) {
17831783
let value = values[i];
17841784
assert(getExpressionType(value) == nativeType);
@@ -1788,7 +1788,7 @@ export class Compiler extends DiagnosticEmitter {
17881788
}
17891789
break;
17901790
}
1791-
case NativeType.F64: {
1791+
case <u32>NativeType.F64: {
17921792
for (let i = 0; i < length; ++i) {
17931793
let value = values[i];
17941794
assert(getExpressionType(value) == nativeType);
@@ -2913,8 +2913,8 @@ export class Compiler extends DiagnosticEmitter {
29132913
initExpr = module.precomputeExpression(initExpr);
29142914
if (getExpressionId(initExpr) == ExpressionId.Const) {
29152915
let local = new Local(name, -1, type, flow.parentFunction);
2916-
switch (getExpressionType(initExpr)) {
2917-
case NativeType.I32: {
2916+
switch (<u32>getExpressionType(initExpr)) {
2917+
case <u32>NativeType.I32: {
29182918
local.setConstantIntegerValue(
29192919
i64_new(
29202920
getConstValueI32(initExpr),
@@ -2924,7 +2924,7 @@ export class Compiler extends DiagnosticEmitter {
29242924
);
29252925
break;
29262926
}
2927-
case NativeType.I64: {
2927+
case <u32>NativeType.I64: {
29282928
local.setConstantIntegerValue(
29292929
i64_new(
29302930
getConstValueI64Low(initExpr),
@@ -2934,11 +2934,11 @@ export class Compiler extends DiagnosticEmitter {
29342934
);
29352935
break;
29362936
}
2937-
case NativeType.F32: {
2937+
case <u32>NativeType.F32: {
29382938
local.setConstantFloatValue(<f64>getConstValueF32(initExpr), type);
29392939
break;
29402940
}
2941-
case NativeType.F64: {
2941+
case <u32>NativeType.F64: {
29422942
local.setConstantFloatValue(getConstValueF64(initExpr), type);
29432943
break;
29442944
}

0 commit comments

Comments
 (0)