diff --git a/Changes.md b/Changes.md index 54466e163..c0b4a95d9 100644 --- a/Changes.md +++ b/Changes.md @@ -2,6 +2,13 @@ libhxcpp 6.0.0 (unreleased) ------------------------------------------------------------ +* Fixed a cppia class that implements both a script interface and a host interface, such as haxe.Constraints.IMap, calling the wrong method or crashing: the script interface's first method that the host does not know got the slot of the host's last interface method, so both were stored in one slot. Script interface methods are numbered after the host's now (libhxcpp #462) +* Fixed a thread spinning on Haxe 4's haxe.atomic.AtomicInt, as in while (flag.load() == 0) {}, stopping every collection, and so every other thread, for as long as it spun: the atomic operations were not safe points, so a collection waited for it, and it waited for a flag the collecting thread would set afterwards. They stop for a pending collection now, as Haxe 5's AtomicInt and Mutex.tryAcquire do, and so do the AtomicObject operations (libhxcpp #455) +* Fixed trace, Sys.print and Sys.println stopping every thread when stdout blocked, as it does for a pipe nobody reads, a slow log reader or a Windows console with text selected: they wrote outside a GC-free zone, so the next collection on any thread waited for the blocked write, and every other thread waited for the collection. On Windows, Process.stdin.close() did the same while another thread was blocked writing to the child, and waited itself until the child exited. They write in a zone now, and stdin.close() cancels the writes in progress before it closes, as Process.close() does (libhxcpp #454) +* Fixed a finalizer set with cpp.vm.Gc.setFinalizer that takes a Mutex ending the process with "Bad Allocation while collecting - from finalizer?", even with the lock free: finalizers run on the collecting thread inside the collection, and Mutex's uncontended path stopped there for the collection as if it were another thread. The collecting thread passes that stop now, so a finalizer can take a Mutex, as with stock hxcpp. A finalizer still must not allocate (libhxcpp #452) +* Fixed exceptions under the cppia JIT running on past the throw, or skipping the script's catch, when they came from a native helper of the jitted code: a Dynamic field or index updated with +=, -= and the others, Dynamic + Dynamic, ++ and -- on a Dynamic, a Dynamic or host ArrayAccess index, the typed array setters and increments, Array stores, string iterators and enum construction. Some of these caught the exception and the jitted code never looked, so it ran on and, if it allocated, could free the exception before the catch got it, crashing the next call; the rest let it unwind through the jitted frames, past the script's catch to the host's, or out of the process. Each now catches, the jitted code checks after each call, and the collector keeps a caught exception until it is handled. MSVC builds now compile with -bigobj, as debug builds already did (libhxcpp #465) +* Fixed three cppia array builtins writing to the wrong memory: under the JIT, a[i]++ or --a[i] whose result was used as a Float stored that result through whatever the third argument register held, corrupting the array or memory near it, and a typed push made room before running its argument, so an argument that grew the same array had the value stored past its buffer. Interpreted, a[i] = rhs and a[i] += rhs found the element before running rhs, so an rhs that grew the array stored into the old buffer, and a[a.length] = a.length stored the length after the store. The interpreter and the JIT now agree, and match the other targets (libhxcpp #463) +* Fixed HXCPP_GC_MOVING, and HXCPP_GC_DEBUG_ALWAYS_MOVE without generational, corrupting live objects after a collection that ran out of blocks to move into: the block it was emptying kept, in part, the start bits of the objects it had moved out, and a stale stack word holding one of their old addresses had a later collection take the moved header for an object of 254 rows and mark rows past the block's row table, over the objects in its first rows. The start bits go as the objects move, and a moved header is never taken for an object (libhxcpp #450) * Fixed a Haxe 4 haxe.atomic.AtomicInt kept in a field reading freed memory after a collection: Haxe 4's AtomicInt on C++ is a cpp.Pointer into a one-element array nothing else holds, and the collector ignored cpp.Pointer fields, so it freed the array (HaxeFoundation/hxcpp#1225; Haxe 5 changed AtomicInt instead, in HaxeFoundation/haxe#12236). A cpp.Pointer field, or a pointer boxed in a Dynamic, now keeps what it points into in the GC heap, as a pointer on the stack does, and pins it under HXCPP_GC_MOVING. Of 10,000 atomics in fields, 9,999 read freed memory after a collection and none do now * Fixed HXCPP_GC_INCREMENTAL failing to compile ("Incremental GC requires regenerated C++") with libhxcpp installed from a release, 6.0.0-rc.2 among them: the release workflow rewrote extraParams.hxml with the version and dropped its other line, the macro that turns on the generated write barriers the incremental collector needs. Only the version lines are rewritten now * Fixed a change of link flags or libraries alone leaving the program as it was: the build tool linked again only when an object or library file had changed, so -D HXCPP_LINK_STACK_SIZE, HXCPP_LINK_NO_MEMORY_GROWTH, HXCPP_LINK_NO_EMBIND or HXCPP_LINK_NODERAWFS on an Emscripten build, which change nothing that is compiled, or a flag or library added to a target in Build.xml, did nothing until the objects changed. The flags, libraries and library paths are now part of what a link is checked against, so each program links once more after updating diff --git a/include/cpp/Pointer.h b/include/cpp/Pointer.h index 74a68ee35..054662584 100644 --- a/include/cpp/Pointer.h +++ b/include/cpp/Pointer.h @@ -574,4 +574,21 @@ T *StarOf(T &x) { return &x; } } +// Haxe 4's haxe.atomic.AtomicInt is a cpp.Pointer, and its methods call +// these. A thread spinning on one never otherwise reached a safe point, so a +// collection on another thread waited for it for ever, as Haxe 5's +// hx::atomic::AtomicInt does not (libhxcpp #455). The runtime's own spinlocks +// call the volatile int * forms, which do not stop. +#define HX_ATOMIC_SAFE_POINT if (::hx::gPauseForCollect) __hxcpp_gc_safe_point(); +inline int _hx_atomic_add(::cpp::Pointer a, int b) { HX_ATOMIC_SAFE_POINT return _hx_atomic_add((volatile int *)a.ptr, b); } +inline int _hx_atomic_sub(::cpp::Pointer a, int b) { HX_ATOMIC_SAFE_POINT return _hx_atomic_sub((volatile int *)a.ptr, b); } +inline int _hx_atomic_and(::cpp::Pointer a, int b) { HX_ATOMIC_SAFE_POINT return _hx_atomic_and((volatile int *)a.ptr, b); } +inline int _hx_atomic_or(::cpp::Pointer a, int b) { HX_ATOMIC_SAFE_POINT return _hx_atomic_or((volatile int *)a.ptr, b); } +inline int _hx_atomic_xor(::cpp::Pointer a, int b) { HX_ATOMIC_SAFE_POINT return _hx_atomic_xor((int *)a.ptr, b); } +inline int _hx_atomic_compare_exchange(::cpp::Pointer a, int expected, int replacement) { HX_ATOMIC_SAFE_POINT return _hx_atomic_compare_exchange((volatile int *)a.ptr, expected, replacement); } +inline int _hx_atomic_exchange(::cpp::Pointer a, int replacement) { HX_ATOMIC_SAFE_POINT return _hx_atomic_exchange((volatile int *)a.ptr, replacement); } +inline int _hx_atomic_load(::cpp::Pointer a) { HX_ATOMIC_SAFE_POINT return _hx_atomic_load((volatile int *)a.ptr); } +inline int _hx_atomic_store(::cpp::Pointer a, int value) { HX_ATOMIC_SAFE_POINT return _hx_atomic_store((volatile int *)a.ptr, value); } +#undef HX_ATOMIC_SAFE_POINT + #endif diff --git a/include/hx/StdLibs.h b/include/hx/StdLibs.h index 58e724f0b..7f937943a 100644 --- a/include/hx/StdLibs.h +++ b/include/hx/StdLibs.h @@ -554,6 +554,9 @@ inline Dynamic __hxcpp_atomic_object_create(Dynamic value) { } inline Dynamic __hxcpp_atomic_object_store(Dynamic dynObj, Dynamic val) { + // A thread spinning on one must still reach a safe point (libhxcpp #455) + if (hx::gPauseForCollect) + __hxcpp_gc_safe_point(); AtomicObject *obj = dynamic_cast(dynObj.mPtr); if (!obj) throw HX_INVALID_OBJECT; @@ -561,6 +564,9 @@ inline Dynamic __hxcpp_atomic_object_store(Dynamic dynObj, Dynamic val) { } inline Dynamic __hxcpp_atomic_object_load(Dynamic dynObj) { + // A thread spinning on one must still reach a safe point (libhxcpp #455) + if (hx::gPauseForCollect) + __hxcpp_gc_safe_point(); AtomicObject *obj = dynamic_cast(dynObj.mPtr); if (!obj) throw HX_INVALID_OBJECT; @@ -568,6 +574,9 @@ inline Dynamic __hxcpp_atomic_object_load(Dynamic dynObj) { } inline Dynamic __hxcpp_atomic_object_exchange(Dynamic dynObj, Dynamic newVal) { + // A thread spinning on one must still reach a safe point (libhxcpp #455) + if (hx::gPauseForCollect) + __hxcpp_gc_safe_point(); AtomicObject *obj = dynamic_cast(dynObj.mPtr); if (!obj) throw HX_INVALID_OBJECT; @@ -575,6 +584,9 @@ inline Dynamic __hxcpp_atomic_object_exchange(Dynamic dynObj, Dynamic newVal) { } inline Dynamic __hxcpp_atomic_object_compare_exchange(Dynamic dynObj, Dynamic expected, Dynamic replacement) { + // A thread spinning on one must still reach a safe point (libhxcpp #455) + if (hx::gPauseForCollect) + __hxcpp_gc_safe_point(); AtomicObject *obj = dynamic_cast(dynObj.mPtr); if (!obj) throw HX_INVALID_OBJECT; diff --git a/src/hx/StdLibs.cpp b/src/hx/StdLibs.cpp index 7553df56b..6789c81ac 100644 --- a/src/hx/StdLibs.cpp +++ b/src/hx/StdLibs.cpp @@ -423,6 +423,23 @@ void WriteConsoleAllA(HANDLE h, const char *str, DWORD length) { } #endif +namespace +{ +// Output to stdout can block for a long time: a pipe nobody reads, a slow +// reader, or a Windows console with text selected. Outside a GC-free zone, the +// next collection on any thread waits for it, and every other thread with it. +// The text is made before, since nothing may allocate in a zone, and a thread +// the collector does not know needs no zone. +struct OutputZone +{ + bool entered; + OutputZone() : entered(HX_CTX_GET && hx::TryGCFreeZone()) { } + ~OutputZone() { if (entered) hx::ExitGCFreeZone(); } + OutputZone(const OutputZone &) = delete; + OutputZone &operator=(const OutputZone &) = delete; +}; +} + void __trace(Dynamic inObj, Dynamic info) { String text; @@ -434,7 +451,6 @@ void __trace(Dynamic inObj, Dynamic info) DWORD mode; if (GetConsoleMode(handle, &mode)) { - fflush(stdout); String s; if (info == null()) { s = HX_CSTRING("?? ") + text + HX_CSTRING("\n"); @@ -445,30 +461,38 @@ void __trace(Dynamic inObj, Dynamic info) } if (s.isUTF16Encoded()) { - WriteConsoleAllW(handle, s.__WCStr(), s.length); + const wchar_t *wide = s.__WCStr(); + OutputZone zone; + fflush(stdout); + WriteConsoleAllW(handle, wide, s.length); } else { // ascii - WriteConsoleAllA(handle, s.__CStr(), s.length); + const char *narrow = s.__CStr(); + OutputZone zone; + fflush(stdout); + WriteConsoleAllA(handle, narrow, s.length); } return; } #endif hx::strbuf convertBuf; + const char *textOut = text.raw_ptr() ? text.out_str(&convertBuf) : "null"; if (info==null()) { - PRINTF("?? %s\n", text.raw_ptr() ? text.out_str(&convertBuf) : "null"); + OutputZone zone; + PRINTF("?? %s\n", textOut); + fflush(stdout); } else { const char *filename = Dynamic((info)->__Field(HX_CSTRING("fileName"), HX_PROP_DYNAMIC))->toString().utf8_str(0,false); int line = Dynamic((info)->__Field( HX_CSTRING("lineNumber") , HX_PROP_DYNAMIC))->__ToInt(); - hx::strbuf convertBuf; - //PRINTF("%s:%d: %s\n", filename, line, text.raw_ptr() ? text.out_str(&convertBuf) : "null"); - PRINTF("%s:%d: %s\n", filename, line, text.raw_ptr() ? text.out_str(&convertBuf) : "null"); + OutputZone zone; + PRINTF("%s:%d: %s\n", filename, line, textOut); + fflush(stdout); } - fflush(stdout); } void __hxcpp_exit(int inExitCode) @@ -779,13 +803,17 @@ void __hxcpp_print_string(const String &inString) HANDLE handle; if (hxStdoutIsConsole(handle) && inV.isUTF16Encoded()) { + const wchar_t *wide = inV.__WCStr(); + OutputZone zone; fflush(stdout); - WriteConsoleAllW(handle, inV.__WCStr(), inV.length); + WriteConsoleAllW(handle, wide, inV.length); return; } #endif hx::strbuf convertBuf; - PRINTF("%s", inV.out_str(&convertBuf) ); + const char *out = inV.out_str(&convertBuf); + OutputZone zone; + PRINTF("%s", out ); } void __hxcpp_println_string(const String &inString) @@ -796,15 +824,19 @@ void __hxcpp_println_string(const String &inString) bool isConsole = hxStdoutIsConsole(handle); if (isConsole && inV.isUTF16Encoded()) { + const wchar_t *wide = inV.__WCStr(); + OutputZone zone; fflush(stdout); - WriteConsoleAllW(handle, inV.__WCStr(), inV.length); + WriteConsoleAllW(handle, wide, inV.length); fwrite("\n", 1, 1, stdout); fflush(stdout); return; } #endif hx::strbuf convertBuf; - PRINTF("%s\n", inV.out_str(&convertBuf)); + const char *out = inV.out_str(&convertBuf); + OutputZone zone; + PRINTF("%s\n", out); // Flush every line, redirected or not. Boot asks for line buffering, // but the Windows CRT treats _IOLBF as full buffering, so a redirected // stdout there held a server's log lines back from whatever reads them, diff --git a/src/hx/cppia/ArrayBuiltin.cpp b/src/hx/cppia/ArrayBuiltin.cpp index 0ecacbf92..f4813b92f 100644 --- a/src/hx/cppia/ArrayBuiltin.cpp +++ b/src/hx/cppia/ArrayBuiltin.cpp @@ -95,8 +95,11 @@ inline JitType elem4JitType() { return ExprTypeOf::value==etFloat ? jtFloa static ArrayBase * SLJIT_CALL array_expand_size(ArrayBase *inArray, int inSize) { + TRY_NATIVE inArray->Realloc(inSize+1); return inArray; + CATCH_NATIVE + return 0; } // blit, __SetSizeExact and resize throw for a range or size the array cannot @@ -153,8 +156,14 @@ struct ArraySetter : public ArrayBuiltinBase CPPIA_CHECK(thisVal); int i = args[0]->runInt(ctx); BCR_CHECK; + // On a copy, and the element found after: the right-hand side can grow + // the array or move its items, which left a reference taken before + // pointing at the old buffer + ELEM value = thisVal->__get(i); + FUNC::run(value, ctx, args[1]); + BCR_CHECK; ELEM &elem = thisVal->Item(i); - FUNC::run(elem, ctx, args[1]); + elem = value; #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_CTX(thisVal,hx::PointerOf(elem),ctx); @@ -168,8 +177,14 @@ struct ArraySetter : public ArrayBuiltinBase CPPIA_CHECK(thisVal); int i = args[0]->runInt(ctx); BCR_CHECK; + // On a copy, and the element found after: the right-hand side can grow + // the array or move its items, which left a reference taken before + // pointing at the old buffer + ELEM value = thisVal->__get(i); + FUNC::run(value, ctx, args[1]); + BCR_CHECK; ELEM &elem = thisVal->Item(i); - FUNC::run(elem, ctx, args[1]); + elem = value; #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_CTX(thisVal,hx::PointerOf(elem),ctx); @@ -183,8 +198,14 @@ struct ArraySetter : public ArrayBuiltinBase CPPIA_CHECK(thisVal); int i = args[0]->runInt(ctx); BCR_CHECK; + // On a copy, and the element found after: the right-hand side can grow + // the array or move its items, which left a reference taken before + // pointing at the old buffer + ELEM value = thisVal->__get(i); + FUNC::run(value, ctx, args[1]); + BCR_CHECK; ELEM &elem = thisVal->Item(i); - FUNC::run(elem, ctx, args[1]); + elem = value; #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_CTX(thisVal,hx::PointerOf(elem),ctx); @@ -198,8 +219,14 @@ struct ArraySetter : public ArrayBuiltinBase CPPIA_CHECK(thisVal); int i = args[0]->runInt(ctx); BCR_CHECK; + // On a copy, and the element found after: the right-hand side can grow + // the array or move its items, which left a reference taken before + // pointing at the old buffer + ELEM value = thisVal->__get(i); + FUNC::run(value, ctx, args[1]); + BCR_CHECK; ELEM &elem = thisVal->Item(i); - FUNC::run(elem, ctx, args[1]); + elem = value; #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_CTX(thisVal,hx::PointerOf(elem),ctx); @@ -211,6 +238,7 @@ struct ArraySetter : public ArrayBuiltinBase static void * SLJIT_CALL nativeRunInt(JitMultiArg *args) { + TRY_NATIVE Array_obj *thisVal = reinterpret_cast *>(JitArg(args,0).obj); ELEM &elem = thisVal->Item( JitArg(args,1).ival ); JitMultiArg arg2 = JitArg(args,2); @@ -220,10 +248,13 @@ struct ArraySetter : public ArrayBuiltinBase HX_OBJ_WB_GET(thisVal,hx::PointerOf(elem)); #endif return &elem; - } + CATCH_NATIVE + return 0; +} static void * SLJIT_CALL nativeRunFloat(JitMultiArg *args) { + TRY_NATIVE Array_obj *thisVal = reinterpret_cast *>(JitArg(args,0).obj); ELEM &elem = thisVal->Item( JitArg(args,1).ival ); JitMultiArg arg2 = JitArg(args,2); @@ -233,10 +264,13 @@ struct ArraySetter : public ArrayBuiltinBase HX_OBJ_WB_GET(thisVal,hx::PointerOf(elem)); #endif return &elem; - } + CATCH_NATIVE + return 0; +} static void * SLJIT_CALL nativeRunObject(JitMultiArg *args) { + TRY_NATIVE Array_obj *thisVal = reinterpret_cast *>(JitArg(args,0).obj); ELEM &elem = thisVal->Item( JitArg(args,1).ival ); Dynamic obj(JitArg(args,2).obj); @@ -246,10 +280,13 @@ struct ArraySetter : public ArrayBuiltinBase HX_OBJ_WB_GET(thisVal,hx::PointerOf(elem)); #endif return &elem; - } + CATCH_NATIVE + return 0; +} static void * SLJIT_CALL nativeRunString(JitMultiArg *args) { + TRY_NATIVE Array_obj *thisVal = reinterpret_cast *>(JitArg(args,0).obj); ELEM &elem = thisVal->Item( JitArg(args,1).ival ); JitMultiArg arg2 = JitArg(args,2); @@ -259,7 +296,9 @@ struct ArraySetter : public ArrayBuiltinBase HX_OBJ_WB_GET(thisVal,hx::PointerOf(elem)); #endif return &elem; - } + CATCH_NATIVE + return 0; +} void genCode(CppiaCompiler *compiler, const JitVal &inDest, ExprType destType) HXCPP_OVERRIDE @@ -328,6 +367,7 @@ struct ArraySetter : public ArrayBuiltinBase sJitTemp0.star(jtInt, ArrayBase::allocOffset()) ); // Make some room compiler->callNative( (void *)array_expand_size, sJitTemp0.as(jtPointer), sJitTemp1.as(jtInt) ); + compiler->checkException(); // sJitTemp0 is still this, restore length... compiler->move( sJitTemp1,index); @@ -410,15 +450,19 @@ struct ArraySetter : public ArrayBuiltinBase { case etInt: compiler->callNative( (void *)nativeRunInt, margs ); + compiler->checkException(); break; case etFloat: compiler->callNative( (void *)nativeRunFloat, margs ); + compiler->checkException(); break; case etString: compiler->callNative( (void *)nativeRunString, margs ); + compiler->checkException(); break; case etObject: compiler->callNative( (void *)nativeRunObject, margs ); + compiler->checkException(); break; default: throw "Bad array set type"; @@ -1149,8 +1193,11 @@ struct ArrayBuiltin : public ArrayBuiltinBase #ifdef CPPIA_JIT static ArrayBase * SLJIT_CALL array_expand(ArrayBase *inArray) { + TRY_NATIVE inArray->Realloc( inArray->length + 1 ); return inArray; + CATCH_NATIVE + return 0; } static void SLJIT_CALL runSort( Array_obj *inArray, hx::Object *inFunc) { @@ -1167,16 +1214,19 @@ struct ArrayBuiltin : public ArrayBuiltinBase static void SLJIT_CALL runElem( Array_obj *inArray, int inIndex) { + TRY_NATIVE ELEM &t = Array(inArray)[inIndex]; CREMENT::run(t); #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_GET(inArray,hx::PointerOf(t)); #endif - } + CATCH_NATIVE +} static int SLJIT_CALL runIntCrement( Array_obj *inArray, int inIndex) { + TRY_NATIVE ELEM &t = Array(inArray)[inIndex]; int result = ValToInt( CREMENT::run(t) ); #ifdef HXCPP_GC_GENERATIONAL @@ -1184,21 +1234,25 @@ struct ArrayBuiltin : public ArrayBuiltinBase HX_OBJ_WB_GET(inArray,hx::PointerOf(t)); #endif return result; - } + CATCH_NATIVE + return 0; +} static void SLJIT_CALL runFloatCrement( Array_obj *inArray, int inIndex, double *d) { + TRY_NATIVE ELEM &t = Array(inArray)[inIndex]; JitStore(d, ValToFloat( CREMENT::run(t) )); #ifdef HXCPP_GC_GENERATIONAL if (hx::ContainsPointers()) HX_OBJ_WB_GET(inArray,hx::PointerOf(t)); #endif - - } + CATCH_NATIVE +} static hx::Object * SLJIT_CALL runObjCrement( Array_obj *inArray, int inIndex) { + TRY_NATIVE ELEM &t = Array(inArray)[inIndex]; Dynamic result( CREMENT::run(t) ); #ifdef HXCPP_GC_GENERATIONAL @@ -1206,7 +1260,9 @@ struct ArrayBuiltin : public ArrayBuiltinBase HX_OBJ_WB_GET(inArray,hx::PointerOf(t)); #endif return result.mPtr; - } + CATCH_NATIVE + return 0; +} static int SLJIT_CALL runContains( Array_obj *inArray, typename ExprBaseTypeOf::Base inBase) { @@ -1333,20 +1389,24 @@ struct ArrayBuiltin : public ArrayBuiltinBase { thisExpr->genCode(compiler, sJitTemp0, etObject); genNullReferenceExceptionCheck(compiler, sJitTemp0); - JumpId enough = compiler->compare( cmpI_LESS, sJitTemp0.star(jtInt, ArrayBase::lengthOffset()), - sJitTemp0.star(jtInt, ArrayBase::allocOffset()) ); - - // result comes back in sJitTemp0 - compiler->callNative( (void *)array_expand, sJitTemp0 ); - compiler->comeFrom(enough); JitTemp arrayThis(compiler,jtPointer); compiler->move(arrayThis, sJitTemp0); + // The value first: an argument that grows the array would otherwise + // leave the room made for it too small ExprType elemType = (ExprType)ExprTypeOf::value; JitTemp tempVal(compiler,getJitType(elemType)); args[0]->genCode(compiler, tempVal, elemType); + compiler->move(sJitTemp0, arrayThis); + JumpId enough = compiler->compare( cmpI_LESS, sJitTemp0.star(jtInt, ArrayBase::lengthOffset()), + sJitTemp0.star(jtInt, ArrayBase::allocOffset()) ); + + compiler->callNative( (void *)array_expand, sJitTemp0 ); + compiler->checkException(); + compiler->comeFrom(enough); + // sJitTemp1 = this compiler->move(sJitTemp1, arrayThis); // sJitTemp0 = length @@ -1443,6 +1503,7 @@ struct ArrayBuiltin : public ArrayBuiltinBase // result comes back in sJitTemp0 compiler->callNative( (void *)array_expand_size, sJitTemp0, sJitTemp1 ); + compiler->checkException(); // but need to reload sJitTemp1 compiler->move(sJitTemp1.as(jtInt), index); @@ -1962,23 +2023,28 @@ struct ArrayBuiltin : public ArrayBuiltinBase if (destType==etVoid || destType==etNull) { compiler->callNative( (void *)runElem, thisVal, sJitTemp1 ); + compiler->checkException(); } else if (destType==etInt) { compiler->callNative( (void *)runIntCrement, thisVal, sJitTemp1 ); + compiler->checkException(); compiler->move( inDest.as(jtInt), sJitReturnReg.as(jtInt) ); } else if (destType==etFloat) { JitTemp tempFloat(compiler, jtFloat); JitVal dVal = isMemoryVal(inDest) ? inDest : tempFloat; - compiler->callNative( (void *)runFloatCrement, thisVal, sJitTemp1 ); + // The result goes where dVal is: a float in memory is passed by address + compiler->callNative( (void *)runFloatCrement, thisVal, sJitTemp1, dVal.as(jtFloat) ); + compiler->checkException(); if (!isMemoryVal(inDest)) compiler->move(inDest.as(jtFloat), tempFloat); } else { compiler->callNative( (void *)runObjCrement, thisVal, sJitTemp1 ); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType); } } diff --git a/src/hx/cppia/ArrayVirtual.cpp b/src/hx/cppia/ArrayVirtual.cpp index 46ba3fb6f..5dd014a7b 100644 --- a/src/hx/cppia/ArrayVirtual.cpp +++ b/src/hx/cppia/ArrayVirtual.cpp @@ -91,60 +91,90 @@ static void SLJIT_CALL runJoin( ArrayAnyImpl *inArray, String *ioValue) static int SLJIT_CALL arrayPushInt( ArrayAnyImpl *inArray, int inVal) { + TRY_NATIVE return inArray->push(inVal); + CATCH_NATIVE + return 0; } static int SLJIT_CALL arrayPushObject( ArrayAnyImpl *inArray, hx::Object *inVal) { + TRY_NATIVE return inArray->push(Dynamic(inVal)); + CATCH_NATIVE + return 0; } static int SLJIT_CALL arrayPushFloat( ArrayAnyImpl *inArray, double *inVal) { + TRY_NATIVE return inArray->push(JitLoad(inVal)); + CATCH_NATIVE + return 0; } static int SLJIT_CALL arrayPushString( ArrayAnyImpl *inArray, String *inVal) { + TRY_NATIVE return inArray->push(JitLoad(inVal)); + CATCH_NATIVE + return 0; } static int SLJIT_CALL arraySetInt( ArrayAnyImpl *inArray, int inIndex, int inVal) { + TRY_NATIVE inArray->set(inIndex,inVal); return inVal; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL arraySetObject( ArrayAnyImpl *inArray, int inIndex, hx::Object *inVal) { + TRY_NATIVE inArray->set(inIndex,Dynamic(inVal)); return inVal; + CATCH_NATIVE + return 0; } static void SLJIT_CALL arraySetFloat( ArrayAnyImpl *inArray, int inIndex, double *inVal) { + TRY_NATIVE inArray->set(inIndex,JitLoad(inVal)); + CATCH_NATIVE } static void SLJIT_CALL arraySetString( ArrayAnyImpl *inArray, int inIndex, String *inVal) { + TRY_NATIVE inArray->set(inIndex,JitLoad(inVal)); + CATCH_NATIVE } static void SLJIT_CALL arrayUnshiftInt( ArrayAnyImpl *inArray, int inVal) { + TRY_NATIVE inArray->unshift(inVal); + CATCH_NATIVE } static void SLJIT_CALL arrayUnshiftObject( ArrayAnyImpl *inArray, hx::Object *inVal) { + TRY_NATIVE inArray->unshift(Dynamic(inVal)); + CATCH_NATIVE } static void SLJIT_CALL arrayUnshiftFloat( ArrayAnyImpl *inArray, double *inVal) { + TRY_NATIVE inArray->unshift(JitLoad(inVal)); + CATCH_NATIVE } static void SLJIT_CALL arrayUnshiftString( ArrayAnyImpl *inArray, String *inVal) { + TRY_NATIVE inArray->unshift(JitLoad(inVal)); + CATCH_NATIVE } @@ -831,6 +861,7 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase case etInt: args[1]->genCode(compiler, sJitArg2.as(jtInt), etInt); compiler->callNative( (void *)arraySetInt, thisVal, index, sJitArg2.as(jtInt)); + compiler->checkException(); compiler->convertReturnReg(etInt, inDest, destType); break; case etFloat: @@ -838,6 +869,7 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase JitTemp value(compiler, jtFloat); args[1]->genCode(compiler, value, etFloat); compiler->callNative( (void *)arraySetFloat, thisVal, index, value); + compiler->checkException(); compiler->convert(value,etFloat, inDest, destType); } break; @@ -846,12 +878,14 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase JitTemp value(compiler, jtString); args[1]->genCode(compiler, value, etString); compiler->callNative( (void *)arraySetString, thisVal, index, value); + compiler->checkException(); compiler->convert(value,etString, inDest, destType); } break; case etObject: args[1]->genCode(compiler, sJitArg2.as(jtPointer), etObject); compiler->callNative( (void *)arraySetObject, thisVal, index, sJitArg2.as(jtPointer)); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType); break; default: ; //? @@ -868,12 +902,14 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase case etInt: args[0]->genCode(compiler, sJitArg1.as(jtInt), etInt); compiler->callNative( (void *)arrayPushInt, thisVal, sJitArg1.as(jtInt)); + compiler->checkException(); break; case etFloat: { JitTemp value(compiler, jtFloat); args[0]->genCode(compiler, value, etFloat); compiler->callNative( (void *)arrayPushFloat, thisVal, value); + compiler->checkException(); } break; case etString: @@ -881,11 +917,13 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase JitTemp value(compiler, jtString); args[0]->genCode(compiler, value, etString); compiler->callNative( (void *)arrayPushString, thisVal, value); + compiler->checkException(); } break; case etObject: args[0]->genCode(compiler, sJitArg1.as(jtPointer), etObject); compiler->callNative( (void *)arrayPushObject, thisVal, sJitArg1.as(jtPointer)); + compiler->checkException(); break; default: ; //? } @@ -901,12 +939,14 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase case etInt: args[0]->genCode(compiler, sJitArg1.as(jtInt), etInt); compiler->callNative( (void *)arrayUnshiftInt, thisVal, sJitArg1.as(jtInt)); + compiler->checkException(); break; case etFloat: { JitTemp value(compiler, jtFloat); args[0]->genCode(compiler, value, etFloat); compiler->callNative( (void *)arrayUnshiftFloat, thisVal, value); + compiler->checkException(); } break; case etString: @@ -914,11 +954,13 @@ struct ArrayBuiltinAny : public ArrayBuiltinBase JitTemp value(compiler, jtString); args[0]->genCode(compiler, value, etString); compiler->callNative( (void *)arrayUnshiftString, thisVal, value); + compiler->checkException(); } break; case etObject: args[0]->genCode(compiler, sJitArg1.as(jtPointer), etObject); compiler->callNative( (void *)arrayUnshiftObject, thisVal, sJitArg1.as(jtPointer)); + compiler->checkException(); break; default: ; //? } diff --git a/src/hx/cppia/Cppia.cpp b/src/hx/cppia/Cppia.cpp index 3094c88b0..9f8d56862 100644 --- a/src/hx/cppia/Cppia.cpp +++ b/src/hx/cppia/Cppia.cpp @@ -2745,7 +2745,9 @@ static void SLJIT_CALL addVariantObject( cpp::Variant *ioVar, hx::Object *inValu static void SLJIT_CALL addVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, JitLoad(ioVar) + inValue); + CATCH_NATIVE } @@ -2759,58 +2761,80 @@ static void SLJIT_CALL addVariantString( cpp::Variant *ioVar, String *inValue ) static void SLJIT_CALL addVariantFloat( cpp::Variant *ioVar, double *inValue ) { + TRY_NATIVE JitStore(ioVar, JitLoad(ioVar) + JitLoad(inValue)); + CATCH_NATIVE } static void SLJIT_CALL subVariantFloat( cpp::Variant *ioVar, double *inValue ) { + TRY_NATIVE JitStore(ioVar, JitLoad(ioVar) - JitLoad(inValue)); + CATCH_NATIVE } static void SLJIT_CALL divVariantFloat( cpp::Variant *ioVar, double *inValue ) { + TRY_NATIVE JitStore(ioVar, JitLoad(ioVar) / JitLoad(inValue)); + CATCH_NATIVE } static void SLJIT_CALL multVariantFloat( cpp::Variant *ioVar, double *inValue ) { + TRY_NATIVE JitStore(ioVar, JitLoad(ioVar) * JitLoad(inValue)); + CATCH_NATIVE } static void SLJIT_CALL modVariantFloat( cpp::Variant *ioVar, double *inValue ) { + TRY_NATIVE JitStore(ioVar, hx::Mod(JitLoad(ioVar),JitLoad(inValue))); + CATCH_NATIVE } static void SLJIT_CALL andVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (int)(JitLoad(ioVar)) & inValue); + CATCH_NATIVE } static void SLJIT_CALL orVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (int)(JitLoad(ioVar)) | inValue); + CATCH_NATIVE } static void SLJIT_CALL xorVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (int)(JitLoad(ioVar)) ^ inValue); + CATCH_NATIVE } static void SLJIT_CALL shlVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (int)(JitLoad(ioVar)) << inValue); + CATCH_NATIVE } static void SLJIT_CALL shrVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (int)(JitLoad(ioVar)) >> inValue); + CATCH_NATIVE } static void SLJIT_CALL ushrVariantInt( cpp::Variant *ioVar, int inValue ) { + TRY_NATIVE JitStore(ioVar, (unsigned int)(int)(JitLoad(ioVar)) >> inValue); + CATCH_NATIVE } @@ -3084,6 +3108,7 @@ struct FieldByName : public CppiaDynamicExpr { JitTemp gotVal(compiler, etString, sizeof(cpp::Variant)); compiler->callNative( (void *)getFieldVariant, objSrc, (void *)&name, gotVal ); + compiler->checkException(); if (assign==aoAdd) { @@ -3092,16 +3117,19 @@ struct FieldByName : public CppiaDynamicExpr case etObject: value->genCode(compiler,sJitArg1.as(jtPointer), etObject); compiler->callNative( (void *)addVariantObject, gotVal, sJitArg1.as(jtPointer) ); + compiler->checkException(); break; case etInt: value->genCode(compiler,sJitArg1.as(jtInt), etInt); compiler->callNative( (void *)addVariantInt, gotVal, sJitArg1.as(jtPointer) ); + compiler->checkException(); break; case etString: { JitTemp sval(compiler, etString); value->genCode(compiler,sval, etString); compiler->callNative( (void *)addVariantString, gotVal, sval); + compiler->checkException(); } break; case etFloat: @@ -3109,6 +3137,7 @@ struct FieldByName : public CppiaDynamicExpr JitTemp fval(compiler, jtFloat); value->genCode(compiler,fval, etFloat); compiler->callNative( (void *)addVariantFloat, gotVal, fval); + compiler->checkException(); } break; default: @@ -3122,10 +3151,10 @@ struct FieldByName : public CppiaDynamicExpr value->genCode(compiler, fval, etFloat); switch(assign) { - case aoMult: compiler->callNative( (void *)multVariantFloat, gotVal, fval); break; - case aoDiv: compiler->callNative( (void *)divVariantFloat, gotVal, fval); break; - case aoMod: compiler->callNative( (void *)modVariantFloat, gotVal, fval); break; - case aoSub: compiler->callNative( (void *)subVariantFloat, gotVal, fval); break; + case aoMult: compiler->callNative( (void *)multVariantFloat, gotVal, fval); compiler->checkException(); break; + case aoDiv: compiler->callNative( (void *)divVariantFloat, gotVal, fval); compiler->checkException(); break; + case aoMod: compiler->callNative( (void *)modVariantFloat, gotVal, fval); compiler->checkException(); break; + case aoSub: compiler->callNative( (void *)subVariantFloat, gotVal, fval); compiler->checkException(); break; default: ; } } @@ -3134,12 +3163,12 @@ struct FieldByName : public CppiaDynamicExpr value->genCode(compiler, sJitTemp2, etInt); switch(assign) { - case aoAnd: compiler->callNative( (void *)andVariantInt, gotVal, sJitTemp2.as(jtInt)); break; - case aoOr: compiler->callNative( (void *)orVariantInt, gotVal, sJitTemp2.as(jtInt)); break; - case aoXOr: compiler->callNative( (void *)xorVariantInt, gotVal, sJitTemp2.as(jtInt)); break; - case aoShl: compiler->callNative( (void *)shlVariantInt, gotVal, sJitTemp2.as(jtInt)); break; - case aoShr: compiler->callNative( (void *)shrVariantInt, gotVal, sJitTemp2.as(jtInt)); break; - case aoUShr: compiler->callNative( (void *)ushrVariantInt, gotVal, sJitTemp2.as(jtInt)); break; + case aoAnd: compiler->callNative( (void *)andVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; + case aoOr: compiler->callNative( (void *)orVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; + case aoXOr: compiler->callNative( (void *)xorVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; + case aoShl: compiler->callNative( (void *)shlVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; + case aoShr: compiler->callNative( (void *)shrVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; + case aoUShr: compiler->callNative( (void *)ushrVariantInt, gotVal, sJitTemp2.as(jtInt)); compiler->checkException(); break; default: ; } } @@ -3147,10 +3176,12 @@ struct FieldByName : public CppiaDynamicExpr if (ret) { compiler->callNative( (void *)setFieldVariant, objSrc, (void *)&name, gotVal ); + compiler->checkException(); compiler->genVariantValueTemp0(0, inDest, destType); } else compiler->callNative( (void *)setFieldVariantV, objSrc, (void *)&name, gotVal ); + compiler->checkException(); } } #endif @@ -3940,7 +3971,10 @@ static hx::Object * SLJIT_CALL dynamicCatString(hx::Object *inLeft, String *inRi static hx::Object * SLJIT_CALL dynamicCatDynamic(hx::Object *inLeft, hx::Object *inRight) { + TRY_NATIVE return ( Dynamic(inLeft) + Dynamic(inRight) ).mPtr; + CATCH_NATIVE + return 0; } static int SLJIT_CALL modIntFloat(int inI, double *inMod) @@ -4058,6 +4092,7 @@ void genSetter(CppiaCompiler *compiler, const JitVal &ioValue, ExprType exprType { inExpr->genCode(compiler, sJitArg1, etObject); compiler->callNative((void *)dynamicCatDynamic, ioValue, sJitArg1.as(jtPointer) ); + compiler->checkException(); } compiler->move(ioValue, sJitReturnReg.as(jtPointer) ); } @@ -4458,81 +4493,113 @@ static double sMinusOne = -1.0; static void SLJIT_CALL objDec(hx::Object **ioVal) { + TRY_NATIVE JitStore(ioVal, (Dynamic(JitLoad(ioVal))-1).mPtr); + CATCH_NATIVE } static void SLJIT_CALL objInc(hx::Object **ioVal) { + TRY_NATIVE JitStore(ioVal, (Dynamic(JitLoad(ioVal))+1).mPtr); + CATCH_NATIVE } static hx::Object * SLJIT_CALL objPostInc(hx::Object **ioVal) { + TRY_NATIVE hx::Object *result = JitLoad(ioVal); JitStore(ioVal, (Dynamic(JitLoad(ioVal))+1).mPtr); return result; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPostDec(hx::Object **ioVal) { + TRY_NATIVE hx::Object *result = JitLoad(ioVal); JitStore(ioVal, (Dynamic(JitLoad(ioVal))-1).mPtr); return result; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPreInc(hx::Object **ioVal) { + TRY_NATIVE JitStore(ioVal, (Dynamic(JitLoad(ioVal))+1).mPtr); return JitLoad(ioVal); + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPreDec(hx::Object **ioVal) { + TRY_NATIVE JitStore(ioVal, (Dynamic(JitLoad(ioVal))-1).mPtr); return JitLoad(ioVal); + CATCH_NATIVE + return 0; } #ifdef HXCPP_GC_GENERATIONAL static void SLJIT_CALL objDecWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); *ioVal = (Dynamic(*ioVal)-1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); + CATCH_NATIVE } static void SLJIT_CALL objIncWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); *ioVal = (Dynamic(*ioVal)+1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); + CATCH_NATIVE } static hx::Object * SLJIT_CALL objPostIncWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); hx::Object *result = *ioVal; *ioVal = (Dynamic(result)+1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); return result; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPostDecWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); hx::Object *result = *ioVal; *ioVal = (Dynamic(result)-1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); return result; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPreIncWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); *ioVal = (Dynamic(*ioVal)+1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); return *ioVal; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL objPreDecWb(hx::Object *inObj,int inOffset) { + TRY_NATIVE hx::Object ** ioVal = (hx::Object **)( (char *)inObj + inOffset ); *ioVal = (Dynamic(*ioVal)-1).mPtr; HX_OBJ_WB_GET(inObj, *ioVal); return *ioVal; + CATCH_NATIVE + return 0; } #endif @@ -4721,6 +4788,7 @@ struct MemReferenceCrement : public CppiaExpr if ( inDest.type==jtVoid) { compiler->callNative( diff<0 ? (void *)objDecWb : (void *)objIncWb, obj, offset ); + compiler->checkException(); } else { @@ -4734,6 +4802,7 @@ struct MemReferenceCrement : public CppiaExpr default: ; } compiler->callNative(func, obj, offset); + compiler->checkException(); compiler->convertReturnReg( etObject, inDest, destType ); } @@ -4746,6 +4815,7 @@ struct MemReferenceCrement : public CppiaExpr if ( inDest.type==jtVoid) { compiler->callNative( diff<0 ? (void *)objDec : (void *)objInc, ioPtr ); + compiler->checkException(); } else { @@ -4759,6 +4829,7 @@ struct MemReferenceCrement : public CppiaExpr default: ; } compiler->callNative(func, ioPtr); + compiler->checkException(); compiler->convertReturnReg( etObject, inDest, destType ); } } @@ -5622,54 +5693,76 @@ struct ArrayDef : public CppiaDynamicExpr #ifdef CPPIA_JIT hx::Object * SLJIT_CALL getItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE return (inObj->__GetItem(inIndex)).mPtr; + CATCH_NATIVE + return 0; } void SLJIT_CALL incItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE inObj->__SetItem( inIndex, inObj->__GetItem(inIndex) + 1 ); - } + CATCH_NATIVE +} void SLJIT_CALL decItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE inObj->__SetItem( inIndex, inObj->__GetItem(inIndex) - 1 ); - } + CATCH_NATIVE +} hx::Object * SLJIT_CALL preIncItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE Dynamic val = inObj->__GetItem(inIndex) +1; inObj->__SetItem( inIndex, val ); return val.mPtr; - } + CATCH_NATIVE + return 0; +} hx::Object * SLJIT_CALL postIncItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE Dynamic val = inObj->__GetItem(inIndex); inObj->__SetItem( inIndex, val + 1 ); return val.mPtr; - } + CATCH_NATIVE + return 0; +} hx::Object * SLJIT_CALL setDynamicI(hx::Object *inObj, int inIndex, hx::Object *inValue) { + TRY_NATIVE inObj->__SetItem( inIndex, inValue ); return inValue; - } + CATCH_NATIVE + return 0; +} hx::Object * SLJIT_CALL preDecItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE Dynamic val = inObj->__GetItem(inIndex) - 1; inObj->__SetItem( inIndex, val ); return val.mPtr; - } + CATCH_NATIVE + return 0; +} hx::Object * SLJIT_CALL postDecItem(hx::Object *inObj, int inIndex) { + TRY_NATIVE Dynamic val = inObj->__GetItem(inIndex); inObj->__SetItem( inIndex, val - 1 ); return val.mPtr; - } + CATCH_NATIVE + return 0; +} struct DynIndexArgs { @@ -5683,17 +5776,23 @@ struct ArrayDef : public CppiaDynamicExpr #define DynIndexFunc(name, OP) \ hx::Object * SLJIT_CALL name(hx::Object *inObj, DynIndexArgs *args) \ { \ + TRY_NATIVE \ Dynamic result = Dynamic(args->lvalue.obj) OP ; \ inObj->__SetItem( args->index.ival, result); \ return result.mPtr; \ + CATCH_NATIVE \ + return 0; \ } #define DynIndexIntFunc(name, OP) \ hx::Object * SLJIT_CALL name(hx::Object *inObj, DynIndexArgs *args) \ { \ + TRY_NATIVE \ Dynamic result = ((int)Dynamic(args->lvalue.obj)) OP ; \ inObj->__SetItem( args->index.ival, result); \ return result.mPtr; \ + CATCH_NATIVE \ + return 0; \ } @@ -5704,10 +5803,13 @@ struct ArrayDef : public CppiaDynamicExpr hx::Object * SLJIT_CALL dynMod(hx::Object *inObj, DynIndexArgs *args) { + TRY_NATIVE Dynamic result = hx::Mod( Dynamic(args->lvalue.obj), args->rvalue.dval ); inObj->__SetItem( args->index.ival, result); return result.mPtr; - } + CATCH_NATIVE + return 0; +} DynIndexIntFunc(dynAnd, & args->rvalue.ival ); DynIndexIntFunc(dynOr, | args->rvalue.ival ); @@ -5717,10 +5819,13 @@ struct ArrayDef : public CppiaDynamicExpr hx::Object * SLJIT_CALL dynUShr(hx::Object *inObj, DynIndexArgs *args) { + TRY_NATIVE Dynamic result = hx::UShr( Dynamic(args->lvalue.obj), args->rvalue.ival ); inObj->__SetItem( args->index.ival, result); return result.mPtr; - } + CATCH_NATIVE + return 0; +} #endif @@ -5821,6 +5926,7 @@ struct DynamicArrayI : public CppiaDynamicExpr { index->genCode(compiler, sJitTemp1, etInt); compiler->callNative( (void *)getItem, obj, sJitTemp1.as(jtInt) ); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType); return; } @@ -5831,6 +5937,7 @@ struct DynamicArrayI : public CppiaDynamicExpr { compiler->callNative( crement==coPostInc || crement==coPostInc ? (void *)incItem : (void *)decItem, obj, sJitTemp1.as(jtInt) ); + compiler->checkException(); } else { @@ -5847,6 +5954,7 @@ struct DynamicArrayI : public CppiaDynamicExpr throw "Bad crement in DynamicArrayI"; compiler->callNative( func, obj, sJitTemp1.as(jtInt) ); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType ); } return; @@ -5859,6 +5967,7 @@ struct DynamicArrayI : public CppiaDynamicExpr value->genCode(compiler, sJitTemp2, etObject); compiler->callNative( (void *)setDynamicI, obj, idx, sJitTemp2); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType ); return; } @@ -5871,6 +5980,7 @@ struct DynamicArrayI : public CppiaDynamicExpr compiler->move(argsBuf.arg(0,etInt), sJitTemp1); compiler->callNative( (void *)getItem, obj, sJitTemp1.as(jtInt) ); + compiler->checkException(); compiler->move( argsBuf.arg(1,jtPointer), sJitReturnReg.as(jtPointer)); @@ -5905,6 +6015,7 @@ struct DynamicArrayI : public CppiaDynamicExpr if (!func) throw "Bad set in DynamicArrayI"; compiler->callNative( func, obj, argsBuf ); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType); } @@ -6168,25 +6279,34 @@ struct ArrayAccessI : public CppiaDynamicExpr // args: this expression, the object, the index, the operand, the value read static hx::Object * SLJIT_CALL jitGet(JitMultiArg *args) { + TRY_NATIVE ArrayAccessI *expr = (ArrayAccessI *)JitArg(args,0).obj; return expr->callGet(CppiaCtx::getCurrent(), JitArg(args,1).obj, JitArg(args,2).ival).mPtr; + CATCH_NATIVE + return 0; } static hx::Object * SLJIT_CALL jitSet(JitMultiArg *args) { + TRY_NATIVE ArrayAccessI *expr = (ArrayAccessI *)JitArg(args,0).obj; expr->callSet(CppiaCtx::getCurrent(), JitArg(args,1).obj, JitArg(args,2).ival, JitArg(args,3).obj); return JitArg(args,3).obj; - } + CATCH_NATIVE + return 0; +} static hx::Object * SLJIT_CALL jitUpdate(JitMultiArg *args) { + TRY_NATIVE ArrayAccessI *expr = (ArrayAccessI *)JitArg(args,0).obj; Dynamic before = JitArg(args,4).obj; Dynamic after = expr->update(before, JitArg(args,3).obj); expr->callSet(CppiaCtx::getCurrent(), JitArg(args,1).obj, JitArg(args,2).ival, after); return expr->crement==coPostInc || expr->crement==coPostDec ? before.mPtr : after.mPtr; - } + CATCH_NATIVE + return 0; +} void genCode(CppiaCompiler *compiler, const JitVal &inDest, ExprType destType) HXCPP_OVERRIDE { @@ -6200,21 +6320,27 @@ struct ArrayAccessI : public CppiaDynamicExpr index->genCode(compiler, args.arg(2,jtInt), etInt); if (crement==coNone && assign==aoNone) + { compiler->callNative((void *)jitGet, args); + compiler->checkException(); + } else if (crement==coNone && assign==aoSet) { value->genCode(compiler, args.arg(3,jtPointer), etObject); compiler->callNative((void *)jitSet, args); + compiler->checkException(); } else { compiler->callNative((void *)jitGet, args); + compiler->checkException(); compiler->move(args.arg(4,jtPointer), sJitReturnReg.as(jtPointer)); if (crement==coNone) value->genCode(compiler, args.arg(3,jtPointer), etObject); else compiler->move(args.arg(3,jtPointer), JitVal((void *)0)); compiler->callNative((void *)jitUpdate, args); + compiler->checkException(); } if (destType!=etVoid && destType!=etNull) diff --git a/src/hx/cppia/Cppia.h b/src/hx/cppia/Cppia.h index 4eb9e2483..271145102 100644 --- a/src/hx/cppia/Cppia.h +++ b/src/hx/cppia/Cppia.h @@ -452,6 +452,8 @@ class CppiaModule std::unordered_set allFileIds; typedef std::map< std::string, int > InterfaceSlots; InterfaceSlots interfaceSlots; + // The slot the next name the host does not know gets + int nextInterfaceSlot; StackLayout *layout; CppiaClassInfo *linkingClass; diff --git a/src/hx/cppia/CppiaClasses.cpp b/src/hx/cppia/CppiaClasses.cpp index 3b30bbfdc..d3d351842 100644 --- a/src/hx/cppia/CppiaClasses.cpp +++ b/src/hx/cppia/CppiaClasses.cpp @@ -502,6 +502,7 @@ struct EnumField : public CppiaDynamicExpr compiler->add(sJitCtxFrame, sJitFrame, compiler->getCurrentFrameSize()); compiler->callNative((void *)createEnum,(void *)enumClass.mPtr,(void *)&enumName,(int)args.size() ); + compiler->checkException(); if (destType!=etVoid && destType!=etNull) compiler->convertResult( etObject, inDest, destType ); diff --git a/src/hx/cppia/CppiaModule.cpp b/src/hx/cppia/CppiaModule.cpp index f8be08f8f..44139cd03 100644 --- a/src/hx/cppia/CppiaModule.cpp +++ b/src/hx/cppia/CppiaModule.cpp @@ -135,6 +135,10 @@ CppiaModule::CppiaModule() if (sgNativeNameSlotCount>0) for(int i=2;i2 ? sgNativeNameSlotCount : 1; std::lock_guard lock(sModuleLock); allModules().push_back(this); @@ -338,7 +342,7 @@ int CppiaModule::getInterfaceSlot(const std::string &inName) InterfaceSlots::iterator it = interfaceSlots.find(inName); if (it==interfaceSlots.end()) { - int result = interfaceSlots.size()+1; + int result = nextInterfaceSlot++; interfaceSlots[inName] = result; return result; } diff --git a/src/hx/cppia/StringBuiltin.cpp b/src/hx/cppia/StringBuiltin.cpp index 2e7a6b94f..17888ef4b 100644 --- a/src/hx/cppia/StringBuiltin.cpp +++ b/src/hx/cppia/StringBuiltin.cpp @@ -102,8 +102,11 @@ struct StringIteratorExpr : public StringExpr #ifdef CPPIA_JIT static hx::Object *SLJIT_CALL run(String *inValue) { + TRY_NATIVE String value = JitLoad(inValue); return ( KEYS ? value.keyValueIterator() : value.iterator() ).mPtr; + CATCH_NATIVE + return 0; } void genCode(CppiaCompiler *compiler, const JitVal &inDest,ExprType destType) HXCPP_OVERRIDE @@ -111,6 +114,7 @@ struct StringIteratorExpr : public StringExpr JitTemp value(compiler,jtString); strVal->genCode(compiler, value, etString); compiler->callNative( (void *)run, value); + compiler->checkException(); compiler->convertReturnReg(etObject, inDest, destType); } #endif diff --git a/src/hx/gc/Immix.cpp b/src/hx/gc/Immix.cpp index 96dd27863..5a17130d8 100644 --- a/src/hx/gc/Immix.cpp +++ b/src/hx/gc/Immix.cpp @@ -1433,6 +1433,11 @@ struct BlockDataInfo // When known to be an actual object start... AllocType GetAllocTypeChecked(uintptr_t inOffset, bool allowPrevious) const { + // Where an object moved out, not an object: its mark byte is 0, which + // passes for the previous mark one collection in 16 + if (*reinterpret_cast(mPtr->mData + inOffset) == IMMIX_OBJECT_HAS_MOVED) + return allocNone; + unsigned char time{ mPtr->mData[inOffset + HX_ENDIAN_MARK_ID_BYTE_HEADER] }; if (((time + 1) & MARK_BYTE_MASK) != (gByteMarkID & MARK_BYTE_MASK)) { @@ -5129,6 +5134,11 @@ class GlobalAllocator header = IMMIX_OBJECT_HAS_MOVED; moveObjs++; + // The block's own start bit goes too: when the to blocks run + // out, this block is kept in part, and a start left here + // would have the next collection take the moved header for + // an object of 254 rows, marking rows past the row table + allocStart[r] &= ~(1u< pipeCalls; std::atomic closing; + // The same for the writes to stdin alone, which stdin_close cancels + std::atomic stdinCalls; + std::atomic stdinClosing; #define HANDLE_INIT 0 #else int oread; @@ -221,6 +224,8 @@ struct vprocess : public hx::Object #ifdef NEKO_WINDOWS pipeCalls = 0; closing = false; + stdinCalls = 0; + stdinClosing = false; #else reaped = false; exitStatus = 0; @@ -309,12 +314,20 @@ struct PipeCall { vprocess *process; HANDLE handle; - PipeCall(vprocess *inProcess, HANDLE inHandle) : process(inProcess) + bool stdinWrite; + PipeCall(vprocess *inProcess, HANDLE inHandle, bool inStdinWrite=false) : process(inProcess), stdinWrite(inStdinWrite) { process->pipeCalls++; - handle = process->closing ? 0 : inHandle; + if (stdinWrite) + process->stdinCalls++; + handle = process->closing || (stdinWrite && process->stdinClosing) ? 0 : inHandle; + } + ~PipeCall() + { + if (stdinWrite) + process->stdinCalls--; + process->pipeCalls--; } - ~PipeCall() { process->pipeCalls--; } }; #endif @@ -903,7 +916,7 @@ int _hx_std_process_stdin_write( Dynamic handle, Array buf, int p DWORD nbytes =0; bool written; { - PipeCall call(p, p->iwrite); + PipeCall call(p, p->iwrite, true); written = call.handle && WriteFile(call.handle,src+pos,len,&nbytes,0); } if( !written ) @@ -938,7 +951,20 @@ void _hx_std_process_stdin_close( Dynamic handle ) #ifdef NEKO_WINDOWS if ( p->iwrite ) + { + // CloseHandle waits for a WriteFile in progress on the pipe in another + // thread, for as long as the child does not read, so the writes are + // refused and cancelled first, as destroy does for all the pipes. It + // waits in a zone, so a collection meanwhile need not wait for it + hx::AutoGCFreeZone zone; + p->stdinClosing = true; + for(int spins=0; p->stdinCalls>0; spins++) + { + CancelIoEx(p->iwrite, 0); + Sleep(spins<10 ? 0 : 1); + } CloseHandle(p->iwrite); + } #else if( p->iwrite!=-1 ) do_close(p->iwrite); diff --git a/test/regression/AtomicSpinSafePoint/Main.hx b/test/regression/AtomicSpinSafePoint/Main.hx new file mode 100644 index 000000000..74db08d92 --- /dev/null +++ b/test/regression/AtomicSpinSafePoint/Main.hx @@ -0,0 +1,54 @@ +import cpp.vm.Gc; +import haxe.atomic.AtomicInt; +import sys.thread.Thread; + +// libhxcpp #455. A thread spins on haxe.atomic.AtomicInt.load(), waiting for a +// flag the main thread sets after a collection. Haxe 4's AtomicInt calls the +// _hx_atomic_* functions, which were not safe points, so the collection waited +// for the spinning thread for ever. A native watchdog, which the collector +// does not know, ends the test if that happens again. +@:cppFileCode(' +#include +#include +#include +#include +#include +static std::atomic gCollected(false); +static void startWatchdog() +{ + std::thread([]{ + std::this_thread::sleep_for(std::chrono::seconds(60)); + if (!gCollected) + { + fputs("no collection after 60 s\\n", stdout); + fflush(stdout); + std::_Exit(1); + } + }).detach(); +} +') +class Main { + static var flag = new AtomicInt(0); + static var started = new AtomicInt(0); + static var spins = new AtomicInt(0); + + static function main() { + untyped __cpp__("startWatchdog()"); + var done = new sys.thread.Lock(); + Thread.create(() -> { + started.store(1); + while (flag.load() == 0) + spins.add(1); + done.release(); + }); + while (started.load() == 0) + Sys.sleep(0.001); + Sys.sleep(0.1); + Gc.run(true); + untyped __cpp__("gCollected = true"); + Sys.println("collected while a thread spun on an AtomicInt"); + flag.store(1); + done.wait(); + Sys.println("the spinning thread saw the flag"); + } +} diff --git a/test/regression/AtomicSpinSafePoint/build.hxml b/test/regression/AtomicSpinSafePoint/build.hxml new file mode 100644 index 000000000..b484e67e7 --- /dev/null +++ b/test/regression/AtomicSpinSafePoint/build.hxml @@ -0,0 +1,2 @@ +-m Main +--cpp bin diff --git a/test/regression/AtomicSpinSafePoint/stdout.txt b/test/regression/AtomicSpinSafePoint/stdout.txt new file mode 100644 index 000000000..b808c6ac2 --- /dev/null +++ b/test/regression/AtomicSpinSafePoint/stdout.txt @@ -0,0 +1,2 @@ +collected while a thread spun on an AtomicInt +the spinning thread saw the flag diff --git a/test/regression/CppiaArrayWrites/Main.hx b/test/regression/CppiaArrayWrites/Main.hx new file mode 100644 index 000000000..e1b4cc7a2 --- /dev/null +++ b/test/regression/CppiaArrayWrites/Main.hx @@ -0,0 +1,13 @@ +// Runs the script interpreted and then under the JIT +function main() { + var script = haxe.io.Path.join([haxe.io.Path.directory(Sys.programPath()), "script.cppia"]); + for (jit in [false, true]) { + cpp.cppia.Host.enableJit(jit); + Sys.println(jit ? "jit" : "interpreted"); + try { + cpp.cppia.Host.runFile(script); + } catch (e:Dynamic) { + Sys.println("error: " + e); + } + } +} diff --git a/test/regression/CppiaArrayWrites/Script.hx b/test/regression/CppiaArrayWrites/Script.hx new file mode 100644 index 000000000..941862872 --- /dev/null +++ b/test/regression/CppiaArrayWrites/Script.hx @@ -0,0 +1,70 @@ +// libhxcpp #463: array builtins that wrote to the wrong memory. +// - Under the JIT, a[i]++ used as a Float stored its result through whatever +// the third argument register held. +// - Under the JIT, a typed push made room before running its argument, so an +// argument that grew the array left too little room. +// - Interpreted, a[i] = rhs found the element before running rhs, so an rhs +// that grew the array stored into the old buffer. +class Script { + static var spy:Array; + static var arr:Array; + + static function main() { + crements(); + pushes(); + stores(); + } + + static function crements() { + var f:Array = [1.5, 2.5]; + var x:Float = f[0]++; + var y:Float = ++f[1]; + Sys.println("float crement: x=" + x + " y=" + y + " " + f); + var a = [10, 20]; + var x:Float = a[0]++; + var y:Float = --a[1]; + Sys.println("int crement: x=" + x + " y=" + y + " " + a); + } + + // Grows a to exactly its capacity, then puts spy's buffer right after it + static function grow(a:Array):String { + a.resize(a.length + 100); + spy.resize(4); + return "pushed"; + } + + static function growInt(a:Array):Int { + a.resize(a.length + 101); + spy.resize(4); + return 0x7777; + } + + static function pushes() { + spy = []; + var a = ["x"]; + a.push(grow(a)); + Sys.println("push string: length=" + a.length + " last=" + a[a.length - 1] + " spy=" + spy); + spy = []; + var b = [1]; + b.push(growInt(b)); + Sys.println("push int: length=" + b.length + " last=" + b[b.length - 1] + " spy=" + spy); + } + + static function growAndGet():Int { + for (i in 0...1000) + arr.push(i); + return 42; + } + + static function stores() { + arr = [1, 2, 3]; + arr[0] = growAndGet(); + Sys.println("store: " + arr[0] + " length=" + arr.length); + arr = [1, 2, 3]; + arr[0] += growAndGet(); + Sys.println("compound store: " + arr[0]); + arr = [1, 2, 3]; + arr[arr.length] = arr.length; + Sys.println("store past the end: " + arr); + } +} diff --git a/test/regression/CppiaArrayWrites/build.hxml b/test/regression/CppiaArrayWrites/build.hxml new file mode 100644 index 000000000..d20d36bd4 --- /dev/null +++ b/test/regression/CppiaArrayWrites/build.hxml @@ -0,0 +1,7 @@ +--main Script +-cppia bin/script.cppia +--next +--main Main +-cpp bin +-D scriptable +--dce no diff --git a/test/regression/CppiaArrayWrites/stdout.txt b/test/regression/CppiaArrayWrites/stdout.txt new file mode 100644 index 000000000..ba3d97ced --- /dev/null +++ b/test/regression/CppiaArrayWrites/stdout.txt @@ -0,0 +1,16 @@ +interpreted +float crement: x=1.5 y=3.5 [2.5,3.5] +int crement: x=10 y=19 [11,19] +push string: length=102 last=pushed spy=[0,0,0,0] +push int: length=103 last=30583 spy=[0,0,0,0] +store: 42 length=1003 +compound store: 43 +store past the end: [1,2,3,3] +jit +float crement: x=1.5 y=3.5 [2.5,3.5] +int crement: x=10 y=19 [11,19] +push string: length=102 last=pushed spy=[0,0,0,0] +push int: length=103 last=30583 spy=[0,0,0,0] +store: 42 length=1003 +compound store: 43 +store past the end: [1,2,3,3] diff --git a/test/regression/CppiaInterfaceSlots/Main.hx b/test/regression/CppiaInterfaceSlots/Main.hx new file mode 100644 index 000000000..e1b4cc7a2 --- /dev/null +++ b/test/regression/CppiaInterfaceSlots/Main.hx @@ -0,0 +1,13 @@ +// Runs the script interpreted and then under the JIT +function main() { + var script = haxe.io.Path.join([haxe.io.Path.directory(Sys.programPath()), "script.cppia"]); + for (jit in [false, true]) { + cpp.cppia.Host.enableJit(jit); + Sys.println(jit ? "jit" : "interpreted"); + try { + cpp.cppia.Host.runFile(script); + } catch (e:Dynamic) { + Sys.println("error: " + e); + } + } +} diff --git a/test/regression/CppiaInterfaceSlots/Script.hx b/test/regression/CppiaInterfaceSlots/Script.hx new file mode 100644 index 000000000..ee0de9cde --- /dev/null +++ b/test/regression/CppiaInterfaceSlots/Script.hx @@ -0,0 +1,67 @@ +// libhxcpp #462. A script interface's first method that the host does not +// know got the interface slot of the host's last interface method, which in +// this host is IMap's clear, so a class implementing both had fooOnly and +// clear in one slot, and calls through one interface ran the other's method. +interface IFoo { + function fooOnly():String; +} + +interface IBar { + function barOnly():String; +} + +class Both implements IFoo implements IBar implements haxe.Constraints.IMap { + public var log = ""; + + public function new() {} + + public function fooOnly():String + return "fooOnly"; + + public function barOnly():String + return "barOnly"; + + public function get(k:String):Null + return 1; + + public function set(k:String, v:Int):Void {} + + public function exists(k:String):Bool + return true; + + public function remove(k:String):Bool + return false; + + public function keys():Iterator + return [].iterator(); + + public function iterator():Iterator + return [].iterator(); + + public function keyValueIterator():KeyValueIterator + return null; + + public function copy():haxe.Constraints.IMap + return this; + + public function toString():String + return "Both"; + + public function clear():Void { + log += "clear "; + } +} + +class Script { + static function main() { + var b = new Both(); + var f:IFoo = b; + var g:IBar = b; + var m:haxe.Constraints.IMap = b; + Sys.println("IFoo.fooOnly: " + f.fooOnly()); + Sys.println("IBar.barOnly: " + g.barOnly()); + m.clear(); + Sys.println("after IMap.clear: " + b.log); + Sys.println("IMap.exists: " + m.exists("k")); + } +} diff --git a/test/regression/CppiaInterfaceSlots/build.hxml b/test/regression/CppiaInterfaceSlots/build.hxml new file mode 100644 index 000000000..d20d36bd4 --- /dev/null +++ b/test/regression/CppiaInterfaceSlots/build.hxml @@ -0,0 +1,7 @@ +--main Script +-cppia bin/script.cppia +--next +--main Main +-cpp bin +-D scriptable +--dce no diff --git a/test/regression/CppiaInterfaceSlots/stdout.txt b/test/regression/CppiaInterfaceSlots/stdout.txt new file mode 100644 index 000000000..bb1004221 --- /dev/null +++ b/test/regression/CppiaInterfaceSlots/stdout.txt @@ -0,0 +1,10 @@ +interpreted +IFoo.fooOnly: fooOnly +IBar.barOnly: barOnly +after IMap.clear: clear +IMap.exists: true +jit +IFoo.fooOnly: fooOnly +IBar.barOnly: barOnly +after IMap.clear: clear +IMap.exists: true diff --git a/test/regression/CppiaJitHelperExceptions/Main.hx b/test/regression/CppiaJitHelperExceptions/Main.hx new file mode 100644 index 000000000..e1b4cc7a2 --- /dev/null +++ b/test/regression/CppiaJitHelperExceptions/Main.hx @@ -0,0 +1,13 @@ +// Runs the script interpreted and then under the JIT +function main() { + var script = haxe.io.Path.join([haxe.io.Path.directory(Sys.programPath()), "script.cppia"]); + for (jit in [false, true]) { + cpp.cppia.Host.enableJit(jit); + Sys.println(jit ? "jit" : "interpreted"); + try { + cpp.cppia.Host.runFile(script); + } catch (e:Dynamic) { + Sys.println("error: " + e); + } + } +} diff --git a/test/regression/CppiaJitHelperExceptions/Script.hx b/test/regression/CppiaJitHelperExceptions/Script.hx new file mode 100644 index 000000000..f3085932d --- /dev/null +++ b/test/regression/CppiaJitHelperExceptions/Script.hx @@ -0,0 +1,67 @@ +// libhxcpp #465: exceptions from the native helpers jitted code calls. +// - Some helpers caught the exception into the context, but the jitted code +// did not check for it, and ran on past the throw. The exception was held +// only by the context, which the collector did not mark, so allocating +// before the catch could free it. +// - Others did not catch at all, so the exception unwound through the jitted +// frames, past the script's catch. +// Each case catches in its own function, interpreted and under the JIT, and +// counts the statements that ran after the throw. +class Thrower { + public function new() {} + + public function toString():String + throw "toString threw"; +} + +class Script { + static var ranOn = 0; + + static function fieldAdd():String { + try { + var d:Dynamic = {s: "a"}; + var t:Dynamic = new Thrower(); + d.s += t; + ranOn++; + var parts = new Array(); + for (i in 0...100000) + parts.push("x" + i); + ranOn += parts.length > 0 ? 1 : 0; + return "no exception"; + } catch (e:Dynamic) { + return "caught " + e; + } + } + + static function dynamicAdd():String { + try { + var d:Dynamic = "x"; + var t:Dynamic = new Thrower(); + d += t; + ranOn++; + return "no exception"; + } catch (e:Dynamic) { + return "caught " + e; + } + } + + static function dynamicIndexAdd():String { + try { + var d:Dynamic = ["x"]; + var t:Dynamic = new Thrower(); + d[0] += t; + ranOn++; + return "no exception"; + } catch (e:Dynamic) { + return "caught " + e; + } + } + + static function main() { + for (round in 0...3) + Sys.println("field += throwing toString, then allocating: " + fieldAdd()); + Sys.println("Dynamic += throwing toString: " + dynamicAdd()); + Sys.println("Dynamic index += throwing toString: " + dynamicIndexAdd()); + Sys.println("statements run after a throw: " + ranOn); + } +} diff --git a/test/regression/CppiaJitHelperExceptions/build.hxml b/test/regression/CppiaJitHelperExceptions/build.hxml new file mode 100644 index 000000000..d20d36bd4 --- /dev/null +++ b/test/regression/CppiaJitHelperExceptions/build.hxml @@ -0,0 +1,7 @@ +--main Script +-cppia bin/script.cppia +--next +--main Main +-cpp bin +-D scriptable +--dce no diff --git a/test/regression/CppiaJitHelperExceptions/stdout.txt b/test/regression/CppiaJitHelperExceptions/stdout.txt new file mode 100644 index 000000000..13ffdba2d --- /dev/null +++ b/test/regression/CppiaJitHelperExceptions/stdout.txt @@ -0,0 +1,14 @@ +interpreted +field += throwing toString, then allocating: caught toString threw +field += throwing toString, then allocating: caught toString threw +field += throwing toString, then allocating: caught toString threw +Dynamic += throwing toString: caught toString threw +Dynamic index += throwing toString: caught toString threw +statements run after a throw: 0 +jit +field += throwing toString, then allocating: caught toString threw +field += throwing toString, then allocating: caught toString threw +field += throwing toString, then allocating: caught toString threw +Dynamic += throwing toString: caught toString threw +Dynamic index += throwing toString: caught toString threw +statements run after a throw: 0 diff --git a/test/regression/FinalizersAcrossFreeZones/Main.hx b/test/regression/FinalizersAcrossFreeZones/Main.hx index 7aa34ff26..d3ff838ce 100644 --- a/test/regression/FinalizersAcrossFreeZones/Main.hx +++ b/test/regression/FinalizersAcrossFreeZones/Main.hx @@ -15,8 +15,7 @@ class Item { class Main { // Finalizers run inside a collection, one collection at a time and under - // the collector's lock, so the count needs no lock of its own; taking a - // Mutex there would reach a safe point from inside the collection. + // the collector's lock, so the count needs no lock of its own. static var finalized = 0; static function onFinalize(item:Item):Void { diff --git a/test/regression/GcFinalizerTakesMutex/Main.hx b/test/regression/GcFinalizerTakesMutex/Main.hx new file mode 100644 index 000000000..f5b868cb7 --- /dev/null +++ b/test/regression/GcFinalizerTakesMutex/Main.hx @@ -0,0 +1,43 @@ +import sys.thread.Mutex; + +class Resource { + public function new() {} +} + +// libhxcpp #452. A finalizer runs on the collecting thread, inside the +// collection. Mutex stops at a pending collection on its uncontended paths, +// and that stop took the collecting thread for one that had to wait, ending +// the process with "Bad Allocation while collecting". Stock hxcpp took the +// lock in a GC-free zone, which the collecting thread can enter, so a +// finalizer could take a Mutex. It still must not allocate. +class Main { + static var lock = new Mutex(); + static var counted = 0; + static var tried = 0; + + static function onFinalize(r:Resource):Void { + lock.acquire(); + counted++; + lock.release(); + if (lock.tryAcquire()) { + tried++; + lock.release(); + } + } + + static function make() { + for (i in 0...1000) { + var r = new Resource(); + cpp.vm.Gc.setFinalizer(r, cpp.Callable.fromStaticFunction(onFinalize)); + } + } + + static function main() { + make(); + cpp.vm.Gc.run(true); + cpp.vm.Gc.run(true); + // The conservative stack scan may keep a few alive + Sys.println("finalizers took the mutex: " + (counted > 900)); + Sys.println("finalizers tried it: " + (tried == counted)); + } +} diff --git a/test/regression/GcFinalizerTakesMutex/build.hxml b/test/regression/GcFinalizerTakesMutex/build.hxml new file mode 100644 index 000000000..b484e67e7 --- /dev/null +++ b/test/regression/GcFinalizerTakesMutex/build.hxml @@ -0,0 +1,2 @@ +-m Main +--cpp bin diff --git a/test/regression/GcFinalizerTakesMutex/stdout.txt b/test/regression/GcFinalizerTakesMutex/stdout.txt new file mode 100644 index 000000000..211ba2930 --- /dev/null +++ b/test/regression/GcFinalizerTakesMutex/stdout.txt @@ -0,0 +1,2 @@ +finalizers took the mutex: true +finalizers tried it: true diff --git a/test/regression/GcMovedStartBits/Main.hx b/test/regression/GcMovedStartBits/Main.hx new file mode 100644 index 000000000..455a38632 --- /dev/null +++ b/test/regression/GcMovedStartBits/Main.hx @@ -0,0 +1,154 @@ +import cpp.vm.Gc; + +class Item { + public var x:Int; + public var y:Int; + public var z:Float; + public var next:Item; + + public function new(i:Int) { + x = i; + } +} + +class Filler { + public var a:Int = 0; + public var b:Int = 0; + public var c:Int = 0; + public var d:Int = 0; + public var e:Int = 0; + public var f:Int = 0; + + public function new() {} +} + +// libhxcpp #450. A moving collection that runs out of blocks to move into +// keeps the block it was emptying, in part. That block kept the start bits of +// the objects it had moved out, whose headers say they moved. A stale word on +// the stack still holding one of those addresses then had the next collection +// take the moved header for an object of 254 rows, and mark rows past the +// block's row table, over the objects in its first rows. +// +// Old addresses are kept encoded, so the collector does not see them, and put +// on the stack only for the collections below, as stale slots of a deeper call +// would be on a real stack. +@:cppFileCode(' +#include +#include +#include +static std::vector gOld; +static std::vector gStale; +static std::vector gNow; +static int gPartial = 0; +static void recordOld(hx::Object *o) { gOld.push_back(~(uintptr_t)o); } +static void recordNow(hx::Object *o) { gNow.push_back(~(uintptr_t)o); } +// Reads headers in blocks the collector may be zeroing on its own thread, on +// purpose, which ThreadSanitizer would report +#if defined(__GNUC__) || defined(__clang__) +__attribute__((noinline, no_sanitize("thread"))) +#endif +static unsigned int headerAt(uintptr_t p) { return ((unsigned int *)p)[-1]; } +// The moved-out addresses in blocks that kept some of their objects +static int pickStale() +{ + enum { BLOCK = 1<<15 }; + std::map flags; + int n = (int)gOld.size(); + for(int i=0;i::iterator f=flags.begin(); f!=flags.end(); ++f) + if (f->second==3) + gPartial++; + gStale.clear(); + for(int i=0;i>24)!=0) + n++; + } + return n; +} +static void collectWithStale() +{ + volatile uintptr_t slots[4096]; + size_t n = gStale.size(); + for(size_t i=0;i = []; + var junk:Array = []; + for (i in 0...300000) { + var it = new Item(i); + if (i % 3 == 2) + junk.push(it); + else + keep.push(it); + } + junk = null; + + // The collection after the moving one takes a mark byte of 0 for the + // previous mark when its mark id ends in 1 + while (markNibble() != 15) + Gc.run(false); + + for (it in keep) + untyped __cpp__("recordOld({0}.mPtr)", it); + Gc.run(true); + for (it in keep) + untyped __cpp__("recordNow({0}.mPtr)", it); + var stale:Int = untyped __cpp__("pickStale()"); + var partial:Int = untyped __cpp__("gPartial"); + Sys.stderr().writeString('partly emptied blocks: $partial, moved-out addresses: $stale\n'); + + var fillers = new haxe.ds.Vector(40000); + untyped __cpp__("collectWithStale()"); + // Nothing else allocates before the fillers take the rows the moved objects left + for (i in 0...fillers.length) + fillers[i] = new Filler(); + Sys.println("moved-out locations marked as objects: " + untyped __cpp__("remarked()")); + untyped __cpp__("collectWithStale()"); + Sys.println("moved-out locations marked as objects, again: " + untyped __cpp__("remarked()")); + + var bad = 0; + for (f in fillers) + if (f.a != 0 || f.b != 0 || f.c != 0 || f.d != 0 || f.e != 0 || f.f != 0) + bad++; + Sys.println("fillers changed: " + bad); + var wrong = 0; + for (i in 0...keep.length) + if (keep[i].x != ((i >> 1) * 3) + (i & 1)) + wrong++; + Sys.println("kept items with a wrong value: " + wrong); + } +} diff --git a/test/regression/GcMovedStartBits/build.hxml b/test/regression/GcMovedStartBits/build.hxml new file mode 100644 index 000000000..d97fb6164 --- /dev/null +++ b/test/regression/GcMovedStartBits/build.hxml @@ -0,0 +1,3 @@ +-m Main +--cpp bin +-D HXCPP_GC_MOVING diff --git a/test/regression/GcMovedStartBits/stdout.txt b/test/regression/GcMovedStartBits/stdout.txt new file mode 100644 index 000000000..441c15b4b --- /dev/null +++ b/test/regression/GcMovedStartBits/stdout.txt @@ -0,0 +1,4 @@ +moved-out locations marked as objects: 0 +moved-out locations marked as objects, again: 0 +fillers changed: 0 +kept items with a wrong value: 0 diff --git a/test/regression/GcStdoutBlocked/Main.hx b/test/regression/GcStdoutBlocked/Main.hx new file mode 100644 index 000000000..01f5c79f7 --- /dev/null +++ b/test/regression/GcStdoutBlocked/Main.hx @@ -0,0 +1,58 @@ +import cpp.vm.Gc; +import sys.io.Process; +import sys.thread.Lock; +import sys.thread.Thread; + +// libhxcpp #454. A child process whose stdout nobody reads: one of its threads +// prints until the pipe is full and the write blocks, then its main thread +// collects. trace and Sys.println wrote outside a GC-free zone, so the +// collection waited for the blocked writer, and every other thread with it. +// Sys.stdout().writeString blocked inside one and was fine. +class Main { + static function main() { + var args = Sys.args(); + if (args.length == 0) + parent(); + else + child(args[0]); + } + + static function parent() { + for (mode in ["write", "println", "trace"]) { + var p = new Process(Sys.programPath(), [mode]); + var got = new Lock(); + var line = "(nothing)"; + Thread.create(() -> { + try { + line = p.stderr.readLine(); + } catch (e:Dynamic) {} + got.release(); + }); + if (got.wait(20.0)) + Sys.println('$mode: child said $line'); + else + Sys.println('$mode: no collection after 20 s'); + p.kill(); + p.close(); + } + } + + static function child(mode:String) { + var text = StringTools.lpad("", "x", 1000); + Thread.create(() -> { + while (true) { + switch (mode) { + case "trace": trace(text); + case "println": Sys.println(text); + default: Sys.stdout().writeString(text + "\n"); + } + } + }); + // Long enough for the pipe to fill + Sys.sleep(1.0); + Gc.run(true); + Sys.stderr().writeString('collected\n'); + Sys.stderr().flush(); + Sys.sleep(60); + } +} diff --git a/test/regression/GcStdoutBlocked/build.hxml b/test/regression/GcStdoutBlocked/build.hxml new file mode 100644 index 000000000..b484e67e7 --- /dev/null +++ b/test/regression/GcStdoutBlocked/build.hxml @@ -0,0 +1,2 @@ +-m Main +--cpp bin diff --git a/test/regression/GcStdoutBlocked/stdout.txt b/test/regression/GcStdoutBlocked/stdout.txt new file mode 100644 index 000000000..4df2d8c27 --- /dev/null +++ b/test/regression/GcStdoutBlocked/stdout.txt @@ -0,0 +1,3 @@ +write: child said collected +println: child said collected +trace: child said collected diff --git a/test/regression/ProcessStdinCloseCollects/Main.hx b/test/regression/ProcessStdinCloseCollects/Main.hx new file mode 100644 index 000000000..73a754c4c --- /dev/null +++ b/test/regression/ProcessStdinCloseCollects/Main.hx @@ -0,0 +1,52 @@ +import cpp.vm.Gc; +import haxe.io.Bytes; +import sys.io.Process; +import sys.thread.Lock; +import sys.thread.Thread; + +// libhxcpp #454. One thread is blocked writing to a child's stdin, which the +// child never reads, and another closes that stdin. On Windows, CloseHandle +// waits for the WriteFile in progress, and stdin.close called it outside a +// GC-free zone, so a collection started meanwhile, and the close itself, +// waited until the child exited. Process.close cancelled pending pipe I/O +// first (#261); stdin.close now does too. +class Main { + static function main() { + if (Sys.args().length > 0) { + Sys.sleep(Std.parseFloat(Sys.args()[0])); + return; + } + // Elsewhere close does not wait for a write in progress, and closing a + // descriptor another thread is writing to is a race of the test's own + if (Sys.systemName() != "Windows") { + Sys.println("collected while the child ran: true"); + Sys.println("stdin closed while the child ran: true"); + return; + } + var p = new Process(Sys.programPath(), ["30"]); + var writerDone = new Lock(); + Thread.create(() -> { + try { + p.stdin.write(Bytes.alloc(1 << 22)); + } catch (e:Dynamic) {} + writerDone.release(); + }); + Sys.sleep(0.5); + var closed = new Lock(); + var closedWhileRunning = false; + Thread.create(() -> { + p.stdin.close(); + closedWhileRunning = p.exitCode(false) == null; + closed.release(); + }); + Sys.sleep(0.5); + Gc.run(true); + var collectedWhileRunning = p.exitCode(false) == null; + closed.wait(); + Sys.println("collected while the child ran: " + collectedWhileRunning); + Sys.println("stdin closed while the child ran: " + closedWhileRunning); + p.kill(); + writerDone.wait(); + p.close(); + } +} diff --git a/test/regression/ProcessStdinCloseCollects/build.hxml b/test/regression/ProcessStdinCloseCollects/build.hxml new file mode 100644 index 000000000..b484e67e7 --- /dev/null +++ b/test/regression/ProcessStdinCloseCollects/build.hxml @@ -0,0 +1,2 @@ +-m Main +--cpp bin diff --git a/test/regression/ProcessStdinCloseCollects/stdout.txt b/test/regression/ProcessStdinCloseCollects/stdout.txt new file mode 100644 index 000000000..cf983ae06 --- /dev/null +++ b/test/regression/ProcessStdinCloseCollects/stdout.txt @@ -0,0 +1,2 @@ +collected while the child ran: true +stdin closed while the child ran: true diff --git a/test/regression/emscripten-skip.txt b/test/regression/emscripten-skip.txt index 6342a8d49..48a985cea 100644 --- a/test/regression/emscripten-skip.txt +++ b/test/regression/emscripten-skip.txt @@ -6,6 +6,7 @@ AnonConcurrentString: threads ArrayConcurrentString: threads +AtomicSpinSafePoint: threads (std::thread, which needs a pthreads build) AttachedThreadId: threads (std::thread, which needs a pthreads build) CffiNekoNullBoolWithoutInit: runs neko, which loads an ndll the test builds CffiNekoValueTags: runs neko, which loads an ndll the test builds @@ -45,6 +46,7 @@ GcRunKeepsHeap: expects the desktop 20 MB working target; other platforms, Emscr GcScopeOwnership: counts thread attachments, which single-threaded Emscripten builds do not make GcSmallNursery: threads (std::thread, which needs a pthreads build) GcStackLargeContainer: threads (std::thread, which needs a pthreads build) +GcStdoutBlocked: processes (runs itself) and threads GcTraceDeepGraph: processes (runs itself) and threads (std::thread, which needs a pthreads build) GcTraceLargeObjects: processes (runs itself) GcWeakMapChain: threads @@ -84,6 +86,7 @@ ProcessExitCodeTwice: processes ProcessPosixStartError: processes ProcessReapAfterClose: processes ProcessSigpipeHandler: processes +ProcessStdinCloseCollects: processes and threads ProcessWaitError: processes PthreadFastTls: threads RegexpConcurrentCollection: threads diff --git a/toolchain/msvc-toolchain.xml b/toolchain/msvc-toolchain.xml index 23b839431..05ef6c61c 100644 --- a/toolchain/msvc-toolchain.xml +++ b/toolchain/msvc-toolchain.xml @@ -119,7 +119,10 @@ - + + @@ -136,8 +139,6 @@ fuzzer-no-link too. The objects name the runtime libraries for link.exe --> - -