From 6f6eb51e0c2ba0f2af0a3f75a9a8d76df0a08734 Mon Sep 17 00:00:00 2001 From: Dylan Araps Date: Thu, 26 Sep 2019 10:52:48 +0300 Subject: [PATCH] nodejs: bump to 12.11.0 --- extra/nodejs/build | 4 + extra/nodejs/checksums | 3 +- extra/nodejs/files/test-torque.tq | 1010 +++++++++++++++++++++++++++++ extra/nodejs/sources | 3 +- extra/nodejs/version | 2 +- 5 files changed, 1019 insertions(+), 3 deletions(-) create mode 100644 extra/nodejs/files/test-torque.tq diff --git a/extra/nodejs/build b/extra/nodejs/build index 7477bf32..2d401640 100755 --- a/extra/nodejs/build +++ b/extra/nodejs/build @@ -1,5 +1,9 @@ #!/bin/sh -e +# Fix upstream build bug. +mkdir -p deps/v8/test/torque +cp test-torque.tq deps/v8/test/torque + export PYTHON=python2 chmod +x configure diff --git a/extra/nodejs/checksums b/extra/nodejs/checksums index 175885ea..be18aeb6 100644 --- a/extra/nodejs/checksums +++ b/extra/nodejs/checksums @@ -1 +1,2 @@ -2515b87c60921f22514a58830e86e54831daa2453d0e82f2ed7ab02134ee30cd node-v12.10.0.tar.xz +8306491e9b7bb95f8ee34dcd8daa4c071b94d523e63c0f2b8c605f2ca43dcf91 node-v12.11.0.tar.xz +02c77219d9ef942e2aeed3aea1137f8d1bc2828bef0edc5992dbd2c5283e11c7 test-torque.tq diff --git a/extra/nodejs/files/test-torque.tq b/extra/nodejs/files/test-torque.tq new file mode 100644 index 00000000..6d2aee14 --- /dev/null +++ b/extra/nodejs/files/test-torque.tq @@ -0,0 +1,1010 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +namespace test { + macro ElementsKindTestHelper1(kind: constexpr ElementsKind): bool { + if constexpr ((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)) { + return true; + } else { + return false; + } + } + + macro ElementsKindTestHelper2(kind: constexpr ElementsKind): constexpr bool { + return ((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)); + } + + macro LabelTestHelper1(): never + labels Label1 { + goto Label1; + } + + macro LabelTestHelper2(): never + labels Label2(Smi) { + goto Label2(42); + } + + macro LabelTestHelper3(): never + labels Label3(Oddball, Smi) { + goto Label3(Null, 7); + } + + @export + macro TestConstexpr1() { + check(FromConstexpr(IsFastElementsKind(PACKED_SMI_ELEMENTS))); + } + + @export + macro TestConstexprIf() { + check(ElementsKindTestHelper1(UINT8_ELEMENTS)); + check(ElementsKindTestHelper1(UINT16_ELEMENTS)); + check(!ElementsKindTestHelper1(UINT32_ELEMENTS)); + } + + @export + macro TestConstexprReturn() { + check(FromConstexpr(ElementsKindTestHelper2(UINT8_ELEMENTS))); + check(FromConstexpr(ElementsKindTestHelper2(UINT16_ELEMENTS))); + check(!FromConstexpr(ElementsKindTestHelper2(UINT32_ELEMENTS))); + check(FromConstexpr(!ElementsKindTestHelper2(UINT32_ELEMENTS))); + } + + @export + macro TestGotoLabel(): Boolean { + try { + LabelTestHelper1() otherwise Label1; + } + label Label1 { + return True; + } + } + + @export + macro TestGotoLabelWithOneParameter(): Boolean { + try { + LabelTestHelper2() otherwise Label2; + } + label Label2(smi: Smi) { + check(smi == 42); + return True; + } + } + + @export + macro TestGotoLabelWithTwoParameters(): Boolean { + try { + LabelTestHelper3() otherwise Label3; + } + label Label3(o: Oddball, smi: Smi) { + check(o == Null); + check(smi == 7); + return True; + } + } + + builtin GenericBuiltinTest(_c: Context, _param: T): Object { + return Null; + } + + GenericBuiltinTest(_c: Context, param: Object): Object { + return param; + } + + @export + macro TestBuiltinSpecialization(c: Context) { + check(GenericBuiltinTest(c, 0) == Null); + check(GenericBuiltinTest(c, 1) == Null); + check(GenericBuiltinTest(c, Undefined) == Undefined); + check(GenericBuiltinTest(c, Undefined) == Undefined); + } + + macro LabelTestHelper4(flag: constexpr bool): never + labels Label4, Label5 { + if constexpr (flag) { + goto Label4; + } else { + goto Label5; + } + } + + macro CallLabelTestHelper4(flag: constexpr bool): bool { + try { + LabelTestHelper4(flag) otherwise Label4, Label5; + } + label Label4 { + return true; + } + label Label5 { + return false; + } + } + + @export + macro TestPartiallyUnusedLabel(): Boolean { + const r1: bool = CallLabelTestHelper4(true); + const r2: bool = CallLabelTestHelper4(false); + + if (r1 && !r2) { + return True; + } else { + return False; + } + } + + macro GenericMacroTest(_param: T): Object { + return Undefined; + } + + GenericMacroTest(param2: Object): Object { + return param2; + } + + macro GenericMacroTestWithLabels(_param: T): Object + labels _X { + return Undefined; + } + + GenericMacroTestWithLabels(param2: Object): Object + labels Y { + return Cast(param2) otherwise Y; + } + + @export + macro TestMacroSpecialization() { + try { + const _smi0: Smi = 0; + check(GenericMacroTest(0) == Undefined); + check(GenericMacroTest(1) == Undefined); + check(GenericMacroTest(Null) == Null); + check(GenericMacroTest(False) == False); + check(GenericMacroTest(True) == True); + check((GenericMacroTestWithLabels(0) otherwise Fail) == Undefined); + check((GenericMacroTestWithLabels(0) otherwise Fail) == Undefined); + try { + GenericMacroTestWithLabels(False) otherwise Expected; + } + label Expected {} + } + label Fail { + unreachable; + } + } + + builtin TestHelperPlus1(_context: Context, x: Smi): Smi { + return x + 1; + } + builtin TestHelperPlus2(_context: Context, x: Smi): Smi { + return x + 2; + } + + @export + macro TestFunctionPointers(implicit context: Context)(): Boolean { + let fptr: builtin(Context, Smi) => Smi = TestHelperPlus1; + check(fptr(context, 42) == 43); + fptr = TestHelperPlus2; + check(fptr(context, 42) == 44); + return True; + } + + @export + macro TestVariableRedeclaration(implicit context: Context)(): Boolean { + let _var1: int31 = FromConstexpr(42 == 0) ? 0 : 1; + let _var2: int31 = FromConstexpr(42 == 0) ? 1 : 0; + return True; + } + + @export + macro TestTernaryOperator(x: Smi): Smi { + const b: bool = x < 0 ? true : false; + return b ? x - 10 : x + 100; + } + + @export + macro TestFunctionPointerToGeneric(c: Context) { + const fptr1: builtin(Context, Smi) => Object = GenericBuiltinTest; + const fptr2: builtin(Context, Object) => Object = + GenericBuiltinTest; + + check(fptr1(c, 0) == Null); + check(fptr1(c, 1) == Null); + check(fptr2(c, Undefined) == Undefined); + check(fptr2(c, Undefined) == Undefined); + } + + type ObjectToObject = builtin(Context, Object) => Object; + @export + macro TestTypeAlias(x: ObjectToObject): BuiltinPtr { + return x; + } + + @export + macro TestUnsafeCast(implicit context: Context)(n: Number): Boolean { + if (TaggedIsSmi(n)) { + const m: Smi = UnsafeCast(n); + + check(TestHelperPlus1(context, m) == 11); + return True; + } + return False; + } + + @export + macro TestHexLiteral() { + check(Convert(0xffff) + 1 == 0x10000); + check(Convert(-0xffff) == -65535); + } + + @export + macro TestLargeIntegerLiterals(implicit c: Context)() { + let _x: int32 = 0x40000000; + let _y: int32 = 0x7fffffff; + } + + @export + macro TestMultilineAssert() { + const someVeryLongVariableNameThatWillCauseLineBreaks: Smi = 5; + check( + someVeryLongVariableNameThatWillCauseLineBreaks > 0 && + someVeryLongVariableNameThatWillCauseLineBreaks < 10); + } + + @export + macro TestNewlineInString() { + Print('Hello, World!\n'); + } + + const kConstexprConst: constexpr int31 = 5; + const kIntptrConst: intptr = 4; + const kSmiConst: Smi = 3; + + @export + macro TestModuleConstBindings() { + check(kConstexprConst == Int32Constant(5)); + check(kIntptrConst == 4); + check(kSmiConst == 3); + } + + @export + macro TestLocalConstBindings() { + const x: constexpr int31 = 3; + const xSmi: Smi = x; + { + const x: Smi = x + FromConstexpr(1); + check(x == xSmi + 1); + const xSmi: Smi = x; + check(x == xSmi); + check(x == 4); + } + check(xSmi == 3); + check(x == xSmi); + } + + struct TestStructA { + indexes: FixedArray; + i: Smi; + k: Number; + } + + struct TestStructB { + x: TestStructA; + y: Smi; + } + + @export + macro TestStruct1(i: TestStructA): Smi { + return i.i; + } + + @export + macro TestStruct2(implicit context: Context)(): TestStructA { + return TestStructA{ + indexes: UnsafeCast(kEmptyFixedArray), + i: 27, + k: 31 + }; + } + + @export + macro TestStruct3(implicit context: Context)(): TestStructA { + let a: TestStructA = + TestStructA{indexes: UnsafeCast(kEmptyFixedArray), i: 13, k: 5}; + let _b: TestStructA = a; + const c: TestStructA = TestStruct2(); + a.i = TestStruct1(c); + a.k = a.i; + let d: TestStructB; + d.x = a; + d = TestStructB{x: a, y: 7}; + let _e: TestStructA = d.x; + let f: Smi = TestStructA{ + indexes: UnsafeCast(kEmptyFixedArray), + i: 27, + k: 31 + }.i; + f = TestStruct2().i; + return a; + } + + struct TestStructC { + x: TestStructA; + y: TestStructA; + } + + @export + macro TestStruct4(implicit context: Context)(): TestStructC { + return TestStructC{x: TestStruct2(), y: TestStruct2()}; + } + + macro TestStructInLabel(implicit context: Context)(): never labels + Foo(TestStructA) { + goto Foo(TestStruct2()); + } + @export // Silence unused warning. + macro CallTestStructInLabel(implicit context: Context)() { + try { + TestStructInLabel() otherwise Foo; + } + label Foo(_s: TestStructA) {} + } + + // This macro tests different versions of the for-loop where some parts + // are (not) present. + @export + macro TestForLoop() { + let sum: Smi = 0; + for (let i: Smi = 0; i < 5; ++i) sum += i; + check(sum == 10); + + sum = 0; + let j: Smi = 0; + for (; j < 5; ++j) sum += j; + check(sum == 10); + + sum = 0; + j = 0; + for (; j < 5;) sum += j++; + check(sum == 10); + + // Check that break works. No test expression. + sum = 0; + for (let i: Smi = 0;; ++i) { + if (i == 5) break; + sum += i; + } + check(sum == 10); + + sum = 0; + j = 0; + for (;;) { + if (j == 5) break; + sum += j; + j++; + } + check(sum == 10); + + // The following tests are the same as above, but use continue to skip + // index 3. + sum = 0; + for (let i: Smi = 0; i < 5; ++i) { + if (i == 3) continue; + sum += i; + } + check(sum == 7); + + sum = 0; + j = 0; + for (; j < 5; ++j) { + if (j == 3) continue; + sum += j; + } + check(sum == 7); + + sum = 0; + j = 0; + for (; j < 5;) { + if (j == 3) { + j++; + continue; + } + sum += j; + j++; + } + check(sum == 7); + + sum = 0; + for (let i: Smi = 0;; ++i) { + if (i == 3) continue; + if (i == 5) break; + sum += i; + } + check(sum == 7); + + sum = 0; + j = 0; + for (;;) { + if (j == 3) { + j++; + continue; + } + + if (j == 5) break; + sum += j; + j++; + } + check(sum == 7); + + j = 0; + try { + for (;;) { + if (++j == 10) goto Exit; + } + } + label Exit { + check(j == 10); + } + + // Test if we can handle uninitialized values on the stack. + let _i: Smi; + for (let j: Smi = 0; j < 10; ++j) { + } + } + + @export + macro TestSubtyping(x: Smi) { + const _foo: Object = x; + } + + macro IncrementIfSmi(x: A): A { + typeswitch (x) { + case (x: Smi): { + return x + 1; + } + case (o: A): { + return o; + } + } + } + + type NumberOrFixedArray = Number | FixedArray; + macro TypeswitchExample(implicit context: Context)(x: NumberOrFixedArray): + int32 { + let result: int32 = 0; + typeswitch (IncrementIfSmi(x)) { + case (_x: FixedArray): { + result = result + 1; + } + case (Number): { + result = result + 2; + } + } + + result = result * 10; + + typeswitch (IncrementIfSmi(x)) { + case (x: Smi): { + result = result + Convert(x); + } + case (a: FixedArray): { + result = result + Convert(a.length); + } + case (_x: HeapNumber): { + result = result + 7; + } + } + + return result; + } + + @export + macro TestTypeswitch(implicit context: Context)() { + check(TypeswitchExample(FromConstexpr(5)) == 26); + const a: FixedArray = AllocateZeroedFixedArray(3); + check(TypeswitchExample(a) == 13); + check(TypeswitchExample(FromConstexpr(0.5)) == 27); + } + + @export + macro TestTypeswitchAsanLsanFailure(implicit context: Context)(obj: Object) { + typeswitch (obj) { + case (_o: Smi): { + } + case (_o: JSTypedArray): { + } + case (_o: JSReceiver): { + } + case (_o: HeapObject): { + } + } + } + + macro ExampleGenericOverload(o: Object): A { + return o; + } + macro ExampleGenericOverload(o: Smi): A { + return o + 1; + } + + @export + macro TestGenericOverload(implicit context: Context)() { + const xSmi: Smi = 5; + const xObject: Object = xSmi; + check(ExampleGenericOverload(xSmi) == 6); + check(UnsafeCast(ExampleGenericOverload(xObject)) == 5); + } + + @export + macro TestEquality(implicit context: Context)() { + const notEqual: bool = + AllocateHeapNumberWithValue(0.5) != AllocateHeapNumberWithValue(0.5); + check(!notEqual); + const equal: bool = + AllocateHeapNumberWithValue(0.5) == AllocateHeapNumberWithValue(0.5); + check(equal); + } + + macro BoolToBranch(x: bool): never + labels Taken, NotTaken { + if (x) { + goto Taken; + } else { + goto NotTaken; + } + } + + @export + macro TestOrAnd1(x: bool, y: bool, z: bool): bool { + return BoolToBranch(x) || y && z ? true : false; + } + + @export + macro TestOrAnd2(x: bool, y: bool, z: bool): bool { + return x || BoolToBranch(y) && z ? true : false; + } + + @export + macro TestOrAnd3(x: bool, y: bool, z: bool): bool { + return x || y && BoolToBranch(z) ? true : false; + } + + @export + macro TestAndOr1(x: bool, y: bool, z: bool): bool { + return BoolToBranch(x) && y || z ? true : false; + } + + @export + macro TestAndOr2(x: bool, y: bool, z: bool): bool { + return x && BoolToBranch(y) || z ? true : false; + } + + @export + macro TestAndOr3(x: bool, y: bool, z: bool): bool { + return x && y || BoolToBranch(z) ? true : false; + } + + @export + macro TestLogicalOperators() { + check(TestAndOr1(true, true, true)); + check(TestAndOr2(true, true, true)); + check(TestAndOr3(true, true, true)); + check(TestAndOr1(true, true, false)); + check(TestAndOr2(true, true, false)); + check(TestAndOr3(true, true, false)); + check(TestAndOr1(true, false, true)); + check(TestAndOr2(true, false, true)); + check(TestAndOr3(true, false, true)); + check(!TestAndOr1(true, false, false)); + check(!TestAndOr2(true, false, false)); + check(!TestAndOr3(true, false, false)); + check(TestAndOr1(false, true, true)); + check(TestAndOr2(false, true, true)); + check(TestAndOr3(false, true, true)); + check(!TestAndOr1(false, true, false)); + check(!TestAndOr2(false, true, false)); + check(!TestAndOr3(false, true, false)); + check(TestAndOr1(false, false, true)); + check(TestAndOr2(false, false, true)); + check(TestAndOr3(false, false, true)); + check(!TestAndOr1(false, false, false)); + check(!TestAndOr2(false, false, false)); + check(!TestAndOr3(false, false, false)); + check(TestOrAnd1(true, true, true)); + check(TestOrAnd2(true, true, true)); + check(TestOrAnd3(true, true, true)); + check(TestOrAnd1(true, true, false)); + check(TestOrAnd2(true, true, false)); + check(TestOrAnd3(true, true, false)); + check(TestOrAnd1(true, false, true)); + check(TestOrAnd2(true, false, true)); + check(TestOrAnd3(true, false, true)); + check(TestOrAnd1(true, false, false)); + check(TestOrAnd2(true, false, false)); + check(TestOrAnd3(true, false, false)); + check(TestOrAnd1(false, true, true)); + check(TestOrAnd2(false, true, true)); + check(TestOrAnd3(false, true, true)); + check(!TestOrAnd1(false, true, false)); + check(!TestOrAnd2(false, true, false)); + check(!TestOrAnd3(false, true, false)); + check(!TestOrAnd1(false, false, true)); + check(!TestOrAnd2(false, false, true)); + check(!TestOrAnd3(false, false, true)); + check(!TestOrAnd1(false, false, false)); + check(!TestOrAnd2(false, false, false)); + check(!TestOrAnd3(false, false, false)); + } + + @export + macro TestCall(i: Smi): Smi labels A { + if (i < 5) return i; + goto A; + } + + @export + macro TestOtherwiseWithCode1() { + let v: Smi = 0; + let s: Smi = 1; + try { + TestCall(10) otherwise goto B(++s); + } + label B(v1: Smi) { + v = v1; + } + assert(v == 2); + } + + @export + macro TestOtherwiseWithCode2() { + let s: Smi = 0; + for (let i: Smi = 0; i < 10; ++i) { + TestCall(i) otherwise break; + ++s; + } + assert(s == 5); + } + + @export + macro TestOtherwiseWithCode3() { + let s: Smi = 0; + for (let i: Smi = 0; i < 10; ++i) { + s += TestCall(i) otherwise break; + } + assert(s == 10); + } + + @export + macro TestForwardLabel() { + try { + goto A; + } + label A { + goto B(5); + } + label B(b: Smi) { + assert(b == 5); + } + } + + @export + macro TestQualifiedAccess(implicit context: Context)() { + const s: Smi = 0; + check(!array::IsJSArray(s)); + } + + @export + macro TestCatch1(implicit context: Context)(): Smi { + let r: Smi = 0; + try { + ThrowTypeError(kInvalidArrayLength); + } catch (_e) { + r = 1; + return r; + } + } + + @export + macro TestCatch2Wrapper(implicit context: Context)(): never { + ThrowTypeError(kInvalidArrayLength); + } + + @export + macro TestCatch2(implicit context: Context)(): Smi { + let r: Smi = 0; + try { + TestCatch2Wrapper(); + } catch (_e) { + r = 2; + return r; + } + } + + @export + macro TestCatch3WrapperWithLabel(implicit context: Context)(): + never labels _Abort { + ThrowTypeError(kInvalidArrayLength); + } + + @export + macro TestCatch3(implicit context: Context)(): Smi { + let r: Smi = 0; + try { + TestCatch3WrapperWithLabel() otherwise Abort; + } + label Abort { + return -1; + } + catch (_e) { + r = 2; + return r; + } + } + + // This test doesn't actually test the functionality of iterators, + // it's only purpose is to make sure tha the CSA macros in the + // IteratorBuiltinsAssembler match the signatures provided in + // iterator.tq. + @export + macro TestIterator(implicit context: Context)(o: JSReceiver, map: Map) { + try { + const t1: Object = iterator::GetIteratorMethod(o); + const t2: iterator::IteratorRecord = iterator::GetIterator(o); + + const _t3: Object = iterator::IteratorStep(t2) otherwise Fail; + const _t4: Object = iterator::IteratorStep(t2, map) otherwise Fail; + + const t5: Object = iterator::IteratorValue(o); + const _t6: Object = iterator::IteratorValue(o, map); + + const _t7: JSArray = iterator::IterableToList(t1, t1); + + iterator::IteratorCloseOnException(t2, t5); + } + label Fail {} + } + + @export + macro TestFrame1(implicit context: Context)() { + const f: Frame = LoadFramePointer(); + const frameType: FrameType = + Cast(f.context_or_frame_type) otherwise unreachable; + assert(frameType == STUB_FRAME); + assert(f.caller == LoadParentFramePointer()); + typeswitch (f) { + case (_f: StandardFrame): { + unreachable; + } + case (_f: ArgumentsAdaptorFrame): { + unreachable; + } + case (_f: StubFrame): { + } + } + } + + @export + macro TestNew(implicit context: Context)() { + const f: JSArray = NewJSArray(); + check(f.IsEmpty()); + f.length = 0; + } + + struct TestInner { + SetX(newValue: int32) { + this.x = newValue; + } + GetX(): int32 { + return this.x; + } + x: int32; + y: int32; + } + + struct TestOuter { + a: int32; + b: TestInner; + c: int32; + } + + @export + macro TestStructConstructor(implicit context: Context)() { + // Test default constructor + let a: TestOuter = TestOuter{a: 5, b: TestInner{x: 6, y: 7}, c: 8}; + check(a.a == 5); + check(a.b.x == 6); + check(a.b.y == 7); + check(a.c == 8); + a.b.x = 1; + check(a.b.x == 1); + a.b.SetX(2); + check(a.b.x == 2); + check(a.b.GetX() == 2); + } + + class InternalClass extends Struct { + Flip() labels NotASmi { + const tmp = Cast(this.b) otherwise NotASmi; + this.b = this.a; + this.a = tmp; + } + a: Smi; + b: Number; + } + + macro NewInternalClass(x: Smi): InternalClass { + return new InternalClass{a: x, b: x + 1}; + } + + @export + macro TestInternalClass(implicit context: Context)() { + const o = NewInternalClass(5); + o.Flip() otherwise unreachable; + check(o.a == 6); + check(o.b == 5); + } + + struct StructWithConst { + TestMethod1(): int32 { + return this.b; + } + TestMethod2(): Object { + return this.a; + } + a: Object; + const b: int32; + } + + @export + macro TestConstInStructs() { + const x = StructWithConst{a: Null, b: 1}; + let y = StructWithConst{a: Null, b: 1}; + y.a = Undefined; + const _copy = x; + + check(x.TestMethod1() == 1); + check(x.TestMethod2() == Null); + } + + struct TestIterator { + Next(): Object labels NoMore { + if (this.count-- == 0) goto NoMore; + return TheHole; + } + count: Smi; + } + + @export + macro TestNewFixedArrayFromSpread(implicit context: Context)(): Object { + let i = TestIterator{count: 5}; + return new FixedArray{map: kFixedArrayMap, length: 5, objects: ...i}; + } + + class SmiPair extends Struct { + GetA():&Smi { + return & this.a; + } + a: Smi; + b: Smi; + } + + macro Swap(a:&T, b:&T) { + const tmp = * a; + * a = * b; + * b = tmp; + } + + @export + macro TestReferences() { + const array = new SmiPair{a: 7, b: 2}; + const ref:&Smi = & array.a; + * ref = 3 + * ref; + -- * ref; + Swap(& array.b, array.GetA()); + check(array.a == 2); + check(array.b == 9); + } + + @export + macro TestStaticAssert() { + StaticAssert(1 + 2 == 3); + } + + class SmiBox extends Struct { + value: Smi; + unrelated: Smi; + } + + builtin NewSmiBox(implicit context: Context)(value: Smi): SmiBox { + return new SmiBox{value, unrelated: 0}; + } + + @export + macro TestLoadEliminationFixed(implicit context: Context)() { + const box = NewSmiBox(123); + const v1 = box.value; + box.unrelated = 999; + const v2 = (box.unrelated == 0) ? box.value : box.value; + StaticAssert(WordEqual(v1, v2)); + + box.value = 11; + const v3 = box.value; + const eleven: Smi = 11; + StaticAssert(WordEqual(v3, eleven)); + } + + @export + macro TestLoadEliminationVariable(implicit context: Context)() { + const a = UnsafeCast(kEmptyFixedArray); + const box = NewSmiBox(1); + const v1 = a.objects[box.value]; + const u1 = a.objects[box.value + 2]; + const v2 = a.objects[box.value]; + const u2 = a.objects[box.value + 2]; + StaticAssert(WordEqual(v1, v2)); + StaticAssert(WordEqual(u1, u2)); + } + + @export + macro TestRedundantArrayElementCheck(implicit context: Context)(): Smi { + const a = kEmptyFixedArray; + for (let i: Smi = 0; i < a.length; i++) { + if (a.objects[i] == TheHole) { + if (a.objects[i] == TheHole) { + return -1; + } else { + StaticAssert(false); + } + } + } + return 1; + } + + @export + macro TestRedundantSmiCheck(implicit context: Context)(): Smi { + const a = kEmptyFixedArray; + const x = a.objects[1]; + typeswitch (x) { + case (Smi): { + Cast(x) otherwise VerifiedUnreachable(); + return -1; + } + case (Object): { + } + } + return 1; + } + + struct SBox { + value: T; + } + + @export + macro TestGenericStruct1(): intptr { + const i: intptr = 123; + let box = SBox{value: i}; + let boxbox = SBox>{value: box}; + check(box.value == 123); + boxbox.value.value *= 2; + check(boxbox.value.value == 246); + return boxbox.value.value; + } + + struct TestTuple { + const fst: T1; + const snd: T2; + } + + macro Swap(tuple: TestTuple): + TestTuple { + return TestTuple{fst: tuple.snd, snd: tuple.fst}; + } + + @export + macro TestGenericStruct2(): TestTuple { + const intptrAndSmi = TestTuple{fst: 1, snd: 2}; + const smiAndIntptr = Swap(intptrAndSmi); + check(intptrAndSmi.fst == smiAndIntptr.snd); + check(intptrAndSmi.snd == smiAndIntptr.fst); + return smiAndIntptr; + } + +} diff --git a/extra/nodejs/sources b/extra/nodejs/sources index 99686b79..87695be5 100644 --- a/extra/nodejs/sources +++ b/extra/nodejs/sources @@ -1 +1,2 @@ -https://nodejs.org/dist/v12.10.0/node-v12.10.0.tar.xz +https://nodejs.org/dist/v12.11.0/node-v12.11.0.tar.xz +files/test-torque.tq diff --git a/extra/nodejs/version b/extra/nodejs/version index 7d5a0057..0431809b 100644 --- a/extra/nodejs/version +++ b/extra/nodejs/version @@ -1 +1 @@ -12.10.0 1 +12.11.0 1