ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-01-06 05:04:20 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
5399c6bdbb
corda/src/thunks.cpp

74 lines
1.8 KiB
C++
Raw Normal View History

improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(tryInitClass)
THUNK(findInterfaceMethodFromInstance)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(findInterfaceMethodFromInstanceAndReference)
THUNK(findSpecialMethodFromReference)
THUNK(findStaticMethodFromReference)
THUNK(findVirtualMethodFromReference)
fix crash when encountering invokespecial call to abstract method We must throw an AbstractMethodError when such a call is executed (not when the call is compiled), so we compile this case as a call to a thunk which throws such an error.
2011-07-18 01:54:55 +00:00
THUNK(getMethodAddress)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(compareDoublesG)
THUNK(compareDoublesL)
THUNK(compareFloatsG)
THUNK(compareFloatsL)
snapshot
2009-10-07 00:50:32 +00:00
THUNK(compareLongs)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(addDouble)
THUNK(subtractDouble)
THUNK(multiplyDouble)
THUNK(divideDouble)
THUNK(moduloDouble)
THUNK(negateDouble)
refactor intrinsic support This ensures that the low-level, architecture specific code need not be aware of the semantics and names of Java methods.
2009-10-18 01:26:14 +00:00
THUNK(squareRootDouble)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(doubleToFloat)
THUNK(doubleToInt)
THUNK(doubleToLong)
THUNK(addFloat)
THUNK(subtractFloat)
THUNK(multiplyFloat)
THUNK(divideFloat)
THUNK(moduloFloat)
THUNK(negateFloat)
refactor intrinsic support This ensures that the low-level, architecture specific code need not be aware of the semantics and names of Java methods.
2009-10-18 01:26:14 +00:00
THUNK(absoluteFloat)
powerpc bugfixes
2009-12-01 16:21:33 +00:00
THUNK(absoluteLong)
THUNK(absoluteInt)
always return an 8-byte value (or void) from native functions called from Java This is important on the 32-bit OS X PowerPC ABI, since the location of the low 32-bits of a return value change depending on whether the entire value is 64-bits or not.
2009-02-28 21:20:43 +00:00
THUNK(divideLong)
ARM port work
2009-10-29 16:12:30 +00:00
THUNK(divideInt)
always return an 8-byte value (or void) from native functions called from Java This is important on the 32-bit OS X PowerPC ABI, since the location of the low 32-bits of a return value change depending on whether the entire value is 64-bits or not.
2009-02-28 21:20:43 +00:00
THUNK(moduloLong)
moduloInt + arm work
2009-10-29 20:14:44 +00:00
THUNK(moduloInt)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(floatToDouble)
THUNK(floatToInt)
THUNK(floatToLong)
THUNK(intToDouble)
THUNK(intToFloat)
THUNK(longToDouble)
THUNK(longToFloat)
THUNK(makeBlankObjectArray)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(makeBlankObjectArrayFromReference)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(makeBlankArray)
THUNK(lookUpAddress)
THUNK(setMaybeNull)
THUNK(acquireMonitorForObject)
don't try to release monitor if we get OOME when trying to acquire it We can't blindly try release the monitors for all synchronized methods when unwinding the stack since we may not have finished acquiring the most recent one when the exception was thrown.
2011-03-26 00:37:02 +00:00
THUNK(acquireMonitorForObjectOnEntrance)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(releaseMonitorForObject)
THUNK(makeMultidimensionalArray)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(makeMultidimensionalArrayFromReference)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(throw_)
THUNK(checkCast)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(checkCastFromReference)
THUNK(getStaticFieldValueFromReference)
THUNK(getFieldValueFromReference)
THUNK(setStaticFieldValueFromReference)
THUNK(setFieldValueFromReference)
THUNK(setStaticLongFieldValueFromReference)
THUNK(setLongFieldValueFromReference)
THUNK(setStaticObjectFieldValueFromReference)
THUNK(setObjectFieldValueFromReference)
always return an 8-byte value (or void) from native functions called from Java This is important on the 32-bit OS X PowerPC ABI, since the location of the low 32-bits of a return value change depending on whether the entire value is 64-bits or not.
2009-02-28 21:20:43 +00:00
THUNK(instanceOf64)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(instanceOfFromReference)
implement basic finalization support This implementation does not conform to the Java standard in that finalize methods are called from whichever thread happens to be garbage collecting, and that thread may hold locks, whereas the standard guarantees that finalize will be run from a thread which holds no locks. Also, an object will never be finalized more than once, even if its finalize method "rescues" (i.e. makes reachable) the object such that it might become unreachable a second time and thus a candidate for finalization once more. It's not clear to me from the standard if this is OK or not. Nonwithstanding the above, this implementation is useful for "normal" finalize methods which simply release resources associated with an object.
2009-07-22 00:57:55 +00:00
THUNK(makeNewGeneral64)
always return an 8-byte value (or void) from native functions called from Java This is important on the 32-bit OS X PowerPC ABI, since the location of the low 32-bits of a return value change depending on whether the entire value is 64-bits or not.
2009-02-28 21:20:43 +00:00
THUNK(makeNew64)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(makeNewFromReference)
add util.cpp/.h changes
2014-06-28 20:41:27 +00:00
THUNK(setObject)
fix PowerPC build
2010-12-03 20:42:13 +00:00
THUNK(getJClass64)
implement lazy class/field/method resolution in JIT compiler Unlike the interpreter, the JIT compiler tries to resolve all the symbols referenced by a method when compiling that method. However, this can backfire if a symbol cannot be resolved: we end up throwing an e.g. NoClassDefFoundError for code which may never be executed. This is particularly troublesome for code which supports multiple APIs, choosing one at runtime. The solution is to defer to stub code for symbols which can't be resolved at JIT compile time. Such a stub will try again at runtime to resolve the needed symbol and throw an appropriate error if it still can't be found.
2011-03-15 23:52:02 +00:00
THUNK(getJClassFromReference)
improve efficiency of array bounds checks and generate a thunk table for native functions called indirectly
2008-05-31 22:14:27 +00:00
THUNK(gcIfNecessary)
make sure a busy-waiting loop can't block the GC (and hence the whole VM)
2013-12-13 17:39:36 +00:00
THUNK(idleIfNecessary)
Reference in New Issue Copy Permalink