diff options
| author | 2018-02-06 16:02:49 +0000 | |
|---|---|---|
| committer | 2018-02-06 16:02:49 +0000 | |
| commit | c4d3bf4eaff9720ed0bb7775db6fc24a1bd755dd (patch) | |
| tree | f84ebefc503e5cffb6df5989979492ae04f85cbb | |
| parent | becc83b59ff703c02198f832dbc3216a0ab8a022 (diff) | |
Revert "ART: Interpreter support for VarHandle accessors"
This reverts commit becc83b59ff703c02198f832dbc3216a0ab8a022.
Reason for revert: breaks on the ART buildbots due to localized toolchain differences.
Change-Id: Ieb1d93b0fc7116ddc542d8bbfee1975bcb30a8f7
29 files changed, 307 insertions, 9377 deletions
diff --git a/runtime/common_throws.cc b/runtime/common_throws.cc index f7ff15fbfd..19e7f7686d 100644 --- a/runtime/common_throws.cc +++ b/runtime/common_throws.cc @@ -53,11 +53,6 @@ static void AddReferrerLocation(std::ostream& os, ObjPtr<mirror::Class> referrer } } -static void ThrowException(const char* exception_descriptor) REQUIRES_SHARED(Locks::mutator_lock_) { - Thread* self = Thread::Current(); - self->ThrowNewException(exception_descriptor, nullptr); -} - static void ThrowException(const char* exception_descriptor, ObjPtr<mirror::Class> referrer, const char* fmt, @@ -248,11 +243,6 @@ void ThrowIllegalArgumentException(const char* msg) { ThrowException("Ljava/lang/IllegalArgumentException;", nullptr, msg); } -// IllegalStateException - -void ThrowIllegalStateException(const char* msg) { - ThrowException("Ljava/lang/IllegalStateException;", nullptr, msg); -} // IncompatibleClassChangeError @@ -324,13 +314,6 @@ void ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod* method) { ArtMethod::PrettyMethod(method).c_str()).c_str()); } -// IndexOutOfBoundsException - -void ThrowIndexOutOfBoundsException(int index, int length) { - ThrowException("Ljava/lang/IndexOutOfBoundsException;", nullptr, - StringPrintf("length=%d; index=%d", length, index).c_str()); -} - // InternalError void ThrowInternalError(const char* fmt, ...) { @@ -736,12 +719,6 @@ void ThrowNullPointerException(const char* msg) { ThrowException("Ljava/lang/NullPointerException;", nullptr, msg); } -// ReadOnlyBufferException - -void ThrowReadOnlyBufferException() { - Thread::Current()->ThrowNewException("Ljava/nio/ReadOnlyBufferException;", nullptr); -} - // RuntimeException void ThrowRuntimeException(const char* fmt, ...) { @@ -865,12 +842,6 @@ void ThrowStringIndexOutOfBoundsException(int index, int length) { StringPrintf("length=%d; index=%d", length, index).c_str()); } -// UnsupportedOperationException - -void ThrowUnsupportedOperationException() { - ThrowException("Ljava/lang/UnsupportedOperationException;"); -} - // VerifyError void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...) { @@ -882,13 +853,13 @@ void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...) { // WrongMethodTypeException -void ThrowWrongMethodTypeException(mirror::MethodType* expected_type, - mirror::MethodType* actual_type) { +void ThrowWrongMethodTypeException(mirror::MethodType* callee_type, + mirror::MethodType* callsite_type) { ThrowException("Ljava/lang/invoke/WrongMethodTypeException;", nullptr, StringPrintf("Expected %s but was %s", - expected_type->PrettyDescriptor().c_str(), - actual_type->PrettyDescriptor().c_str()).c_str()); + callee_type->PrettyDescriptor().c_str(), + callsite_type->PrettyDescriptor().c_str()).c_str()); } } // namespace art diff --git a/runtime/common_throws.h b/runtime/common_throws.h index e9baa4fef0..3512b2b5bf 100644 --- a/runtime/common_throws.h +++ b/runtime/common_throws.h @@ -120,11 +120,6 @@ void ThrowIllegalAccessException(const char* msg) void ThrowIllegalArgumentException(const char* msg) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; -// IllegalAccessException - -void ThrowIllegalStateException(const char* msg) - REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; - // IncompatibleClassChangeError void ThrowIncompatibleClassChangeError(InvokeType expected_type, @@ -156,11 +151,6 @@ void ThrowIncompatibleClassChangeError(ObjPtr<mirror::Class> referrer, const cha void ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; -// IndexOutOfBoundsException - -void ThrowIndexOutOfBoundsException(int index, int length) - REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; - // InternalError void ThrowInternalError(const char* fmt, ...) @@ -233,10 +223,6 @@ void ThrowNullPointerExceptionFromDexPC(bool check_address = false, uintptr_t ad void ThrowNullPointerException(const char* msg) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; -// ReadOnlyBufferException - -void ThrowReadOnlyBufferException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; - // RuntimeException void ThrowRuntimeException(const char* fmt, ...) @@ -258,10 +244,6 @@ void ThrowStackOverflowError(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) void ThrowStringIndexOutOfBoundsException(int index, int length) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; -// UnsupportedOperationException - -void ThrowUnsupportedOperationException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; - // VerifyError void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...) @@ -269,7 +251,6 @@ void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; // WrongMethodTypeException - void ThrowWrongMethodTypeException(mirror::MethodType* callee_type, mirror::MethodType* callsite_type) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR; diff --git a/runtime/dex/dex_instruction.cc b/runtime/dex/dex_instruction.cc index 886218129e..b84791ffae 100644 --- a/runtime/dex/dex_instruction.cc +++ b/runtime/dex/dex_instruction.cc @@ -558,11 +558,4 @@ uint32_t VarArgsInstructionOperands::GetOperand(size_t operand_index) const { return operands_[operand_index]; } -uint32_t NoReceiverInstructionOperands::GetOperand(size_t operand_index) const { - DCHECK_LT(GetNumberOfOperands(), inner_->GetNumberOfOperands()); - // The receiver is the first operand and since we're skipping it, we need to - // add 1 to the operand_index. - return inner_->GetOperand(operand_index + 1); -} - } // namespace art diff --git a/runtime/dex/dex_instruction.h b/runtime/dex/dex_instruction.h index de14ed3c41..8b1a5ce670 100644 --- a/runtime/dex/dex_instruction.h +++ b/runtime/dex/dex_instruction.h @@ -701,7 +701,7 @@ class InstructionOperands { size_t GetNumberOfOperands() const { return num_operands_; } private: - const size_t num_operands_; + size_t num_operands_; DISALLOW_IMPLICIT_CONSTRUCTORS(InstructionOperands); }; @@ -737,21 +737,6 @@ class VarArgsInstructionOperands FINAL : public InstructionOperands { DISALLOW_IMPLICIT_CONSTRUCTORS(VarArgsInstructionOperands); }; -// Class for accessing operands without the receiver by wrapping an -// existing InstructionOperands instance. -class NoReceiverInstructionOperands FINAL : public InstructionOperands { - public: - explicit NoReceiverInstructionOperands(InstructionOperands* inner) - : InstructionOperands(inner->GetNumberOfOperands() - 1), inner_(inner) {} - ~NoReceiverInstructionOperands() {} - uint32_t GetOperand(size_t operand_index) const OVERRIDE; - - private: - const InstructionOperands* const inner_; - - DISALLOW_IMPLICIT_CONSTRUCTORS(NoReceiverInstructionOperands); -}; - } // namespace art #endif // ART_RUNTIME_DEX_DEX_INSTRUCTION_H_ diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc index 91b2d0e1e3..12b8c38bbb 100644 --- a/runtime/interpreter/interpreter_common.cc +++ b/runtime/interpreter/interpreter_common.cc @@ -31,7 +31,6 @@ #include "mirror/class.h" #include "mirror/emulated_stack_frame.h" #include "mirror/method_handle_impl-inl.h" -#include "mirror/var_handle.h" #include "reflection-inl.h" #include "reflection.h" #include "stack.h" @@ -724,149 +723,263 @@ bool DoMethodHandleInvoke(Thread* self, } } -static bool DoVarHandleInvokeChecked(Thread* self, - Handle<mirror::VarHandle> var_handle, - Handle<mirror::MethodType> callsite_type, - mirror::VarHandle::AccessMode access_mode, - ShadowFrame& shadow_frame, - InstructionOperands* operands, - JValue* result) +static bool UnimplementedSignaturePolymorphicMethod(Thread* self ATTRIBUTE_UNUSED, + ShadowFrame& shadow_frame ATTRIBUTE_UNUSED, + const Instruction* inst ATTRIBUTE_UNUSED, + uint16_t inst_data ATTRIBUTE_UNUSED, + JValue* result ATTRIBUTE_UNUSED) REQUIRES_SHARED(Locks::mutator_lock_) { - // TODO(oth): GetMethodTypeForAccessMode() allocates a MethodType() - // which is only required if we need to convert argument and/or - // return types. - StackHandleScope<1> hs(self); - Handle<mirror::MethodType> accessor_type(hs.NewHandle( - var_handle->GetMethodTypeForAccessMode(self, access_mode))); - const size_t num_vregs = accessor_type->NumberOfVRegs(); - const int num_params = accessor_type->GetPTypes()->GetLength(); - ShadowFrameAllocaUniquePtr accessor_frame = - CREATE_SHADOW_FRAME(num_vregs, nullptr, shadow_frame.GetMethod(), shadow_frame.GetDexPC()); - ShadowFrameGetter getter(shadow_frame, operands); - static const uint32_t kFirstDestinationReg = 0; - ShadowFrameSetter setter(accessor_frame.get(), kFirstDestinationReg); - if (!PerformConversions(self, callsite_type, accessor_type, &getter, &setter, num_params)) { - return false; - } - RangeInstructionOperands accessor_operands(kFirstDestinationReg, - kFirstDestinationReg + num_vregs); - if (!var_handle->Access(access_mode, accessor_frame.get(), &accessor_operands, result)) { - return false; - } - return ConvertReturnValue(callsite_type, accessor_type, result); + UNIMPLEMENTED(FATAL) << "TODO(oth): b/65872996"; + return false; } -static bool DoVarHandleInvokeCommon(Thread* self, - ShadowFrame& shadow_frame, - const Instruction* inst, - uint16_t inst_data, - JValue* result, - mirror::VarHandle::AccessMode access_mode) - REQUIRES_SHARED(Locks::mutator_lock_) { - // Make sure to check for async exceptions - if (UNLIKELY(self->ObserveAsyncException())) { - return false; - } +bool DoVarHandleCompareAndExchange(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} - bool is_var_args = inst->HasVarArgs(); - const uint32_t vRegC = is_var_args ? inst->VRegC_45cc() : inst->VRegC_4rcc(); - ObjPtr<mirror::Object> receiver(shadow_frame.GetVRegReference(vRegC)); - if (receiver.IsNull()) { - ThrowNullPointerExceptionFromDexPC(); - return false; - } +bool DoVarHandleCompareAndExchangeAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} - StackHandleScope<2> hs(self); - Handle<mirror::VarHandle> var_handle(hs.NewHandle(down_cast<mirror::VarHandle*>(receiver.Ptr()))); - if (!var_handle->IsAccessModeSupported(access_mode)) { - ThrowUnsupportedOperationException(); - return false; - } +bool DoVarHandleCompareAndExchangeRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} - const uint32_t vRegH = is_var_args ? inst->VRegH_45cc() : inst->VRegH_4rcc(); - ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); - Handle<mirror::MethodType> callsite_type(hs.NewHandle( - class_linker->ResolveMethodType(self, vRegH, shadow_frame.GetMethod()))); - // This implies we couldn't resolve one or more types in this VarHandle. - if (UNLIKELY(callsite_type == nullptr)) { - CHECK(self->IsExceptionPending()); - return false; - } +bool DoVarHandleCompareAndSet(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} - if (!var_handle->IsMethodTypeCompatible(access_mode, callsite_type.Get())) { - ThrowWrongMethodTypeException(var_handle->GetMethodTypeForAccessMode(self, access_mode), - callsite_type.Get()); - return false; - } +bool DoVarHandleGet(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} - if (is_var_args) { - uint32_t args[Instruction::kMaxVarArgRegs]; - inst->GetVarArgs(args, inst_data); - VarArgsInstructionOperands all_operands(args, inst->VRegA_45cc()); - NoReceiverInstructionOperands operands(&all_operands); - return DoVarHandleInvokeChecked(self, - var_handle, - callsite_type, - access_mode, - shadow_frame, - &operands, - result); - } else { - RangeInstructionOperands all_operands(inst->VRegC_4rcc(), inst->VRegA_4rcc()); - NoReceiverInstructionOperands operands(&all_operands); - return DoVarHandleInvokeChecked(self, - var_handle, - callsite_type, - access_mode, - shadow_frame, - &operands, - result); - } +bool DoVarHandleGetAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndAdd(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndAddAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndAddRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseAnd(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseAndAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseAndRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseOr(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseOrAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseOrRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseXor(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseXorAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndBitwiseXorRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndSet(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndSetAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetAndSetRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetOpaque(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleGetVolatile(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleSet(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleSetOpaque(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleSetRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleSetVolatile(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleWeakCompareAndSet(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); } -#define DO_VAR_HANDLE_ACCESSOR(_access_mode) \ -bool DoVarHandle ## _access_mode(Thread* self, \ - ShadowFrame& shadow_frame, \ - const Instruction* inst, \ - uint16_t inst_data, \ - JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { \ - const auto access_mode = mirror::VarHandle::AccessMode::k ## _access_mode; \ - return DoVarHandleInvokeCommon(self, shadow_frame, inst, inst_data, result, access_mode); \ +bool DoVarHandleWeakCompareAndSetAcquire(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); } -DO_VAR_HANDLE_ACCESSOR(CompareAndExchange) -DO_VAR_HANDLE_ACCESSOR(CompareAndExchangeAcquire) -DO_VAR_HANDLE_ACCESSOR(CompareAndExchangeRelease) -DO_VAR_HANDLE_ACCESSOR(CompareAndSet) -DO_VAR_HANDLE_ACCESSOR(Get) -DO_VAR_HANDLE_ACCESSOR(GetAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndAdd) -DO_VAR_HANDLE_ACCESSOR(GetAndAddAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndAddRelease) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseAnd) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseAndAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseAndRelease) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseOr) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseOrAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseOrRelease) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseXor) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseXorAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndBitwiseXorRelease) -DO_VAR_HANDLE_ACCESSOR(GetAndSet) -DO_VAR_HANDLE_ACCESSOR(GetAndSetAcquire) -DO_VAR_HANDLE_ACCESSOR(GetAndSetRelease) -DO_VAR_HANDLE_ACCESSOR(GetOpaque) -DO_VAR_HANDLE_ACCESSOR(GetVolatile) -DO_VAR_HANDLE_ACCESSOR(Set) -DO_VAR_HANDLE_ACCESSOR(SetOpaque) -DO_VAR_HANDLE_ACCESSOR(SetRelease) -DO_VAR_HANDLE_ACCESSOR(SetVolatile) -DO_VAR_HANDLE_ACCESSOR(WeakCompareAndSet) -DO_VAR_HANDLE_ACCESSOR(WeakCompareAndSetAcquire) -DO_VAR_HANDLE_ACCESSOR(WeakCompareAndSetPlain) -DO_VAR_HANDLE_ACCESSOR(WeakCompareAndSetRelease) - -#undef DO_VAR_HANDLE_ACCESSOR +bool DoVarHandleWeakCompareAndSetPlain(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} + +bool DoVarHandleWeakCompareAndSetRelease(Thread* self, + ShadowFrame& shadow_frame, + const Instruction* inst, + uint16_t inst_data, + JValue* result) REQUIRES_SHARED(Locks::mutator_lock_) { + return UnimplementedSignaturePolymorphicMethod(self, shadow_frame, inst, inst_data, result); +} template<bool is_range> bool DoInvokePolymorphic(Thread* self, diff --git a/runtime/method_handles.cc b/runtime/method_handles.cc index 9b21e1d9bf..2701ec66a4 100644 --- a/runtime/method_handles.cc +++ b/runtime/method_handles.cc @@ -346,7 +346,7 @@ inline bool ConvertAndCopyArgumentsFromCallerFrame( return false; } - ShadowFrameGetter getter(caller_frame, operands); + ShadowFrameGetter getter(operands, caller_frame); ShadowFrameSetter setter(callee_frame, first_dest_reg); return PerformConversions<ShadowFrameGetter, ShadowFrameSetter>(self, callsite_type, diff --git a/runtime/method_handles.h b/runtime/method_handles.h index 3b1bf2ee66..6ffd1a81fc 100644 --- a/runtime/method_handles.h +++ b/runtime/method_handles.h @@ -130,10 +130,8 @@ bool PerformConversions(Thread* self, // arguments while performing standard argument conversions. class ShadowFrameGetter { public: - ShadowFrameGetter(const ShadowFrame& shadow_frame, - const InstructionOperands* const operands, - size_t operand_index = 0u) - : shadow_frame_(shadow_frame), operands_(operands), operand_index_(operand_index) {} + ShadowFrameGetter(const InstructionOperands* const operands, const ShadowFrame& shadow_frame) + : operands_(operands), operand_index_(0), shadow_frame_(shadow_frame) {} ALWAYS_INLINE uint32_t Get() REQUIRES_SHARED(Locks::mutator_lock_) { return shadow_frame_.GetVReg(Next()); @@ -153,24 +151,26 @@ class ShadowFrameGetter { operand_index_ += 1; return next; } - uint32_t NextLong() { const uint32_t next = operands_->GetOperand(operand_index_); operand_index_ += 2; return next; } - const ShadowFrame& shadow_frame_; - const InstructionOperands* const operands_; // the set of register operands to read + const InstructionOperands* const operands_; size_t operand_index_; // the next register operand to read from frame + const ShadowFrame& shadow_frame_; }; // A convenience class that allows values to be written to a given shadow frame, // starting at location |first_dst_reg|. class ShadowFrameSetter { public: - ShadowFrameSetter(ShadowFrame* shadow_frame, size_t first_dst_reg) - : shadow_frame_(shadow_frame), arg_index_(first_dst_reg) {} + ShadowFrameSetter(ShadowFrame* shadow_frame, + size_t first_dst_reg) : + shadow_frame_(shadow_frame), + arg_index_(first_dst_reg) { + } ALWAYS_INLINE void Set(uint32_t value) REQUIRES_SHARED(Locks::mutator_lock_) { shadow_frame_->SetVReg(arg_index_++, value); diff --git a/runtime/mirror/emulated_stack_frame.cc b/runtime/mirror/emulated_stack_frame.cc index 5f00c6e9c7..5757992167 100644 --- a/runtime/mirror/emulated_stack_frame.cc +++ b/runtime/mirror/emulated_stack_frame.cc @@ -183,7 +183,7 @@ mirror::EmulatedStackFrame* EmulatedStackFrame::CreateFromShadowFrameAndArgs( } // Step 4 : Perform argument conversions (if required). - ShadowFrameGetter getter(caller_frame, operands); + ShadowFrameGetter getter(operands, caller_frame); EmulatedStackFrameAccessor setter(references, stack_frame, stack_frame->GetLength()); if (!PerformConversions<ShadowFrameGetter, EmulatedStackFrameAccessor>( self, caller_type, callee_type, &getter, &setter, num_method_params)) { diff --git a/runtime/mirror/object-inl.h b/runtime/mirror/object-inl.h index 6c1cb73282..6e2a07c9e0 100644 --- a/runtime/mirror/object-inl.h +++ b/runtime/mirror/object-inl.h @@ -935,195 +935,6 @@ inline bool Object::CasFieldWeakReleaseObjectWithoutWriteBarrier( return success; } -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline ObjPtr<Object> Object::CompareAndExchangeFieldObject(MemberOffset field_offset, - ObjPtr<Object> old_value, - ObjPtr<Object> new_value) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - if (kVerifyFlags & kVerifyWrites) { - VerifyObject(new_value); - } - if (kVerifyFlags & kVerifyReads) { - VerifyObject(old_value); - } - uint32_t old_ref(PtrCompression<kPoisonHeapReferences, Object>::Compress(old_value)); - uint32_t new_ref(PtrCompression<kPoisonHeapReferences, Object>::Compress(new_value)); - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); - bool success = atomic_addr->CompareAndExchangeStrongSequentiallyConsistent(&old_ref, new_ref); - ObjPtr<Object> witness_value(PtrCompression<kPoisonHeapReferences, Object>::Decompress(old_ref)); - if (kIsDebugBuild) { - // Ensure caller has done read barrier on the reference field so it's in the to-space. - ReadBarrier::AssertToSpaceInvariant(witness_value.Ptr()); - } - if (kTransactionActive && success) { - Runtime::Current()->RecordWriteFieldReference(this, field_offset, witness_value, true); - } - if (kVerifyFlags & kVerifyReads) { - VerifyObject(witness_value); - } - return witness_value; -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline ObjPtr<Object> Object::ExchangeFieldObject(MemberOffset field_offset, - ObjPtr<Object> new_value) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - if (kVerifyFlags & kVerifyWrites) { - VerifyObject(new_value); - } - uint32_t new_ref(PtrCompression<kPoisonHeapReferences, Object>::Compress(new_value)); - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); - uint32_t old_ref = atomic_addr->ExchangeSequentiallyConsistent(new_ref); - ObjPtr<Object> old_value(PtrCompression<kPoisonHeapReferences, Object>::Decompress(old_ref)); - if (kIsDebugBuild) { - // Ensure caller has done read barrier on the reference field so it's in the to-space. - ReadBarrier::AssertToSpaceInvariant(old_value.Ptr()); - } - if (kTransactionActive) { - Runtime::Current()->RecordWriteFieldReference(this, field_offset, old_value, true); - } - if (kVerifyFlags & kVerifyReads) { - VerifyObject(old_value); - } - return old_value; -} - -template<typename T, VerifyObjectFlags kVerifyFlags> -inline void Object::GetPrimitiveFieldViaAccessor(MemberOffset field_offset, Accessor<T>* accessor) { - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - T* addr = reinterpret_cast<T*>(raw_addr); - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateFieldBooleanViaAccessor(MemberOffset field_offset, - Accessor<uint8_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - uint8_t old_value = GetFieldBoolean<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteFieldBoolean(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - uint8_t* addr = raw_addr; - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateFieldByteViaAccessor(MemberOffset field_offset, - Accessor<int8_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - int8_t old_value = GetFieldByte<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteFieldByte(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - int8_t* addr = reinterpret_cast<int8_t*>(raw_addr); - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateFieldCharViaAccessor(MemberOffset field_offset, - Accessor<uint16_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - uint16_t old_value = GetFieldChar<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteFieldChar(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - uint16_t* addr = reinterpret_cast<uint16_t*>(raw_addr); - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateFieldShortViaAccessor(MemberOffset field_offset, - Accessor<int16_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - int16_t old_value = GetFieldShort<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteFieldShort(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - int16_t* addr = reinterpret_cast<int16_t*>(raw_addr); - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateField32ViaAccessor(MemberOffset field_offset, - Accessor<int32_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - int32_t old_value = GetField32<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteField32(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - int32_t* addr = reinterpret_cast<int32_t*>(raw_addr); - accessor->Access(addr); -} - -template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> -inline void Object::UpdateField64ViaAccessor(MemberOffset field_offset, - Accessor<int64_t>* accessor) { - if (kCheckTransaction) { - DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); - } - if (kTransactionActive) { - static const bool kIsVolatile = true; - int64_t old_value = GetField64<kVerifyFlags, kIsVolatile>(field_offset); - Runtime::Current()->RecordWriteField64(this, field_offset, old_value, kIsVolatile); - } - if (kVerifyFlags & kVerifyThis) { - VerifyObject(this); - } - uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); - int64_t* addr = reinterpret_cast<int64_t*>(raw_addr); - accessor->Access(addr); -} - template<bool kIsStatic, VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption, diff --git a/runtime/mirror/object.h b/runtime/mirror/object.h index 816ac69b29..25b86a527d 100644 --- a/runtime/mirror/object.h +++ b/runtime/mirror/object.h @@ -347,21 +347,6 @@ class MANAGED LOCKABLE Object { ObjPtr<Object> old_value, ObjPtr<Object> new_value) REQUIRES_SHARED(Locks::mutator_lock_); - - template<bool kTransactionActive, - bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - ObjPtr<Object> CompareAndExchangeFieldObject(MemberOffset field_offset, - ObjPtr<Object> old_value, - ObjPtr<Object> new_value) - REQUIRES_SHARED(Locks::mutator_lock_); - - template<bool kTransactionActive, - bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - ObjPtr<Object> ExchangeFieldObject(MemberOffset field_offset, ObjPtr<Object> new_value) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> @@ -607,52 +592,6 @@ class MANAGED LOCKABLE Object { field_offset, reinterpret_cast64<int64_t>(new_value)); } } - - // Base class for accessors used to describe accesses performed by VarHandle methods. - template <typename T> - class Accessor { - public: - virtual ~Accessor() { - static_assert(std::is_arithmetic<T>::value, "unsupported type"); - } - virtual void Access(T* field_address) = 0; - }; - - // Getter method that exposes the raw address of a primitive value-type field to an Accessor - // instance. This are used by VarHandle accessor methods to read fields with a wider range of - // memory orderings than usually required. - template<typename T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void GetPrimitiveFieldViaAccessor(MemberOffset field_offset, Accessor<T>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - - // Update methods that expose the raw address of a primitive value-type to an Accessor instance - // that will attempt to update the field. These are used by VarHandle accessor methods to - // atomically update fields with a wider range of memory orderings than usually required. - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateFieldBooleanViaAccessor(MemberOffset field_offset, Accessor<uint8_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateFieldByteViaAccessor(MemberOffset field_offset, Accessor<int8_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateFieldCharViaAccessor(MemberOffset field_offset, Accessor<uint16_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateFieldShortViaAccessor(MemberOffset field_offset, Accessor<int16_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateField32ViaAccessor(MemberOffset field_offset, Accessor<int32_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - template<bool kTransactionActive, bool kCheckTransaction = true, - VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> - void UpdateField64ViaAccessor(MemberOffset field_offset, Accessor<int64_t>* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); - // TODO fix thread safety analysis broken by the use of template. This should be // REQUIRES_SHARED(Locks::mutator_lock_). template <bool kVisitNativeRoots = true, diff --git a/runtime/mirror/var_handle.cc b/runtime/mirror/var_handle.cc index 85d06f03fe..3f4a28ce9d 100644 --- a/runtime/mirror/var_handle.cc +++ b/runtime/mirror/var_handle.cc @@ -16,23 +16,14 @@ #include "var_handle.h" -#include "array-inl.h" -#include "art_field-inl.h" #include "class-inl.h" #include "class_linker.h" #include "gc_root-inl.h" -#include "jni_internal.h" -#include "jvalue-inl.h" -#include "method_handles.h" #include "method_type.h" -#include "well_known_classes.h" namespace art { namespace mirror { -static constexpr bool kTransactionActive = true; -static constexpr bool kTransactionInactive = !kTransactionActive; - namespace { struct VarHandleAccessorToAccessModeEntry { @@ -167,62 +158,30 @@ AccessModeTemplate GetAccessModeTemplate(VarHandle::AccessMode access_mode) { } } -int32_t GetNumberOfVarTypeParameters(AccessModeTemplate access_mode_template) { - switch (access_mode_template) { - case AccessModeTemplate::kGet: - return 0; - case AccessModeTemplate::kSet: - case AccessModeTemplate::kGetAndUpdate: - return 1; - case AccessModeTemplate::kCompareAndSet: - case AccessModeTemplate::kCompareAndExchange: - return 2; - } - UNREACHABLE(); -} - // Returns the number of parameters associated with an // AccessModeTemplate and the supplied coordinate types. -int32_t GetNumberOfParameters(AccessModeTemplate access_mode_template, - ObjPtr<Class> coordinateType0, - ObjPtr<Class> coordinateType1) { - int32_t count = 0; +int32_t GetParameterCount(AccessModeTemplate access_mode_template, + ObjPtr<Class> coordinateType0, + ObjPtr<Class> coordinateType1) { + int32_t index = 0; if (!coordinateType0.IsNull()) { - count++; + index++; if (!coordinateType1.IsNull()) { - count++; + index++; } } - return count + GetNumberOfVarTypeParameters(access_mode_template); -} - -void ThrowNullPointerExceptionForCoordinate() REQUIRES_SHARED(Locks::mutator_lock_) { - ThrowNullPointerException("Attempt to access memory on a null object"); -} -bool CheckElementIndex(Primitive::Type type, - int32_t relative_index, - int32_t start, - int32_t limit) REQUIRES_SHARED(Locks::mutator_lock_) { - int64_t index = start + relative_index; - int64_t max_index = limit - Primitive::ComponentSize(type); - if (index < start || index > max_index) { - ThrowIndexOutOfBoundsException(index, limit - start); - return false; + switch (access_mode_template) { + case AccessModeTemplate::kGet: + return index; + case AccessModeTemplate::kSet: + case AccessModeTemplate::kGetAndUpdate: + return index + 1; + case AccessModeTemplate::kCompareAndSet: + case AccessModeTemplate::kCompareAndExchange: + return index + 2; } - return true; -} - -bool CheckElementIndex(Primitive::Type type, int32_t index, int32_t range_limit) - REQUIRES_SHARED(Locks::mutator_lock_) { - return CheckElementIndex(type, index, 0, range_limit); -} - -// Returns true if access_mode only entails a memory read. False if -// access_mode may write to memory. -bool IsReadOnlyAccessMode(VarHandle::AccessMode access_mode) { - AccessModeTemplate access_mode_template = GetAccessModeTemplate(access_mode); - return access_mode_template == AccessModeTemplate::kGet; + UNREACHABLE(); } // Writes the parameter types associated with the AccessModeTemplate @@ -289,1123 +248,6 @@ ObjectArray<Class>* NewArrayOfClasses(Thread* self, int count) return ObjectArray<Class>::Alloc(Thread::Current(), array_of_class, count); } -// Method to insert a read barrier for accessors to reference fields. -inline void ReadBarrierForVarHandleAccess(ObjPtr<Object> obj, MemberOffset field_offset) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (kUseReadBarrier) { - // We need to ensure that the reference stored in the field is a to-space one before attempting - // the CompareAndSet/CompareAndExchange/Exchange operation otherwise it will fail incorrectly - // if obj is in the process of being moved. - uint8_t* raw_field_addr = reinterpret_cast<uint8_t*>(obj.Ptr()) + field_offset.SizeValue(); - auto field_addr = reinterpret_cast<mirror::HeapReference<mirror::Object>*>(raw_field_addr); - // Note that the read barrier load does NOT need to be volatile. - static constexpr bool kIsVolatile = false; - static constexpr bool kAlwaysUpdateField = true; - ReadBarrier::Barrier<mirror::Object, kIsVolatile, kWithReadBarrier, kAlwaysUpdateField>( - obj.Ptr(), - MemberOffset(field_offset), - field_addr); - } -} - -inline MemberOffset GetMemberOffset(jfieldID field_id) REQUIRES_SHARED(Locks::mutator_lock_) { - ArtField* const field = jni::DecodeArtField(field_id); - return field->GetOffset(); -} - -// -// Helper methods for storing results from atomic operations into -// JValue instances. -// - -inline void StoreResult(uint8_t value, JValue* result) { - result->SetZ(value); -} - -inline void StoreResult(int8_t value, JValue* result) { - result->SetB(value); -} - -inline void StoreResult(uint16_t value, JValue* result) { - result->SetC(value); -} - -inline void StoreResult(int16_t value, JValue* result) { - result->SetS(value); -} - -inline void StoreResult(int32_t value, JValue* result) { - result->SetI(value); -} - -inline void StoreResult(int64_t value, JValue* result) { - result->SetJ(value); -} - -inline void StoreResult(float value, JValue* result) { - result->SetF(value); -} - -inline void StoreResult(double value, JValue* result) { - result->SetD(value); -} - -inline void StoreResult(ObjPtr<Object> value, JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_) { - result->SetL(value); -} - -// -// Helper class for byte-swapping value that has been stored in a JValue. -// - -template <typename T> -class JValueByteSwapper FINAL { - public: - static void ByteSwap(JValue* value); - static void MaybeByteSwap(bool byte_swap, JValue* value) { - if (byte_swap) { - ByteSwap(value); - } - } -}; - -template <> -void JValueByteSwapper<uint16_t>::ByteSwap(JValue* value) { - value->SetC(BSWAP(value->GetC())); -} - -template <> -void JValueByteSwapper<int16_t>::ByteSwap(JValue* value) { - value->SetS(BSWAP(value->GetS())); -} - -template <> -void JValueByteSwapper<int32_t>::ByteSwap(JValue* value) { - value->SetI(BSWAP(value->GetI())); -} - -template <> -void JValueByteSwapper<int64_t>::ByteSwap(JValue* value) { - value->SetJ(BSWAP(value->GetJ())); -} - -// -// Accessor implementations, shared across all VarHandle types. -// - -template <typename T, std::memory_order MO> -class AtomicGetAccessor : public Object::Accessor<T> { - public: - explicit AtomicGetAccessor(JValue* result) : result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - StoreResult(atom->load(MO), result_); - } - - private: - JValue* result_; -}; - -template <typename T, std::memory_order MO> -class AtomicSetAccessor : public Object::Accessor<T> { - public: - explicit AtomicSetAccessor(T new_value) : new_value_(new_value) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - atom->store(new_value_, MO); - } - - private: - T new_value_; -}; - -template <typename T> using GetAccessor = AtomicGetAccessor<T, std::memory_order_relaxed>; - -template <typename T> using SetAccessor = AtomicSetAccessor<T, std::memory_order_relaxed>; - -template <typename T> -using GetVolatileAccessor = AtomicGetAccessor<T, std::memory_order_seq_cst>; - -template <typename T> -using SetVolatileAccessor = AtomicSetAccessor<T, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MOS, std::memory_order MOF> -class AtomicStrongCompareAndSetAccessor : public Object::Accessor<T> { - public: - AtomicStrongCompareAndSetAccessor(T expected_value, T desired_value, JValue* result) - : expected_value_(expected_value), desired_value_(desired_value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - bool success = atom->compare_exchange_strong(expected_value_, desired_value_, MOS, MOF); - StoreResult(success ? JNI_TRUE : JNI_FALSE, result_); - } - - private: - T expected_value_; - T desired_value_; - JValue* result_; -}; - -template<typename T> -using CompareAndSetAccessor = - AtomicStrongCompareAndSetAccessor<T, std::memory_order_seq_cst, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MOS, std::memory_order MOF> -class AtomicStrongCompareAndExchangeAccessor : public Object::Accessor<T> { - public: - AtomicStrongCompareAndExchangeAccessor(T expected_value, T desired_value, JValue* result) - : expected_value_(expected_value), desired_value_(desired_value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - atom->compare_exchange_strong(expected_value_, desired_value_, MOS, MOF); - StoreResult(expected_value_, result_); - } - - private: - T expected_value_; - T desired_value_; - JValue* result_; -}; - -template <typename T> -using CompareAndExchangeAccessor = - AtomicStrongCompareAndExchangeAccessor<T, std::memory_order_seq_cst, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MOS, std::memory_order MOF> -class AtomicWeakCompareAndSetAccessor : public Object::Accessor<T> { - public: - AtomicWeakCompareAndSetAccessor(T expected_value, T desired_value, JValue* result) - : expected_value_(expected_value), desired_value_(desired_value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - bool success = atom->compare_exchange_weak(expected_value_, desired_value_, MOS, MOF); - StoreResult(success ? JNI_TRUE : JNI_FALSE, result_); - } - - private: - T expected_value_; - T desired_value_; - JValue* result_; -}; - -template <typename T> -using WeakCompareAndSetAccessor = - AtomicWeakCompareAndSetAccessor<T, std::memory_order_seq_cst, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MO> -class AtomicGetAndSetAccessor : public Object::Accessor<T> { - public: - AtomicGetAndSetAccessor(T new_value, JValue* result) : new_value_(new_value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - T old_value = atom->exchange(new_value_, MO); - StoreResult(old_value, result_); - } - - private: - T new_value_; - JValue* result_; -}; - -template <typename T> -using GetAndSetAccessor = AtomicGetAndSetAccessor<T, std::memory_order_seq_cst>; - -template <typename T, bool kIsFloat, std::memory_order MO> -class AtomicGetAndAddOperator { - public: - static T Apply(T* addr, T addend) { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - return atom->fetch_add(addend, MO); - } -}; - -template <typename T, std::memory_order MO> -class AtomicGetAndAddOperator<T, /* kIsFloat */ true, MO> { - public: - static T Apply(T* addr, T addend) { - // c++11 does not have std::atomic<T>::fetch_and_add for floating - // point types, so we effect one with a compare and swap. - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - T old_value = atom->load(std::memory_order_relaxed); - T new_value; - do { - new_value = old_value + addend; - } while (!atom->compare_exchange_weak(old_value, new_value, MO, std::memory_order_relaxed)); - return old_value; - } -}; - -template <typename T, std::memory_order MO> -class AtomicGetAndAddAccessor : public Object::Accessor<T> { - public: - AtomicGetAndAddAccessor(T addend, JValue* result) : addend_(addend), result_(result) {} - - void Access(T* addr) OVERRIDE { - constexpr bool kIsFloatingPoint = std::is_floating_point<T>::value; - T old_value = AtomicGetAndAddOperator<T, kIsFloatingPoint, MO>::Apply(addr, addend_); - StoreResult(old_value, result_); - } - - private: - T addend_; - JValue* result_; -}; - -template <typename T> -using GetAndAddAccessor = AtomicGetAndAddAccessor<T, std::memory_order_seq_cst>; - -// Accessor specifically for memory views where the caller can specify -// the byte-ordering. Addition only works outside of the byte-swapped -// memory view because of the direction of carries. -template <typename T, std::memory_order MO> -class AtomicGetAndAddWithByteSwapAccessor : public Object::Accessor<T> { - public: - AtomicGetAndAddWithByteSwapAccessor(T value, JValue* result) : value_(value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* const atom = reinterpret_cast<std::atomic<T>*>(addr); - T current_value = atom->load(std::memory_order_relaxed); - T sum; - do { - sum = BSWAP(current_value) + value_; - // NB current_value is a pass-by-reference argument in the call to - // atomic<T>::compare_exchange_weak(). - } while (!atom->compare_exchange_weak(current_value, - BSWAP(sum), - MO, - std::memory_order_relaxed)); - StoreResult(BSWAP(current_value), result_); - } - - private: - T value_; - JValue* result_; -}; - -template <typename T> -using GetAndAddWithByteSwapAccessor = - AtomicGetAndAddWithByteSwapAccessor<T, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MO> -class AtomicGetAndBitwiseOrAccessor : public Object::Accessor<T> { - public: - AtomicGetAndBitwiseOrAccessor(T value, JValue* result) : value_(value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - T old_value = atom->fetch_or(value_, MO); - StoreResult(old_value, result_); - } - - private: - T value_; - JValue* result_; -}; - -template <typename T> -using GetAndBitwiseOrAccessor = AtomicGetAndBitwiseOrAccessor<T, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MO> -class AtomicGetAndBitwiseAndAccessor : public Object::Accessor<T> { - public: - AtomicGetAndBitwiseAndAccessor(T value, JValue* result) : value_(value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - T old_value = atom->fetch_and(value_, MO); - StoreResult(old_value, result_); - } - - private: - T value_; - JValue* result_; -}; - -template <typename T> -using GetAndBitwiseAndAccessor = - AtomicGetAndBitwiseAndAccessor<T, std::memory_order_seq_cst>; - -template <typename T, std::memory_order MO> -class AtomicGetAndBitwiseXorAccessor : public Object::Accessor<T> { - public: - AtomicGetAndBitwiseXorAccessor(T value, JValue* result) : value_(value), result_(result) {} - - void Access(T* addr) OVERRIDE { - std::atomic<T>* atom = reinterpret_cast<std::atomic<T>*>(addr); - T old_value = atom->fetch_xor(value_, MO); - StoreResult(old_value, result_); - } - - private: - T value_; - JValue* result_; -}; - -template <typename T> -using GetAndBitwiseXorAccessor = AtomicGetAndBitwiseXorAccessor<T, std::memory_order_seq_cst>; - -// -// Unreachable access modes. -// - -NO_RETURN void UnreachableAccessMode(const char* access_mode, const char* type_name) { - LOG(FATAL) << "Unreachable access mode :" << access_mode << " for type " << type_name; - UNREACHABLE(); -} - -#define UNREACHABLE_ACCESS_MODE(ACCESS_MODE, TYPE) \ -template<> void ACCESS_MODE ## Accessor<TYPE>::Access(TYPE*) { \ - UnreachableAccessMode(#ACCESS_MODE, #TYPE); \ -} - -// The boolean primitive type is not numeric (boolean == std::uint8_t). -UNREACHABLE_ACCESS_MODE(GetAndAdd, uint8_t) - -// The floating point types do not support bitwise operations. -UNREACHABLE_ACCESS_MODE(GetAndBitwiseOr, float) -UNREACHABLE_ACCESS_MODE(GetAndBitwiseAnd, float) -UNREACHABLE_ACCESS_MODE(GetAndBitwiseXor, float) -UNREACHABLE_ACCESS_MODE(GetAndBitwiseOr, double) -UNREACHABLE_ACCESS_MODE(GetAndBitwiseAnd, double) -UNREACHABLE_ACCESS_MODE(GetAndBitwiseXor, double) - -// A helper class for object field accesses for floats and -// doubles. The object interface deals with Field32 and Field64. The -// former is used for both integers and floats, the latter for longs -// and doubles. This class provides the necessary coercion. -template <typename T, typename U> -class TypeAdaptorAccessor : public Object::Accessor<T> { - public: - explicit TypeAdaptorAccessor(Object::Accessor<U>* inner_accessor) - : inner_accessor_(inner_accessor) {} - - void Access(T* addr) OVERRIDE { - static_assert(sizeof(T) == sizeof(U), "bad conversion"); - inner_accessor_->Access(reinterpret_cast<U*>(addr)); - } - - private: - Object::Accessor<U>* inner_accessor_; -}; - -template <typename T> -class FieldAccessViaAccessor { - public: - typedef Object::Accessor<T> Accessor; - - // Apply an Accessor to get a field in an object. - static void Get(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - obj->GetPrimitiveFieldViaAccessor(field_offset, accessor); - } - - // Apply an Accessor to update a field in an object. - static void Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_); -}; - -template <> -inline void FieldAccessViaAccessor<float>::Get(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - TypeAdaptorAccessor<int32_t, float> float_to_int_accessor(accessor); - obj->GetPrimitiveFieldViaAccessor(field_offset, &float_to_int_accessor); -} - -template <> -inline void FieldAccessViaAccessor<double>::Get(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - TypeAdaptorAccessor<int64_t, double> double_to_int_accessor(accessor); - obj->GetPrimitiveFieldViaAccessor(field_offset, &double_to_int_accessor); -} - -template <> -void FieldAccessViaAccessor<uint8_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateFieldBooleanViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateFieldBooleanViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<int8_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateFieldByteViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateFieldByteViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<uint16_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateFieldCharViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateFieldCharViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<int16_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateFieldShortViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateFieldShortViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<int32_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateField32ViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateField32ViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<int64_t>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateField64ViaAccessor<kTransactionActive>(field_offset, accessor); - } else { - obj->UpdateField64ViaAccessor<kTransactionInactive>(field_offset, accessor); - } -} - -template <> -void FieldAccessViaAccessor<float>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - TypeAdaptorAccessor<int32_t, float> float_to_int_accessor(accessor); - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateField32ViaAccessor<kTransactionActive>(field_offset, &float_to_int_accessor); - } else { - obj->UpdateField32ViaAccessor<kTransactionInactive>(field_offset, &float_to_int_accessor); - } -} - -template <> -void FieldAccessViaAccessor<double>::Update(ObjPtr<Object> obj, - MemberOffset field_offset, - Accessor* accessor) - REQUIRES_SHARED(Locks::mutator_lock_) { - TypeAdaptorAccessor<int64_t, double> double_to_int_accessor(accessor); - if (Runtime::Current()->IsActiveTransaction()) { - obj->UpdateField64ViaAccessor<kTransactionActive>(field_offset, &double_to_int_accessor); - } else { - obj->UpdateField64ViaAccessor<kTransactionInactive>(field_offset, &double_to_int_accessor); - } -} - -// Helper class that gets values from a shadow frame with appropriate type coercion. -template <typename T> -class ValueGetter { - public: - static T Get(ShadowFrameGetter* getter) REQUIRES_SHARED(Locks::mutator_lock_) { - static_assert(sizeof(T) <= sizeof(uint32_t), "Bad size"); - uint32_t raw_value = getter->Get(); - return static_cast<T>(raw_value); - } -}; - -template <> -int64_t ValueGetter<int64_t>::Get(ShadowFrameGetter* getter) { - return getter->GetLong(); -} - -template <> -float ValueGetter<float>::Get(ShadowFrameGetter* getter) { - uint32_t raw_value = getter->Get(); - return *reinterpret_cast<float*>(&raw_value); -} - -template <> -double ValueGetter<double>::Get(ShadowFrameGetter* getter) { - int64_t raw_value = getter->GetLong(); - return *reinterpret_cast<double*>(&raw_value); -} - -template <> -ObjPtr<Object> ValueGetter<ObjPtr<Object>>::Get(ShadowFrameGetter* getter) { - return getter->GetReference(); -} - -// Class for accessing fields of Object instances -template <typename T> -class FieldAccessor { - public: - static bool Dispatch(VarHandle::AccessMode access_mode, - ObjPtr<Object> obj, - MemberOffset field_offset, - ShadowFrameGetter* getter, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); -}; - -// Dispatch implementation for primitive fields. -template <typename T> -bool FieldAccessor<T>::Dispatch(VarHandle::AccessMode access_mode, - ObjPtr<Object> obj, - MemberOffset field_offset, - ShadowFrameGetter* getter, - JValue* result) { - switch (access_mode) { - case VarHandle::AccessMode::kGet: { - GetAccessor<T> accessor(result); - FieldAccessViaAccessor<T>::Get(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kSet: { - T new_value = ValueGetter<T>::Get(getter); - SetAccessor<T> accessor(new_value); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAcquire: - case VarHandle::AccessMode::kGetOpaque: - case VarHandle::AccessMode::kGetVolatile: { - GetVolatileAccessor<T> accessor(result); - FieldAccessViaAccessor<T>::Get(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kSetOpaque: - case VarHandle::AccessMode::kSetRelease: - case VarHandle::AccessMode::kSetVolatile: { - T new_value = ValueGetter<T>::Get(getter); - SetVolatileAccessor<T> accessor(new_value); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kCompareAndSet: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - CompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kCompareAndExchange: - case VarHandle::AccessMode::kCompareAndExchangeAcquire: - case VarHandle::AccessMode::kCompareAndExchangeRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - CompareAndExchangeAccessor<T> accessor(expected_value, desired_value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kWeakCompareAndSet: - case VarHandle::AccessMode::kWeakCompareAndSetAcquire: - case VarHandle::AccessMode::kWeakCompareAndSetPlain: - case VarHandle::AccessMode::kWeakCompareAndSetRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - WeakCompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAndSet: - case VarHandle::AccessMode::kGetAndSetAcquire: - case VarHandle::AccessMode::kGetAndSetRelease: { - T new_value = ValueGetter<T>::Get(getter); - GetAndSetAccessor<T> accessor(new_value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAndAdd: - case VarHandle::AccessMode::kGetAndAddAcquire: - case VarHandle::AccessMode::kGetAndAddRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndAddAccessor<T> accessor(value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseOr: - case VarHandle::AccessMode::kGetAndBitwiseOrAcquire: - case VarHandle::AccessMode::kGetAndBitwiseOrRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseOrAccessor<T> accessor(value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseAnd: - case VarHandle::AccessMode::kGetAndBitwiseAndAcquire: - case VarHandle::AccessMode::kGetAndBitwiseAndRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseAndAccessor<T> accessor(value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseXor: - case VarHandle::AccessMode::kGetAndBitwiseXorAcquire: - case VarHandle::AccessMode::kGetAndBitwiseXorRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseXorAccessor<T> accessor(value, result); - FieldAccessViaAccessor<T>::Update(obj, field_offset, &accessor); - break; - } - } - return true; -} - -// Dispatch implementation for reference fields. -template <> -bool FieldAccessor<ObjPtr<Object>>::Dispatch(VarHandle::AccessMode access_mode, - ObjPtr<Object> obj, - MemberOffset field_offset, - ShadowFrameGetter* getter, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_) { - // To keep things simple, use the minimum strongest existing - // field accessor for Object fields. This may be the most - // straightforward strategy in general for the interpreter. - switch (access_mode) { - case VarHandle::AccessMode::kGet: { - StoreResult(obj->GetFieldObject<Object>(field_offset), result); - break; - } - case VarHandle::AccessMode::kSet: { - ObjPtr<Object> new_value = ValueGetter<ObjPtr<Object>>::Get(getter); - if (Runtime::Current()->IsActiveTransaction()) { - obj->SetFieldObject<kTransactionActive>(field_offset, new_value); - } else { - obj->SetFieldObject<kTransactionInactive>(field_offset, new_value); - } - break; - } - case VarHandle::AccessMode::kGetAcquire: - case VarHandle::AccessMode::kGetOpaque: - case VarHandle::AccessMode::kGetVolatile: { - StoreResult(obj->GetFieldObjectVolatile<Object>(field_offset), result); - break; - } - case VarHandle::AccessMode::kSetOpaque: - case VarHandle::AccessMode::kSetRelease: - case VarHandle::AccessMode::kSetVolatile: { - ObjPtr<Object> new_value = ValueGetter<ObjPtr<Object>>::Get(getter); - if (Runtime::Current()->IsActiveTransaction()) { - obj->SetFieldObjectVolatile<kTransactionActive>(field_offset, new_value); - } else { - obj->SetFieldObjectVolatile<kTransactionInactive>(field_offset, new_value); - } - break; - } - case VarHandle::AccessMode::kCompareAndSet: { - ReadBarrierForVarHandleAccess(obj, field_offset); - ObjPtr<Object> expected_value = ValueGetter<ObjPtr<Object>>::Get(getter); - ObjPtr<Object> desired_value = ValueGetter<ObjPtr<Object>>::Get(getter); - bool cas_result; - if (Runtime::Current()->IsActiveTransaction()) { - cas_result = obj->CasFieldStrongSequentiallyConsistentObject<kTransactionActive>( - field_offset, - expected_value, - desired_value); - } else { - cas_result = obj->CasFieldStrongSequentiallyConsistentObject<kTransactionInactive>( - field_offset, - expected_value, - desired_value); - } - StoreResult(cas_result, result); - break; - } - case VarHandle::AccessMode::kWeakCompareAndSet: - case VarHandle::AccessMode::kWeakCompareAndSetAcquire: - case VarHandle::AccessMode::kWeakCompareAndSetPlain: - case VarHandle::AccessMode::kWeakCompareAndSetRelease: { - ReadBarrierForVarHandleAccess(obj, field_offset); - ObjPtr<Object> expected_value = ValueGetter<ObjPtr<Object>>::Get(getter); - ObjPtr<Object> desired_value = ValueGetter<ObjPtr<Object>>::Get(getter); - bool cas_result; - if (Runtime::Current()->IsActiveTransaction()) { - cas_result = obj->CasFieldWeakSequentiallyConsistentObject<kTransactionActive>( - field_offset, - expected_value, - desired_value); - } else { - cas_result = obj->CasFieldWeakSequentiallyConsistentObject<kTransactionInactive>( - field_offset, - expected_value, - desired_value); - } - StoreResult(cas_result, result); - break; - } - case VarHandle::AccessMode::kCompareAndExchange: - case VarHandle::AccessMode::kCompareAndExchangeAcquire: - case VarHandle::AccessMode::kCompareAndExchangeRelease: { - ReadBarrierForVarHandleAccess(obj, field_offset); - ObjPtr<Object> expected_value = ValueGetter<ObjPtr<Object>>::Get(getter); - ObjPtr<Object> desired_value = ValueGetter<ObjPtr<Object>>::Get(getter); - ObjPtr<Object> witness_value; - if (Runtime::Current()->IsActiveTransaction()) { - witness_value = obj->CompareAndExchangeFieldObject<kTransactionActive>( - field_offset, - expected_value, - desired_value); - } else { - witness_value = obj->CompareAndExchangeFieldObject<kTransactionInactive>( - field_offset, - expected_value, - desired_value); - } - StoreResult(witness_value, result); - break; - } - case VarHandle::AccessMode::kGetAndSet: - case VarHandle::AccessMode::kGetAndSetAcquire: - case VarHandle::AccessMode::kGetAndSetRelease: { - ReadBarrierForVarHandleAccess(obj, field_offset); - ObjPtr<Object> new_value = ValueGetter<ObjPtr<Object>>::Get(getter); - ObjPtr<Object> old_value; - if (Runtime::Current()->IsActiveTransaction()) { - old_value = obj->ExchangeFieldObject<kTransactionActive>(field_offset, new_value); - } else { - old_value = obj->ExchangeFieldObject<kTransactionInactive>(field_offset, new_value); - } - StoreResult(old_value, result); - break; - } - case VarHandle::AccessMode::kGetAndAdd: - case VarHandle::AccessMode::kGetAndAddAcquire: - case VarHandle::AccessMode::kGetAndAddRelease: - case VarHandle::AccessMode::kGetAndBitwiseOr: - case VarHandle::AccessMode::kGetAndBitwiseOrAcquire: - case VarHandle::AccessMode::kGetAndBitwiseOrRelease: - case VarHandle::AccessMode::kGetAndBitwiseAnd: - case VarHandle::AccessMode::kGetAndBitwiseAndAcquire: - case VarHandle::AccessMode::kGetAndBitwiseAndRelease: - case VarHandle::AccessMode::kGetAndBitwiseXor: - case VarHandle::AccessMode::kGetAndBitwiseXorAcquire: - case VarHandle::AccessMode::kGetAndBitwiseXorRelease: { - size_t index = static_cast<size_t>(access_mode); - const char* access_mode_name = kAccessorToAccessMode[index].method_name; - UnreachableAccessMode(access_mode_name, "Object"); - } - } - return true; -} - -// Class for accessing primitive array elements. -template <typename T> -class PrimitiveArrayElementAccessor { - public: - static T* GetElementAddress(ObjPtr<Array> target_array, int target_element) - REQUIRES_SHARED(Locks::mutator_lock_) { - auto primitive_array = ObjPtr<PrimitiveArray<T>>::DownCast(target_array); - DCHECK(primitive_array->CheckIsValidIndex(target_element)); - return &primitive_array->GetData()[target_element]; - } - - static bool Dispatch(VarHandle::AccessMode access_mode, - ObjPtr<Array> target_array, - int target_element, - ShadowFrameGetter* getter, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_) { - T* element_address = GetElementAddress(target_array, target_element); - switch (access_mode) { - case VarHandle::AccessMode::kGet: { - GetAccessor<T> accessor(result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kSet: { - T new_value = ValueGetter<T>::Get(getter); - SetAccessor<T> accessor(new_value); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAcquire: - case VarHandle::AccessMode::kGetOpaque: - case VarHandle::AccessMode::kGetVolatile: { - GetVolatileAccessor<T> accessor(result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kSetOpaque: - case VarHandle::AccessMode::kSetRelease: - case VarHandle::AccessMode::kSetVolatile: { - T new_value = ValueGetter<T>::Get(getter); - SetVolatileAccessor<T> accessor(new_value); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kCompareAndSet: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - CompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kCompareAndExchange: - case VarHandle::AccessMode::kCompareAndExchangeAcquire: - case VarHandle::AccessMode::kCompareAndExchangeRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - CompareAndExchangeAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kWeakCompareAndSet: - case VarHandle::AccessMode::kWeakCompareAndSetAcquire: - case VarHandle::AccessMode::kWeakCompareAndSetPlain: - case VarHandle::AccessMode::kWeakCompareAndSetRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - WeakCompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndSet: - case VarHandle::AccessMode::kGetAndSetAcquire: - case VarHandle::AccessMode::kGetAndSetRelease: { - T new_value = ValueGetter<T>::Get(getter); - GetAndSetAccessor<T> accessor(new_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndAdd: - case VarHandle::AccessMode::kGetAndAddAcquire: - case VarHandle::AccessMode::kGetAndAddRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndAddAccessor<T> accessor(value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseOr: - case VarHandle::AccessMode::kGetAndBitwiseOrAcquire: - case VarHandle::AccessMode::kGetAndBitwiseOrRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseOrAccessor<T> accessor(value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseAnd: - case VarHandle::AccessMode::kGetAndBitwiseAndAcquire: - case VarHandle::AccessMode::kGetAndBitwiseAndRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseAndAccessor<T> accessor(value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseXor: - case VarHandle::AccessMode::kGetAndBitwiseXorAcquire: - case VarHandle::AccessMode::kGetAndBitwiseXorRelease: { - T value = ValueGetter<T>::Get(getter); - GetAndBitwiseXorAccessor<T> accessor(value, result); - accessor.Access(element_address); - break; - } - } - return true; - } -}; - -// Class for accessing primitive array elements. -template <typename T> -class ByteArrayViewAccessor { - public: - static inline bool IsAccessAligned(int8_t* data, int data_index) { - static_assert(IsPowerOfTwo(sizeof(T)), "unexpected size"); - static_assert(std::is_arithmetic<T>::value, "unexpected type"); - uintptr_t alignment_mask = sizeof(T) - 1; - uintptr_t address = reinterpret_cast<uintptr_t>(data + data_index); - return (address & alignment_mask) == 0; - } - - static inline void MaybeByteSwap(bool byte_swap, T* const value) { - if (byte_swap) { - *value = BSWAP(*value); - } - } - - static bool Dispatch(const VarHandle::AccessMode access_mode, - int8_t* const data, - const int data_index, - const bool byte_swap, - ShadowFrameGetter* const getter, - JValue* const result) - REQUIRES_SHARED(Locks::mutator_lock_) { - const bool is_aligned = IsAccessAligned(data, data_index); - if (!is_aligned) { - switch (access_mode) { - case VarHandle::AccessMode::kGet: { - T value; - memcpy(&value, data + data_index, sizeof(T)); - MaybeByteSwap(byte_swap, &value); - StoreResult(value, result); - return true; - } - case VarHandle::AccessMode::kSet: { - T new_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &new_value); - memcpy(data + data_index, &new_value, sizeof(T)); - return true; - } - default: - // No other access modes support unaligned access. - ThrowIllegalStateException("Unaligned access not supported"); - return false; - } - } - - T* const element_address = reinterpret_cast<T*>(data + data_index); - CHECK(IsAccessAligned(reinterpret_cast<int8_t*>(element_address), 0)); - switch (access_mode) { - case VarHandle::AccessMode::kGet: { - GetAccessor<T> accessor(result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kSet: { - T new_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &new_value); - SetAccessor<T> accessor(new_value); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAcquire: - case VarHandle::AccessMode::kGetOpaque: - case VarHandle::AccessMode::kGetVolatile: { - GetVolatileAccessor<T> accessor(result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kSetOpaque: - case VarHandle::AccessMode::kSetRelease: - case VarHandle::AccessMode::kSetVolatile: { - T new_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &new_value); - SetVolatileAccessor<T> accessor(new_value); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kCompareAndSet: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &expected_value); - MaybeByteSwap(byte_swap, &desired_value); - CompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kCompareAndExchange: - case VarHandle::AccessMode::kCompareAndExchangeAcquire: - case VarHandle::AccessMode::kCompareAndExchangeRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &expected_value); - MaybeByteSwap(byte_swap, &desired_value); - CompareAndExchangeAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kWeakCompareAndSet: - case VarHandle::AccessMode::kWeakCompareAndSetAcquire: - case VarHandle::AccessMode::kWeakCompareAndSetPlain: - case VarHandle::AccessMode::kWeakCompareAndSetRelease: { - T expected_value = ValueGetter<T>::Get(getter); - T desired_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &expected_value); - MaybeByteSwap(byte_swap, &desired_value); - WeakCompareAndSetAccessor<T> accessor(expected_value, desired_value, result); - accessor.Access(element_address); - break; - } - case VarHandle::AccessMode::kGetAndSet: - case VarHandle::AccessMode::kGetAndSetAcquire: - case VarHandle::AccessMode::kGetAndSetRelease: { - T new_value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &new_value); - GetAndSetAccessor<T> accessor(new_value, result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kGetAndAdd: - case VarHandle::AccessMode::kGetAndAddAcquire: - case VarHandle::AccessMode::kGetAndAddRelease: { - T value = ValueGetter<T>::Get(getter); - if (byte_swap) { - GetAndAddWithByteSwapAccessor<T> accessor(value, result); - accessor.Access(element_address); - } else { - GetAndAddAccessor<T> accessor(value, result); - accessor.Access(element_address); - } - break; - } - case VarHandle::AccessMode::kGetAndBitwiseOr: - case VarHandle::AccessMode::kGetAndBitwiseOrAcquire: - case VarHandle::AccessMode::kGetAndBitwiseOrRelease: { - T value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &value); - GetAndBitwiseOrAccessor<T> accessor(value, result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseAnd: - case VarHandle::AccessMode::kGetAndBitwiseAndAcquire: - case VarHandle::AccessMode::kGetAndBitwiseAndRelease: { - T value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &value); - GetAndBitwiseAndAccessor<T> accessor(value, result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - case VarHandle::AccessMode::kGetAndBitwiseXor: - case VarHandle::AccessMode::kGetAndBitwiseXorAcquire: - case VarHandle::AccessMode::kGetAndBitwiseXorRelease: { - T value = ValueGetter<T>::Get(getter); - MaybeByteSwap(byte_swap, &value); - GetAndBitwiseXorAccessor<T> accessor(value, result); - accessor.Access(element_address); - JValueByteSwapper<T>::MaybeByteSwap(byte_swap, result); - break; - } - } - return true; - } -}; - } // namespace Class* VarHandle::GetVarType() { @@ -1425,38 +267,35 @@ int32_t VarHandle::GetAccessModesBitMask() { } bool VarHandle::IsMethodTypeCompatible(AccessMode access_mode, MethodType* method_type) { - StackHandleScope<3> hs(Thread::Current()); - Handle<Class> mt_rtype(hs.NewHandle(method_type->GetRType())); - Handle<VarHandle> vh(hs.NewHandle(this)); - Handle<Class> var_type(hs.NewHandle(vh->GetVarType())); - AccessModeTemplate access_mode_template = GetAccessModeTemplate(access_mode); + ScopedAssertNoThreadSuspension ants(__FUNCTION__); - // Check return type first. - if (mt_rtype->GetPrimitiveType() == Primitive::Type::kPrimVoid) { - // The result of the operation will be discarded. The return type - // of the VarHandle is immaterial. - } else { - ObjPtr<Class> vh_rtype(GetReturnType(access_mode_template, var_type.Get())); - if (!IsReturnTypeConvertible(vh_rtype, mt_rtype.Get())) { - return false; - } + AccessModeTemplate access_mode_template = GetAccessModeTemplate(access_mode); + // Check return types first. + ObjPtr<Class> var_type = GetVarType(); + ObjPtr<Class> vh_rtype = GetReturnType(access_mode_template, var_type); + ObjPtr<Class> void_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass('V'); + ObjPtr<Class> mt_rtype = method_type->GetRType(); + + // If the mt_rtype is void, the result of the operation will be discarded (okay). + if (mt_rtype != void_type && mt_rtype != vh_rtype) { + return false; } // Check the number of parameters matches. ObjPtr<Class> vh_ptypes[VarHandle::kMaxAccessorParameters]; const int32_t vh_ptypes_count = BuildParameterArray(vh_ptypes, access_mode_template, - var_type.Get(), + var_type, GetCoordinateType0(), GetCoordinateType1()); if (vh_ptypes_count != method_type->GetPTypes()->GetLength()) { return false; } - // Check the parameter types are compatible. + // Check the parameter types match. ObjPtr<ObjectArray<Class>> mt_ptypes = method_type->GetPTypes(); for (int32_t i = 0; i < vh_ptypes_count; ++i) { - if (!IsParameterTypeConvertible(mt_ptypes->Get(i), vh_ptypes[i])) { + if (mt_ptypes->Get(i) != vh_ptypes[i].Ptr()) { return false; } } @@ -1472,9 +311,8 @@ MethodType* VarHandle::GetMethodTypeForAccessMode(Thread* self, StackHandleScope<3> hs(self); Handle<VarHandle> vh = hs.NewHandle(var_handle); Handle<Class> rtype = hs.NewHandle(GetReturnType(access_mode_template, vh->GetVarType())); - const int32_t ptypes_count = GetNumberOfParameters(access_mode_template, - vh->GetCoordinateType0(), - vh->GetCoordinateType1()); + const int32_t ptypes_count = + GetParameterCount(access_mode_template, vh->GetCoordinateType0(), vh->GetCoordinateType1()); Handle<ObjectArray<Class>> ptypes = hs.NewHandle(NewArrayOfClasses(self, ptypes_count)); if (ptypes == nullptr) { return nullptr; @@ -1496,29 +334,6 @@ MethodType* VarHandle::GetMethodTypeForAccessMode(Thread* self, AccessMode acces return GetMethodTypeForAccessMode(self, this, access_mode); } -bool VarHandle::Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) { - Class* klass = GetClass(); - if (klass == FieldVarHandle::StaticClass()) { - auto vh = reinterpret_cast<FieldVarHandle*>(this); - return vh->Access(access_mode, shadow_frame, operands, result); - } else if (klass == ArrayElementVarHandle::StaticClass()) { - auto vh = reinterpret_cast<ArrayElementVarHandle*>(this); - return vh->Access(access_mode, shadow_frame, operands, result); - } else if (klass == ByteArrayViewVarHandle::StaticClass()) { - auto vh = reinterpret_cast<ByteArrayViewVarHandle*>(this); - return vh->Access(access_mode, shadow_frame, operands, result); - } else if (klass == ByteBufferViewVarHandle::StaticClass()) { - auto vh = reinterpret_cast<ByteBufferViewVarHandle*>(this); - return vh->Access(access_mode, shadow_frame, operands, result); - } else { - LOG(FATAL) << "Unknown varhandle kind"; - UNREACHABLE(); - } -} - const char* VarHandle::GetReturnTypeDescriptor(const char* accessor_name) { AccessMode access_mode; if (!GetAccessModeByMethodName(accessor_name, &access_mode)) { @@ -1554,10 +369,6 @@ bool VarHandle::GetAccessModeByMethodName(const char* method_name, AccessMode* a return true; } -Class* VarHandle::StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { - return static_class_.Read(); -} - void VarHandle::SetClass(Class* klass) { CHECK(static_class_.IsNull()) << static_class_.Read() << " " << klass; CHECK(klass != nullptr); @@ -1580,57 +391,6 @@ ArtField* FieldVarHandle::GetField() { return reinterpret_cast<ArtField*>(opaque_field); } -bool FieldVarHandle::Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) { - ShadowFrameGetter getter(*shadow_frame, operands); - ArtField* field = GetField(); - ObjPtr<Object> obj; - if (field->IsStatic()) { - DCHECK_LE(operands->GetNumberOfOperands(), - 2u * (Primitive::Is64BitType(GetVarType()->GetPrimitiveType()) ? 2u : 1u)); - obj = field->GetDeclaringClass(); - } else { - DCHECK_GE(operands->GetNumberOfOperands(), 1u); - DCHECK_LE(operands->GetNumberOfOperands(), - 1u + 2u * (Primitive::Is64BitType(GetVarType()->GetPrimitiveType()) ? 2u : 1u)); - obj = getter.GetReference(); - if (obj.IsNull()) { - ThrowNullPointerExceptionForCoordinate(); - return false; - } - } - DCHECK(!obj.IsNull()); - - const MemberOffset offset = field->GetOffset(); - const Primitive::Type primitive_type = GetVarType()->GetPrimitiveType(); - switch (primitive_type) { - case Primitive::Type::kPrimNot: - return FieldAccessor<ObjPtr<Object>>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimBoolean: - return FieldAccessor<uint8_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimByte: - return FieldAccessor<int8_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimChar: - return FieldAccessor<uint16_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimShort: - return FieldAccessor<int16_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimInt: - return FieldAccessor<int32_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimFloat: - return FieldAccessor<float>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimLong: - return FieldAccessor<int64_t>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimDouble: - return FieldAccessor<double>::Dispatch(access_mode, obj, offset, &getter, result); - case Primitive::kPrimVoid: - break; - } - LOG(FATAL) << "Unreachable: Unexpected primitive " << primitive_type; - UNREACHABLE(); -} - Class* FieldVarHandle::StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { return static_class_.Read(); } @@ -1652,94 +412,6 @@ void FieldVarHandle::VisitRoots(RootVisitor* visitor) { GcRoot<Class> FieldVarHandle::static_class_; -bool ArrayElementVarHandle::Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) { - ShadowFrameGetter getter(*shadow_frame, operands); - - // The target array is the first co-ordinate type preceeding var type arguments. - ObjPtr<Object> raw_array(getter.GetReference()); - if (raw_array == nullptr) { - ThrowNullPointerExceptionForCoordinate(); - return false; - } - - ObjPtr<Array> target_array(raw_array->AsArray()); - - // The target array element is the second co-ordinate type preceeding var type arguments. - const int target_element = getter.Get(); - if (!target_array->CheckIsValidIndex(target_element)) { - DCHECK(Thread::Current()->IsExceptionPending()); - return false; - } - - const Primitive::Type primitive_type = GetVarType()->GetPrimitiveType(); - switch (primitive_type) { - case Primitive::Type::kPrimNot: { - MemberOffset target_element_offset = - target_array->AsObjectArray<Object>()->OffsetOfElement(target_element); - return FieldAccessor<ObjPtr<Object>>::Dispatch(access_mode, - target_array, - target_element_offset, - &getter, - result); - } - case Primitive::Type::kPrimBoolean: - return PrimitiveArrayElementAccessor<uint8_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimByte: - return PrimitiveArrayElementAccessor<int8_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimChar: - return PrimitiveArrayElementAccessor<uint16_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimShort: - return PrimitiveArrayElementAccessor<int16_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimInt: - return PrimitiveArrayElementAccessor<int32_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimLong: - return PrimitiveArrayElementAccessor<int64_t>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimFloat: - return PrimitiveArrayElementAccessor<float>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimDouble: - return PrimitiveArrayElementAccessor<double>::Dispatch(access_mode, - target_array, - target_element, - &getter, - result); - case Primitive::Type::kPrimVoid: - break; - } - LOG(FATAL) << "Unreachable: Unexpected primitive " << primitive_type; - UNREACHABLE(); -} - Class* ArrayElementVarHandle::StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { return static_class_.Read(); } @@ -1765,90 +437,6 @@ bool ByteArrayViewVarHandle::GetNativeByteOrder() { return GetFieldBoolean(NativeByteOrderOffset()); } -bool ByteArrayViewVarHandle::Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) { - ShadowFrameGetter getter(*shadow_frame, operands); - - // The byte array is the first co-ordinate type preceeding var type arguments. - ObjPtr<Object> raw_byte_array(getter.GetReference()); - if (raw_byte_array == nullptr) { - ThrowNullPointerExceptionForCoordinate(); - return false; - } - - ObjPtr<ByteArray> byte_array(raw_byte_array->AsByteArray()); - - // The offset in the byte array element is the second co-ordinate type. - const int32_t data_offset = getter.Get(); - - // Bounds check requested access. - const Primitive::Type primitive_type = GetVarType()->GetPrimitiveType(); - if (!CheckElementIndex(primitive_type, data_offset, byte_array->GetLength())) { - return false; - } - - int8_t* const data = byte_array->GetData(); - bool byte_swap = !GetNativeByteOrder(); - switch (primitive_type) { - case Primitive::Type::kPrimNot: - case Primitive::kPrimBoolean: - case Primitive::kPrimByte: - case Primitive::kPrimVoid: - // These are not supported for byte array views and not instantiable. - break; - case Primitive::kPrimChar: - return ByteArrayViewAccessor<uint16_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - case Primitive::kPrimShort: - return ByteArrayViewAccessor<int16_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - case Primitive::kPrimInt: - return ByteArrayViewAccessor<int32_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - case Primitive::kPrimFloat: - // Treated as a bitwise representation. See javadoc comments for - // java.lang.invoke.MethodHandles.byteArrayViewVarHandle(). - return ByteArrayViewAccessor<int32_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - case Primitive::kPrimLong: - return ByteArrayViewAccessor<int64_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - case Primitive::kPrimDouble: - // Treated as a bitwise representation. See javadoc comments for - // java.lang.invoke.MethodHandles.byteArrayViewVarHandle(). - return ByteArrayViewAccessor<int64_t>::Dispatch(access_mode, - data, - data_offset, - byte_swap, - &getter, - result); - } - LOG(FATAL) << "Unreachable: Unexpected primitive " << primitive_type; - UNREACHABLE(); -} - Class* ByteArrayViewVarHandle::StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { return static_class_.Read(); } @@ -1874,122 +462,6 @@ bool ByteBufferViewVarHandle::GetNativeByteOrder() { return GetFieldBoolean(NativeByteOrderOffset()); } -bool ByteBufferViewVarHandle::Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) { - ShadowFrameGetter getter(*shadow_frame, operands); - - // The byte buffer is the first co-ordinate argument preceeding var type arguments. - ObjPtr<Object> byte_buffer(getter.GetReference()); - if (byte_buffer == nullptr) { - ThrowNullPointerExceptionForCoordinate(); - return false; - } - - // The byte index for access is the second co-ordinate - // argument. This is relative to the offset field of the ByteBuffer. - const int32_t byte_index = getter.Get(); - - // Check access_mode is compatible with ByteBuffer's read-only property. - bool is_read_only = byte_buffer->GetFieldBoolean( - GetMemberOffset(WellKnownClasses::java_nio_ByteBuffer_isReadOnly)); - if (is_read_only && !IsReadOnlyAccessMode(access_mode)) { - ThrowReadOnlyBufferException(); - return false; - } - - // The native_address is only set for ByteBuffer instances backed by native memory. - const int64_t native_address = - byte_buffer->GetField64(GetMemberOffset(WellKnownClasses::java_nio_ByteBuffer_address)); - - // Determine offset and limit for accesses. - int32_t byte_buffer_offset; - if (native_address == 0l) { - // Accessing a heap allocated byte buffer. - byte_buffer_offset = byte_buffer->GetField32( - GetMemberOffset(WellKnownClasses::java_nio_ByteBuffer_offset)); - } else { - // Accessing direct memory. - byte_buffer_offset = 0; - } - const int32_t byte_buffer_limit = byte_buffer->GetField32( - GetMemberOffset(WellKnownClasses::java_nio_ByteBuffer_limit)); - - const Primitive::Type primitive_type = GetVarType()->GetPrimitiveType(); - if (!CheckElementIndex(primitive_type, byte_index, byte_buffer_offset, byte_buffer_limit)) { - return false; - } - const int32_t checked_offset32 = byte_buffer_offset + byte_index; - - int8_t* data; - if (native_address == 0) { - ObjPtr<ByteArray> heap_byte_array = byte_buffer->GetFieldObject<ByteArray>( - GetMemberOffset(WellKnownClasses::java_nio_ByteBuffer_hb)); - data = heap_byte_array->GetData(); - } else { - data = reinterpret_cast<int8_t*>(static_cast<uint32_t>(native_address)); - } - - bool byte_swap = !GetNativeByteOrder(); - switch (primitive_type) { - case Primitive::kPrimChar: - return ByteArrayViewAccessor<uint16_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::kPrimShort: - return ByteArrayViewAccessor<int16_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::kPrimInt: - return ByteArrayViewAccessor<int32_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::kPrimFloat: - // Treated as a bitwise representation. See javadoc comments for - // java.lang.invoke.MethodHandles.byteArrayViewVarHandle(). - return ByteArrayViewAccessor<int32_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::kPrimLong: - return ByteArrayViewAccessor<int64_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::kPrimDouble: - // Treated as a bitwise representation. See javadoc comments for - // java.lang.invoke.MethodHandles.byteArrayViewVarHandle(). - return ByteArrayViewAccessor<int64_t>::Dispatch(access_mode, - data, - checked_offset32, - byte_swap, - &getter, - result); - case Primitive::Type::kPrimNot: - case Primitive::kPrimBoolean: - case Primitive::kPrimByte: - case Primitive::kPrimVoid: - // These are not supported for byte array views and not instantiable. - break; - } - LOG(FATAL) << "Unreachable: Unexpected primitive " << primitive_type; - UNREACHABLE(); -} - Class* ByteBufferViewVarHandle::StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { return static_class_.Read(); } diff --git a/runtime/mirror/var_handle.h b/runtime/mirror/var_handle.h index 6565af7f06..7b48669bba 100644 --- a/runtime/mirror/var_handle.h +++ b/runtime/mirror/var_handle.h @@ -18,24 +18,18 @@ #define ART_RUNTIME_MIRROR_VAR_HANDLE_H_ #include "handle.h" -#include "interpreter/shadow_frame.h" #include "gc_root.h" -#include "jvalue.h" #include "object.h" namespace art { template<class T> class Handle; -class InstructionOperands; - struct VarHandleOffsets; struct FieldVarHandleOffsets; struct ArrayElementVarHandleOffsets; struct ByteArrayViewVarHandleOffsets; struct ByteBufferViewVarHandleOffsets; -class ShadowFrameGetter; - namespace mirror { class MethodType; @@ -50,10 +44,6 @@ class MANAGED VarHandle : public Object { // (array, index, old, new). static constexpr int kMaxAccessorParameters = 4; - // The maximum number of VarType parameters a VarHandle accessor - // method can take. - static constexpr size_t kMaxVarTypeParameters = 2; - // Enumeration of the possible access modes. This mirrors the enum // in java.lang.invoke.VarHandle. enum class AccessMode : uint32_t { @@ -111,16 +101,11 @@ class MANAGED VarHandle : public Object { // supported operation so the MethodType can be used when raising a // WrongMethodTypeException exception. MethodType* GetMethodTypeForAccessMode(Thread* self, AccessMode accessMode) - REQUIRES_SHARED(Locks::mutator_lock_); - - bool Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); - // Gets the variable type that is operated on by this VarHandle instance. - Class* GetVarType() REQUIRES_SHARED(Locks::mutator_lock_); + static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { + return static_class_.Read(); + } // Gets the return type descriptor for a named accessor method, // nullptr if accessor_method is not supported. @@ -130,13 +115,12 @@ class MANAGED VarHandle : public Object { // VarHandle access method, such as "setOpaque". Returns false otherwise. static bool GetAccessModeByMethodName(const char* method_name, AccessMode* access_mode); - - static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_); static void SetClass(Class* klass) REQUIRES_SHARED(Locks::mutator_lock_); static void ResetClass() REQUIRES_SHARED(Locks::mutator_lock_); static void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_); private: + Class* GetVarType() REQUIRES_SHARED(Locks::mutator_lock_); Class* GetCoordinateType0() REQUIRES_SHARED(Locks::mutator_lock_); Class* GetCoordinateType1() REQUIRES_SHARED(Locks::mutator_lock_); int32_t GetAccessModesBitMask() REQUIRES_SHARED(Locks::mutator_lock_); @@ -179,12 +163,6 @@ class MANAGED VarHandle : public Object { // The corresponding managed class in libart java.lang.invoke.FieldVarHandle. class MANAGED FieldVarHandle : public VarHandle { public: - bool Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - ArtField* GetField() REQUIRES_SHARED(Locks::mutator_lock_); static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_); @@ -212,12 +190,6 @@ class MANAGED FieldVarHandle : public VarHandle { // The corresponding managed class in libart java.lang.invoke.ArrayElementVarHandle. class MANAGED ArrayElementVarHandle : public VarHandle { public: - bool Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_); static void SetClass(Class* klass) REQUIRES_SHARED(Locks::mutator_lock_); static void ResetClass() REQUIRES_SHARED(Locks::mutator_lock_); @@ -235,12 +207,6 @@ class MANAGED ArrayElementVarHandle : public VarHandle { // The corresponding managed class in libart java.lang.invoke.ByteArrayViewVarHandle. class MANAGED ByteArrayViewVarHandle : public VarHandle { public: - bool Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - bool GetNativeByteOrder() REQUIRES_SHARED(Locks::mutator_lock_); static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_); @@ -268,35 +234,17 @@ class MANAGED ByteArrayViewVarHandle : public VarHandle { // The corresponding managed class in libart java.lang.invoke.ByteBufferViewVarHandle. class MANAGED ByteBufferViewVarHandle : public VarHandle { public: - bool Access(AccessMode access_mode, - ShadowFrame* shadow_frame, - InstructionOperands* operands, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - bool GetNativeByteOrder() REQUIRES_SHARED(Locks::mutator_lock_); + static ByteBufferViewVarHandle* Create(Thread* const self, bool native_byte_order) + REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); + static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_); static void SetClass(Class* klass) REQUIRES_SHARED(Locks::mutator_lock_); static void ResetClass() REQUIRES_SHARED(Locks::mutator_lock_); static void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_); private: - bool AccessHeapBuffer(AccessMode access_mode, - ObjPtr<Object> byte_buffer, - int buffer_offset, - ObjPtr<ByteArray> heap_byte_array, - ShadowFrameGetter* getter, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - - bool AccessFixedMemory(AccessMode access_mode, - ObjPtr<Object> byte_buffer, - int buffer_offset, - ShadowFrameGetter* getter, - JValue* result) - REQUIRES_SHARED(Locks::mutator_lock_); - static MemberOffset NativeByteOrderOffset() { return MemberOffset(OFFSETOF_MEMBER(ByteBufferViewVarHandle, native_byte_order_)); } diff --git a/runtime/mirror/var_handle_test.cc b/runtime/mirror/var_handle_test.cc index d9fa07f207..e844fd4436 100644 --- a/runtime/mirror/var_handle_test.cc +++ b/runtime/mirror/var_handle_test.cc @@ -327,7 +327,7 @@ TEST_F(VarHandleTest, InstanceFieldVarHandle) { EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;II)I"))); EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;II)V"))); EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;I)Z"))); - EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(IIII)V"))); + EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(III)V"))); } // Check compatibility - "GetAndUpdate" pattern @@ -336,7 +336,7 @@ TEST_F(VarHandleTest, InstanceFieldVarHandle) { EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;I)I"))); EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;I)V"))); EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(Ljava/lang/Integer;I)Z"))); - EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)S"))); + EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)V"))); } // Check synthesized method types match expected forms. @@ -461,8 +461,8 @@ TEST_F(VarHandleTest, StaticFieldVarHandle) { EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)I"))); EXPECT_TRUE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)V"))); EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(ID)I"))); - EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)S"))); - EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(IIJ)V"))); + EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(II)D"))); + EXPECT_FALSE(fvh->IsMethodTypeCompatible(access_mode, MethodTypeOf("(III)V"))); } // Check compatibility - "GetAndUpdate" pattern diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc index 3e9dfd18d7..afb3224944 100644 --- a/runtime/verifier/method_verifier.cc +++ b/runtime/verifier/method_verifier.cc @@ -4432,8 +4432,6 @@ bool MethodVerifier::CheckSignaturePolymorphicMethod(ArtMethod* method) { expected_return_descriptor = mirror::MethodHandle::GetReturnTypeDescriptor(method_name); } else if (klass == mirror::VarHandle::StaticClass()) { expected_return_descriptor = mirror::VarHandle::GetReturnTypeDescriptor(method_name); - // TODO: add compiler support for VarHandle accessor methods (b/71781600) - Fail(VERIFY_ERROR_FORCE_INTERPRETER); } else { Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Signature polymorphic method in unsuppported class: " << klass->PrettyDescriptor(); diff --git a/runtime/well_known_classes.cc b/runtime/well_known_classes.cc index 902c3b84b5..5fe10f5c12 100644 --- a/runtime/well_known_classes.cc +++ b/runtime/well_known_classes.cc @@ -72,7 +72,6 @@ jclass WellKnownClasses::java_lang_System; jclass WellKnownClasses::java_lang_Thread; jclass WellKnownClasses::java_lang_ThreadGroup; jclass WellKnownClasses::java_lang_Throwable; -jclass WellKnownClasses::java_nio_ByteBuffer; jclass WellKnownClasses::java_nio_DirectByteBuffer; jclass WellKnownClasses::java_util_ArrayList; jclass WellKnownClasses::java_util_Collections; @@ -143,11 +142,6 @@ jfieldID WellKnownClasses::java_lang_Throwable_stackState; jfieldID WellKnownClasses::java_lang_Throwable_suppressedExceptions; jfieldID WellKnownClasses::java_lang_reflect_Executable_artMethod; jfieldID WellKnownClasses::java_lang_reflect_Proxy_h; -jfieldID WellKnownClasses::java_nio_ByteBuffer_address; -jfieldID WellKnownClasses::java_nio_ByteBuffer_hb; -jfieldID WellKnownClasses::java_nio_ByteBuffer_isReadOnly; -jfieldID WellKnownClasses::java_nio_ByteBuffer_limit; -jfieldID WellKnownClasses::java_nio_ByteBuffer_offset; jfieldID WellKnownClasses::java_nio_DirectByteBuffer_capacity; jfieldID WellKnownClasses::java_nio_DirectByteBuffer_effectiveDirectAddress; jfieldID WellKnownClasses::java_util_ArrayList_array; @@ -324,7 +318,6 @@ void WellKnownClasses::Init(JNIEnv* env) { java_lang_Thread = CacheClass(env, "java/lang/Thread"); java_lang_ThreadGroup = CacheClass(env, "java/lang/ThreadGroup"); java_lang_Throwable = CacheClass(env, "java/lang/Throwable"); - java_nio_ByteBuffer = CacheClass(env, "java/nio/ByteBuffer"); java_nio_DirectByteBuffer = CacheClass(env, "java/nio/DirectByteBuffer"); java_util_ArrayList = CacheClass(env, "java/util/ArrayList"); java_util_Collections = CacheClass(env, "java/util/Collections"); @@ -386,11 +379,6 @@ void WellKnownClasses::Init(JNIEnv* env) { java_lang_Throwable_stackState = CacheField(env, java_lang_Throwable, false, "backtrace", "Ljava/lang/Object;"); java_lang_Throwable_suppressedExceptions = CacheField(env, java_lang_Throwable, false, "suppressedExceptions", "Ljava/util/List;"); java_lang_reflect_Executable_artMethod = CacheField(env, java_lang_reflect_Executable, false, "artMethod", "J"); - java_nio_ByteBuffer_address = CacheField(env, java_nio_ByteBuffer, false, "address", "J"); - java_nio_ByteBuffer_hb = CacheField(env, java_nio_ByteBuffer, false, "hb", "[B"); - java_nio_ByteBuffer_isReadOnly = CacheField(env, java_nio_ByteBuffer, false, "isReadOnly", "Z"); - java_nio_ByteBuffer_limit = CacheField(env, java_nio_ByteBuffer, false, "limit", "I"); - java_nio_ByteBuffer_offset = CacheField(env, java_nio_ByteBuffer, false, "offset", "I"); java_nio_DirectByteBuffer_capacity = CacheField(env, java_nio_DirectByteBuffer, false, "capacity", "I"); java_nio_DirectByteBuffer_effectiveDirectAddress = CacheField(env, java_nio_DirectByteBuffer, false, "address", "J"); java_util_ArrayList_array = CacheField(env, java_util_ArrayList, false, "elementData", "[Ljava/lang/Object;"); @@ -474,7 +462,6 @@ void WellKnownClasses::Clear() { java_lang_Throwable = nullptr; java_util_ArrayList = nullptr; java_util_Collections = nullptr; - java_nio_ByteBuffer = nullptr; java_nio_DirectByteBuffer = nullptr; libcore_reflect_AnnotationFactory = nullptr; libcore_reflect_AnnotationMember = nullptr; @@ -543,11 +530,6 @@ void WellKnownClasses::Clear() { java_lang_Throwable_stackTrace = nullptr; java_lang_Throwable_stackState = nullptr; java_lang_Throwable_suppressedExceptions = nullptr; - java_nio_ByteBuffer_address = nullptr; - java_nio_ByteBuffer_hb = nullptr; - java_nio_ByteBuffer_isReadOnly = nullptr; - java_nio_ByteBuffer_limit = nullptr; - java_nio_ByteBuffer_offset = nullptr; java_nio_DirectByteBuffer_capacity = nullptr; java_nio_DirectByteBuffer_effectiveDirectAddress = nullptr; java_util_ArrayList_array = nullptr; diff --git a/runtime/well_known_classes.h b/runtime/well_known_classes.h index d5d7033132..9e0b079b7b 100644 --- a/runtime/well_known_classes.h +++ b/runtime/well_known_classes.h @@ -85,7 +85,6 @@ struct WellKnownClasses { static jclass java_lang_Throwable; static jclass java_util_ArrayList; static jclass java_util_Collections; - static jclass java_nio_ByteBuffer; static jclass java_nio_DirectByteBuffer; static jclass libcore_reflect_AnnotationFactory; static jclass libcore_reflect_AnnotationMember; @@ -154,14 +153,8 @@ struct WellKnownClasses { static jfieldID java_lang_Throwable_stackTrace; static jfieldID java_lang_Throwable_stackState; static jfieldID java_lang_Throwable_suppressedExceptions; - static jfieldID java_nio_ByteBuffer_address; - static jfieldID java_nio_ByteBuffer_hb; - static jfieldID java_nio_ByteBuffer_isReadOnly; - static jfieldID java_nio_ByteBuffer_limit; - static jfieldID java_nio_ByteBuffer_offset; static jfieldID java_nio_DirectByteBuffer_capacity; static jfieldID java_nio_DirectByteBuffer_effectiveDirectAddress; - static jfieldID java_util_ArrayList_array; static jfieldID java_util_ArrayList_size; static jfieldID java_util_Collections_EMPTY_LIST; diff --git a/test/712-varhandle-invocations/build b/test/712-varhandle-invocations/build deleted file mode 100755 index 253765be91..0000000000 --- a/test/712-varhandle-invocations/build +++ /dev/null @@ -1,39 +0,0 @@ -#!/bin/bash -# -# Copyright 2018 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# Make us exit on a failure -set -e - -# Set variables for source directories. Using src-art so we use -# VarHandles in the bootclasspath and can compile with the Java 8 -# compiler. -MANUAL_SRC=src -GENERATED_SRC=src2 - -# Build the Java files -mkdir -p src2 - -# Collate list of manual test classes -MANUAL_TESTS=$(cd "${MANUAL_SRC}" && find . -name 'Var*Tests.java' | sed -e 's@.*\(Var.*Tests\).*@\1@g' | sort) - -# Generate tests and Main that covers both the generated tests and manual tests -python3 ./util-src/generate_java.py "${GENERATED_SRC}" ${MANUAL_TESTS} - -# Desugar is not happy with our Java 9 byte code, it shouldn't be necessary here anyway. -export USE_DESUGAR=false - -# Invoke default build with increased heap size for dx -./default-build "$@" --experimental var-handles --dx-vm-option -JXmx384m diff --git a/test/712-varhandle-invocations/expected.txt b/test/712-varhandle-invocations/expected.txt deleted file mode 100644 index af921901f8..0000000000 --- a/test/712-varhandle-invocations/expected.txt +++ /dev/null @@ -1,3183 +0,0 @@ -FieldGetBoolean...OK -FieldGetByte...OK -FieldGetShort...OK -FieldGetChar...OK -FieldGetInt...OK -FieldGetLong...OK -FieldGetFloat...OK -FieldGetDouble...OK -FieldSetBoolean...OK -FieldSetByte...OK -FieldSetShort...OK -FieldSetChar...OK -FieldSetInt...OK -FieldSetLong...OK -FieldSetFloat...OK -FieldSetDouble...OK -FieldGetVolatileBoolean...OK -FieldGetVolatileByte...OK -FieldGetVolatileShort...OK -FieldGetVolatileChar...OK -FieldGetVolatileInt...OK -FieldGetVolatileLong...OK -FieldGetVolatileFloat...OK -FieldGetVolatileDouble...OK -FieldSetVolatileBoolean...OK -FieldSetVolatileByte...OK -FieldSetVolatileShort...OK -FieldSetVolatileChar...OK -FieldSetVolatileInt...OK -FieldSetVolatileLong...OK -FieldSetVolatileFloat...OK -FieldSetVolatileDouble...OK -FieldGetAcquireBoolean...OK -FieldGetAcquireByte...OK -FieldGetAcquireShort...OK -FieldGetAcquireChar...OK -FieldGetAcquireInt...OK -FieldGetAcquireLong...OK -FieldGetAcquireFloat...OK -FieldGetAcquireDouble...OK -FieldSetReleaseBoolean...OK -FieldSetReleaseByte...OK -FieldSetReleaseShort...OK -FieldSetReleaseChar...OK -FieldSetReleaseInt...OK -FieldSetReleaseLong...OK -FieldSetReleaseFloat...OK -FieldSetReleaseDouble...OK -FieldGetOpaqueBoolean...OK -FieldGetOpaqueByte...OK -FieldGetOpaqueShort...OK -FieldGetOpaqueChar...OK -FieldGetOpaqueInt...OK -FieldGetOpaqueLong...OK -FieldGetOpaqueFloat...OK -FieldGetOpaqueDouble...OK -FieldSetOpaqueBoolean...OK -FieldSetOpaqueByte...OK -FieldSetOpaqueShort...OK -FieldSetOpaqueChar...OK -FieldSetOpaqueInt...OK -FieldSetOpaqueLong...OK -FieldSetOpaqueFloat...OK -FieldSetOpaqueDouble...OK -FieldCompareAndSetBoolean...OK -FieldCompareAndSetByte...OK -FieldCompareAndSetShort...OK -FieldCompareAndSetChar...OK -FieldCompareAndSetInt...OK -FieldCompareAndSetLong...OK -FieldCompareAndSetFloat...OK -FieldCompareAndSetDouble...OK -FieldCompareAndExchangeBoolean...OK -FieldCompareAndExchangeByte...OK -FieldCompareAndExchangeShort...OK -FieldCompareAndExchangeChar...OK -FieldCompareAndExchangeInt...OK -FieldCompareAndExchangeLong...OK -FieldCompareAndExchangeFloat...OK -FieldCompareAndExchangeDouble...OK -FieldCompareAndExchangeAcquireBoolean...OK -FieldCompareAndExchangeAcquireByte...OK -FieldCompareAndExchangeAcquireShort...OK -FieldCompareAndExchangeAcquireChar...OK -FieldCompareAndExchangeAcquireInt...OK -FieldCompareAndExchangeAcquireLong...OK -FieldCompareAndExchangeAcquireFloat...OK -FieldCompareAndExchangeAcquireDouble...OK -FieldCompareAndExchangeReleaseBoolean...OK -FieldCompareAndExchangeReleaseByte...OK -FieldCompareAndExchangeReleaseShort...OK -FieldCompareAndExchangeReleaseChar...OK -FieldCompareAndExchangeReleaseInt...OK -FieldCompareAndExchangeReleaseLong...OK -FieldCompareAndExchangeReleaseFloat...OK -FieldCompareAndExchangeReleaseDouble...OK -FieldWeakCompareAndSetPlainBoolean...OK -FieldWeakCompareAndSetPlainByte...OK -FieldWeakCompareAndSetPlainShort...OK -FieldWeakCompareAndSetPlainChar...OK -FieldWeakCompareAndSetPlainInt...OK -FieldWeakCompareAndSetPlainLong...OK -FieldWeakCompareAndSetPlainFloat...OK -FieldWeakCompareAndSetPlainDouble...OK -FieldWeakCompareAndSetBoolean...OK -FieldWeakCompareAndSetByte...OK -FieldWeakCompareAndSetShort...OK -FieldWeakCompareAndSetChar...OK -FieldWeakCompareAndSetInt...OK -FieldWeakCompareAndSetLong...OK -FieldWeakCompareAndSetFloat...OK -FieldWeakCompareAndSetDouble...OK -FieldWeakCompareAndSetAcquireBoolean...OK -FieldWeakCompareAndSetAcquireByte...OK -FieldWeakCompareAndSetAcquireShort...OK -FieldWeakCompareAndSetAcquireChar...OK -FieldWeakCompareAndSetAcquireInt...OK -FieldWeakCompareAndSetAcquireLong...OK -FieldWeakCompareAndSetAcquireFloat...OK -FieldWeakCompareAndSetAcquireDouble...OK -FieldWeakCompareAndSetReleaseBoolean...OK -FieldWeakCompareAndSetReleaseByte...OK -FieldWeakCompareAndSetReleaseShort...OK -FieldWeakCompareAndSetReleaseChar...OK -FieldWeakCompareAndSetReleaseInt...OK -FieldWeakCompareAndSetReleaseLong...OK -FieldWeakCompareAndSetReleaseFloat...OK -FieldWeakCompareAndSetReleaseDouble...OK -FieldGetAndSetBoolean...OK -FieldGetAndSetByte...OK -FieldGetAndSetShort...OK -FieldGetAndSetChar...OK -FieldGetAndSetInt...OK -FieldGetAndSetLong...OK -FieldGetAndSetFloat...OK -FieldGetAndSetDouble...OK -FieldGetAndSetAcquireBoolean...OK -FieldGetAndSetAcquireByte...OK -FieldGetAndSetAcquireShort...OK -FieldGetAndSetAcquireChar...OK -FieldGetAndSetAcquireInt...OK -FieldGetAndSetAcquireLong...OK -FieldGetAndSetAcquireFloat...OK -FieldGetAndSetAcquireDouble...OK -FieldGetAndSetReleaseBoolean...OK -FieldGetAndSetReleaseByte...OK -FieldGetAndSetReleaseShort...OK -FieldGetAndSetReleaseChar...OK -FieldGetAndSetReleaseInt...OK -FieldGetAndSetReleaseLong...OK -FieldGetAndSetReleaseFloat...OK -FieldGetAndSetReleaseDouble...OK -FieldGetAndAddBoolean...OK -FieldGetAndAddByte...OK -FieldGetAndAddShort...OK -FieldGetAndAddChar...OK -FieldGetAndAddInt...OK -FieldGetAndAddLong...OK -FieldGetAndAddFloat...OK -FieldGetAndAddDouble...OK -FieldGetAndAddAcquireBoolean...OK -FieldGetAndAddAcquireByte...OK -FieldGetAndAddAcquireShort...OK -FieldGetAndAddAcquireChar...OK -FieldGetAndAddAcquireInt...OK -FieldGetAndAddAcquireLong...OK -FieldGetAndAddAcquireFloat...OK -FieldGetAndAddAcquireDouble...OK -FieldGetAndAddReleaseBoolean...OK -FieldGetAndAddReleaseByte...OK -FieldGetAndAddReleaseShort...OK -FieldGetAndAddReleaseChar...OK -FieldGetAndAddReleaseInt...OK -FieldGetAndAddReleaseLong...OK -FieldGetAndAddReleaseFloat...OK -FieldGetAndAddReleaseDouble...OK -FieldGetAndBitwiseOrBoolean...OK -FieldGetAndBitwiseOrByte...OK -FieldGetAndBitwiseOrShort...OK -FieldGetAndBitwiseOrChar...OK -FieldGetAndBitwiseOrInt...OK -FieldGetAndBitwiseOrLong...OK -FieldGetAndBitwiseOrFloat...OK -FieldGetAndBitwiseOrDouble...OK -FieldGetAndBitwiseOrReleaseBoolean...OK -FieldGetAndBitwiseOrReleaseByte...OK -FieldGetAndBitwiseOrReleaseShort...OK -FieldGetAndBitwiseOrReleaseChar...OK -FieldGetAndBitwiseOrReleaseInt...OK -FieldGetAndBitwiseOrReleaseLong...OK -FieldGetAndBitwiseOrReleaseFloat...OK -FieldGetAndBitwiseOrReleaseDouble...OK -FieldGetAndBitwiseOrAcquireBoolean...OK -FieldGetAndBitwiseOrAcquireByte...OK -FieldGetAndBitwiseOrAcquireShort...OK -FieldGetAndBitwiseOrAcquireChar...OK -FieldGetAndBitwiseOrAcquireInt...OK -FieldGetAndBitwiseOrAcquireLong...OK -FieldGetAndBitwiseOrAcquireFloat...OK -FieldGetAndBitwiseOrAcquireDouble...OK -FieldGetAndBitwiseAndBoolean...OK -FieldGetAndBitwiseAndByte...OK -FieldGetAndBitwiseAndShort...OK -FieldGetAndBitwiseAndChar...OK -FieldGetAndBitwiseAndInt...OK -FieldGetAndBitwiseAndLong...OK -FieldGetAndBitwiseAndFloat...OK -FieldGetAndBitwiseAndDouble...OK -FieldGetAndBitwiseAndReleaseBoolean...OK -FieldGetAndBitwiseAndReleaseByte...OK -FieldGetAndBitwiseAndReleaseShort...OK -FieldGetAndBitwiseAndReleaseChar...OK -FieldGetAndBitwiseAndReleaseInt...OK -FieldGetAndBitwiseAndReleaseLong...OK -FieldGetAndBitwiseAndReleaseFloat...OK -FieldGetAndBitwiseAndReleaseDouble...OK -FieldGetAndBitwiseAndAcquireBoolean...OK -FieldGetAndBitwiseAndAcquireByte...OK -FieldGetAndBitwiseAndAcquireShort...OK -FieldGetAndBitwiseAndAcquireChar...OK -FieldGetAndBitwiseAndAcquireInt...OK -FieldGetAndBitwiseAndAcquireLong...OK -FieldGetAndBitwiseAndAcquireFloat...OK -FieldGetAndBitwiseAndAcquireDouble...OK -FieldGetAndBitwiseXorBoolean...OK -FieldGetAndBitwiseXorByte...OK -FieldGetAndBitwiseXorShort...OK -FieldGetAndBitwiseXorChar...OK -FieldGetAndBitwiseXorInt...OK -FieldGetAndBitwiseXorLong...OK -FieldGetAndBitwiseXorFloat...OK -FieldGetAndBitwiseXorDouble...OK -FieldGetAndBitwiseXorReleaseBoolean...OK -FieldGetAndBitwiseXorReleaseByte...OK -FieldGetAndBitwiseXorReleaseShort...OK -FieldGetAndBitwiseXorReleaseChar...OK -FieldGetAndBitwiseXorReleaseInt...OK -FieldGetAndBitwiseXorReleaseLong...OK -FieldGetAndBitwiseXorReleaseFloat...OK -FieldGetAndBitwiseXorReleaseDouble...OK -FieldGetAndBitwiseXorAcquireBoolean...OK -FieldGetAndBitwiseXorAcquireByte...OK -FieldGetAndBitwiseXorAcquireShort...OK -FieldGetAndBitwiseXorAcquireChar...OK -FieldGetAndBitwiseXorAcquireInt...OK -FieldGetAndBitwiseXorAcquireLong...OK -FieldGetAndBitwiseXorAcquireFloat...OK -FieldGetAndBitwiseXorAcquireDouble...OK -FinalFieldGetBoolean...OK -FinalFieldGetByte...OK -FinalFieldGetShort...OK -FinalFieldGetChar...OK -FinalFieldGetInt...OK -FinalFieldGetLong...OK -FinalFieldGetFloat...OK -FinalFieldGetDouble...OK -FinalFieldSetBoolean...OK -FinalFieldSetByte...OK -FinalFieldSetShort...OK -FinalFieldSetChar...OK -FinalFieldSetInt...OK -FinalFieldSetLong...OK -FinalFieldSetFloat...OK -FinalFieldSetDouble...OK -FinalFieldGetVolatileBoolean...OK -FinalFieldGetVolatileByte...OK -FinalFieldGetVolatileShort...OK -FinalFieldGetVolatileChar...OK -FinalFieldGetVolatileInt...OK -FinalFieldGetVolatileLong...OK -FinalFieldGetVolatileFloat...OK -FinalFieldGetVolatileDouble...OK -FinalFieldSetVolatileBoolean...OK -FinalFieldSetVolatileByte...OK -FinalFieldSetVolatileShort...OK -FinalFieldSetVolatileChar...OK -FinalFieldSetVolatileInt...OK -FinalFieldSetVolatileLong...OK -FinalFieldSetVolatileFloat...OK -FinalFieldSetVolatileDouble...OK -FinalFieldGetAcquireBoolean...OK -FinalFieldGetAcquireByte...OK -FinalFieldGetAcquireShort...OK -FinalFieldGetAcquireChar...OK -FinalFieldGetAcquireInt...OK -FinalFieldGetAcquireLong...OK -FinalFieldGetAcquireFloat...OK -FinalFieldGetAcquireDouble...OK -FinalFieldSetReleaseBoolean...OK -FinalFieldSetReleaseByte...OK -FinalFieldSetReleaseShort...OK -FinalFieldSetReleaseChar...OK -FinalFieldSetReleaseInt...OK -FinalFieldSetReleaseLong...OK -FinalFieldSetReleaseFloat...OK -FinalFieldSetReleaseDouble...OK -FinalFieldGetOpaqueBoolean...OK -FinalFieldGetOpaqueByte...OK -FinalFieldGetOpaqueShort...OK -FinalFieldGetOpaqueChar...OK -FinalFieldGetOpaqueInt...OK -FinalFieldGetOpaqueLong...OK -FinalFieldGetOpaqueFloat...OK -FinalFieldGetOpaqueDouble...OK -FinalFieldSetOpaqueBoolean...OK -FinalFieldSetOpaqueByte...OK -FinalFieldSetOpaqueShort...OK -FinalFieldSetOpaqueChar...OK -FinalFieldSetOpaqueInt...OK -FinalFieldSetOpaqueLong...OK -FinalFieldSetOpaqueFloat...OK -FinalFieldSetOpaqueDouble...OK -FinalFieldCompareAndSetBoolean...OK -FinalFieldCompareAndSetByte...OK -FinalFieldCompareAndSetShort...OK -FinalFieldCompareAndSetChar...OK -FinalFieldCompareAndSetInt...OK -FinalFieldCompareAndSetLong...OK -FinalFieldCompareAndSetFloat...OK -FinalFieldCompareAndSetDouble...OK -FinalFieldCompareAndExchangeBoolean...OK -FinalFieldCompareAndExchangeByte...OK -FinalFieldCompareAndExchangeShort...OK -FinalFieldCompareAndExchangeChar...OK -FinalFieldCompareAndExchangeInt...OK -FinalFieldCompareAndExchangeLong...OK -FinalFieldCompareAndExchangeFloat...OK -FinalFieldCompareAndExchangeDouble...OK -FinalFieldCompareAndExchangeAcquireBoolean...OK -FinalFieldCompareAndExchangeAcquireByte...OK -FinalFieldCompareAndExchangeAcquireShort...OK -FinalFieldCompareAndExchangeAcquireChar...OK -FinalFieldCompareAndExchangeAcquireInt...OK -FinalFieldCompareAndExchangeAcquireLong...OK -FinalFieldCompareAndExchangeAcquireFloat...OK -FinalFieldCompareAndExchangeAcquireDouble...OK -FinalFieldCompareAndExchangeReleaseBoolean...OK -FinalFieldCompareAndExchangeReleaseByte...OK -FinalFieldCompareAndExchangeReleaseShort...OK -FinalFieldCompareAndExchangeReleaseChar...OK -FinalFieldCompareAndExchangeReleaseInt...OK -FinalFieldCompareAndExchangeReleaseLong...OK -FinalFieldCompareAndExchangeReleaseFloat...OK -FinalFieldCompareAndExchangeReleaseDouble...OK -FinalFieldWeakCompareAndSetPlainBoolean...OK -FinalFieldWeakCompareAndSetPlainByte...OK -FinalFieldWeakCompareAndSetPlainShort...OK -FinalFieldWeakCompareAndSetPlainChar...OK -FinalFieldWeakCompareAndSetPlainInt...OK -FinalFieldWeakCompareAndSetPlainLong...OK -FinalFieldWeakCompareAndSetPlainFloat...OK -FinalFieldWeakCompareAndSetPlainDouble...OK -FinalFieldWeakCompareAndSetBoolean...OK -FinalFieldWeakCompareAndSetByte...OK -FinalFieldWeakCompareAndSetShort...OK -FinalFieldWeakCompareAndSetChar...OK -FinalFieldWeakCompareAndSetInt...OK -FinalFieldWeakCompareAndSetLong...OK -FinalFieldWeakCompareAndSetFloat...OK -FinalFieldWeakCompareAndSetDouble...OK -FinalFieldWeakCompareAndSetAcquireBoolean...OK -FinalFieldWeakCompareAndSetAcquireByte...OK -FinalFieldWeakCompareAndSetAcquireShort...OK -FinalFieldWeakCompareAndSetAcquireChar...OK -FinalFieldWeakCompareAndSetAcquireInt...OK -FinalFieldWeakCompareAndSetAcquireLong...OK -FinalFieldWeakCompareAndSetAcquireFloat...OK -FinalFieldWeakCompareAndSetAcquireDouble...OK -FinalFieldWeakCompareAndSetReleaseBoolean...OK -FinalFieldWeakCompareAndSetReleaseByte...OK -FinalFieldWeakCompareAndSetReleaseShort...OK -FinalFieldWeakCompareAndSetReleaseChar...OK -FinalFieldWeakCompareAndSetReleaseInt...OK -FinalFieldWeakCompareAndSetReleaseLong...OK -FinalFieldWeakCompareAndSetReleaseFloat...OK -FinalFieldWeakCompareAndSetReleaseDouble...OK -FinalFieldGetAndSetBoolean...OK -FinalFieldGetAndSetByte...OK -FinalFieldGetAndSetShort...OK -FinalFieldGetAndSetChar...OK -FinalFieldGetAndSetInt...OK -FinalFieldGetAndSetLong...OK -FinalFieldGetAndSetFloat...OK -FinalFieldGetAndSetDouble...OK -FinalFieldGetAndSetAcquireBoolean...OK -FinalFieldGetAndSetAcquireByte...OK -FinalFieldGetAndSetAcquireShort...OK -FinalFieldGetAndSetAcquireChar...OK -FinalFieldGetAndSetAcquireInt...OK -FinalFieldGetAndSetAcquireLong...OK -FinalFieldGetAndSetAcquireFloat...OK -FinalFieldGetAndSetAcquireDouble...OK -FinalFieldGetAndSetReleaseBoolean...OK -FinalFieldGetAndSetReleaseByte...OK -FinalFieldGetAndSetReleaseShort...OK -FinalFieldGetAndSetReleaseChar...OK -FinalFieldGetAndSetReleaseInt...OK -FinalFieldGetAndSetReleaseLong...OK -FinalFieldGetAndSetReleaseFloat...OK -FinalFieldGetAndSetReleaseDouble...OK -FinalFieldGetAndAddBoolean...OK -FinalFieldGetAndAddByte...OK -FinalFieldGetAndAddShort...OK -FinalFieldGetAndAddChar...OK -FinalFieldGetAndAddInt...OK -FinalFieldGetAndAddLong...OK -FinalFieldGetAndAddFloat...OK -FinalFieldGetAndAddDouble...OK -FinalFieldGetAndAddAcquireBoolean...OK -FinalFieldGetAndAddAcquireByte...OK -FinalFieldGetAndAddAcquireShort...OK -FinalFieldGetAndAddAcquireChar...OK -FinalFieldGetAndAddAcquireInt...OK -FinalFieldGetAndAddAcquireLong...OK -FinalFieldGetAndAddAcquireFloat...OK -FinalFieldGetAndAddAcquireDouble...OK -FinalFieldGetAndAddReleaseBoolean...OK -FinalFieldGetAndAddReleaseByte...OK -FinalFieldGetAndAddReleaseShort...OK -FinalFieldGetAndAddReleaseChar...OK -FinalFieldGetAndAddReleaseInt...OK -FinalFieldGetAndAddReleaseLong...OK -FinalFieldGetAndAddReleaseFloat...OK -FinalFieldGetAndAddReleaseDouble...OK -FinalFieldGetAndBitwiseOrBoolean...OK -FinalFieldGetAndBitwiseOrByte...OK -FinalFieldGetAndBitwiseOrShort...OK -FinalFieldGetAndBitwiseOrChar...OK -FinalFieldGetAndBitwiseOrInt...OK -FinalFieldGetAndBitwiseOrLong...OK -FinalFieldGetAndBitwiseOrFloat...OK -FinalFieldGetAndBitwiseOrDouble...OK -FinalFieldGetAndBitwiseOrReleaseBoolean...OK -FinalFieldGetAndBitwiseOrReleaseByte...OK -FinalFieldGetAndBitwiseOrReleaseShort...OK -FinalFieldGetAndBitwiseOrReleaseChar...OK -FinalFieldGetAndBitwiseOrReleaseInt...OK -FinalFieldGetAndBitwiseOrReleaseLong...OK -FinalFieldGetAndBitwiseOrReleaseFloat...OK -FinalFieldGetAndBitwiseOrReleaseDouble...OK -FinalFieldGetAndBitwiseOrAcquireBoolean...OK -FinalFieldGetAndBitwiseOrAcquireByte...OK -FinalFieldGetAndBitwiseOrAcquireShort...OK -FinalFieldGetAndBitwiseOrAcquireChar...OK -FinalFieldGetAndBitwiseOrAcquireInt...OK -FinalFieldGetAndBitwiseOrAcquireLong...OK -FinalFieldGetAndBitwiseOrAcquireFloat...OK -FinalFieldGetAndBitwiseOrAcquireDouble...OK -FinalFieldGetAndBitwiseAndBoolean...OK -FinalFieldGetAndBitwiseAndByte...OK -FinalFieldGetAndBitwiseAndShort...OK -FinalFieldGetAndBitwiseAndChar...OK -FinalFieldGetAndBitwiseAndInt...OK -FinalFieldGetAndBitwiseAndLong...OK -FinalFieldGetAndBitwiseAndFloat...OK -FinalFieldGetAndBitwiseAndDouble...OK -FinalFieldGetAndBitwiseAndReleaseBoolean...OK -FinalFieldGetAndBitwiseAndReleaseByte...OK -FinalFieldGetAndBitwiseAndReleaseShort...OK -FinalFieldGetAndBitwiseAndReleaseChar...OK -FinalFieldGetAndBitwiseAndReleaseInt...OK -FinalFieldGetAndBitwiseAndReleaseLong...OK -FinalFieldGetAndBitwiseAndReleaseFloat...OK -FinalFieldGetAndBitwiseAndReleaseDouble...OK -FinalFieldGetAndBitwiseAndAcquireBoolean...OK -FinalFieldGetAndBitwiseAndAcquireByte...OK -FinalFieldGetAndBitwiseAndAcquireShort...OK -FinalFieldGetAndBitwiseAndAcquireChar...OK -FinalFieldGetAndBitwiseAndAcquireInt...OK -FinalFieldGetAndBitwiseAndAcquireLong...OK -FinalFieldGetAndBitwiseAndAcquireFloat...OK -FinalFieldGetAndBitwiseAndAcquireDouble...OK -FinalFieldGetAndBitwiseXorBoolean...OK -FinalFieldGetAndBitwiseXorByte...OK -FinalFieldGetAndBitwiseXorShort...OK -FinalFieldGetAndBitwiseXorChar...OK -FinalFieldGetAndBitwiseXorInt...OK -FinalFieldGetAndBitwiseXorLong...OK -FinalFieldGetAndBitwiseXorFloat...OK -FinalFieldGetAndBitwiseXorDouble...OK -FinalFieldGetAndBitwiseXorReleaseBoolean...OK -FinalFieldGetAndBitwiseXorReleaseByte...OK -FinalFieldGetAndBitwiseXorReleaseShort...OK -FinalFieldGetAndBitwiseXorReleaseChar...OK -FinalFieldGetAndBitwiseXorReleaseInt...OK -FinalFieldGetAndBitwiseXorReleaseLong...OK -FinalFieldGetAndBitwiseXorReleaseFloat...OK -FinalFieldGetAndBitwiseXorReleaseDouble...OK -FinalFieldGetAndBitwiseXorAcquireBoolean...OK -FinalFieldGetAndBitwiseXorAcquireByte...OK -FinalFieldGetAndBitwiseXorAcquireShort...OK -FinalFieldGetAndBitwiseXorAcquireChar...OK -FinalFieldGetAndBitwiseXorAcquireInt...OK -FinalFieldGetAndBitwiseXorAcquireLong...OK -FinalFieldGetAndBitwiseXorAcquireFloat...OK -FinalFieldGetAndBitwiseXorAcquireDouble...OK -StaticFieldGetBoolean...OK -StaticFieldGetByte...OK -StaticFieldGetShort...OK -StaticFieldGetChar...OK -StaticFieldGetInt...OK -StaticFieldGetLong...OK -StaticFieldGetFloat...OK -StaticFieldGetDouble...OK -StaticFieldSetBoolean...OK -StaticFieldSetByte...OK -StaticFieldSetShort...OK -StaticFieldSetChar...OK -StaticFieldSetInt...OK -StaticFieldSetLong...OK -StaticFieldSetFloat...OK -StaticFieldSetDouble...OK -StaticFieldGetVolatileBoolean...OK -StaticFieldGetVolatileByte...OK -StaticFieldGetVolatileShort...OK -StaticFieldGetVolatileChar...OK -StaticFieldGetVolatileInt...OK -StaticFieldGetVolatileLong...OK -StaticFieldGetVolatileFloat...OK -StaticFieldGetVolatileDouble...OK -StaticFieldSetVolatileBoolean...OK -StaticFieldSetVolatileByte...OK -StaticFieldSetVolatileShort...OK -StaticFieldSetVolatileChar...OK -StaticFieldSetVolatileInt...OK -StaticFieldSetVolatileLong...OK -StaticFieldSetVolatileFloat...OK -StaticFieldSetVolatileDouble...OK -StaticFieldGetAcquireBoolean...OK -StaticFieldGetAcquireByte...OK -StaticFieldGetAcquireShort...OK -StaticFieldGetAcquireChar...OK -StaticFieldGetAcquireInt...OK -StaticFieldGetAcquireLong...OK -StaticFieldGetAcquireFloat...OK -StaticFieldGetAcquireDouble...OK -StaticFieldSetReleaseBoolean...OK -StaticFieldSetReleaseByte...OK -StaticFieldSetReleaseShort...OK -StaticFieldSetReleaseChar...OK -StaticFieldSetReleaseInt...OK -StaticFieldSetReleaseLong...OK -StaticFieldSetReleaseFloat...OK -StaticFieldSetReleaseDouble...OK -StaticFieldGetOpaqueBoolean...OK -StaticFieldGetOpaqueByte...OK -StaticFieldGetOpaqueShort...OK -StaticFieldGetOpaqueChar...OK -StaticFieldGetOpaqueInt...OK -StaticFieldGetOpaqueLong...OK -StaticFieldGetOpaqueFloat...OK -StaticFieldGetOpaqueDouble...OK -StaticFieldSetOpaqueBoolean...OK -StaticFieldSetOpaqueByte...OK -StaticFieldSetOpaqueShort...OK -StaticFieldSetOpaqueChar...OK -StaticFieldSetOpaqueInt...OK -StaticFieldSetOpaqueLong...OK -StaticFieldSetOpaqueFloat...OK -StaticFieldSetOpaqueDouble...OK -StaticFieldCompareAndSetBoolean...OK -StaticFieldCompareAndSetByte...OK -StaticFieldCompareAndSetShort...OK -StaticFieldCompareAndSetChar...OK -StaticFieldCompareAndSetInt...OK -StaticFieldCompareAndSetLong...OK -StaticFieldCompareAndSetFloat...OK -StaticFieldCompareAndSetDouble...OK -StaticFieldCompareAndExchangeBoolean...OK -StaticFieldCompareAndExchangeByte...OK -StaticFieldCompareAndExchangeShort...OK -StaticFieldCompareAndExchangeChar...OK -StaticFieldCompareAndExchangeInt...OK -StaticFieldCompareAndExchangeLong...OK -StaticFieldCompareAndExchangeFloat...OK -StaticFieldCompareAndExchangeDouble...OK -StaticFieldCompareAndExchangeAcquireBoolean...OK -StaticFieldCompareAndExchangeAcquireByte...OK -StaticFieldCompareAndExchangeAcquireShort...OK -StaticFieldCompareAndExchangeAcquireChar...OK -StaticFieldCompareAndExchangeAcquireInt...OK -StaticFieldCompareAndExchangeAcquireLong...OK -StaticFieldCompareAndExchangeAcquireFloat...OK -StaticFieldCompareAndExchangeAcquireDouble...OK -StaticFieldCompareAndExchangeReleaseBoolean...OK -StaticFieldCompareAndExchangeReleaseByte...OK -StaticFieldCompareAndExchangeReleaseShort...OK -StaticFieldCompareAndExchangeReleaseChar...OK -StaticFieldCompareAndExchangeReleaseInt...OK -StaticFieldCompareAndExchangeReleaseLong...OK -StaticFieldCompareAndExchangeReleaseFloat...OK -StaticFieldCompareAndExchangeReleaseDouble...OK -StaticFieldWeakCompareAndSetPlainBoolean...OK -StaticFieldWeakCompareAndSetPlainByte...OK -StaticFieldWeakCompareAndSetPlainShort...OK -StaticFieldWeakCompareAndSetPlainChar...OK -StaticFieldWeakCompareAndSetPlainInt...OK -StaticFieldWeakCompareAndSetPlainLong...OK -StaticFieldWeakCompareAndSetPlainFloat...OK -StaticFieldWeakCompareAndSetPlainDouble...OK -StaticFieldWeakCompareAndSetBoolean...OK -StaticFieldWeakCompareAndSetByte...OK -StaticFieldWeakCompareAndSetShort...OK -StaticFieldWeakCompareAndSetChar...OK -StaticFieldWeakCompareAndSetInt...OK -StaticFieldWeakCompareAndSetLong...OK -StaticFieldWeakCompareAndSetFloat...OK -StaticFieldWeakCompareAndSetDouble...OK -StaticFieldWeakCompareAndSetAcquireBoolean...OK -StaticFieldWeakCompareAndSetAcquireByte...OK -StaticFieldWeakCompareAndSetAcquireShort...OK -StaticFieldWeakCompareAndSetAcquireChar...OK -StaticFieldWeakCompareAndSetAcquireInt...OK -StaticFieldWeakCompareAndSetAcquireLong...OK -StaticFieldWeakCompareAndSetAcquireFloat...OK -StaticFieldWeakCompareAndSetAcquireDouble...OK -StaticFieldWeakCompareAndSetReleaseBoolean...OK -StaticFieldWeakCompareAndSetReleaseByte...OK -StaticFieldWeakCompareAndSetReleaseShort...OK -StaticFieldWeakCompareAndSetReleaseChar...OK -StaticFieldWeakCompareAndSetReleaseInt...OK -StaticFieldWeakCompareAndSetReleaseLong...OK -StaticFieldWeakCompareAndSetReleaseFloat...OK -StaticFieldWeakCompareAndSetReleaseDouble...OK -StaticFieldGetAndSetBoolean...OK -StaticFieldGetAndSetByte...OK -StaticFieldGetAndSetShort...OK -StaticFieldGetAndSetChar...OK -StaticFieldGetAndSetInt...OK -StaticFieldGetAndSetLong...OK -StaticFieldGetAndSetFloat...OK -StaticFieldGetAndSetDouble...OK -StaticFieldGetAndSetAcquireBoolean...OK -StaticFieldGetAndSetAcquireByte...OK -StaticFieldGetAndSetAcquireShort...OK -StaticFieldGetAndSetAcquireChar...OK -StaticFieldGetAndSetAcquireInt...OK -StaticFieldGetAndSetAcquireLong...OK -StaticFieldGetAndSetAcquireFloat...OK -StaticFieldGetAndSetAcquireDouble...OK -StaticFieldGetAndSetReleaseBoolean...OK -StaticFieldGetAndSetReleaseByte...OK -StaticFieldGetAndSetReleaseShort...OK -StaticFieldGetAndSetReleaseChar...OK -StaticFieldGetAndSetReleaseInt...OK -StaticFieldGetAndSetReleaseLong...OK -StaticFieldGetAndSetReleaseFloat...OK -StaticFieldGetAndSetReleaseDouble...OK -StaticFieldGetAndAddBoolean...OK -StaticFieldGetAndAddByte...OK -StaticFieldGetAndAddShort...OK -StaticFieldGetAndAddChar...OK -StaticFieldGetAndAddInt...OK -StaticFieldGetAndAddLong...OK -StaticFieldGetAndAddFloat...OK -StaticFieldGetAndAddDouble...OK -StaticFieldGetAndAddAcquireBoolean...OK -StaticFieldGetAndAddAcquireByte...OK -StaticFieldGetAndAddAcquireShort...OK -StaticFieldGetAndAddAcquireChar...OK -StaticFieldGetAndAddAcquireInt...OK -StaticFieldGetAndAddAcquireLong...OK -StaticFieldGetAndAddAcquireFloat...OK -StaticFieldGetAndAddAcquireDouble...OK -StaticFieldGetAndAddReleaseBoolean...OK -StaticFieldGetAndAddReleaseByte...OK -StaticFieldGetAndAddReleaseShort...OK -StaticFieldGetAndAddReleaseChar...OK -StaticFieldGetAndAddReleaseInt...OK -StaticFieldGetAndAddReleaseLong...OK -StaticFieldGetAndAddReleaseFloat...OK -StaticFieldGetAndAddReleaseDouble...OK -StaticFieldGetAndBitwiseOrBoolean...OK -StaticFieldGetAndBitwiseOrByte...OK -StaticFieldGetAndBitwiseOrShort...OK -StaticFieldGetAndBitwiseOrChar...OK -StaticFieldGetAndBitwiseOrInt...OK -StaticFieldGetAndBitwiseOrLong...OK -StaticFieldGetAndBitwiseOrFloat...OK -StaticFieldGetAndBitwiseOrDouble...OK -StaticFieldGetAndBitwiseOrReleaseBoolean...OK -StaticFieldGetAndBitwiseOrReleaseByte...OK -StaticFieldGetAndBitwiseOrReleaseShort...OK -StaticFieldGetAndBitwiseOrReleaseChar...OK -StaticFieldGetAndBitwiseOrReleaseInt...OK -StaticFieldGetAndBitwiseOrReleaseLong...OK -StaticFieldGetAndBitwiseOrReleaseFloat...OK -StaticFieldGetAndBitwiseOrReleaseDouble...OK -StaticFieldGetAndBitwiseOrAcquireBoolean...OK -StaticFieldGetAndBitwiseOrAcquireByte...OK -StaticFieldGetAndBitwiseOrAcquireShort...OK -StaticFieldGetAndBitwiseOrAcquireChar...OK -StaticFieldGetAndBitwiseOrAcquireInt...OK -StaticFieldGetAndBitwiseOrAcquireLong...OK -StaticFieldGetAndBitwiseOrAcquireFloat...OK -StaticFieldGetAndBitwiseOrAcquireDouble...OK -StaticFieldGetAndBitwiseAndBoolean...OK -StaticFieldGetAndBitwiseAndByte...OK -StaticFieldGetAndBitwiseAndShort...OK -StaticFieldGetAndBitwiseAndChar...OK -StaticFieldGetAndBitwiseAndInt...OK -StaticFieldGetAndBitwiseAndLong...OK -StaticFieldGetAndBitwiseAndFloat...OK -StaticFieldGetAndBitwiseAndDouble...OK -StaticFieldGetAndBitwiseAndReleaseBoolean...OK -StaticFieldGetAndBitwiseAndReleaseByte...OK -StaticFieldGetAndBitwiseAndReleaseShort...OK -StaticFieldGetAndBitwiseAndReleaseChar...OK -StaticFieldGetAndBitwiseAndReleaseInt...OK -StaticFieldGetAndBitwiseAndReleaseLong...OK -StaticFieldGetAndBitwiseAndReleaseFloat...OK -StaticFieldGetAndBitwiseAndReleaseDouble...OK -StaticFieldGetAndBitwiseAndAcquireBoolean...OK -StaticFieldGetAndBitwiseAndAcquireByte...OK -StaticFieldGetAndBitwiseAndAcquireShort...OK -StaticFieldGetAndBitwiseAndAcquireChar...OK -StaticFieldGetAndBitwiseAndAcquireInt...OK -StaticFieldGetAndBitwiseAndAcquireLong...OK -StaticFieldGetAndBitwiseAndAcquireFloat...OK -StaticFieldGetAndBitwiseAndAcquireDouble...OK -StaticFieldGetAndBitwiseXorBoolean...OK -StaticFieldGetAndBitwiseXorByte...OK -StaticFieldGetAndBitwiseXorShort...OK -StaticFieldGetAndBitwiseXorChar...OK -StaticFieldGetAndBitwiseXorInt...OK -StaticFieldGetAndBitwiseXorLong...OK -StaticFieldGetAndBitwiseXorFloat...OK -StaticFieldGetAndBitwiseXorDouble...OK -StaticFieldGetAndBitwiseXorReleaseBoolean...OK -StaticFieldGetAndBitwiseXorReleaseByte...OK -StaticFieldGetAndBitwiseXorReleaseShort...OK -StaticFieldGetAndBitwiseXorReleaseChar...OK -StaticFieldGetAndBitwiseXorReleaseInt...OK -StaticFieldGetAndBitwiseXorReleaseLong...OK -StaticFieldGetAndBitwiseXorReleaseFloat...OK -StaticFieldGetAndBitwiseXorReleaseDouble...OK -StaticFieldGetAndBitwiseXorAcquireBoolean...OK -StaticFieldGetAndBitwiseXorAcquireByte...OK -StaticFieldGetAndBitwiseXorAcquireShort...OK -StaticFieldGetAndBitwiseXorAcquireChar...OK -StaticFieldGetAndBitwiseXorAcquireInt...OK -StaticFieldGetAndBitwiseXorAcquireLong...OK -StaticFieldGetAndBitwiseXorAcquireFloat...OK -StaticFieldGetAndBitwiseXorAcquireDouble...OK -StaticFinalFieldGetBoolean...OK -StaticFinalFieldGetByte...OK -StaticFinalFieldGetShort...OK -StaticFinalFieldGetChar...OK -StaticFinalFieldGetInt...OK -StaticFinalFieldGetLong...OK -StaticFinalFieldGetFloat...OK -StaticFinalFieldGetDouble...OK -StaticFinalFieldSetBoolean...OK -StaticFinalFieldSetByte...OK -StaticFinalFieldSetShort...OK -StaticFinalFieldSetChar...OK -StaticFinalFieldSetInt...OK -StaticFinalFieldSetLong...OK -StaticFinalFieldSetFloat...OK -StaticFinalFieldSetDouble...OK -StaticFinalFieldGetVolatileBoolean...OK -StaticFinalFieldGetVolatileByte...OK -StaticFinalFieldGetVolatileShort...OK -StaticFinalFieldGetVolatileChar...OK -StaticFinalFieldGetVolatileInt...OK -StaticFinalFieldGetVolatileLong...OK -StaticFinalFieldGetVolatileFloat...OK -StaticFinalFieldGetVolatileDouble...OK -StaticFinalFieldSetVolatileBoolean...OK -StaticFinalFieldSetVolatileByte...OK -StaticFinalFieldSetVolatileShort...OK -StaticFinalFieldSetVolatileChar...OK -StaticFinalFieldSetVolatileInt...OK -StaticFinalFieldSetVolatileLong...OK -StaticFinalFieldSetVolatileFloat...OK -StaticFinalFieldSetVolatileDouble...OK -StaticFinalFieldGetAcquireBoolean...OK -StaticFinalFieldGetAcquireByte...OK -StaticFinalFieldGetAcquireShort...OK -StaticFinalFieldGetAcquireChar...OK -StaticFinalFieldGetAcquireInt...OK -StaticFinalFieldGetAcquireLong...OK -StaticFinalFieldGetAcquireFloat...OK -StaticFinalFieldGetAcquireDouble...OK -StaticFinalFieldSetReleaseBoolean...OK -StaticFinalFieldSetReleaseByte...OK -StaticFinalFieldSetReleaseShort...OK -StaticFinalFieldSetReleaseChar...OK -StaticFinalFieldSetReleaseInt...OK -StaticFinalFieldSetReleaseLong...OK -StaticFinalFieldSetReleaseFloat...OK -StaticFinalFieldSetReleaseDouble...OK -StaticFinalFieldGetOpaqueBoolean...OK -StaticFinalFieldGetOpaqueByte...OK -StaticFinalFieldGetOpaqueShort...OK -StaticFinalFieldGetOpaqueChar...OK -StaticFinalFieldGetOpaqueInt...OK -StaticFinalFieldGetOpaqueLong...OK -StaticFinalFieldGetOpaqueFloat...OK -StaticFinalFieldGetOpaqueDouble...OK -StaticFinalFieldSetOpaqueBoolean...OK -StaticFinalFieldSetOpaqueByte...OK -StaticFinalFieldSetOpaqueShort...OK -StaticFinalFieldSetOpaqueChar...OK -StaticFinalFieldSetOpaqueInt...OK -StaticFinalFieldSetOpaqueLong...OK -StaticFinalFieldSetOpaqueFloat...OK -StaticFinalFieldSetOpaqueDouble...OK -StaticFinalFieldCompareAndSetBoolean...OK -StaticFinalFieldCompareAndSetByte...OK -StaticFinalFieldCompareAndSetShort...OK -StaticFinalFieldCompareAndSetChar...OK -StaticFinalFieldCompareAndSetInt...OK -StaticFinalFieldCompareAndSetLong...OK -StaticFinalFieldCompareAndSetFloat...OK -StaticFinalFieldCompareAndSetDouble...OK -StaticFinalFieldCompareAndExchangeBoolean...OK -StaticFinalFieldCompareAndExchangeByte...OK -StaticFinalFieldCompareAndExchangeShort...OK -StaticFinalFieldCompareAndExchangeChar...OK -StaticFinalFieldCompareAndExchangeInt...OK -StaticFinalFieldCompareAndExchangeLong...OK -StaticFinalFieldCompareAndExchangeFloat...OK -StaticFinalFieldCompareAndExchangeDouble...OK -StaticFinalFieldCompareAndExchangeAcquireBoolean...OK -StaticFinalFieldCompareAndExchangeAcquireByte...OK -StaticFinalFieldCompareAndExchangeAcquireShort...OK -StaticFinalFieldCompareAndExchangeAcquireChar...OK -StaticFinalFieldCompareAndExchangeAcquireInt...OK -StaticFinalFieldCompareAndExchangeAcquireLong...OK -StaticFinalFieldCompareAndExchangeAcquireFloat...OK -StaticFinalFieldCompareAndExchangeAcquireDouble...OK -StaticFinalFieldCompareAndExchangeReleaseBoolean...OK -StaticFinalFieldCompareAndExchangeReleaseByte...OK -StaticFinalFieldCompareAndExchangeReleaseShort...OK -StaticFinalFieldCompareAndExchangeReleaseChar...OK -StaticFinalFieldCompareAndExchangeReleaseInt...OK -StaticFinalFieldCompareAndExchangeReleaseLong...OK -StaticFinalFieldCompareAndExchangeReleaseFloat...OK -StaticFinalFieldCompareAndExchangeReleaseDouble...OK -StaticFinalFieldWeakCompareAndSetPlainBoolean...OK -StaticFinalFieldWeakCompareAndSetPlainByte...OK -StaticFinalFieldWeakCompareAndSetPlainShort...OK -StaticFinalFieldWeakCompareAndSetPlainChar...OK -StaticFinalFieldWeakCompareAndSetPlainInt...OK -StaticFinalFieldWeakCompareAndSetPlainLong...OK -StaticFinalFieldWeakCompareAndSetPlainFloat...OK -StaticFinalFieldWeakCompareAndSetPlainDouble...OK -StaticFinalFieldWeakCompareAndSetBoolean...OK -StaticFinalFieldWeakCompareAndSetByte...OK -StaticFinalFieldWeakCompareAndSetShort...OK -StaticFinalFieldWeakCompareAndSetChar...OK -StaticFinalFieldWeakCompareAndSetInt...OK -StaticFinalFieldWeakCompareAndSetLong...OK -StaticFinalFieldWeakCompareAndSetFloat...OK -StaticFinalFieldWeakCompareAndSetDouble...OK -StaticFinalFieldWeakCompareAndSetAcquireBoolean...OK -StaticFinalFieldWeakCompareAndSetAcquireByte...OK -StaticFinalFieldWeakCompareAndSetAcquireShort...OK -StaticFinalFieldWeakCompareAndSetAcquireChar...OK -StaticFinalFieldWeakCompareAndSetAcquireInt...OK -StaticFinalFieldWeakCompareAndSetAcquireLong...OK -StaticFinalFieldWeakCompareAndSetAcquireFloat...OK -StaticFinalFieldWeakCompareAndSetAcquireDouble...OK -StaticFinalFieldWeakCompareAndSetReleaseBoolean...OK -StaticFinalFieldWeakCompareAndSetReleaseByte...OK -StaticFinalFieldWeakCompareAndSetReleaseShort...OK -StaticFinalFieldWeakCompareAndSetReleaseChar...OK -StaticFinalFieldWeakCompareAndSetReleaseInt...OK -StaticFinalFieldWeakCompareAndSetReleaseLong...OK -StaticFinalFieldWeakCompareAndSetReleaseFloat...OK -StaticFinalFieldWeakCompareAndSetReleaseDouble...OK -StaticFinalFieldGetAndSetBoolean...OK -StaticFinalFieldGetAndSetByte...OK -StaticFinalFieldGetAndSetShort...OK -StaticFinalFieldGetAndSetChar...OK -StaticFinalFieldGetAndSetInt...OK -StaticFinalFieldGetAndSetLong...OK -StaticFinalFieldGetAndSetFloat...OK -StaticFinalFieldGetAndSetDouble...OK -StaticFinalFieldGetAndSetAcquireBoolean...OK -StaticFinalFieldGetAndSetAcquireByte...OK -StaticFinalFieldGetAndSetAcquireShort...OK -StaticFinalFieldGetAndSetAcquireChar...OK -StaticFinalFieldGetAndSetAcquireInt...OK -StaticFinalFieldGetAndSetAcquireLong...OK -StaticFinalFieldGetAndSetAcquireFloat...OK -StaticFinalFieldGetAndSetAcquireDouble...OK -StaticFinalFieldGetAndSetReleaseBoolean...OK -StaticFinalFieldGetAndSetReleaseByte...OK -StaticFinalFieldGetAndSetReleaseShort...OK -StaticFinalFieldGetAndSetReleaseChar...OK -StaticFinalFieldGetAndSetReleaseInt...OK -StaticFinalFieldGetAndSetReleaseLong...OK -StaticFinalFieldGetAndSetReleaseFloat...OK -StaticFinalFieldGetAndSetReleaseDouble...OK -StaticFinalFieldGetAndAddBoolean...OK -StaticFinalFieldGetAndAddByte...OK -StaticFinalFieldGetAndAddShort...OK -StaticFinalFieldGetAndAddChar...OK -StaticFinalFieldGetAndAddInt...OK -StaticFinalFieldGetAndAddLong...OK -StaticFinalFieldGetAndAddFloat...OK -StaticFinalFieldGetAndAddDouble...OK -StaticFinalFieldGetAndAddAcquireBoolean...OK -StaticFinalFieldGetAndAddAcquireByte...OK -StaticFinalFieldGetAndAddAcquireShort...OK -StaticFinalFieldGetAndAddAcquireChar...OK -StaticFinalFieldGetAndAddAcquireInt...OK -StaticFinalFieldGetAndAddAcquireLong...OK -StaticFinalFieldGetAndAddAcquireFloat...OK -StaticFinalFieldGetAndAddAcquireDouble...OK -StaticFinalFieldGetAndAddReleaseBoolean...OK -StaticFinalFieldGetAndAddReleaseByte...OK -StaticFinalFieldGetAndAddReleaseShort...OK -StaticFinalFieldGetAndAddReleaseChar...OK -StaticFinalFieldGetAndAddReleaseInt...OK -StaticFinalFieldGetAndAddReleaseLong...OK -StaticFinalFieldGetAndAddReleaseFloat...OK -StaticFinalFieldGetAndAddReleaseDouble...OK -StaticFinalFieldGetAndBitwiseOrBoolean...OK -StaticFinalFieldGetAndBitwiseOrByte...OK -StaticFinalFieldGetAndBitwiseOrShort...OK -StaticFinalFieldGetAndBitwiseOrChar...OK -StaticFinalFieldGetAndBitwiseOrInt...OK -StaticFinalFieldGetAndBitwiseOrLong...OK -StaticFinalFieldGetAndBitwiseOrFloat...OK -StaticFinalFieldGetAndBitwiseOrDouble...OK -StaticFinalFieldGetAndBitwiseOrReleaseBoolean...OK -StaticFinalFieldGetAndBitwiseOrReleaseByte...OK -StaticFinalFieldGetAndBitwiseOrReleaseShort...OK -StaticFinalFieldGetAndBitwiseOrReleaseChar...OK -StaticFinalFieldGetAndBitwiseOrReleaseInt...OK -StaticFinalFieldGetAndBitwiseOrReleaseLong...OK -StaticFinalFieldGetAndBitwiseOrReleaseFloat...OK -StaticFinalFieldGetAndBitwiseOrReleaseDouble...OK -StaticFinalFieldGetAndBitwiseOrAcquireBoolean...OK -StaticFinalFieldGetAndBitwiseOrAcquireByte...OK -StaticFinalFieldGetAndBitwiseOrAcquireShort...OK -StaticFinalFieldGetAndBitwiseOrAcquireChar...OK -StaticFinalFieldGetAndBitwiseOrAcquireInt...OK -StaticFinalFieldGetAndBitwiseOrAcquireLong...OK -StaticFinalFieldGetAndBitwiseOrAcquireFloat...OK -StaticFinalFieldGetAndBitwiseOrAcquireDouble...OK -StaticFinalFieldGetAndBitwiseAndBoolean...OK -StaticFinalFieldGetAndBitwiseAndByte...OK -StaticFinalFieldGetAndBitwiseAndShort...OK -StaticFinalFieldGetAndBitwiseAndChar...OK -StaticFinalFieldGetAndBitwiseAndInt...OK -StaticFinalFieldGetAndBitwiseAndLong...OK -StaticFinalFieldGetAndBitwiseAndFloat...OK -StaticFinalFieldGetAndBitwiseAndDouble...OK -StaticFinalFieldGetAndBitwiseAndReleaseBoolean...OK -StaticFinalFieldGetAndBitwiseAndReleaseByte...OK -StaticFinalFieldGetAndBitwiseAndReleaseShort...OK -StaticFinalFieldGetAndBitwiseAndReleaseChar...OK -StaticFinalFieldGetAndBitwiseAndReleaseInt...OK -StaticFinalFieldGetAndBitwiseAndReleaseLong...OK -StaticFinalFieldGetAndBitwiseAndReleaseFloat...OK -StaticFinalFieldGetAndBitwiseAndReleaseDouble...OK -StaticFinalFieldGetAndBitwiseAndAcquireBoolean...OK -StaticFinalFieldGetAndBitwiseAndAcquireByte...OK -StaticFinalFieldGetAndBitwiseAndAcquireShort...OK -StaticFinalFieldGetAndBitwiseAndAcquireChar...OK -StaticFinalFieldGetAndBitwiseAndAcquireInt...OK -StaticFinalFieldGetAndBitwiseAndAcquireLong...OK -StaticFinalFieldGetAndBitwiseAndAcquireFloat...OK -StaticFinalFieldGetAndBitwiseAndAcquireDouble...OK -StaticFinalFieldGetAndBitwiseXorBoolean...OK -StaticFinalFieldGetAndBitwiseXorByte...OK -StaticFinalFieldGetAndBitwiseXorShort...OK -StaticFinalFieldGetAndBitwiseXorChar...OK -StaticFinalFieldGetAndBitwiseXorInt...OK -StaticFinalFieldGetAndBitwiseXorLong...OK -StaticFinalFieldGetAndBitwiseXorFloat...OK -StaticFinalFieldGetAndBitwiseXorDouble...OK -StaticFinalFieldGetAndBitwiseXorReleaseBoolean...OK -StaticFinalFieldGetAndBitwiseXorReleaseByte...OK -StaticFinalFieldGetAndBitwiseXorReleaseShort...OK -StaticFinalFieldGetAndBitwiseXorReleaseChar...OK -StaticFinalFieldGetAndBitwiseXorReleaseInt...OK -StaticFinalFieldGetAndBitwiseXorReleaseLong...OK -StaticFinalFieldGetAndBitwiseXorReleaseFloat...OK -StaticFinalFieldGetAndBitwiseXorReleaseDouble...OK -StaticFinalFieldGetAndBitwiseXorAcquireBoolean...OK -StaticFinalFieldGetAndBitwiseXorAcquireByte...OK -StaticFinalFieldGetAndBitwiseXorAcquireShort...OK -StaticFinalFieldGetAndBitwiseXorAcquireChar...OK -StaticFinalFieldGetAndBitwiseXorAcquireInt...OK -StaticFinalFieldGetAndBitwiseXorAcquireLong...OK -StaticFinalFieldGetAndBitwiseXorAcquireFloat...OK -StaticFinalFieldGetAndBitwiseXorAcquireDouble...OK -ArrayElementGetBoolean...OK -ArrayElementGetByte...OK -ArrayElementGetShort...OK -ArrayElementGetChar...OK -ArrayElementGetInt...OK -ArrayElementGetLong...OK -ArrayElementGetFloat...OK -ArrayElementGetDouble...OK -ArrayElementSetBoolean...OK -ArrayElementSetByte...OK -ArrayElementSetShort...OK -ArrayElementSetChar...OK -ArrayElementSetInt...OK -ArrayElementSetLong...OK -ArrayElementSetFloat...OK -ArrayElementSetDouble...OK -ArrayElementGetVolatileBoolean...OK -ArrayElementGetVolatileByte...OK -ArrayElementGetVolatileShort...OK -ArrayElementGetVolatileChar...OK -ArrayElementGetVolatileInt...OK -ArrayElementGetVolatileLong...OK -ArrayElementGetVolatileFloat...OK -ArrayElementGetVolatileDouble...OK -ArrayElementSetVolatileBoolean...OK -ArrayElementSetVolatileByte...OK -ArrayElementSetVolatileShort...OK -ArrayElementSetVolatileChar...OK -ArrayElementSetVolatileInt...OK -ArrayElementSetVolatileLong...OK -ArrayElementSetVolatileFloat...OK -ArrayElementSetVolatileDouble...OK -ArrayElementGetAcquireBoolean...OK -ArrayElementGetAcquireByte...OK -ArrayElementGetAcquireShort...OK -ArrayElementGetAcquireChar...OK -ArrayElementGetAcquireInt...OK -ArrayElementGetAcquireLong...OK -ArrayElementGetAcquireFloat...OK -ArrayElementGetAcquireDouble...OK -ArrayElementSetReleaseBoolean...OK -ArrayElementSetReleaseByte...OK -ArrayElementSetReleaseShort...OK -ArrayElementSetReleaseChar...OK -ArrayElementSetReleaseInt...OK -ArrayElementSetReleaseLong...OK -ArrayElementSetReleaseFloat...OK -ArrayElementSetReleaseDouble...OK -ArrayElementGetOpaqueBoolean...OK -ArrayElementGetOpaqueByte...OK -ArrayElementGetOpaqueShort...OK -ArrayElementGetOpaqueChar...OK -ArrayElementGetOpaqueInt...OK -ArrayElementGetOpaqueLong...OK -ArrayElementGetOpaqueFloat...OK -ArrayElementGetOpaqueDouble...OK -ArrayElementSetOpaqueBoolean...OK -ArrayElementSetOpaqueByte...OK -ArrayElementSetOpaqueShort...OK -ArrayElementSetOpaqueChar...OK -ArrayElementSetOpaqueInt...OK -ArrayElementSetOpaqueLong...OK -ArrayElementSetOpaqueFloat...OK -ArrayElementSetOpaqueDouble...OK -ArrayElementCompareAndSetBoolean...OK -ArrayElementCompareAndSetByte...OK -ArrayElementCompareAndSetShort...OK -ArrayElementCompareAndSetChar...OK -ArrayElementCompareAndSetInt...OK -ArrayElementCompareAndSetLong...OK -ArrayElementCompareAndSetFloat...OK -ArrayElementCompareAndSetDouble...OK -ArrayElementCompareAndExchangeBoolean...OK -ArrayElementCompareAndExchangeByte...OK -ArrayElementCompareAndExchangeShort...OK -ArrayElementCompareAndExchangeChar...OK -ArrayElementCompareAndExchangeInt...OK -ArrayElementCompareAndExchangeLong...OK -ArrayElementCompareAndExchangeFloat...OK -ArrayElementCompareAndExchangeDouble...OK -ArrayElementCompareAndExchangeAcquireBoolean...OK -ArrayElementCompareAndExchangeAcquireByte...OK -ArrayElementCompareAndExchangeAcquireShort...OK -ArrayElementCompareAndExchangeAcquireChar...OK -ArrayElementCompareAndExchangeAcquireInt...OK -ArrayElementCompareAndExchangeAcquireLong...OK -ArrayElementCompareAndExchangeAcquireFloat...OK -ArrayElementCompareAndExchangeAcquireDouble...OK -ArrayElementCompareAndExchangeReleaseBoolean...OK -ArrayElementCompareAndExchangeReleaseByte...OK -ArrayElementCompareAndExchangeReleaseShort...OK -ArrayElementCompareAndExchangeReleaseChar...OK -ArrayElementCompareAndExchangeReleaseInt...OK -ArrayElementCompareAndExchangeReleaseLong...OK -ArrayElementCompareAndExchangeReleaseFloat...OK -ArrayElementCompareAndExchangeReleaseDouble...OK -ArrayElementWeakCompareAndSetPlainBoolean...OK -ArrayElementWeakCompareAndSetPlainByte...OK -ArrayElementWeakCompareAndSetPlainShort...OK -ArrayElementWeakCompareAndSetPlainChar...OK -ArrayElementWeakCompareAndSetPlainInt...OK -ArrayElementWeakCompareAndSetPlainLong...OK -ArrayElementWeakCompareAndSetPlainFloat...OK -ArrayElementWeakCompareAndSetPlainDouble...OK -ArrayElementWeakCompareAndSetBoolean...OK -ArrayElementWeakCompareAndSetByte...OK -ArrayElementWeakCompareAndSetShort...OK -ArrayElementWeakCompareAndSetChar...OK -ArrayElementWeakCompareAndSetInt...OK -ArrayElementWeakCompareAndSetLong...OK -ArrayElementWeakCompareAndSetFloat...OK -ArrayElementWeakCompareAndSetDouble...OK -ArrayElementWeakCompareAndSetAcquireBoolean...OK -ArrayElementWeakCompareAndSetAcquireByte...OK -ArrayElementWeakCompareAndSetAcquireShort...OK -ArrayElementWeakCompareAndSetAcquireChar...OK -ArrayElementWeakCompareAndSetAcquireInt...OK -ArrayElementWeakCompareAndSetAcquireLong...OK -ArrayElementWeakCompareAndSetAcquireFloat...OK -ArrayElementWeakCompareAndSetAcquireDouble...OK -ArrayElementWeakCompareAndSetReleaseBoolean...OK -ArrayElementWeakCompareAndSetReleaseByte...OK -ArrayElementWeakCompareAndSetReleaseShort...OK -ArrayElementWeakCompareAndSetReleaseChar...OK -ArrayElementWeakCompareAndSetReleaseInt...OK -ArrayElementWeakCompareAndSetReleaseLong...OK -ArrayElementWeakCompareAndSetReleaseFloat...OK -ArrayElementWeakCompareAndSetReleaseDouble...OK -ArrayElementGetAndSetBoolean...OK -ArrayElementGetAndSetByte...OK -ArrayElementGetAndSetShort...OK -ArrayElementGetAndSetChar...OK -ArrayElementGetAndSetInt...OK -ArrayElementGetAndSetLong...OK -ArrayElementGetAndSetFloat...OK -ArrayElementGetAndSetDouble...OK -ArrayElementGetAndSetAcquireBoolean...OK -ArrayElementGetAndSetAcquireByte...OK -ArrayElementGetAndSetAcquireShort...OK -ArrayElementGetAndSetAcquireChar...OK -ArrayElementGetAndSetAcquireInt...OK -ArrayElementGetAndSetAcquireLong...OK -ArrayElementGetAndSetAcquireFloat...OK -ArrayElementGetAndSetAcquireDouble...OK -ArrayElementGetAndSetReleaseBoolean...OK -ArrayElementGetAndSetReleaseByte...OK -ArrayElementGetAndSetReleaseShort...OK -ArrayElementGetAndSetReleaseChar...OK -ArrayElementGetAndSetReleaseInt...OK -ArrayElementGetAndSetReleaseLong...OK -ArrayElementGetAndSetReleaseFloat...OK -ArrayElementGetAndSetReleaseDouble...OK -ArrayElementGetAndAddBoolean...OK -ArrayElementGetAndAddByte...OK -ArrayElementGetAndAddShort...OK -ArrayElementGetAndAddChar...OK -ArrayElementGetAndAddInt...OK -ArrayElementGetAndAddLong...OK -ArrayElementGetAndAddFloat...OK -ArrayElementGetAndAddDouble...OK -ArrayElementGetAndAddAcquireBoolean...OK -ArrayElementGetAndAddAcquireByte...OK -ArrayElementGetAndAddAcquireShort...OK -ArrayElementGetAndAddAcquireChar...OK -ArrayElementGetAndAddAcquireInt...OK -ArrayElementGetAndAddAcquireLong...OK -ArrayElementGetAndAddAcquireFloat...OK -ArrayElementGetAndAddAcquireDouble...OK -ArrayElementGetAndAddReleaseBoolean...OK -ArrayElementGetAndAddReleaseByte...OK -ArrayElementGetAndAddReleaseShort...OK -ArrayElementGetAndAddReleaseChar...OK -ArrayElementGetAndAddReleaseInt...OK -ArrayElementGetAndAddReleaseLong...OK -ArrayElementGetAndAddReleaseFloat...OK -ArrayElementGetAndAddReleaseDouble...OK -ArrayElementGetAndBitwiseOrBoolean...OK -ArrayElementGetAndBitwiseOrByte...OK -ArrayElementGetAndBitwiseOrShort...OK -ArrayElementGetAndBitwiseOrChar...OK -ArrayElementGetAndBitwiseOrInt...OK -ArrayElementGetAndBitwiseOrLong...OK -ArrayElementGetAndBitwiseOrFloat...OK -ArrayElementGetAndBitwiseOrDouble...OK -ArrayElementGetAndBitwiseOrReleaseBoolean...OK -ArrayElementGetAndBitwiseOrReleaseByte...OK -ArrayElementGetAndBitwiseOrReleaseShort...OK -ArrayElementGetAndBitwiseOrReleaseChar...OK -ArrayElementGetAndBitwiseOrReleaseInt...OK -ArrayElementGetAndBitwiseOrReleaseLong...OK -ArrayElementGetAndBitwiseOrReleaseFloat...OK -ArrayElementGetAndBitwiseOrReleaseDouble...OK -ArrayElementGetAndBitwiseOrAcquireBoolean...OK -ArrayElementGetAndBitwiseOrAcquireByte...OK -ArrayElementGetAndBitwiseOrAcquireShort...OK -ArrayElementGetAndBitwiseOrAcquireChar...OK -ArrayElementGetAndBitwiseOrAcquireInt...OK -ArrayElementGetAndBitwiseOrAcquireLong...OK -ArrayElementGetAndBitwiseOrAcquireFloat...OK -ArrayElementGetAndBitwiseOrAcquireDouble...OK -ArrayElementGetAndBitwiseAndBoolean...OK -ArrayElementGetAndBitwiseAndByte...OK -ArrayElementGetAndBitwiseAndShort...OK -ArrayElementGetAndBitwiseAndChar...OK -ArrayElementGetAndBitwiseAndInt...OK -ArrayElementGetAndBitwiseAndLong...OK -ArrayElementGetAndBitwiseAndFloat...OK -ArrayElementGetAndBitwiseAndDouble...OK -ArrayElementGetAndBitwiseAndReleaseBoolean...OK -ArrayElementGetAndBitwiseAndReleaseByte...OK -ArrayElementGetAndBitwiseAndReleaseShort...OK -ArrayElementGetAndBitwiseAndReleaseChar...OK -ArrayElementGetAndBitwiseAndReleaseInt...OK -ArrayElementGetAndBitwiseAndReleaseLong...OK -ArrayElementGetAndBitwiseAndReleaseFloat...OK -ArrayElementGetAndBitwiseAndReleaseDouble...OK -ArrayElementGetAndBitwiseAndAcquireBoolean...OK -ArrayElementGetAndBitwiseAndAcquireByte...OK -ArrayElementGetAndBitwiseAndAcquireShort...OK -ArrayElementGetAndBitwiseAndAcquireChar...OK -ArrayElementGetAndBitwiseAndAcquireInt...OK -ArrayElementGetAndBitwiseAndAcquireLong...OK -ArrayElementGetAndBitwiseAndAcquireFloat...OK -ArrayElementGetAndBitwiseAndAcquireDouble...OK -ArrayElementGetAndBitwiseXorBoolean...OK -ArrayElementGetAndBitwiseXorByte...OK -ArrayElementGetAndBitwiseXorShort...OK -ArrayElementGetAndBitwiseXorChar...OK -ArrayElementGetAndBitwiseXorInt...OK -ArrayElementGetAndBitwiseXorLong...OK -ArrayElementGetAndBitwiseXorFloat...OK -ArrayElementGetAndBitwiseXorDouble...OK -ArrayElementGetAndBitwiseXorReleaseBoolean...OK -ArrayElementGetAndBitwiseXorReleaseByte...OK -ArrayElementGetAndBitwiseXorReleaseShort...OK -ArrayElementGetAndBitwiseXorReleaseChar...OK -ArrayElementGetAndBitwiseXorReleaseInt...OK -ArrayElementGetAndBitwiseXorReleaseLong...OK -ArrayElementGetAndBitwiseXorReleaseFloat...OK -ArrayElementGetAndBitwiseXorReleaseDouble...OK -ArrayElementGetAndBitwiseXorAcquireBoolean...OK -ArrayElementGetAndBitwiseXorAcquireByte...OK -ArrayElementGetAndBitwiseXorAcquireShort...OK -ArrayElementGetAndBitwiseXorAcquireChar...OK -ArrayElementGetAndBitwiseXorAcquireInt...OK -ArrayElementGetAndBitwiseXorAcquireLong...OK -ArrayElementGetAndBitwiseXorAcquireFloat...OK -ArrayElementGetAndBitwiseXorAcquireDouble...OK -ByteArrayViewLEGetShort...OK -ByteArrayViewLEGetChar...OK -ByteArrayViewLEGetInt...OK -ByteArrayViewLEGetLong...OK -ByteArrayViewLEGetFloat...OK -ByteArrayViewLEGetDouble...OK -ByteArrayViewLESetShort...OK -ByteArrayViewLESetChar...OK -ByteArrayViewLESetInt...OK -ByteArrayViewLESetLong...OK -ByteArrayViewLESetFloat...OK -ByteArrayViewLESetDouble...OK -ByteArrayViewLEGetVolatileShort...OK -ByteArrayViewLEGetVolatileChar...OK -ByteArrayViewLEGetVolatileInt...OK -ByteArrayViewLEGetVolatileLong...OK -ByteArrayViewLEGetVolatileFloat...OK -ByteArrayViewLEGetVolatileDouble...OK -ByteArrayViewLESetVolatileShort...OK -ByteArrayViewLESetVolatileChar...OK -ByteArrayViewLESetVolatileInt...OK -ByteArrayViewLESetVolatileLong...OK -ByteArrayViewLESetVolatileFloat...OK -ByteArrayViewLESetVolatileDouble...OK -ByteArrayViewLEGetAcquireShort...OK -ByteArrayViewLEGetAcquireChar...OK -ByteArrayViewLEGetAcquireInt...OK -ByteArrayViewLEGetAcquireLong...OK -ByteArrayViewLEGetAcquireFloat...OK -ByteArrayViewLEGetAcquireDouble...OK -ByteArrayViewLESetReleaseShort...OK -ByteArrayViewLESetReleaseChar...OK -ByteArrayViewLESetReleaseInt...OK -ByteArrayViewLESetReleaseLong...OK -ByteArrayViewLESetReleaseFloat...OK -ByteArrayViewLESetReleaseDouble...OK -ByteArrayViewLEGetOpaqueShort...OK -ByteArrayViewLEGetOpaqueChar...OK -ByteArrayViewLEGetOpaqueInt...OK -ByteArrayViewLEGetOpaqueLong...OK -ByteArrayViewLEGetOpaqueFloat...OK -ByteArrayViewLEGetOpaqueDouble...OK -ByteArrayViewLESetOpaqueShort...OK -ByteArrayViewLESetOpaqueChar...OK -ByteArrayViewLESetOpaqueInt...OK -ByteArrayViewLESetOpaqueLong...OK -ByteArrayViewLESetOpaqueFloat...OK -ByteArrayViewLESetOpaqueDouble...OK -ByteArrayViewLECompareAndSetShort...OK -ByteArrayViewLECompareAndSetChar...OK -ByteArrayViewLECompareAndSetInt...OK -ByteArrayViewLECompareAndSetLong...OK -ByteArrayViewLECompareAndSetFloat...OK -ByteArrayViewLECompareAndSetDouble...OK -ByteArrayViewLECompareAndExchangeShort...OK -ByteArrayViewLECompareAndExchangeChar...OK -ByteArrayViewLECompareAndExchangeInt...OK -ByteArrayViewLECompareAndExchangeLong...OK -ByteArrayViewLECompareAndExchangeFloat...OK -ByteArrayViewLECompareAndExchangeDouble...OK -ByteArrayViewLECompareAndExchangeAcquireShort...OK -ByteArrayViewLECompareAndExchangeAcquireChar...OK -ByteArrayViewLECompareAndExchangeAcquireInt...OK -ByteArrayViewLECompareAndExchangeAcquireLong...OK -ByteArrayViewLECompareAndExchangeAcquireFloat...OK -ByteArrayViewLECompareAndExchangeAcquireDouble...OK -ByteArrayViewLECompareAndExchangeReleaseShort...OK -ByteArrayViewLECompareAndExchangeReleaseChar...OK -ByteArrayViewLECompareAndExchangeReleaseInt...OK -ByteArrayViewLECompareAndExchangeReleaseLong...OK -ByteArrayViewLECompareAndExchangeReleaseFloat...OK -ByteArrayViewLECompareAndExchangeReleaseDouble...OK -ByteArrayViewLEWeakCompareAndSetPlainShort...OK -ByteArrayViewLEWeakCompareAndSetPlainChar...OK -ByteArrayViewLEWeakCompareAndSetPlainInt...OK -ByteArrayViewLEWeakCompareAndSetPlainLong...OK -ByteArrayViewLEWeakCompareAndSetPlainFloat...OK -ByteArrayViewLEWeakCompareAndSetPlainDouble...OK -ByteArrayViewLEWeakCompareAndSetShort...OK -ByteArrayViewLEWeakCompareAndSetChar...OK -ByteArrayViewLEWeakCompareAndSetInt...OK -ByteArrayViewLEWeakCompareAndSetLong...OK -ByteArrayViewLEWeakCompareAndSetFloat...OK -ByteArrayViewLEWeakCompareAndSetDouble...OK -ByteArrayViewLEWeakCompareAndSetAcquireShort...OK -ByteArrayViewLEWeakCompareAndSetAcquireChar...OK -ByteArrayViewLEWeakCompareAndSetAcquireInt...OK -ByteArrayViewLEWeakCompareAndSetAcquireLong...OK -ByteArrayViewLEWeakCompareAndSetAcquireFloat...OK -ByteArrayViewLEWeakCompareAndSetAcquireDouble...OK -ByteArrayViewLEWeakCompareAndSetReleaseShort...OK -ByteArrayViewLEWeakCompareAndSetReleaseChar...OK -ByteArrayViewLEWeakCompareAndSetReleaseInt...OK -ByteArrayViewLEWeakCompareAndSetReleaseLong...OK -ByteArrayViewLEWeakCompareAndSetReleaseFloat...OK -ByteArrayViewLEWeakCompareAndSetReleaseDouble...OK -ByteArrayViewLEGetAndSetShort...OK -ByteArrayViewLEGetAndSetChar...OK -ByteArrayViewLEGetAndSetInt...OK -ByteArrayViewLEGetAndSetLong...OK -ByteArrayViewLEGetAndSetFloat...OK -ByteArrayViewLEGetAndSetDouble...OK -ByteArrayViewLEGetAndSetAcquireShort...OK -ByteArrayViewLEGetAndSetAcquireChar...OK -ByteArrayViewLEGetAndSetAcquireInt...OK -ByteArrayViewLEGetAndSetAcquireLong...OK -ByteArrayViewLEGetAndSetAcquireFloat...OK -ByteArrayViewLEGetAndSetAcquireDouble...OK -ByteArrayViewLEGetAndSetReleaseShort...OK -ByteArrayViewLEGetAndSetReleaseChar...OK -ByteArrayViewLEGetAndSetReleaseInt...OK -ByteArrayViewLEGetAndSetReleaseLong...OK -ByteArrayViewLEGetAndSetReleaseFloat...OK -ByteArrayViewLEGetAndSetReleaseDouble...OK -ByteArrayViewLEGetAndAddShort...OK -ByteArrayViewLEGetAndAddChar...OK -ByteArrayViewLEGetAndAddInt...OK -ByteArrayViewLEGetAndAddLong...OK -ByteArrayViewLEGetAndAddFloat...OK -ByteArrayViewLEGetAndAddDouble...OK -ByteArrayViewLEGetAndAddAcquireShort...OK -ByteArrayViewLEGetAndAddAcquireChar...OK -ByteArrayViewLEGetAndAddAcquireInt...OK -ByteArrayViewLEGetAndAddAcquireLong...OK -ByteArrayViewLEGetAndAddAcquireFloat...OK -ByteArrayViewLEGetAndAddAcquireDouble...OK -ByteArrayViewLEGetAndAddReleaseShort...OK -ByteArrayViewLEGetAndAddReleaseChar...OK -ByteArrayViewLEGetAndAddReleaseInt...OK -ByteArrayViewLEGetAndAddReleaseLong...OK -ByteArrayViewLEGetAndAddReleaseFloat...OK -ByteArrayViewLEGetAndAddReleaseDouble...OK -ByteArrayViewLEGetAndBitwiseOrShort...OK -ByteArrayViewLEGetAndBitwiseOrChar...OK -ByteArrayViewLEGetAndBitwiseOrInt...OK -ByteArrayViewLEGetAndBitwiseOrLong...OK -ByteArrayViewLEGetAndBitwiseOrFloat...OK -ByteArrayViewLEGetAndBitwiseOrDouble...OK -ByteArrayViewLEGetAndBitwiseOrReleaseShort...OK -ByteArrayViewLEGetAndBitwiseOrReleaseChar...OK -ByteArrayViewLEGetAndBitwiseOrReleaseInt...OK -ByteArrayViewLEGetAndBitwiseOrReleaseLong...OK -ByteArrayViewLEGetAndBitwiseOrReleaseFloat...OK -ByteArrayViewLEGetAndBitwiseOrReleaseDouble...OK -ByteArrayViewLEGetAndBitwiseOrAcquireShort...OK -ByteArrayViewLEGetAndBitwiseOrAcquireChar...OK -ByteArrayViewLEGetAndBitwiseOrAcquireInt...OK -ByteArrayViewLEGetAndBitwiseOrAcquireLong...OK -ByteArrayViewLEGetAndBitwiseOrAcquireFloat...OK -ByteArrayViewLEGetAndBitwiseOrAcquireDouble...OK -ByteArrayViewLEGetAndBitwiseAndShort...OK -ByteArrayViewLEGetAndBitwiseAndChar...OK -ByteArrayViewLEGetAndBitwiseAndInt...OK -ByteArrayViewLEGetAndBitwiseAndLong...OK -ByteArrayViewLEGetAndBitwiseAndFloat...OK -ByteArrayViewLEGetAndBitwiseAndDouble...OK -ByteArrayViewLEGetAndBitwiseAndReleaseShort...OK -ByteArrayViewLEGetAndBitwiseAndReleaseChar...OK -ByteArrayViewLEGetAndBitwiseAndReleaseInt...OK -ByteArrayViewLEGetAndBitwiseAndReleaseLong...OK -ByteArrayViewLEGetAndBitwiseAndReleaseFloat...OK -ByteArrayViewLEGetAndBitwiseAndReleaseDouble...OK -ByteArrayViewLEGetAndBitwiseAndAcquireShort...OK -ByteArrayViewLEGetAndBitwiseAndAcquireChar...OK -ByteArrayViewLEGetAndBitwiseAndAcquireInt...OK -ByteArrayViewLEGetAndBitwiseAndAcquireLong...OK -ByteArrayViewLEGetAndBitwiseAndAcquireFloat...OK -ByteArrayViewLEGetAndBitwiseAndAcquireDouble...OK -ByteArrayViewLEGetAndBitwiseXorShort...OK -ByteArrayViewLEGetAndBitwiseXorChar...OK -ByteArrayViewLEGetAndBitwiseXorInt...OK -ByteArrayViewLEGetAndBitwiseXorLong...OK -ByteArrayViewLEGetAndBitwiseXorFloat...OK -ByteArrayViewLEGetAndBitwiseXorDouble...OK -ByteArrayViewLEGetAndBitwiseXorReleaseShort...OK -ByteArrayViewLEGetAndBitwiseXorReleaseChar...OK -ByteArrayViewLEGetAndBitwiseXorReleaseInt...OK -ByteArrayViewLEGetAndBitwiseXorReleaseLong...OK -ByteArrayViewLEGetAndBitwiseXorReleaseFloat...OK -ByteArrayViewLEGetAndBitwiseXorReleaseDouble...OK -ByteArrayViewLEGetAndBitwiseXorAcquireShort...OK -ByteArrayViewLEGetAndBitwiseXorAcquireChar...OK -ByteArrayViewLEGetAndBitwiseXorAcquireInt...OK -ByteArrayViewLEGetAndBitwiseXorAcquireLong...OK -ByteArrayViewLEGetAndBitwiseXorAcquireFloat...OK -ByteArrayViewLEGetAndBitwiseXorAcquireDouble...OK -ByteArrayViewBEGetShort...OK -ByteArrayViewBEGetChar...OK -ByteArrayViewBEGetInt...OK -ByteArrayViewBEGetLong...OK -ByteArrayViewBEGetFloat...OK -ByteArrayViewBEGetDouble...OK -ByteArrayViewBESetShort...OK -ByteArrayViewBESetChar...OK -ByteArrayViewBESetInt...OK -ByteArrayViewBESetLong...OK -ByteArrayViewBESetFloat...OK -ByteArrayViewBESetDouble...OK -ByteArrayViewBEGetVolatileShort...OK -ByteArrayViewBEGetVolatileChar...OK -ByteArrayViewBEGetVolatileInt...OK -ByteArrayViewBEGetVolatileLong...OK -ByteArrayViewBEGetVolatileFloat...OK -ByteArrayViewBEGetVolatileDouble...OK -ByteArrayViewBESetVolatileShort...OK -ByteArrayViewBESetVolatileChar...OK -ByteArrayViewBESetVolatileInt...OK -ByteArrayViewBESetVolatileLong...OK -ByteArrayViewBESetVolatileFloat...OK -ByteArrayViewBESetVolatileDouble...OK -ByteArrayViewBEGetAcquireShort...OK -ByteArrayViewBEGetAcquireChar...OK -ByteArrayViewBEGetAcquireInt...OK -ByteArrayViewBEGetAcquireLong...OK -ByteArrayViewBEGetAcquireFloat...OK -ByteArrayViewBEGetAcquireDouble...OK -ByteArrayViewBESetReleaseShort...OK -ByteArrayViewBESetReleaseChar...OK -ByteArrayViewBESetReleaseInt...OK -ByteArrayViewBESetReleaseLong...OK -ByteArrayViewBESetReleaseFloat...OK -ByteArrayViewBESetReleaseDouble...OK -ByteArrayViewBEGetOpaqueShort...OK -ByteArrayViewBEGetOpaqueChar...OK -ByteArrayViewBEGetOpaqueInt...OK -ByteArrayViewBEGetOpaqueLong...OK -ByteArrayViewBEGetOpaqueFloat...OK -ByteArrayViewBEGetOpaqueDouble...OK -ByteArrayViewBESetOpaqueShort...OK -ByteArrayViewBESetOpaqueChar...OK -ByteArrayViewBESetOpaqueInt...OK -ByteArrayViewBESetOpaqueLong...OK -ByteArrayViewBESetOpaqueFloat...OK -ByteArrayViewBESetOpaqueDouble...OK -ByteArrayViewBECompareAndSetShort...OK -ByteArrayViewBECompareAndSetChar...OK -ByteArrayViewBECompareAndSetInt...OK -ByteArrayViewBECompareAndSetLong...OK -ByteArrayViewBECompareAndSetFloat...OK -ByteArrayViewBECompareAndSetDouble...OK -ByteArrayViewBECompareAndExchangeShort...OK -ByteArrayViewBECompareAndExchangeChar...OK -ByteArrayViewBECompareAndExchangeInt...OK -ByteArrayViewBECompareAndExchangeLong...OK -ByteArrayViewBECompareAndExchangeFloat...OK -ByteArrayViewBECompareAndExchangeDouble...OK -ByteArrayViewBECompareAndExchangeAcquireShort...OK -ByteArrayViewBECompareAndExchangeAcquireChar...OK -ByteArrayViewBECompareAndExchangeAcquireInt...OK -ByteArrayViewBECompareAndExchangeAcquireLong...OK -ByteArrayViewBECompareAndExchangeAcquireFloat...OK -ByteArrayViewBECompareAndExchangeAcquireDouble...OK -ByteArrayViewBECompareAndExchangeReleaseShort...OK -ByteArrayViewBECompareAndExchangeReleaseChar...OK -ByteArrayViewBECompareAndExchangeReleaseInt...OK -ByteArrayViewBECompareAndExchangeReleaseLong...OK -ByteArrayViewBECompareAndExchangeReleaseFloat...OK -ByteArrayViewBECompareAndExchangeReleaseDouble...OK -ByteArrayViewBEWeakCompareAndSetPlainShort...OK -ByteArrayViewBEWeakCompareAndSetPlainChar...OK -ByteArrayViewBEWeakCompareAndSetPlainInt...OK -ByteArrayViewBEWeakCompareAndSetPlainLong...OK -ByteArrayViewBEWeakCompareAndSetPlainFloat...OK -ByteArrayViewBEWeakCompareAndSetPlainDouble...OK -ByteArrayViewBEWeakCompareAndSetShort...OK -ByteArrayViewBEWeakCompareAndSetChar...OK -ByteArrayViewBEWeakCompareAndSetInt...OK -ByteArrayViewBEWeakCompareAndSetLong...OK -ByteArrayViewBEWeakCompareAndSetFloat...OK -ByteArrayViewBEWeakCompareAndSetDouble...OK -ByteArrayViewBEWeakCompareAndSetAcquireShort...OK -ByteArrayViewBEWeakCompareAndSetAcquireChar...OK -ByteArrayViewBEWeakCompareAndSetAcquireInt...OK -ByteArrayViewBEWeakCompareAndSetAcquireLong...OK -ByteArrayViewBEWeakCompareAndSetAcquireFloat...OK -ByteArrayViewBEWeakCompareAndSetAcquireDouble...OK -ByteArrayViewBEWeakCompareAndSetReleaseShort...OK -ByteArrayViewBEWeakCompareAndSetReleaseChar...OK -ByteArrayViewBEWeakCompareAndSetReleaseInt...OK -ByteArrayViewBEWeakCompareAndSetReleaseLong...OK -ByteArrayViewBEWeakCompareAndSetReleaseFloat...OK -ByteArrayViewBEWeakCompareAndSetReleaseDouble...OK -ByteArrayViewBEGetAndSetShort...OK -ByteArrayViewBEGetAndSetChar...OK -ByteArrayViewBEGetAndSetInt...OK -ByteArrayViewBEGetAndSetLong...OK -ByteArrayViewBEGetAndSetFloat...OK -ByteArrayViewBEGetAndSetDouble...OK -ByteArrayViewBEGetAndSetAcquireShort...OK -ByteArrayViewBEGetAndSetAcquireChar...OK -ByteArrayViewBEGetAndSetAcquireInt...OK -ByteArrayViewBEGetAndSetAcquireLong...OK -ByteArrayViewBEGetAndSetAcquireFloat...OK -ByteArrayViewBEGetAndSetAcquireDouble...OK -ByteArrayViewBEGetAndSetReleaseShort...OK -ByteArrayViewBEGetAndSetReleaseChar...OK -ByteArrayViewBEGetAndSetReleaseInt...OK -ByteArrayViewBEGetAndSetReleaseLong...OK -ByteArrayViewBEGetAndSetReleaseFloat...OK -ByteArrayViewBEGetAndSetReleaseDouble...OK -ByteArrayViewBEGetAndAddShort...OK -ByteArrayViewBEGetAndAddChar...OK -ByteArrayViewBEGetAndAddInt...OK -ByteArrayViewBEGetAndAddLong...OK -ByteArrayViewBEGetAndAddFloat...OK -ByteArrayViewBEGetAndAddDouble...OK -ByteArrayViewBEGetAndAddAcquireShort...OK -ByteArrayViewBEGetAndAddAcquireChar...OK -ByteArrayViewBEGetAndAddAcquireInt...OK -ByteArrayViewBEGetAndAddAcquireLong...OK -ByteArrayViewBEGetAndAddAcquireFloat...OK -ByteArrayViewBEGetAndAddAcquireDouble...OK -ByteArrayViewBEGetAndAddReleaseShort...OK -ByteArrayViewBEGetAndAddReleaseChar...OK -ByteArrayViewBEGetAndAddReleaseInt...OK -ByteArrayViewBEGetAndAddReleaseLong...OK -ByteArrayViewBEGetAndAddReleaseFloat...OK -ByteArrayViewBEGetAndAddReleaseDouble...OK -ByteArrayViewBEGetAndBitwiseOrShort...OK -ByteArrayViewBEGetAndBitwiseOrChar...OK -ByteArrayViewBEGetAndBitwiseOrInt...OK -ByteArrayViewBEGetAndBitwiseOrLong...OK -ByteArrayViewBEGetAndBitwiseOrFloat...OK -ByteArrayViewBEGetAndBitwiseOrDouble...OK -ByteArrayViewBEGetAndBitwiseOrReleaseShort...OK -ByteArrayViewBEGetAndBitwiseOrReleaseChar...OK -ByteArrayViewBEGetAndBitwiseOrReleaseInt...OK -ByteArrayViewBEGetAndBitwiseOrReleaseLong...OK -ByteArrayViewBEGetAndBitwiseOrReleaseFloat...OK -ByteArrayViewBEGetAndBitwiseOrReleaseDouble...OK -ByteArrayViewBEGetAndBitwiseOrAcquireShort...OK -ByteArrayViewBEGetAndBitwiseOrAcquireChar...OK -ByteArrayViewBEGetAndBitwiseOrAcquireInt...OK -ByteArrayViewBEGetAndBitwiseOrAcquireLong...OK -ByteArrayViewBEGetAndBitwiseOrAcquireFloat...OK -ByteArrayViewBEGetAndBitwiseOrAcquireDouble...OK -ByteArrayViewBEGetAndBitwiseAndShort...OK -ByteArrayViewBEGetAndBitwiseAndChar...OK -ByteArrayViewBEGetAndBitwiseAndInt...OK -ByteArrayViewBEGetAndBitwiseAndLong...OK -ByteArrayViewBEGetAndBitwiseAndFloat...OK -ByteArrayViewBEGetAndBitwiseAndDouble...OK -ByteArrayViewBEGetAndBitwiseAndReleaseShort...OK -ByteArrayViewBEGetAndBitwiseAndReleaseChar...OK -ByteArrayViewBEGetAndBitwiseAndReleaseInt...OK -ByteArrayViewBEGetAndBitwiseAndReleaseLong...OK -ByteArrayViewBEGetAndBitwiseAndReleaseFloat...OK -ByteArrayViewBEGetAndBitwiseAndReleaseDouble...OK -ByteArrayViewBEGetAndBitwiseAndAcquireShort...OK -ByteArrayViewBEGetAndBitwiseAndAcquireChar...OK -ByteArrayViewBEGetAndBitwiseAndAcquireInt...OK -ByteArrayViewBEGetAndBitwiseAndAcquireLong...OK -ByteArrayViewBEGetAndBitwiseAndAcquireFloat...OK -ByteArrayViewBEGetAndBitwiseAndAcquireDouble...OK -ByteArrayViewBEGetAndBitwiseXorShort...OK -ByteArrayViewBEGetAndBitwiseXorChar...OK -ByteArrayViewBEGetAndBitwiseXorInt...OK -ByteArrayViewBEGetAndBitwiseXorLong...OK -ByteArrayViewBEGetAndBitwiseXorFloat...OK -ByteArrayViewBEGetAndBitwiseXorDouble...OK -ByteArrayViewBEGetAndBitwiseXorReleaseShort...OK -ByteArrayViewBEGetAndBitwiseXorReleaseChar...OK -ByteArrayViewBEGetAndBitwiseXorReleaseInt...OK -ByteArrayViewBEGetAndBitwiseXorReleaseLong...OK -ByteArrayViewBEGetAndBitwiseXorReleaseFloat...OK -ByteArrayViewBEGetAndBitwiseXorReleaseDouble...OK -ByteArrayViewBEGetAndBitwiseXorAcquireShort...OK -ByteArrayViewBEGetAndBitwiseXorAcquireChar...OK -ByteArrayViewBEGetAndBitwiseXorAcquireInt...OK -ByteArrayViewBEGetAndBitwiseXorAcquireLong...OK -ByteArrayViewBEGetAndBitwiseXorAcquireFloat...OK -ByteArrayViewBEGetAndBitwiseXorAcquireDouble...OK -DirectByteBufferViewLEGetShort...OK -DirectByteBufferViewLEGetChar...OK -DirectByteBufferViewLEGetInt...OK -DirectByteBufferViewLEGetLong...OK -DirectByteBufferViewLEGetFloat...OK -DirectByteBufferViewLEGetDouble...OK -DirectByteBufferViewLESetShort...OK -DirectByteBufferViewLESetChar...OK -DirectByteBufferViewLESetInt...OK -DirectByteBufferViewLESetLong...OK -DirectByteBufferViewLESetFloat...OK -DirectByteBufferViewLESetDouble...OK -DirectByteBufferViewLEGetVolatileShort...OK -DirectByteBufferViewLEGetVolatileChar...OK -DirectByteBufferViewLEGetVolatileInt...OK -DirectByteBufferViewLEGetVolatileLong...OK -DirectByteBufferViewLEGetVolatileFloat...OK -DirectByteBufferViewLEGetVolatileDouble...OK -DirectByteBufferViewLESetVolatileShort...OK -DirectByteBufferViewLESetVolatileChar...OK -DirectByteBufferViewLESetVolatileInt...OK -DirectByteBufferViewLESetVolatileLong...OK -DirectByteBufferViewLESetVolatileFloat...OK -DirectByteBufferViewLESetVolatileDouble...OK -DirectByteBufferViewLEGetAcquireShort...OK -DirectByteBufferViewLEGetAcquireChar...OK -DirectByteBufferViewLEGetAcquireInt...OK -DirectByteBufferViewLEGetAcquireLong...OK -DirectByteBufferViewLEGetAcquireFloat...OK -DirectByteBufferViewLEGetAcquireDouble...OK -DirectByteBufferViewLESetReleaseShort...OK -DirectByteBufferViewLESetReleaseChar...OK -DirectByteBufferViewLESetReleaseInt...OK -DirectByteBufferViewLESetReleaseLong...OK -DirectByteBufferViewLESetReleaseFloat...OK -DirectByteBufferViewLESetReleaseDouble...OK -DirectByteBufferViewLEGetOpaqueShort...OK -DirectByteBufferViewLEGetOpaqueChar...OK -DirectByteBufferViewLEGetOpaqueInt...OK -DirectByteBufferViewLEGetOpaqueLong...OK -DirectByteBufferViewLEGetOpaqueFloat...OK -DirectByteBufferViewLEGetOpaqueDouble...OK -DirectByteBufferViewLESetOpaqueShort...OK -DirectByteBufferViewLESetOpaqueChar...OK -DirectByteBufferViewLESetOpaqueInt...OK -DirectByteBufferViewLESetOpaqueLong...OK -DirectByteBufferViewLESetOpaqueFloat...OK -DirectByteBufferViewLESetOpaqueDouble...OK -DirectByteBufferViewLECompareAndSetShort...OK -DirectByteBufferViewLECompareAndSetChar...OK -DirectByteBufferViewLECompareAndSetInt...OK -DirectByteBufferViewLECompareAndSetLong...OK -DirectByteBufferViewLECompareAndSetFloat...OK -DirectByteBufferViewLECompareAndSetDouble...OK -DirectByteBufferViewLECompareAndExchangeShort...OK -DirectByteBufferViewLECompareAndExchangeChar...OK -DirectByteBufferViewLECompareAndExchangeInt...OK -DirectByteBufferViewLECompareAndExchangeLong...OK -DirectByteBufferViewLECompareAndExchangeFloat...OK -DirectByteBufferViewLECompareAndExchangeDouble...OK -DirectByteBufferViewLECompareAndExchangeAcquireShort...OK -DirectByteBufferViewLECompareAndExchangeAcquireChar...OK -DirectByteBufferViewLECompareAndExchangeAcquireInt...OK -DirectByteBufferViewLECompareAndExchangeAcquireLong...OK -DirectByteBufferViewLECompareAndExchangeAcquireFloat...OK -DirectByteBufferViewLECompareAndExchangeAcquireDouble...OK -DirectByteBufferViewLECompareAndExchangeReleaseShort...OK -DirectByteBufferViewLECompareAndExchangeReleaseChar...OK -DirectByteBufferViewLECompareAndExchangeReleaseInt...OK -DirectByteBufferViewLECompareAndExchangeReleaseLong...OK -DirectByteBufferViewLECompareAndExchangeReleaseFloat...OK -DirectByteBufferViewLECompareAndExchangeReleaseDouble...OK -DirectByteBufferViewLEWeakCompareAndSetPlainShort...OK -DirectByteBufferViewLEWeakCompareAndSetPlainChar...OK -DirectByteBufferViewLEWeakCompareAndSetPlainInt...OK -DirectByteBufferViewLEWeakCompareAndSetPlainLong...OK -DirectByteBufferViewLEWeakCompareAndSetPlainFloat...OK -DirectByteBufferViewLEWeakCompareAndSetPlainDouble...OK -DirectByteBufferViewLEWeakCompareAndSetShort...OK -DirectByteBufferViewLEWeakCompareAndSetChar...OK -DirectByteBufferViewLEWeakCompareAndSetInt...OK -DirectByteBufferViewLEWeakCompareAndSetLong...OK -DirectByteBufferViewLEWeakCompareAndSetFloat...OK -DirectByteBufferViewLEWeakCompareAndSetDouble...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireShort...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireChar...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireInt...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireLong...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireFloat...OK -DirectByteBufferViewLEWeakCompareAndSetAcquireDouble...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseShort...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseChar...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseInt...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseLong...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseFloat...OK -DirectByteBufferViewLEWeakCompareAndSetReleaseDouble...OK -DirectByteBufferViewLEGetAndSetShort...OK -DirectByteBufferViewLEGetAndSetChar...OK -DirectByteBufferViewLEGetAndSetInt...OK -DirectByteBufferViewLEGetAndSetLong...OK -DirectByteBufferViewLEGetAndSetFloat...OK -DirectByteBufferViewLEGetAndSetDouble...OK -DirectByteBufferViewLEGetAndSetAcquireShort...OK -DirectByteBufferViewLEGetAndSetAcquireChar...OK -DirectByteBufferViewLEGetAndSetAcquireInt...OK -DirectByteBufferViewLEGetAndSetAcquireLong...OK -DirectByteBufferViewLEGetAndSetAcquireFloat...OK -DirectByteBufferViewLEGetAndSetAcquireDouble...OK -DirectByteBufferViewLEGetAndSetReleaseShort...OK -DirectByteBufferViewLEGetAndSetReleaseChar...OK -DirectByteBufferViewLEGetAndSetReleaseInt...OK -DirectByteBufferViewLEGetAndSetReleaseLong...OK -DirectByteBufferViewLEGetAndSetReleaseFloat...OK -DirectByteBufferViewLEGetAndSetReleaseDouble...OK -DirectByteBufferViewLEGetAndAddShort...OK -DirectByteBufferViewLEGetAndAddChar...OK -DirectByteBufferViewLEGetAndAddInt...OK -DirectByteBufferViewLEGetAndAddLong...OK -DirectByteBufferViewLEGetAndAddFloat...OK -DirectByteBufferViewLEGetAndAddDouble...OK -DirectByteBufferViewLEGetAndAddAcquireShort...OK -DirectByteBufferViewLEGetAndAddAcquireChar...OK -DirectByteBufferViewLEGetAndAddAcquireInt...OK -DirectByteBufferViewLEGetAndAddAcquireLong...OK -DirectByteBufferViewLEGetAndAddAcquireFloat...OK -DirectByteBufferViewLEGetAndAddAcquireDouble...OK -DirectByteBufferViewLEGetAndAddReleaseShort...OK -DirectByteBufferViewLEGetAndAddReleaseChar...OK -DirectByteBufferViewLEGetAndAddReleaseInt...OK -DirectByteBufferViewLEGetAndAddReleaseLong...OK -DirectByteBufferViewLEGetAndAddReleaseFloat...OK -DirectByteBufferViewLEGetAndAddReleaseDouble...OK -DirectByteBufferViewLEGetAndBitwiseOrShort...OK -DirectByteBufferViewLEGetAndBitwiseOrChar...OK -DirectByteBufferViewLEGetAndBitwiseOrInt...OK -DirectByteBufferViewLEGetAndBitwiseOrLong...OK -DirectByteBufferViewLEGetAndBitwiseOrFloat...OK -DirectByteBufferViewLEGetAndBitwiseOrDouble...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseShort...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseChar...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseInt...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseLong...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseFloat...OK -DirectByteBufferViewLEGetAndBitwiseOrReleaseDouble...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireShort...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireChar...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireInt...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireLong...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireFloat...OK -DirectByteBufferViewLEGetAndBitwiseOrAcquireDouble...OK -DirectByteBufferViewLEGetAndBitwiseAndShort...OK -DirectByteBufferViewLEGetAndBitwiseAndChar...OK -DirectByteBufferViewLEGetAndBitwiseAndInt...OK -DirectByteBufferViewLEGetAndBitwiseAndLong...OK -DirectByteBufferViewLEGetAndBitwiseAndFloat...OK -DirectByteBufferViewLEGetAndBitwiseAndDouble...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseShort...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseChar...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseInt...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseLong...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseFloat...OK -DirectByteBufferViewLEGetAndBitwiseAndReleaseDouble...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireShort...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireChar...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireInt...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireLong...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireFloat...OK -DirectByteBufferViewLEGetAndBitwiseAndAcquireDouble...OK -DirectByteBufferViewLEGetAndBitwiseXorShort...OK -DirectByteBufferViewLEGetAndBitwiseXorChar...OK -DirectByteBufferViewLEGetAndBitwiseXorInt...OK -DirectByteBufferViewLEGetAndBitwiseXorLong...OK -DirectByteBufferViewLEGetAndBitwiseXorFloat...OK -DirectByteBufferViewLEGetAndBitwiseXorDouble...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseShort...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseChar...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseInt...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseLong...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseFloat...OK -DirectByteBufferViewLEGetAndBitwiseXorReleaseDouble...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireShort...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireChar...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireInt...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireLong...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireFloat...OK -DirectByteBufferViewLEGetAndBitwiseXorAcquireDouble...OK -DirectByteBufferViewBEGetShort...OK -DirectByteBufferViewBEGetChar...OK -DirectByteBufferViewBEGetInt...OK -DirectByteBufferViewBEGetLong...OK -DirectByteBufferViewBEGetFloat...OK -DirectByteBufferViewBEGetDouble...OK -DirectByteBufferViewBESetShort...OK -DirectByteBufferViewBESetChar...OK -DirectByteBufferViewBESetInt...OK -DirectByteBufferViewBESetLong...OK -DirectByteBufferViewBESetFloat...OK -DirectByteBufferViewBESetDouble...OK -DirectByteBufferViewBEGetVolatileShort...OK -DirectByteBufferViewBEGetVolatileChar...OK -DirectByteBufferViewBEGetVolatileInt...OK -DirectByteBufferViewBEGetVolatileLong...OK -DirectByteBufferViewBEGetVolatileFloat...OK -DirectByteBufferViewBEGetVolatileDouble...OK -DirectByteBufferViewBESetVolatileShort...OK -DirectByteBufferViewBESetVolatileChar...OK -DirectByteBufferViewBESetVolatileInt...OK -DirectByteBufferViewBESetVolatileLong...OK -DirectByteBufferViewBESetVolatileFloat...OK -DirectByteBufferViewBESetVolatileDouble...OK -DirectByteBufferViewBEGetAcquireShort...OK -DirectByteBufferViewBEGetAcquireChar...OK -DirectByteBufferViewBEGetAcquireInt...OK -DirectByteBufferViewBEGetAcquireLong...OK -DirectByteBufferViewBEGetAcquireFloat...OK -DirectByteBufferViewBEGetAcquireDouble...OK -DirectByteBufferViewBESetReleaseShort...OK -DirectByteBufferViewBESetReleaseChar...OK -DirectByteBufferViewBESetReleaseInt...OK -DirectByteBufferViewBESetReleaseLong...OK -DirectByteBufferViewBESetReleaseFloat...OK -DirectByteBufferViewBESetReleaseDouble...OK -DirectByteBufferViewBEGetOpaqueShort...OK -DirectByteBufferViewBEGetOpaqueChar...OK -DirectByteBufferViewBEGetOpaqueInt...OK -DirectByteBufferViewBEGetOpaqueLong...OK -DirectByteBufferViewBEGetOpaqueFloat...OK -DirectByteBufferViewBEGetOpaqueDouble...OK -DirectByteBufferViewBESetOpaqueShort...OK -DirectByteBufferViewBESetOpaqueChar...OK -DirectByteBufferViewBESetOpaqueInt...OK -DirectByteBufferViewBESetOpaqueLong...OK -DirectByteBufferViewBESetOpaqueFloat...OK -DirectByteBufferViewBESetOpaqueDouble...OK -DirectByteBufferViewBECompareAndSetShort...OK -DirectByteBufferViewBECompareAndSetChar...OK -DirectByteBufferViewBECompareAndSetInt...OK -DirectByteBufferViewBECompareAndSetLong...OK -DirectByteBufferViewBECompareAndSetFloat...OK -DirectByteBufferViewBECompareAndSetDouble...OK -DirectByteBufferViewBECompareAndExchangeShort...OK -DirectByteBufferViewBECompareAndExchangeChar...OK -DirectByteBufferViewBECompareAndExchangeInt...OK -DirectByteBufferViewBECompareAndExchangeLong...OK -DirectByteBufferViewBECompareAndExchangeFloat...OK -DirectByteBufferViewBECompareAndExchangeDouble...OK -DirectByteBufferViewBECompareAndExchangeAcquireShort...OK -DirectByteBufferViewBECompareAndExchangeAcquireChar...OK -DirectByteBufferViewBECompareAndExchangeAcquireInt...OK -DirectByteBufferViewBECompareAndExchangeAcquireLong...OK -DirectByteBufferViewBECompareAndExchangeAcquireFloat...OK -DirectByteBufferViewBECompareAndExchangeAcquireDouble...OK -DirectByteBufferViewBECompareAndExchangeReleaseShort...OK -DirectByteBufferViewBECompareAndExchangeReleaseChar...OK -DirectByteBufferViewBECompareAndExchangeReleaseInt...OK -DirectByteBufferViewBECompareAndExchangeReleaseLong...OK -DirectByteBufferViewBECompareAndExchangeReleaseFloat...OK -DirectByteBufferViewBECompareAndExchangeReleaseDouble...OK -DirectByteBufferViewBEWeakCompareAndSetPlainShort...OK -DirectByteBufferViewBEWeakCompareAndSetPlainChar...OK -DirectByteBufferViewBEWeakCompareAndSetPlainInt...OK -DirectByteBufferViewBEWeakCompareAndSetPlainLong...OK -DirectByteBufferViewBEWeakCompareAndSetPlainFloat...OK -DirectByteBufferViewBEWeakCompareAndSetPlainDouble...OK -DirectByteBufferViewBEWeakCompareAndSetShort...OK -DirectByteBufferViewBEWeakCompareAndSetChar...OK -DirectByteBufferViewBEWeakCompareAndSetInt...OK -DirectByteBufferViewBEWeakCompareAndSetLong...OK -DirectByteBufferViewBEWeakCompareAndSetFloat...OK -DirectByteBufferViewBEWeakCompareAndSetDouble...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireShort...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireChar...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireInt...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireLong...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireFloat...OK -DirectByteBufferViewBEWeakCompareAndSetAcquireDouble...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseShort...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseChar...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseInt...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseLong...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseFloat...OK -DirectByteBufferViewBEWeakCompareAndSetReleaseDouble...OK -DirectByteBufferViewBEGetAndSetShort...OK -DirectByteBufferViewBEGetAndSetChar...OK -DirectByteBufferViewBEGetAndSetInt...OK -DirectByteBufferViewBEGetAndSetLong...OK -DirectByteBufferViewBEGetAndSetFloat...OK -DirectByteBufferViewBEGetAndSetDouble...OK -DirectByteBufferViewBEGetAndSetAcquireShort...OK -DirectByteBufferViewBEGetAndSetAcquireChar...OK -DirectByteBufferViewBEGetAndSetAcquireInt...OK -DirectByteBufferViewBEGetAndSetAcquireLong...OK -DirectByteBufferViewBEGetAndSetAcquireFloat...OK -DirectByteBufferViewBEGetAndSetAcquireDouble...OK -DirectByteBufferViewBEGetAndSetReleaseShort...OK -DirectByteBufferViewBEGetAndSetReleaseChar...OK -DirectByteBufferViewBEGetAndSetReleaseInt...OK -DirectByteBufferViewBEGetAndSetReleaseLong...OK -DirectByteBufferViewBEGetAndSetReleaseFloat...OK -DirectByteBufferViewBEGetAndSetReleaseDouble...OK -DirectByteBufferViewBEGetAndAddShort...OK -DirectByteBufferViewBEGetAndAddChar...OK -DirectByteBufferViewBEGetAndAddInt...OK -DirectByteBufferViewBEGetAndAddLong...OK -DirectByteBufferViewBEGetAndAddFloat...OK -DirectByteBufferViewBEGetAndAddDouble...OK -DirectByteBufferViewBEGetAndAddAcquireShort...OK -DirectByteBufferViewBEGetAndAddAcquireChar...OK -DirectByteBufferViewBEGetAndAddAcquireInt...OK -DirectByteBufferViewBEGetAndAddAcquireLong...OK -DirectByteBufferViewBEGetAndAddAcquireFloat...OK -DirectByteBufferViewBEGetAndAddAcquireDouble...OK -DirectByteBufferViewBEGetAndAddReleaseShort...OK -DirectByteBufferViewBEGetAndAddReleaseChar...OK -DirectByteBufferViewBEGetAndAddReleaseInt...OK -DirectByteBufferViewBEGetAndAddReleaseLong...OK -DirectByteBufferViewBEGetAndAddReleaseFloat...OK -DirectByteBufferViewBEGetAndAddReleaseDouble...OK -DirectByteBufferViewBEGetAndBitwiseOrShort...OK -DirectByteBufferViewBEGetAndBitwiseOrChar...OK -DirectByteBufferViewBEGetAndBitwiseOrInt...OK -DirectByteBufferViewBEGetAndBitwiseOrLong...OK -DirectByteBufferViewBEGetAndBitwiseOrFloat...OK -DirectByteBufferViewBEGetAndBitwiseOrDouble...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseShort...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseChar...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseInt...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseLong...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseFloat...OK -DirectByteBufferViewBEGetAndBitwiseOrReleaseDouble...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireShort...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireChar...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireInt...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireLong...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireFloat...OK -DirectByteBufferViewBEGetAndBitwiseOrAcquireDouble...OK -DirectByteBufferViewBEGetAndBitwiseAndShort...OK -DirectByteBufferViewBEGetAndBitwiseAndChar...OK -DirectByteBufferViewBEGetAndBitwiseAndInt...OK -DirectByteBufferViewBEGetAndBitwiseAndLong...OK -DirectByteBufferViewBEGetAndBitwiseAndFloat...OK -DirectByteBufferViewBEGetAndBitwiseAndDouble...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseShort...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseChar...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseInt...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseLong...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseFloat...OK -DirectByteBufferViewBEGetAndBitwiseAndReleaseDouble...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireShort...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireChar...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireInt...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireLong...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireFloat...OK -DirectByteBufferViewBEGetAndBitwiseAndAcquireDouble...OK -DirectByteBufferViewBEGetAndBitwiseXorShort...OK -DirectByteBufferViewBEGetAndBitwiseXorChar...OK -DirectByteBufferViewBEGetAndBitwiseXorInt...OK -DirectByteBufferViewBEGetAndBitwiseXorLong...OK -DirectByteBufferViewBEGetAndBitwiseXorFloat...OK -DirectByteBufferViewBEGetAndBitwiseXorDouble...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseShort...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseChar...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseInt...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseLong...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseFloat...OK -DirectByteBufferViewBEGetAndBitwiseXorReleaseDouble...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireShort...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireChar...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireInt...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireLong...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireFloat...OK -DirectByteBufferViewBEGetAndBitwiseXorAcquireDouble...OK -HeapByteBufferViewLEGetShort...OK -HeapByteBufferViewLEGetChar...OK -HeapByteBufferViewLEGetInt...OK -HeapByteBufferViewLEGetLong...OK -HeapByteBufferViewLEGetFloat...OK -HeapByteBufferViewLEGetDouble...OK -HeapByteBufferViewLESetShort...OK -HeapByteBufferViewLESetChar...OK -HeapByteBufferViewLESetInt...OK -HeapByteBufferViewLESetLong...OK -HeapByteBufferViewLESetFloat...OK -HeapByteBufferViewLESetDouble...OK -HeapByteBufferViewLEGetVolatileShort...OK -HeapByteBufferViewLEGetVolatileChar...OK -HeapByteBufferViewLEGetVolatileInt...OK -HeapByteBufferViewLEGetVolatileLong...OK -HeapByteBufferViewLEGetVolatileFloat...OK -HeapByteBufferViewLEGetVolatileDouble...OK -HeapByteBufferViewLESetVolatileShort...OK -HeapByteBufferViewLESetVolatileChar...OK -HeapByteBufferViewLESetVolatileInt...OK -HeapByteBufferViewLESetVolatileLong...OK -HeapByteBufferViewLESetVolatileFloat...OK -HeapByteBufferViewLESetVolatileDouble...OK -HeapByteBufferViewLEGetAcquireShort...OK -HeapByteBufferViewLEGetAcquireChar...OK -HeapByteBufferViewLEGetAcquireInt...OK -HeapByteBufferViewLEGetAcquireLong...OK -HeapByteBufferViewLEGetAcquireFloat...OK -HeapByteBufferViewLEGetAcquireDouble...OK -HeapByteBufferViewLESetReleaseShort...OK -HeapByteBufferViewLESetReleaseChar...OK -HeapByteBufferViewLESetReleaseInt...OK -HeapByteBufferViewLESetReleaseLong...OK -HeapByteBufferViewLESetReleaseFloat...OK -HeapByteBufferViewLESetReleaseDouble...OK -HeapByteBufferViewLEGetOpaqueShort...OK -HeapByteBufferViewLEGetOpaqueChar...OK -HeapByteBufferViewLEGetOpaqueInt...OK -HeapByteBufferViewLEGetOpaqueLong...OK -HeapByteBufferViewLEGetOpaqueFloat...OK -HeapByteBufferViewLEGetOpaqueDouble...OK -HeapByteBufferViewLESetOpaqueShort...OK -HeapByteBufferViewLESetOpaqueChar...OK -HeapByteBufferViewLESetOpaqueInt...OK -HeapByteBufferViewLESetOpaqueLong...OK -HeapByteBufferViewLESetOpaqueFloat...OK -HeapByteBufferViewLESetOpaqueDouble...OK -HeapByteBufferViewLECompareAndSetShort...OK -HeapByteBufferViewLECompareAndSetChar...OK -HeapByteBufferViewLECompareAndSetInt...OK -HeapByteBufferViewLECompareAndSetLong...OK -HeapByteBufferViewLECompareAndSetFloat...OK -HeapByteBufferViewLECompareAndSetDouble...OK -HeapByteBufferViewLECompareAndExchangeShort...OK -HeapByteBufferViewLECompareAndExchangeChar...OK -HeapByteBufferViewLECompareAndExchangeInt...OK -HeapByteBufferViewLECompareAndExchangeLong...OK -HeapByteBufferViewLECompareAndExchangeFloat...OK -HeapByteBufferViewLECompareAndExchangeDouble...OK -HeapByteBufferViewLECompareAndExchangeAcquireShort...OK -HeapByteBufferViewLECompareAndExchangeAcquireChar...OK -HeapByteBufferViewLECompareAndExchangeAcquireInt...OK -HeapByteBufferViewLECompareAndExchangeAcquireLong...OK -HeapByteBufferViewLECompareAndExchangeAcquireFloat...OK -HeapByteBufferViewLECompareAndExchangeAcquireDouble...OK -HeapByteBufferViewLECompareAndExchangeReleaseShort...OK -HeapByteBufferViewLECompareAndExchangeReleaseChar...OK -HeapByteBufferViewLECompareAndExchangeReleaseInt...OK -HeapByteBufferViewLECompareAndExchangeReleaseLong...OK -HeapByteBufferViewLECompareAndExchangeReleaseFloat...OK -HeapByteBufferViewLECompareAndExchangeReleaseDouble...OK -HeapByteBufferViewLEWeakCompareAndSetPlainShort...OK -HeapByteBufferViewLEWeakCompareAndSetPlainChar...OK -HeapByteBufferViewLEWeakCompareAndSetPlainInt...OK -HeapByteBufferViewLEWeakCompareAndSetPlainLong...OK -HeapByteBufferViewLEWeakCompareAndSetPlainFloat...OK -HeapByteBufferViewLEWeakCompareAndSetPlainDouble...OK -HeapByteBufferViewLEWeakCompareAndSetShort...OK -HeapByteBufferViewLEWeakCompareAndSetChar...OK -HeapByteBufferViewLEWeakCompareAndSetInt...OK -HeapByteBufferViewLEWeakCompareAndSetLong...OK -HeapByteBufferViewLEWeakCompareAndSetFloat...OK -HeapByteBufferViewLEWeakCompareAndSetDouble...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireShort...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireChar...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireInt...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireLong...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireFloat...OK -HeapByteBufferViewLEWeakCompareAndSetAcquireDouble...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseShort...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseChar...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseInt...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseLong...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseFloat...OK -HeapByteBufferViewLEWeakCompareAndSetReleaseDouble...OK -HeapByteBufferViewLEGetAndSetShort...OK -HeapByteBufferViewLEGetAndSetChar...OK -HeapByteBufferViewLEGetAndSetInt...OK -HeapByteBufferViewLEGetAndSetLong...OK -HeapByteBufferViewLEGetAndSetFloat...OK -HeapByteBufferViewLEGetAndSetDouble...OK -HeapByteBufferViewLEGetAndSetAcquireShort...OK -HeapByteBufferViewLEGetAndSetAcquireChar...OK -HeapByteBufferViewLEGetAndSetAcquireInt...OK -HeapByteBufferViewLEGetAndSetAcquireLong...OK -HeapByteBufferViewLEGetAndSetAcquireFloat...OK -HeapByteBufferViewLEGetAndSetAcquireDouble...OK -HeapByteBufferViewLEGetAndSetReleaseShort...OK -HeapByteBufferViewLEGetAndSetReleaseChar...OK -HeapByteBufferViewLEGetAndSetReleaseInt...OK -HeapByteBufferViewLEGetAndSetReleaseLong...OK -HeapByteBufferViewLEGetAndSetReleaseFloat...OK -HeapByteBufferViewLEGetAndSetReleaseDouble...OK -HeapByteBufferViewLEGetAndAddShort...OK -HeapByteBufferViewLEGetAndAddChar...OK -HeapByteBufferViewLEGetAndAddInt...OK -HeapByteBufferViewLEGetAndAddLong...OK -HeapByteBufferViewLEGetAndAddFloat...OK -HeapByteBufferViewLEGetAndAddDouble...OK -HeapByteBufferViewLEGetAndAddAcquireShort...OK -HeapByteBufferViewLEGetAndAddAcquireChar...OK -HeapByteBufferViewLEGetAndAddAcquireInt...OK -HeapByteBufferViewLEGetAndAddAcquireLong...OK -HeapByteBufferViewLEGetAndAddAcquireFloat...OK -HeapByteBufferViewLEGetAndAddAcquireDouble...OK -HeapByteBufferViewLEGetAndAddReleaseShort...OK -HeapByteBufferViewLEGetAndAddReleaseChar...OK -HeapByteBufferViewLEGetAndAddReleaseInt...OK -HeapByteBufferViewLEGetAndAddReleaseLong...OK -HeapByteBufferViewLEGetAndAddReleaseFloat...OK -HeapByteBufferViewLEGetAndAddReleaseDouble...OK -HeapByteBufferViewLEGetAndBitwiseOrShort...OK -HeapByteBufferViewLEGetAndBitwiseOrChar...OK -HeapByteBufferViewLEGetAndBitwiseOrInt...OK -HeapByteBufferViewLEGetAndBitwiseOrLong...OK -HeapByteBufferViewLEGetAndBitwiseOrFloat...OK -HeapByteBufferViewLEGetAndBitwiseOrDouble...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseShort...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseChar...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseInt...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseLong...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseFloat...OK -HeapByteBufferViewLEGetAndBitwiseOrReleaseDouble...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireShort...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireChar...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireInt...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireLong...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireFloat...OK -HeapByteBufferViewLEGetAndBitwiseOrAcquireDouble...OK -HeapByteBufferViewLEGetAndBitwiseAndShort...OK -HeapByteBufferViewLEGetAndBitwiseAndChar...OK -HeapByteBufferViewLEGetAndBitwiseAndInt...OK -HeapByteBufferViewLEGetAndBitwiseAndLong...OK -HeapByteBufferViewLEGetAndBitwiseAndFloat...OK -HeapByteBufferViewLEGetAndBitwiseAndDouble...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseShort...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseChar...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseInt...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseLong...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseFloat...OK -HeapByteBufferViewLEGetAndBitwiseAndReleaseDouble...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireShort...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireChar...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireInt...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireLong...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireFloat...OK -HeapByteBufferViewLEGetAndBitwiseAndAcquireDouble...OK -HeapByteBufferViewLEGetAndBitwiseXorShort...OK -HeapByteBufferViewLEGetAndBitwiseXorChar...OK -HeapByteBufferViewLEGetAndBitwiseXorInt...OK -HeapByteBufferViewLEGetAndBitwiseXorLong...OK -HeapByteBufferViewLEGetAndBitwiseXorFloat...OK -HeapByteBufferViewLEGetAndBitwiseXorDouble...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseShort...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseChar...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseInt...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseLong...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseFloat...OK -HeapByteBufferViewLEGetAndBitwiseXorReleaseDouble...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireShort...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireChar...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireInt...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireLong...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireFloat...OK -HeapByteBufferViewLEGetAndBitwiseXorAcquireDouble...OK -HeapByteBufferViewBEGetShort...OK -HeapByteBufferViewBEGetChar...OK -HeapByteBufferViewBEGetInt...OK -HeapByteBufferViewBEGetLong...OK -HeapByteBufferViewBEGetFloat...OK -HeapByteBufferViewBEGetDouble...OK -HeapByteBufferViewBESetShort...OK -HeapByteBufferViewBESetChar...OK -HeapByteBufferViewBESetInt...OK -HeapByteBufferViewBESetLong...OK -HeapByteBufferViewBESetFloat...OK -HeapByteBufferViewBESetDouble...OK -HeapByteBufferViewBEGetVolatileShort...OK -HeapByteBufferViewBEGetVolatileChar...OK -HeapByteBufferViewBEGetVolatileInt...OK -HeapByteBufferViewBEGetVolatileLong...OK -HeapByteBufferViewBEGetVolatileFloat...OK -HeapByteBufferViewBEGetVolatileDouble...OK -HeapByteBufferViewBESetVolatileShort...OK -HeapByteBufferViewBESetVolatileChar...OK -HeapByteBufferViewBESetVolatileInt...OK -HeapByteBufferViewBESetVolatileLong...OK -HeapByteBufferViewBESetVolatileFloat...OK -HeapByteBufferViewBESetVolatileDouble...OK -HeapByteBufferViewBEGetAcquireShort...OK -HeapByteBufferViewBEGetAcquireChar...OK -HeapByteBufferViewBEGetAcquireInt...OK -HeapByteBufferViewBEGetAcquireLong...OK -HeapByteBufferViewBEGetAcquireFloat...OK -HeapByteBufferViewBEGetAcquireDouble...OK -HeapByteBufferViewBESetReleaseShort...OK -HeapByteBufferViewBESetReleaseChar...OK -HeapByteBufferViewBESetReleaseInt...OK -HeapByteBufferViewBESetReleaseLong...OK -HeapByteBufferViewBESetReleaseFloat...OK -HeapByteBufferViewBESetReleaseDouble...OK -HeapByteBufferViewBEGetOpaqueShort...OK -HeapByteBufferViewBEGetOpaqueChar...OK -HeapByteBufferViewBEGetOpaqueInt...OK -HeapByteBufferViewBEGetOpaqueLong...OK -HeapByteBufferViewBEGetOpaqueFloat...OK -HeapByteBufferViewBEGetOpaqueDouble...OK -HeapByteBufferViewBESetOpaqueShort...OK -HeapByteBufferViewBESetOpaqueChar...OK -HeapByteBufferViewBESetOpaqueInt...OK -HeapByteBufferViewBESetOpaqueLong...OK -HeapByteBufferViewBESetOpaqueFloat...OK -HeapByteBufferViewBESetOpaqueDouble...OK -HeapByteBufferViewBECompareAndSetShort...OK -HeapByteBufferViewBECompareAndSetChar...OK -HeapByteBufferViewBECompareAndSetInt...OK -HeapByteBufferViewBECompareAndSetLong...OK -HeapByteBufferViewBECompareAndSetFloat...OK -HeapByteBufferViewBECompareAndSetDouble...OK -HeapByteBufferViewBECompareAndExchangeShort...OK -HeapByteBufferViewBECompareAndExchangeChar...OK -HeapByteBufferViewBECompareAndExchangeInt...OK -HeapByteBufferViewBECompareAndExchangeLong...OK -HeapByteBufferViewBECompareAndExchangeFloat...OK -HeapByteBufferViewBECompareAndExchangeDouble...OK -HeapByteBufferViewBECompareAndExchangeAcquireShort...OK -HeapByteBufferViewBECompareAndExchangeAcquireChar...OK -HeapByteBufferViewBECompareAndExchangeAcquireInt...OK -HeapByteBufferViewBECompareAndExchangeAcquireLong...OK -HeapByteBufferViewBECompareAndExchangeAcquireFloat...OK -HeapByteBufferViewBECompareAndExchangeAcquireDouble...OK -HeapByteBufferViewBECompareAndExchangeReleaseShort...OK -HeapByteBufferViewBECompareAndExchangeReleaseChar...OK -HeapByteBufferViewBECompareAndExchangeReleaseInt...OK -HeapByteBufferViewBECompareAndExchangeReleaseLong...OK -HeapByteBufferViewBECompareAndExchangeReleaseFloat...OK -HeapByteBufferViewBECompareAndExchangeReleaseDouble...OK -HeapByteBufferViewBEWeakCompareAndSetPlainShort...OK -HeapByteBufferViewBEWeakCompareAndSetPlainChar...OK -HeapByteBufferViewBEWeakCompareAndSetPlainInt...OK -HeapByteBufferViewBEWeakCompareAndSetPlainLong...OK -HeapByteBufferViewBEWeakCompareAndSetPlainFloat...OK -HeapByteBufferViewBEWeakCompareAndSetPlainDouble...OK -HeapByteBufferViewBEWeakCompareAndSetShort...OK -HeapByteBufferViewBEWeakCompareAndSetChar...OK -HeapByteBufferViewBEWeakCompareAndSetInt...OK -HeapByteBufferViewBEWeakCompareAndSetLong...OK -HeapByteBufferViewBEWeakCompareAndSetFloat...OK -HeapByteBufferViewBEWeakCompareAndSetDouble...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireShort...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireChar...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireInt...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireLong...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireFloat...OK -HeapByteBufferViewBEWeakCompareAndSetAcquireDouble...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseShort...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseChar...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseInt...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseLong...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseFloat...OK -HeapByteBufferViewBEWeakCompareAndSetReleaseDouble...OK -HeapByteBufferViewBEGetAndSetShort...OK -HeapByteBufferViewBEGetAndSetChar...OK -HeapByteBufferViewBEGetAndSetInt...OK -HeapByteBufferViewBEGetAndSetLong...OK -HeapByteBufferViewBEGetAndSetFloat...OK -HeapByteBufferViewBEGetAndSetDouble...OK -HeapByteBufferViewBEGetAndSetAcquireShort...OK -HeapByteBufferViewBEGetAndSetAcquireChar...OK -HeapByteBufferViewBEGetAndSetAcquireInt...OK -HeapByteBufferViewBEGetAndSetAcquireLong...OK -HeapByteBufferViewBEGetAndSetAcquireFloat...OK -HeapByteBufferViewBEGetAndSetAcquireDouble...OK -HeapByteBufferViewBEGetAndSetReleaseShort...OK -HeapByteBufferViewBEGetAndSetReleaseChar...OK -HeapByteBufferViewBEGetAndSetReleaseInt...OK -HeapByteBufferViewBEGetAndSetReleaseLong...OK -HeapByteBufferViewBEGetAndSetReleaseFloat...OK -HeapByteBufferViewBEGetAndSetReleaseDouble...OK -HeapByteBufferViewBEGetAndAddShort...OK -HeapByteBufferViewBEGetAndAddChar...OK -HeapByteBufferViewBEGetAndAddInt...OK -HeapByteBufferViewBEGetAndAddLong...OK -HeapByteBufferViewBEGetAndAddFloat...OK -HeapByteBufferViewBEGetAndAddDouble...OK -HeapByteBufferViewBEGetAndAddAcquireShort...OK -HeapByteBufferViewBEGetAndAddAcquireChar...OK -HeapByteBufferViewBEGetAndAddAcquireInt...OK -HeapByteBufferViewBEGetAndAddAcquireLong...OK -HeapByteBufferViewBEGetAndAddAcquireFloat...OK -HeapByteBufferViewBEGetAndAddAcquireDouble...OK -HeapByteBufferViewBEGetAndAddReleaseShort...OK -HeapByteBufferViewBEGetAndAddReleaseChar...OK -HeapByteBufferViewBEGetAndAddReleaseInt...OK -HeapByteBufferViewBEGetAndAddReleaseLong...OK -HeapByteBufferViewBEGetAndAddReleaseFloat...OK -HeapByteBufferViewBEGetAndAddReleaseDouble...OK -HeapByteBufferViewBEGetAndBitwiseOrShort...OK -HeapByteBufferViewBEGetAndBitwiseOrChar...OK -HeapByteBufferViewBEGetAndBitwiseOrInt...OK -HeapByteBufferViewBEGetAndBitwiseOrLong...OK -HeapByteBufferViewBEGetAndBitwiseOrFloat...OK -HeapByteBufferViewBEGetAndBitwiseOrDouble...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseShort...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseChar...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseInt...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseLong...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseFloat...OK -HeapByteBufferViewBEGetAndBitwiseOrReleaseDouble...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireShort...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireChar...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireInt...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireLong...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireFloat...OK -HeapByteBufferViewBEGetAndBitwiseOrAcquireDouble...OK -HeapByteBufferViewBEGetAndBitwiseAndShort...OK -HeapByteBufferViewBEGetAndBitwiseAndChar...OK -HeapByteBufferViewBEGetAndBitwiseAndInt...OK -HeapByteBufferViewBEGetAndBitwiseAndLong...OK -HeapByteBufferViewBEGetAndBitwiseAndFloat...OK -HeapByteBufferViewBEGetAndBitwiseAndDouble...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseShort...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseChar...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseInt...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseLong...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseFloat...OK -HeapByteBufferViewBEGetAndBitwiseAndReleaseDouble...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireShort...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireChar...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireInt...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireLong...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireFloat...OK -HeapByteBufferViewBEGetAndBitwiseAndAcquireDouble...OK -HeapByteBufferViewBEGetAndBitwiseXorShort...OK -HeapByteBufferViewBEGetAndBitwiseXorChar...OK -HeapByteBufferViewBEGetAndBitwiseXorInt...OK -HeapByteBufferViewBEGetAndBitwiseXorLong...OK -HeapByteBufferViewBEGetAndBitwiseXorFloat...OK -HeapByteBufferViewBEGetAndBitwiseXorDouble...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseShort...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseChar...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseInt...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseLong...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseFloat...OK -HeapByteBufferViewBEGetAndBitwiseXorReleaseDouble...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireShort...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireChar...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireInt...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireLong...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireFloat...OK -HeapByteBufferViewBEGetAndBitwiseXorAcquireDouble...OK -HeapByteBufferReadOnlyViewLEGetShort...OK -HeapByteBufferReadOnlyViewLEGetChar...OK -HeapByteBufferReadOnlyViewLEGetInt...OK -HeapByteBufferReadOnlyViewLEGetLong...OK -HeapByteBufferReadOnlyViewLEGetFloat...OK -HeapByteBufferReadOnlyViewLEGetDouble...OK -HeapByteBufferReadOnlyViewLESetShort...OK -HeapByteBufferReadOnlyViewLESetChar...OK -HeapByteBufferReadOnlyViewLESetInt...OK -HeapByteBufferReadOnlyViewLESetLong...OK -HeapByteBufferReadOnlyViewLESetFloat...OK -HeapByteBufferReadOnlyViewLESetDouble...OK -HeapByteBufferReadOnlyViewLEGetVolatileShort...OK -HeapByteBufferReadOnlyViewLEGetVolatileChar...OK -HeapByteBufferReadOnlyViewLEGetVolatileInt...OK -HeapByteBufferReadOnlyViewLEGetVolatileLong...OK -HeapByteBufferReadOnlyViewLEGetVolatileFloat...OK -HeapByteBufferReadOnlyViewLEGetVolatileDouble...OK -HeapByteBufferReadOnlyViewLESetVolatileShort...OK -HeapByteBufferReadOnlyViewLESetVolatileChar...OK -HeapByteBufferReadOnlyViewLESetVolatileInt...OK -HeapByteBufferReadOnlyViewLESetVolatileLong...OK -HeapByteBufferReadOnlyViewLESetVolatileFloat...OK -HeapByteBufferReadOnlyViewLESetVolatileDouble...OK -HeapByteBufferReadOnlyViewLEGetAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAcquireDouble...OK -HeapByteBufferReadOnlyViewLESetReleaseShort...OK -HeapByteBufferReadOnlyViewLESetReleaseChar...OK -HeapByteBufferReadOnlyViewLESetReleaseInt...OK -HeapByteBufferReadOnlyViewLESetReleaseLong...OK -HeapByteBufferReadOnlyViewLESetReleaseFloat...OK -HeapByteBufferReadOnlyViewLESetReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetOpaqueShort...OK -HeapByteBufferReadOnlyViewLEGetOpaqueChar...OK -HeapByteBufferReadOnlyViewLEGetOpaqueInt...OK -HeapByteBufferReadOnlyViewLEGetOpaqueLong...OK -HeapByteBufferReadOnlyViewLEGetOpaqueFloat...OK -HeapByteBufferReadOnlyViewLEGetOpaqueDouble...OK -HeapByteBufferReadOnlyViewLESetOpaqueShort...OK -HeapByteBufferReadOnlyViewLESetOpaqueChar...OK -HeapByteBufferReadOnlyViewLESetOpaqueInt...OK -HeapByteBufferReadOnlyViewLESetOpaqueLong...OK -HeapByteBufferReadOnlyViewLESetOpaqueFloat...OK -HeapByteBufferReadOnlyViewLESetOpaqueDouble...OK -HeapByteBufferReadOnlyViewLECompareAndSetShort...OK -HeapByteBufferReadOnlyViewLECompareAndSetChar...OK -HeapByteBufferReadOnlyViewLECompareAndSetInt...OK -HeapByteBufferReadOnlyViewLECompareAndSetLong...OK -HeapByteBufferReadOnlyViewLECompareAndSetFloat...OK -HeapByteBufferReadOnlyViewLECompareAndSetDouble...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeShort...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeChar...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeInt...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeLong...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeFloat...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeDouble...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireShort...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireChar...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireInt...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireLong...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireFloat...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeAcquireDouble...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseShort...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseChar...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseInt...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseLong...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseFloat...OK -HeapByteBufferReadOnlyViewLECompareAndExchangeReleaseDouble...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainShort...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainChar...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainInt...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainLong...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainFloat...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetPlainDouble...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetShort...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetChar...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetInt...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetLong...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetFloat...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetDouble...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireShort...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireChar...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireInt...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireLong...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireFloat...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetAcquireDouble...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseShort...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseChar...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseInt...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseLong...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseFloat...OK -HeapByteBufferReadOnlyViewLEWeakCompareAndSetReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndSetShort...OK -HeapByteBufferReadOnlyViewLEGetAndSetChar...OK -HeapByteBufferReadOnlyViewLEGetAndSetInt...OK -HeapByteBufferReadOnlyViewLEGetAndSetLong...OK -HeapByteBufferReadOnlyViewLEGetAndSetFloat...OK -HeapByteBufferReadOnlyViewLEGetAndSetDouble...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAndSetAcquireDouble...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseShort...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseChar...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseInt...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseLong...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseFloat...OK -HeapByteBufferReadOnlyViewLEGetAndSetReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndAddShort...OK -HeapByteBufferReadOnlyViewLEGetAndAddChar...OK -HeapByteBufferReadOnlyViewLEGetAndAddInt...OK -HeapByteBufferReadOnlyViewLEGetAndAddLong...OK -HeapByteBufferReadOnlyViewLEGetAndAddFloat...OK -HeapByteBufferReadOnlyViewLEGetAndAddDouble...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAndAddAcquireDouble...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseShort...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseChar...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseInt...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseLong...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseFloat...OK -HeapByteBufferReadOnlyViewLEGetAndAddReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseOrAcquireDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseAndAcquireDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorReleaseDouble...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireShort...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireChar...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireInt...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireLong...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireFloat...OK -HeapByteBufferReadOnlyViewLEGetAndBitwiseXorAcquireDouble...OK -HeapByteBufferReadOnlyViewBEGetShort...OK -HeapByteBufferReadOnlyViewBEGetChar...OK -HeapByteBufferReadOnlyViewBEGetInt...OK -HeapByteBufferReadOnlyViewBEGetLong...OK -HeapByteBufferReadOnlyViewBEGetFloat...OK -HeapByteBufferReadOnlyViewBEGetDouble...OK -HeapByteBufferReadOnlyViewBESetShort...OK -HeapByteBufferReadOnlyViewBESetChar...OK -HeapByteBufferReadOnlyViewBESetInt...OK -HeapByteBufferReadOnlyViewBESetLong...OK -HeapByteBufferReadOnlyViewBESetFloat...OK -HeapByteBufferReadOnlyViewBESetDouble...OK -HeapByteBufferReadOnlyViewBEGetVolatileShort...OK -HeapByteBufferReadOnlyViewBEGetVolatileChar...OK -HeapByteBufferReadOnlyViewBEGetVolatileInt...OK -HeapByteBufferReadOnlyViewBEGetVolatileLong...OK -HeapByteBufferReadOnlyViewBEGetVolatileFloat...OK -HeapByteBufferReadOnlyViewBEGetVolatileDouble...OK -HeapByteBufferReadOnlyViewBESetVolatileShort...OK -HeapByteBufferReadOnlyViewBESetVolatileChar...OK -HeapByteBufferReadOnlyViewBESetVolatileInt...OK -HeapByteBufferReadOnlyViewBESetVolatileLong...OK -HeapByteBufferReadOnlyViewBESetVolatileFloat...OK -HeapByteBufferReadOnlyViewBESetVolatileDouble...OK -HeapByteBufferReadOnlyViewBEGetAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAcquireDouble...OK -HeapByteBufferReadOnlyViewBESetReleaseShort...OK -HeapByteBufferReadOnlyViewBESetReleaseChar...OK -HeapByteBufferReadOnlyViewBESetReleaseInt...OK -HeapByteBufferReadOnlyViewBESetReleaseLong...OK -HeapByteBufferReadOnlyViewBESetReleaseFloat...OK -HeapByteBufferReadOnlyViewBESetReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetOpaqueShort...OK -HeapByteBufferReadOnlyViewBEGetOpaqueChar...OK -HeapByteBufferReadOnlyViewBEGetOpaqueInt...OK -HeapByteBufferReadOnlyViewBEGetOpaqueLong...OK -HeapByteBufferReadOnlyViewBEGetOpaqueFloat...OK -HeapByteBufferReadOnlyViewBEGetOpaqueDouble...OK -HeapByteBufferReadOnlyViewBESetOpaqueShort...OK -HeapByteBufferReadOnlyViewBESetOpaqueChar...OK -HeapByteBufferReadOnlyViewBESetOpaqueInt...OK -HeapByteBufferReadOnlyViewBESetOpaqueLong...OK -HeapByteBufferReadOnlyViewBESetOpaqueFloat...OK -HeapByteBufferReadOnlyViewBESetOpaqueDouble...OK -HeapByteBufferReadOnlyViewBECompareAndSetShort...OK -HeapByteBufferReadOnlyViewBECompareAndSetChar...OK -HeapByteBufferReadOnlyViewBECompareAndSetInt...OK -HeapByteBufferReadOnlyViewBECompareAndSetLong...OK -HeapByteBufferReadOnlyViewBECompareAndSetFloat...OK -HeapByteBufferReadOnlyViewBECompareAndSetDouble...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeShort...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeChar...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeInt...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeLong...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeFloat...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeDouble...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireShort...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireChar...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireInt...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireLong...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireFloat...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeAcquireDouble...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseShort...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseChar...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseInt...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseLong...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseFloat...OK -HeapByteBufferReadOnlyViewBECompareAndExchangeReleaseDouble...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainShort...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainChar...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainInt...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainLong...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainFloat...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetPlainDouble...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetShort...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetChar...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetInt...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetLong...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetFloat...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetDouble...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireShort...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireChar...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireInt...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireLong...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireFloat...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetAcquireDouble...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseShort...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseChar...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseInt...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseLong...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseFloat...OK -HeapByteBufferReadOnlyViewBEWeakCompareAndSetReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndSetShort...OK -HeapByteBufferReadOnlyViewBEGetAndSetChar...OK -HeapByteBufferReadOnlyViewBEGetAndSetInt...OK -HeapByteBufferReadOnlyViewBEGetAndSetLong...OK -HeapByteBufferReadOnlyViewBEGetAndSetFloat...OK -HeapByteBufferReadOnlyViewBEGetAndSetDouble...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAndSetAcquireDouble...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseShort...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseChar...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseInt...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseLong...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseFloat...OK -HeapByteBufferReadOnlyViewBEGetAndSetReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndAddShort...OK -HeapByteBufferReadOnlyViewBEGetAndAddChar...OK -HeapByteBufferReadOnlyViewBEGetAndAddInt...OK -HeapByteBufferReadOnlyViewBEGetAndAddLong...OK -HeapByteBufferReadOnlyViewBEGetAndAddFloat...OK -HeapByteBufferReadOnlyViewBEGetAndAddDouble...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAndAddAcquireDouble...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseShort...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseChar...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseInt...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseLong...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseFloat...OK -HeapByteBufferReadOnlyViewBEGetAndAddReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseOrAcquireDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseAndAcquireDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorReleaseDouble...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireShort...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireChar...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireInt...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireLong...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireFloat...OK -HeapByteBufferReadOnlyViewBEGetAndBitwiseXorAcquireDouble...OK -FieldGetWidget...OK -FieldSetWidget...OK -FieldGetVolatileWidget...OK -FieldSetVolatileWidget...OK -FieldGetAcquireWidget...OK -FieldSetReleaseWidget...OK -FieldGetOpaqueWidget...OK -FieldSetOpaqueWidget...OK -FieldCompareAndSetWidget...OK -FieldCompareAndExchangeWidget...OK -FieldCompareAndExchangeAcquireWidget...OK -FieldCompareAndExchangeReleaseWidget...OK -FieldWeakCompareAndSetPlainWidget...OK -FieldWeakCompareAndSetWidget...OK -FieldWeakCompareAndSetAcquireWidget...OK -FieldWeakCompareAndSetReleaseWidget...OK -FieldGetAndSetWidget...OK -FieldGetAndSetAcquireWidget...OK -FieldGetAndSetReleaseWidget...OK -FieldGetAndAddWidget...OK -FieldGetAndAddAcquireWidget...OK -FieldGetAndAddReleaseWidget...OK -FieldGetAndBitwiseOrWidget...OK -FieldGetAndBitwiseOrReleaseWidget...OK -FieldGetAndBitwiseOrAcquireWidget...OK -FieldGetAndBitwiseAndWidget...OK -FieldGetAndBitwiseAndReleaseWidget...OK -FieldGetAndBitwiseAndAcquireWidget...OK -FieldGetAndBitwiseXorWidget...OK -FieldGetAndBitwiseXorReleaseWidget...OK -FieldGetAndBitwiseXorAcquireWidget...OK -FinalFieldGetWidget...OK -FinalFieldSetWidget...OK -FinalFieldGetVolatileWidget...OK -FinalFieldSetVolatileWidget...OK -FinalFieldGetAcquireWidget...OK -FinalFieldSetReleaseWidget...OK -FinalFieldGetOpaqueWidget...OK -FinalFieldSetOpaqueWidget...OK -FinalFieldCompareAndSetWidget...OK -FinalFieldCompareAndExchangeWidget...OK -FinalFieldCompareAndExchangeAcquireWidget...OK -FinalFieldCompareAndExchangeReleaseWidget...OK -FinalFieldWeakCompareAndSetPlainWidget...OK -FinalFieldWeakCompareAndSetWidget...OK -FinalFieldWeakCompareAndSetAcquireWidget...OK -FinalFieldWeakCompareAndSetReleaseWidget...OK -FinalFieldGetAndSetWidget...OK -FinalFieldGetAndSetAcquireWidget...OK -FinalFieldGetAndSetReleaseWidget...OK -FinalFieldGetAndAddWidget...OK -FinalFieldGetAndAddAcquireWidget...OK -FinalFieldGetAndAddReleaseWidget...OK -FinalFieldGetAndBitwiseOrWidget...OK -FinalFieldGetAndBitwiseOrReleaseWidget...OK -FinalFieldGetAndBitwiseOrAcquireWidget...OK -FinalFieldGetAndBitwiseAndWidget...OK -FinalFieldGetAndBitwiseAndReleaseWidget...OK -FinalFieldGetAndBitwiseAndAcquireWidget...OK -FinalFieldGetAndBitwiseXorWidget...OK -FinalFieldGetAndBitwiseXorReleaseWidget...OK -FinalFieldGetAndBitwiseXorAcquireWidget...OK -StaticFieldGetWidget...OK -StaticFieldSetWidget...OK -StaticFieldGetVolatileWidget...OK -StaticFieldSetVolatileWidget...OK -StaticFieldGetAcquireWidget...OK -StaticFieldSetReleaseWidget...OK -StaticFieldGetOpaqueWidget...OK -StaticFieldSetOpaqueWidget...OK -StaticFieldCompareAndSetWidget...OK -StaticFieldCompareAndExchangeWidget...OK -StaticFieldCompareAndExchangeAcquireWidget...OK -StaticFieldCompareAndExchangeReleaseWidget...OK -StaticFieldWeakCompareAndSetPlainWidget...OK -StaticFieldWeakCompareAndSetWidget...OK -StaticFieldWeakCompareAndSetAcquireWidget...OK -StaticFieldWeakCompareAndSetReleaseWidget...OK -StaticFieldGetAndSetWidget...OK -StaticFieldGetAndSetAcquireWidget...OK -StaticFieldGetAndSetReleaseWidget...OK -StaticFieldGetAndAddWidget...OK -StaticFieldGetAndAddAcquireWidget...OK -StaticFieldGetAndAddReleaseWidget...OK -StaticFieldGetAndBitwiseOrWidget...OK -StaticFieldGetAndBitwiseOrReleaseWidget...OK -StaticFieldGetAndBitwiseOrAcquireWidget...OK -StaticFieldGetAndBitwiseAndWidget...OK -StaticFieldGetAndBitwiseAndReleaseWidget...OK -StaticFieldGetAndBitwiseAndAcquireWidget...OK -StaticFieldGetAndBitwiseXorWidget...OK -StaticFieldGetAndBitwiseXorReleaseWidget...OK -StaticFieldGetAndBitwiseXorAcquireWidget...OK -StaticFinalFieldGetWidget...OK -StaticFinalFieldSetWidget...OK -StaticFinalFieldGetVolatileWidget...OK -StaticFinalFieldSetVolatileWidget...OK -StaticFinalFieldGetAcquireWidget...OK -StaticFinalFieldSetReleaseWidget...OK -StaticFinalFieldGetOpaqueWidget...OK -StaticFinalFieldSetOpaqueWidget...OK -StaticFinalFieldCompareAndSetWidget...OK -StaticFinalFieldCompareAndExchangeWidget...OK -StaticFinalFieldCompareAndExchangeAcquireWidget...OK -StaticFinalFieldCompareAndExchangeReleaseWidget...OK -StaticFinalFieldWeakCompareAndSetPlainWidget...OK -StaticFinalFieldWeakCompareAndSetWidget...OK -StaticFinalFieldWeakCompareAndSetAcquireWidget...OK -StaticFinalFieldWeakCompareAndSetReleaseWidget...OK -StaticFinalFieldGetAndSetWidget...OK -StaticFinalFieldGetAndSetAcquireWidget...OK -StaticFinalFieldGetAndSetReleaseWidget...OK -StaticFinalFieldGetAndAddWidget...OK -StaticFinalFieldGetAndAddAcquireWidget...OK -StaticFinalFieldGetAndAddReleaseWidget...OK -StaticFinalFieldGetAndBitwiseOrWidget...OK -StaticFinalFieldGetAndBitwiseOrReleaseWidget...OK -StaticFinalFieldGetAndBitwiseOrAcquireWidget...OK -StaticFinalFieldGetAndBitwiseAndWidget...OK -StaticFinalFieldGetAndBitwiseAndReleaseWidget...OK -StaticFinalFieldGetAndBitwiseAndAcquireWidget...OK -StaticFinalFieldGetAndBitwiseXorWidget...OK -StaticFinalFieldGetAndBitwiseXorReleaseWidget...OK -StaticFinalFieldGetAndBitwiseXorAcquireWidget...OK -ArrayElementGetWidget...OK -ArrayElementSetWidget...OK -ArrayElementGetVolatileWidget...OK -ArrayElementSetVolatileWidget...OK -ArrayElementGetAcquireWidget...OK -ArrayElementSetReleaseWidget...OK -ArrayElementGetOpaqueWidget...OK -ArrayElementSetOpaqueWidget...OK -ArrayElementCompareAndSetWidget...OK -ArrayElementCompareAndExchangeWidget...OK -ArrayElementCompareAndExchangeAcquireWidget...OK -ArrayElementCompareAndExchangeReleaseWidget...OK -ArrayElementWeakCompareAndSetPlainWidget...OK -ArrayElementWeakCompareAndSetWidget...OK -ArrayElementWeakCompareAndSetAcquireWidget...OK -ArrayElementWeakCompareAndSetReleaseWidget...OK -ArrayElementGetAndSetWidget...OK -ArrayElementGetAndSetAcquireWidget...OK -ArrayElementGetAndSetReleaseWidget...OK -ArrayElementGetAndAddWidget...OK -ArrayElementGetAndAddAcquireWidget...OK -ArrayElementGetAndAddReleaseWidget...OK -ArrayElementGetAndBitwiseOrWidget...OK -ArrayElementGetAndBitwiseOrReleaseWidget...OK -ArrayElementGetAndBitwiseOrAcquireWidget...OK -ArrayElementGetAndBitwiseAndWidget...OK -ArrayElementGetAndBitwiseAndReleaseWidget...OK -ArrayElementGetAndBitwiseAndAcquireWidget...OK -ArrayElementGetAndBitwiseXorWidget...OK -ArrayElementGetAndBitwiseXorReleaseWidget...OK -ArrayElementGetAndBitwiseXorAcquireWidget...OK -BoxingReturnGetBoolean...OK -BoxingSetBoolean...OK -BoxingReturnGetVolatileBoolean...OK -BoxingSetVolatileBoolean...OK -BoxingReturnGetAcquireBoolean...OK -BoxingSetReleaseBoolean...OK -BoxingReturnGetOpaqueBoolean...OK -BoxingSetOpaqueBoolean...OK -BoxingCompareAndSetBoolean...OK -BoxingCompareAndExchangeBoolean...OK -BoxingCompareAndExchangeAcquireBoolean...OK -BoxingCompareAndExchangeReleaseBoolean...OK -BoxingWeakCompareAndSetPlainBoolean...OK -BoxingWeakCompareAndSetBoolean...OK -BoxingWeakCompareAndSetAcquireBoolean...OK -BoxingWeakCompareAndSetReleaseBoolean...OK -BoxingGetAndSetBoolean...OK -BoxingGetAndSetAcquireBoolean...OK -BoxingGetAndSetReleaseBoolean...OK -BoxingGetAndAddBoolean...OK -BoxingGetAndAddAcquireBoolean...OK -BoxingGetAndAddReleaseBoolean...OK -BoxingGetAndBitwiseOrBoolean...OK -BoxingGetAndBitwiseOrReleaseBoolean...OK -BoxingGetAndBitwiseOrAcquireBoolean...OK -BoxingGetAndBitwiseAndBoolean...OK -BoxingGetAndBitwiseAndReleaseBoolean...OK -BoxingGetAndBitwiseAndAcquireBoolean...OK -BoxingGetAndBitwiseXorBoolean...OK -BoxingGetAndBitwiseXorReleaseBoolean...OK -BoxingGetAndBitwiseXorAcquireBoolean...OK -BoxingReturnGetByte...OK -BoxingSetByte...OK -BoxingReturnGetVolatileByte...OK -BoxingSetVolatileByte...OK -BoxingReturnGetAcquireByte...OK -BoxingSetReleaseByte...OK -BoxingReturnGetOpaqueByte...OK -BoxingSetOpaqueByte...OK -BoxingCompareAndSetByte...OK -BoxingCompareAndExchangeByte...OK -BoxingCompareAndExchangeAcquireByte...OK -BoxingCompareAndExchangeReleaseByte...OK -BoxingWeakCompareAndSetPlainByte...OK -BoxingWeakCompareAndSetByte...OK -BoxingWeakCompareAndSetAcquireByte...OK -BoxingWeakCompareAndSetReleaseByte...OK -BoxingGetAndSetByte...OK -BoxingGetAndSetAcquireByte...OK -BoxingGetAndSetReleaseByte...OK -BoxingGetAndAddByte...OK -BoxingGetAndAddAcquireByte...OK -BoxingGetAndAddReleaseByte...OK -BoxingGetAndBitwiseOrByte...OK -BoxingGetAndBitwiseOrReleaseByte...OK -BoxingGetAndBitwiseOrAcquireByte...OK -BoxingGetAndBitwiseAndByte...OK -BoxingGetAndBitwiseAndReleaseByte...OK -BoxingGetAndBitwiseAndAcquireByte...OK -BoxingGetAndBitwiseXorByte...OK -BoxingGetAndBitwiseXorReleaseByte...OK -BoxingGetAndBitwiseXorAcquireByte...OK -BoxingReturnGetShort...OK -BoxingSetShort...OK -BoxingReturnGetVolatileShort...OK -BoxingSetVolatileShort...OK -BoxingReturnGetAcquireShort...OK -BoxingSetReleaseShort...OK -BoxingReturnGetOpaqueShort...OK -BoxingSetOpaqueShort...OK -BoxingCompareAndSetShort...OK -BoxingCompareAndExchangeShort...OK -BoxingCompareAndExchangeAcquireShort...OK -BoxingCompareAndExchangeReleaseShort...OK -BoxingWeakCompareAndSetPlainShort...OK -BoxingWeakCompareAndSetShort...OK -BoxingWeakCompareAndSetAcquireShort...OK -BoxingWeakCompareAndSetReleaseShort...OK -BoxingGetAndSetShort...OK -BoxingGetAndSetAcquireShort...OK -BoxingGetAndSetReleaseShort...OK -BoxingGetAndAddShort...OK -BoxingGetAndAddAcquireShort...OK -BoxingGetAndAddReleaseShort...OK -BoxingGetAndBitwiseOrShort...OK -BoxingGetAndBitwiseOrReleaseShort...OK -BoxingGetAndBitwiseOrAcquireShort...OK -BoxingGetAndBitwiseAndShort...OK -BoxingGetAndBitwiseAndReleaseShort...OK -BoxingGetAndBitwiseAndAcquireShort...OK -BoxingGetAndBitwiseXorShort...OK -BoxingGetAndBitwiseXorReleaseShort...OK -BoxingGetAndBitwiseXorAcquireShort...OK -BoxingReturnGetChar...OK -BoxingSetChar...OK -BoxingReturnGetVolatileChar...OK -BoxingSetVolatileChar...OK -BoxingReturnGetAcquireChar...OK -BoxingSetReleaseChar...OK -BoxingReturnGetOpaqueChar...OK -BoxingSetOpaqueChar...OK -BoxingCompareAndSetChar...OK -BoxingCompareAndExchangeChar...OK -BoxingCompareAndExchangeAcquireChar...OK -BoxingCompareAndExchangeReleaseChar...OK -BoxingWeakCompareAndSetPlainChar...OK -BoxingWeakCompareAndSetChar...OK -BoxingWeakCompareAndSetAcquireChar...OK -BoxingWeakCompareAndSetReleaseChar...OK -BoxingGetAndSetChar...OK -BoxingGetAndSetAcquireChar...OK -BoxingGetAndSetReleaseChar...OK -BoxingGetAndAddChar...OK -BoxingGetAndAddAcquireChar...OK -BoxingGetAndAddReleaseChar...OK -BoxingGetAndBitwiseOrChar...OK -BoxingGetAndBitwiseOrReleaseChar...OK -BoxingGetAndBitwiseOrAcquireChar...OK -BoxingGetAndBitwiseAndChar...OK -BoxingGetAndBitwiseAndReleaseChar...OK -BoxingGetAndBitwiseAndAcquireChar...OK -BoxingGetAndBitwiseXorChar...OK -BoxingGetAndBitwiseXorReleaseChar...OK -BoxingGetAndBitwiseXorAcquireChar...OK -BoxingReturnGetInt...OK -BoxingSetInt...OK -BoxingReturnGetVolatileInt...OK -BoxingSetVolatileInt...OK -BoxingReturnGetAcquireInt...OK -BoxingSetReleaseInt...OK -BoxingReturnGetOpaqueInt...OK -BoxingSetOpaqueInt...OK -BoxingCompareAndSetInt...OK -BoxingCompareAndExchangeInt...OK -BoxingCompareAndExchangeAcquireInt...OK -BoxingCompareAndExchangeReleaseInt...OK -BoxingWeakCompareAndSetPlainInt...OK -BoxingWeakCompareAndSetInt...OK -BoxingWeakCompareAndSetAcquireInt...OK -BoxingWeakCompareAndSetReleaseInt...OK -BoxingGetAndSetInt...OK -BoxingGetAndSetAcquireInt...OK -BoxingGetAndSetReleaseInt...OK -BoxingGetAndAddInt...OK -BoxingGetAndAddAcquireInt...OK -BoxingGetAndAddReleaseInt...OK -BoxingGetAndBitwiseOrInt...OK -BoxingGetAndBitwiseOrReleaseInt...OK -BoxingGetAndBitwiseOrAcquireInt...OK -BoxingGetAndBitwiseAndInt...OK -BoxingGetAndBitwiseAndReleaseInt...OK -BoxingGetAndBitwiseAndAcquireInt...OK -BoxingGetAndBitwiseXorInt...OK -BoxingGetAndBitwiseXorReleaseInt...OK -BoxingGetAndBitwiseXorAcquireInt...OK -BoxingReturnGetLong...OK -BoxingSetLong...OK -BoxingReturnGetVolatileLong...OK -BoxingSetVolatileLong...OK -BoxingReturnGetAcquireLong...OK -BoxingSetReleaseLong...OK -BoxingReturnGetOpaqueLong...OK -BoxingSetOpaqueLong...OK -BoxingCompareAndSetLong...OK -BoxingCompareAndExchangeLong...OK -BoxingCompareAndExchangeAcquireLong...OK -BoxingCompareAndExchangeReleaseLong...OK -BoxingWeakCompareAndSetPlainLong...OK -BoxingWeakCompareAndSetLong...OK -BoxingWeakCompareAndSetAcquireLong...OK -BoxingWeakCompareAndSetReleaseLong...OK -BoxingGetAndSetLong...OK -BoxingGetAndSetAcquireLong...OK -BoxingGetAndSetReleaseLong...OK -BoxingGetAndAddLong...OK -BoxingGetAndAddAcquireLong...OK -BoxingGetAndAddReleaseLong...OK -BoxingGetAndBitwiseOrLong...OK -BoxingGetAndBitwiseOrReleaseLong...OK -BoxingGetAndBitwiseOrAcquireLong...OK -BoxingGetAndBitwiseAndLong...OK -BoxingGetAndBitwiseAndReleaseLong...OK -BoxingGetAndBitwiseAndAcquireLong...OK -BoxingGetAndBitwiseXorLong...OK -BoxingGetAndBitwiseXorReleaseLong...OK -BoxingGetAndBitwiseXorAcquireLong...OK -BoxingReturnGetFloat...OK -BoxingSetFloat...OK -BoxingReturnGetVolatileFloat...OK -BoxingSetVolatileFloat...OK -BoxingReturnGetAcquireFloat...OK -BoxingSetReleaseFloat...OK -BoxingReturnGetOpaqueFloat...OK -BoxingSetOpaqueFloat...OK -BoxingCompareAndSetFloat...OK -BoxingCompareAndExchangeFloat...OK -BoxingCompareAndExchangeAcquireFloat...OK -BoxingCompareAndExchangeReleaseFloat...OK -BoxingWeakCompareAndSetPlainFloat...OK -BoxingWeakCompareAndSetFloat...OK -BoxingWeakCompareAndSetAcquireFloat...OK -BoxingWeakCompareAndSetReleaseFloat...OK -BoxingGetAndSetFloat...OK -BoxingGetAndSetAcquireFloat...OK -BoxingGetAndSetReleaseFloat...OK -BoxingGetAndAddFloat...OK -BoxingGetAndAddAcquireFloat...OK -BoxingGetAndAddReleaseFloat...OK -BoxingGetAndBitwiseOrFloat...OK -BoxingGetAndBitwiseOrReleaseFloat...OK -BoxingGetAndBitwiseOrAcquireFloat...OK -BoxingGetAndBitwiseAndFloat...OK -BoxingGetAndBitwiseAndReleaseFloat...OK -BoxingGetAndBitwiseAndAcquireFloat...OK -BoxingGetAndBitwiseXorFloat...OK -BoxingGetAndBitwiseXorReleaseFloat...OK -BoxingGetAndBitwiseXorAcquireFloat...OK -BoxingReturnGetDouble...OK -BoxingSetDouble...OK -BoxingReturnGetVolatileDouble...OK -BoxingSetVolatileDouble...OK -BoxingReturnGetAcquireDouble...OK -BoxingSetReleaseDouble...OK -BoxingReturnGetOpaqueDouble...OK -BoxingSetOpaqueDouble...OK -BoxingCompareAndSetDouble...OK -BoxingCompareAndExchangeDouble...OK -BoxingCompareAndExchangeAcquireDouble...OK -BoxingCompareAndExchangeReleaseDouble...OK -BoxingWeakCompareAndSetPlainDouble...OK -BoxingWeakCompareAndSetDouble...OK -BoxingWeakCompareAndSetAcquireDouble...OK -BoxingWeakCompareAndSetReleaseDouble...OK -BoxingGetAndSetDouble...OK -BoxingGetAndSetAcquireDouble...OK -BoxingGetAndSetReleaseDouble...OK -BoxingGetAndAddDouble...OK -BoxingGetAndAddAcquireDouble...OK -BoxingGetAndAddReleaseDouble...OK -BoxingGetAndBitwiseOrDouble...OK -BoxingGetAndBitwiseOrReleaseDouble...OK -BoxingGetAndBitwiseOrAcquireDouble...OK -BoxingGetAndBitwiseAndDouble...OK -BoxingGetAndBitwiseAndReleaseDouble...OK -BoxingGetAndBitwiseAndAcquireDouble...OK -BoxingGetAndBitwiseXorDouble...OK -BoxingGetAndBitwiseXorReleaseDouble...OK -BoxingGetAndBitwiseXorAcquireDouble...OK -NullReceiverTest...OK -UnsupportedAccessModeTest...OK -WrongArgumentTypeCausingWrongMethodTypeTest...OK -TooManyArgumentsCausingWrongMethodTypeTest...OK -TooFewArgumentsCausingWrongMethodTypeTest...OK -ReturnTypeCausingWrongMethodTypeTest...OK -UnsupportedAccessModePreemptsWrongMethodTypeExceptionTest...OK -FieldCoordinateTypeTest...OK -ArrayElementOutOfBoundsIndexTest...OK -ArrayElementBadIndexTypeTest...OK -ArrayElementNullArrayTest...OK -ArrayElementWrongArrayTypeTest...OK -ArrayElementMissingIndexTest...OK -ByteArrayViewOutOfBoundsIndexTest...OK -ByteArrayViewUnalignedAccessesIndexTest...OK -ByteArrayViewBadIndexTypeTest...OK -ByteArrayViewMissingIndexTest...OK -ByteArrayViewBadByteArrayTest...OK -ByteBufferViewOutOfBoundsIndexTest...OK -ByteBufferViewUnalignedAccessesIndexTest...OK -ByteBufferViewBadIndexTypeTest...OK -ByteBufferViewMissingIndexTest...OK -ByteBufferViewBadByteBufferTest...OK -VoidReturnTypeTest...OK -BoxedNullBooleanThrowsNPETest...OK -BoxedNullByteThrowsNPETest...OK -BoxedNullCharacterThrowsNPETest...OK -BoxedNullShortThrowsNPETest...OK -BoxedNullIntegerThrowsNPETest...OK -BoxedNullLongThrowsNPETest...OK -BoxedNullFloatThrowsNPETest...OK -BoxedNullDoubleThrowsNPETest...OK -WideningBooleanArgumentTest...OK -WideningByteArgumentTest...OK -WideningCharacterArgumentTest...OK -WideningShortArgumentTest...OK -WideningIntegerArgumentTest...OK -WideningLongArgumentTest...OK -WideningFloatArgumentTest...OK -WideningDoubleArgumentTest...OK -WideningBooleanReturnValueTest...OK -WideningByteReturnValueTest...OK -WideningCharacterReturnValueTest...OK -WideningShortReturnValueTest...OK -WideningIntegerReturnValueTest...OK -WideningLongReturnValueTest...OK -WideningFloatReturnValueTest...OK -WideningDoubleReturnValueTest...OK -SubtypeTest...OK -SupertypeTest...OK -ImplicitBoxingIntegerTest...OK -3182 successes, 0 skips, 0 failures. diff --git a/test/712-varhandle-invocations/info.txt b/test/712-varhandle-invocations/info.txt deleted file mode 100644 index e2de024d8e..0000000000 --- a/test/712-varhandle-invocations/info.txt +++ /dev/null @@ -1 +0,0 @@ -Generates and runs tests that invoke VarHandle accessor methods. diff --git a/test/712-varhandle-invocations/src/SimpleTests.java b/test/712-varhandle-invocations/src/SimpleTests.java deleted file mode 100644 index 6e62bff4b4..0000000000 --- a/test/712-varhandle-invocations/src/SimpleTests.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -public class SimpleTests { - public static class TestGuardSkips extends VarHandleUnitTest { - public boolean checkGuard() { - return false; - } - - @Override - protected void doTest() { - throw new IllegalStateException("Not reachable"); - } - - public static void main(String[] args) { - new TestGuardSkips().run(); - } - } - - public static class TestEqualsOK extends VarHandleUnitTest { - @Override - protected void doTest() { - assertEquals(true, true); - } - } - - public static class TestEqualsOK2 extends VarHandleUnitTest { - @Override - protected void doTest() { - assertEquals(true, false); - } - } - - public static class TestExceptionsFail extends VarHandleUnitTest { - @Override - protected void doTest() { - throw new NullPointerException(); - } - } - - public static void main(String[] args) { - new TestGuardSkips().run(); - new TestEqualsOK().run(); - new TestEqualsOK2().run(); - new TestExceptionsFail().run(); - VarHandleUnitTest.DEFAULT_COLLECTOR.printSummary(); - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleAccessorExceptionTests.java b/test/712-varhandle-invocations/src/VarHandleAccessorExceptionTests.java deleted file mode 100644 index 4c9013b14d..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleAccessorExceptionTests.java +++ /dev/null @@ -1,232 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.lang.invoke.MethodHandles; -import java.lang.invoke.VarHandle; -import java.lang.invoke.WrongMethodTypeException; - -// These tests cover DoVarHandleInvokeCommon in interpreter_common.cc. - -public class VarHandleAccessorExceptionTests { - public static class NullReceiverTest extends VarHandleUnitTest { - private static final VarHandle vh = null; - - @Override - protected void doTest() { - try { - vh.set(3); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new NullReceiverTest().run(); - } - } - - public static class UnsupportedAccessModeTest extends VarHandleUnitTest { - private static final boolean b = true; - private static final VarHandle vh; - - static { - try { - Class<?> cls = UnsupportedAccessModeTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "b", boolean.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - // A final field should not support an VarHandle access modes which can update it - boolean isSupported = - vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND); - assertFalse(isSupported); - try { - vh.getAndBitwiseAnd(true); - failUnreachable(); - } catch (UnsupportedOperationException ex) { - } - } - - public static void main(String[] args) { - new UnsupportedAccessModeTest().run(); - } - } - - public static class WrongArgumentTypeCausingWrongMethodTypeTest extends VarHandleUnitTest { - private short s; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WrongArgumentTypeCausingWrongMethodTypeTest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "s", short.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.set(this, (short) 0xcafe); - try { - vh.setVolatile(this, System.out); // System.out is a PrintStream, not short! - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WrongArgumentTypeCausingWrongMethodTypeTest().run(); - } - } - - // Too many arguments causing WMTE - public static class TooManyArgumentsCausingWrongMethodTypeTest extends VarHandleUnitTest { - private int i; - private static final VarHandle vh; - - static { - try { - Class<?> cls = TooManyArgumentsCausingWrongMethodTypeTest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "i", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.set(this, 0x12345678); - try { - vh.setVolatile(this, 0x5a5a55aa, 0xc3c30f0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new TooManyArgumentsCausingWrongMethodTypeTest().run(); - } - } - - public static class TooFewArgumentsCausingWrongMethodTypeTest extends VarHandleUnitTest { - private int i; - private static final VarHandle vh; - - static { - try { - Class<?> cls = TooFewArgumentsCausingWrongMethodTypeTest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "i", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - i = 33; - vh.compareAndSet(this, 33, 44); - boolean updated = false; - try { - updated = (boolean) vh.compareAndSet(this, 44); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - assertFalse(updated); // Should have failed too few arguments - } - - public static void main(String[] args) { - new TooFewArgumentsCausingWrongMethodTypeTest().run(); - } - } - - public static class ReturnTypeCausingWrongMethodTypeTest extends VarHandleUnitTest { - private int i; - private static final VarHandle vh; - - static { - try { - Class<?> cls = ReturnTypeCausingWrongMethodTypeTest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "i", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - i = 33; - vh.getAndSet(this, 44); - Runtime runtime = null; - try { - runtime = (Runtime) vh.getAndSet(this, 44); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - assertEquals(null, runtime); - } - - public static void main(String[] args) { - new ReturnTypeCausingWrongMethodTypeTest().run(); - } - } - - public static class UnsupportedAccessModePreemptsWrongMethodTypeExceptionTest - extends VarHandleUnitTest { - private static final boolean b = true; - private static final VarHandle vh; - - static { - try { - Class<?> cls = UnsupportedAccessModePreemptsWrongMethodTypeExceptionTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "b", boolean.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - // A final field should not support an VarHandle access modes which can update it - boolean supported = vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND); - assertFalse(supported); - try { - // The following is both unsupported and a wrong method type... - vh.getAndBitwiseAnd(System.out); - failUnreachable(); - } catch (UnsupportedOperationException ex) { - } - } - - public static void main(String[] args) { - new UnsupportedAccessModePreemptsWrongMethodTypeExceptionTest().run(); - } - } - - public static void main(String[] args) { - NullReceiverTest.main(args); - UnsupportedAccessModeTest.main(args); - WrongArgumentTypeCausingWrongMethodTypeTest.main(args); - TooManyArgumentsCausingWrongMethodTypeTest.main(args); - TooFewArgumentsCausingWrongMethodTypeTest.main(args); - ReturnTypeCausingWrongMethodTypeTest.main(args); - UnsupportedAccessModePreemptsWrongMethodTypeExceptionTest.main(args); - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleBadCoordinateTests.java b/test/712-varhandle-invocations/src/VarHandleBadCoordinateTests.java deleted file mode 100644 index 8f81c94a89..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleBadCoordinateTests.java +++ /dev/null @@ -1,948 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.lang.invoke.MethodHandles; -import java.lang.invoke.VarHandle; -import java.lang.invoke.WrongMethodTypeException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - -public class VarHandleBadCoordinateTests { - public static class FieldCoordinateTypeTest extends VarHandleUnitTest { - private static final VarHandle vh; - - public static class A { - public byte field; - } - - public static class B extends A { - private byte other_field; - } - - public static class C {} - - static { - try { - vh = MethodHandles.lookup().findVarHandle(A.class, "field", byte.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.compareAndSet(new A(), (byte) 0, (byte) 3); - vh.compareAndSet(new B(), (byte) 0, (byte) 3); - try { - vh.compareAndSet(new C(), (byte) 0, (byte) 3); - failUnreachable(); - } catch (ClassCastException ex) { - } - try { - vh.compareAndSet(0xbad0bad0, (byte) 0, (byte) 3); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.compareAndSet(0xbad0bad0, (byte) 0, Integer.MAX_VALUE); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.compareAndSet(0xbad0bad0, (byte) 0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.compareAndSet(new A(), (byte) 0, Integer.MAX_VALUE); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.compareAndSet((A) null, (byte) 0, (byte) 3); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new FieldCoordinateTypeTest().run(); - } - } - - public static class ArrayElementOutOfBoundsIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(long[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - long[] values = new long[33]; - try { - vh.get(values, -1); - failUnreachable(); - } catch (ArrayIndexOutOfBoundsException ex) { - } - try { - vh.get(values, values.length); - failUnreachable(); - } catch (ArrayIndexOutOfBoundsException ex) { - } - try { - vh.get(values, Integer.MAX_VALUE - 1); - failUnreachable(); - } catch (ArrayIndexOutOfBoundsException ex) { - } - } - - public static void main(String[] args) { - new ArrayElementOutOfBoundsIndexTest().run(); - } - } - - public static class ArrayElementBadIndexTypeTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(long[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - long[] values = new long[33]; - vh.set(values, Integer.valueOf(3), Long.MIN_VALUE); - vh.set(values, Byte.valueOf((byte) 0), Long.MIN_VALUE); - try { - vh.set(values, 3.3f, Long.MAX_VALUE); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new ArrayElementBadIndexTypeTest().run(); - } - } - - public static class ArrayElementNullArrayTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(long[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - long[] values = null; - try { - vh.get(values); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new ArrayElementNullArrayTest().run(); - } - } - - public static class ArrayElementWrongArrayTypeTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(long[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.get(new char[10], 0); - failUnreachable(); - } catch (ClassCastException ex) { - } - } - - public static void main(String[] args) { - new ArrayElementWrongArrayTypeTest().run(); - } - } - - public static class ArrayElementMissingIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(long[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - long[] values = new long[33]; - try { - vh.get(values); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new ArrayElementMissingIndexTest().run(); - } - } - - public static class ByteArrayViewOutOfBoundsIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[16]; - try { - vh.get(bytes, -1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(bytes, bytes.length); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(bytes, Integer.MAX_VALUE - 1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(bytes, bytes.length - Integer.SIZE / 8 + 1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - vh.get(bytes, bytes.length - Integer.SIZE / 8); - } - - public static void main(String[] args) { - new ByteArrayViewOutOfBoundsIndexTest().run(); - } - } - - public static class ByteArrayViewUnalignedAccessesIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[33]; - - int alignedIndex = VarHandleUnitTestHelpers.alignedOffset_int(bytes, 0); - for (int i = alignedIndex; i < Integer.SIZE / 8; ++i) { - // No exceptions are expected for GET and SET - // accessors irrespective of the access alignment. - vh.set(bytes, i, 380); - vh.get(bytes, i); - // Other accessors raise an IllegalStateException if - // the access is unaligned. - try { - vh.compareAndExchange(bytes, i, 777, 320); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndExchangeAcquire(bytes, i, 320, 767); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndExchangeRelease(bytes, i, 767, 321); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndSet(bytes, i, 767, 321); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAcquire(bytes, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAdd(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAddAcquire(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAddRelease(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAnd(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAndAcquire(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAndRelease(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOr(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOrAcquire(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOrRelease(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXor(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXorAcquire(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXorRelease(bytes, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSet(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSetAcquire(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSetRelease(bytes, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getOpaque(bytes, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getVolatile(bytes, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setOpaque(bytes, i, 777); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setRelease(bytes, i, 319); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setVolatile(bytes, i, 787); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSet(bytes, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetAcquire(bytes, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetPlain(bytes, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetRelease(bytes, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - } - } - - public static void main(String[] args) { - new ByteArrayViewUnalignedAccessesIndexTest().run(); - } - } - - public static class ByteArrayViewBadIndexTypeTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[16]; - // Boxed index goes through argument conversion so no exception expected. - vh.get(bytes, Integer.valueOf(3)); - vh.get(bytes, Short.valueOf((short) 3)); - - try { - vh.get(bytes, System.out); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new ByteArrayViewBadIndexTypeTest().run(); - } - } - - public static class ByteArrayViewMissingIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[16]; - try { - vh.get(bytes); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new ByteArrayViewMissingIndexTest().run(); - } - } - - public static class ByteArrayViewBadByteArrayTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = null; - try { - vh.get(bytes, Integer.valueOf(3)); - failUnreachable(); - } catch (NullPointerException ex) { - } - try { - vh.get(System.err, Integer.valueOf(3)); - failUnreachable(); - } catch (ClassCastException ex) { - } - } - - public static void main(String[] args) { - new ByteArrayViewBadByteArrayTest().run(); - } - } - - public static class ByteBufferViewOutOfBoundsIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(float[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer[] buffers = - new ByteBuffer[] { - ByteBuffer.allocateDirect(16), - ByteBuffer.allocate(37), - ByteBuffer.wrap(new byte[27], 3, 27 - 3) - }; - for (ByteBuffer buffer : buffers) { - try { - vh.get(buffer, -1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(buffer, buffer.limit()); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(buffer, Integer.MAX_VALUE - 1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - try { - vh.get(buffer, buffer.limit() - Integer.SIZE / 8 + 1); - failUnreachable(); - } catch (IndexOutOfBoundsException ex) { - } - vh.get(buffer, buffer.limit() - Integer.SIZE / 8); - } - } - - public static void main(String[] args) { - new ByteBufferViewOutOfBoundsIndexTest().run(); - } - } - - public static class ByteBufferViewUnalignedAccessesIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer[] buffers = - new ByteBuffer[] { - ByteBuffer.allocateDirect(16), - ByteBuffer.allocate(37), - ByteBuffer.wrap(new byte[27], 3, 27 - 3) - }; - - for (ByteBuffer buffer : buffers) { - int alignedIndex = VarHandleUnitTestHelpers.alignedOffset_int(buffer, 0); - for (int i = alignedIndex; i < Integer.SIZE / 8; ++i) { - // No exceptions are expected for GET and SET - // accessors irrespective of the access alignment. - vh.set(buffer, i, 380); - vh.get(buffer, i); - // Other accessors raise an IllegalStateException if - // the access is unaligned. - try { - vh.compareAndExchange(buffer, i, 777, 320); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndExchangeAcquire(buffer, i, 320, 767); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndExchangeRelease(buffer, i, 767, 321); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.compareAndSet(buffer, i, 767, 321); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAcquire(buffer, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAdd(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAddAcquire(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndAddRelease(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAnd(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAndAcquire(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseAndRelease(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOr(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOrAcquire(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseOrRelease(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXor(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXorAcquire(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndBitwiseXorRelease(buffer, i, 118); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSet(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSetAcquire(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getAndSetRelease(buffer, i, 117); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getOpaque(buffer, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.getVolatile(buffer, i); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setOpaque(buffer, i, 777); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setRelease(buffer, i, 319); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.setVolatile(buffer, i, 787); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSet(buffer, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetAcquire(buffer, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetPlain(buffer, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - try { - vh.weakCompareAndSetRelease(buffer, i, 787, 340); - assertTrue(i == alignedIndex); - } catch (IllegalStateException ex) { - assertFalse(i == alignedIndex); - } - } - } - } - - public static void main(String[] args) { - new ByteBufferViewUnalignedAccessesIndexTest().run(); - } - } - - public static class ByteBufferViewBadIndexTypeTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer[] buffers = - new ByteBuffer[] { - ByteBuffer.allocateDirect(16), - ByteBuffer.allocate(16), - ByteBuffer.wrap(new byte[32], 4, 32 - 4) - }; - - for (ByteBuffer buffer : buffers) { - // Boxed index goes through argument conversion so no exception expected. - vh.get(buffer, Integer.valueOf(3)); - vh.get(buffer, Short.valueOf((short) 3)); - vh.get(buffer, Byte.valueOf((byte) 7)); - try { - vh.get(buffer, System.out); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - } - - public static void main(String[] args) { - new ByteBufferViewBadIndexTypeTest().run(); - } - } - - public static class ByteBufferViewMissingIndexTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer[] buffers = - new ByteBuffer[] { - ByteBuffer.allocateDirect(16), - ByteBuffer.allocate(16), - ByteBuffer.wrap(new byte[32], 4, 32 - 4) - }; - for (ByteBuffer buffer : buffers) { - try { - vh.get(buffer); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - } - - public static void main(String[] args) { - new ByteBufferViewMissingIndexTest().run(); - } - } - - public static class ByteBufferViewBadByteBufferTest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - if (VarHandleUnitTestHelpers.isRunningOnAndroid()) { - ByteBuffer buffer = null; - // The RI does not like this test - try { - vh.get(buffer, 3); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - try { - vh.get(System.err, 3); - failUnreachable(); - } catch (ClassCastException ex) { - } - } - - public static void main(String[] args) { - new ByteBufferViewBadByteBufferTest().run(); - } - } - - public static void main(String[] args) { - FieldCoordinateTypeTest.main(args); - - ArrayElementOutOfBoundsIndexTest.main(args); - ArrayElementBadIndexTypeTest.main(args); - ArrayElementNullArrayTest.main(args); - ArrayElementWrongArrayTypeTest.main(args); - ArrayElementMissingIndexTest.main(args); - - ByteArrayViewOutOfBoundsIndexTest.main(args); - ByteArrayViewUnalignedAccessesIndexTest.main(args); - ByteArrayViewBadIndexTypeTest.main(args); - ByteArrayViewMissingIndexTest.main(args); - ByteArrayViewBadByteArrayTest.main(args); - - ByteBufferViewOutOfBoundsIndexTest.main(args); - ByteBufferViewUnalignedAccessesIndexTest.main(args); - ByteBufferViewBadIndexTypeTest.main(args); - ByteBufferViewMissingIndexTest.main(args); - ByteBufferViewBadByteBufferTest.main(args); - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleTypeConversionTests.java b/test/712-varhandle-invocations/src/VarHandleTypeConversionTests.java deleted file mode 100644 index c0fbd492b2..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleTypeConversionTests.java +++ /dev/null @@ -1,1343 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.lang.invoke.MethodHandles; -import java.lang.invoke.VarHandle; -import java.lang.invoke.WrongMethodTypeException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - -public class VarHandleTypeConversionTests { - public static class VoidReturnTypeTest extends VarHandleUnitTest { - private int i; - private static final VarHandle vh; - - static { - try { - Class<?> cls = VoidReturnTypeTest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "i", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - // Void is always okay for a return type. - vh.setVolatile(this, 33); - vh.get(this); - vh.compareAndSet(this, 33, 44); - vh.compareAndSet(this, 27, 16); - vh.weakCompareAndSet(this, 17, 19); - vh.getAndSet(this, 200000); - vh.getAndBitwiseXor(this, 0x5a5a5a5a); - vh.getAndAdd(this, 99); - } - - public static void main(String[] args) { - new VoidReturnTypeTest().run(); - } - } - - // - // Tests that a null reference as a boxed primitive type argument - // throws a NullPointerException. These vary the VarHandle type - // with each primitive for coverage. - // - - public static class BoxedNullBooleanThrowsNPETest extends VarHandleUnitTest { - private static boolean z; - private static final VarHandle vh; - - static { - try { - Class<?> cls = BoxedNullBooleanThrowsNPETest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "z", boolean.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - Boolean newValue = null; - try { - vh.getAndSet(newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullBooleanThrowsNPETest().run(); - } - } - - public static class BoxedNullByteThrowsNPETest extends VarHandleUnitTest { - private byte b; - private static final VarHandle vh; - - static { - try { - Class<?> cls = BoxedNullByteThrowsNPETest.class; - vh = MethodHandles.lookup().findVarHandle(cls, "b", byte.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - Byte newValue = null; - try { - vh.getAndSet(this, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullByteThrowsNPETest().run(); - } - } - - public static class BoxedNullCharacterThrowsNPETest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.arrayElementVarHandle(char[].class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - char[] values = new char[3]; - Character newValue = null; - try { - vh.getAndSet(values, 0, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullCharacterThrowsNPETest().run(); - } - } - - public static class BoxedNullShortThrowsNPETest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - Class<?> cls = BoxedNullShortThrowsNPETest.class; - vh = MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[2 * Short.SIZE]; - int index = VarHandleUnitTestHelpers.alignedOffset_short(bytes, 0); - Short newValue = null; - try { - vh.set(bytes, index, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullShortThrowsNPETest().run(); - } - } - - public static class BoxedNullIntegerThrowsNPETest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[2 * Integer.SIZE]; - int index = VarHandleUnitTestHelpers.alignedOffset_int(bytes, 0); - Integer newValue = null; - try { - vh.setVolatile(bytes, index, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullIntegerThrowsNPETest().run(); - } - } - - public static class BoxedNullLongThrowsNPETest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - Class<?> cls = BoxedNullLongThrowsNPETest.class; - vh = MethodHandles.byteBufferViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer bb = ByteBuffer.allocateDirect(2 * Long.SIZE); - int index = VarHandleUnitTestHelpers.alignedOffset_long(bb, 0); - Long newValue = null; - try { - vh.getAndAdd(bb, index, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullLongThrowsNPETest().run(); - } - } - - public static class BoxedNullFloatThrowsNPETest extends VarHandleUnitTest { - private static final VarHandle vh; - - static { - try { - Class<?> cls = BoxedNullFloatThrowsNPETest.class; - vh = MethodHandles.byteBufferViewVarHandle(float[].class, ByteOrder.BIG_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - ByteBuffer bb = ByteBuffer.allocate(2 * Float.SIZE); - int index = VarHandleUnitTestHelpers.alignedOffset_float(bb, 0); - Float newValue = null; - try { - vh.set(bb, index, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullFloatThrowsNPETest().run(); - } - } - - public static class BoxedNullDoubleThrowsNPETest extends VarHandleUnitTest { - private double d; - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.byteBufferViewVarHandle(double[].class, ByteOrder.LITTLE_ENDIAN); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - byte[] bytes = new byte[3 * Double.SIZE]; - int offset = 1; - ByteBuffer bb = ByteBuffer.wrap(bytes, offset, bytes.length - offset); - int index = VarHandleUnitTestHelpers.alignedOffset_double(bb, 0); - Double newValue = null; - try { - vh.set(bb, index, newValue); - failUnreachable(); - } catch (NullPointerException ex) { - } - } - - public static void main(String[] args) { - new BoxedNullDoubleThrowsNPETest().run(); - } - } - - public static class WideningBooleanArgumentTest extends VarHandleUnitTest { - private static boolean v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningBooleanArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", boolean.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.set(true); - try { - vh.set((byte) 3); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set('c'); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((short) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((int) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((long) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningBooleanArgumentTest().run(); - } - } - - public static class WideningByteArgumentTest extends VarHandleUnitTest { - private static byte v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningByteArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", byte.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - try { - vh.set('c'); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((short) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((int) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((long) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningByteArgumentTest().run(); - } - } - - public static class WideningCharacterArgumentTest extends VarHandleUnitTest { - private static char v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningCharacterArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", char.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((byte) 3); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set('c'); - try { - vh.set((short) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((int) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((long) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningCharacterArgumentTest().run(); - } - } - - public static class WideningShortArgumentTest extends VarHandleUnitTest { - private static short v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningShortArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", short.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - try { - vh.set('c'); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((short) 1); - try { - vh.set((int) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((long) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningShortArgumentTest().run(); - } - } - - public static class WideningIntegerArgumentTest extends VarHandleUnitTest { - private static int v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningIntegerArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - vh.set('c'); - vh.set((char) 0x8fff); - assertEquals(0x8fff, v); - vh.set((short) 1); - vh.set((int) 1); - try { - vh.set((long) 1); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningIntegerArgumentTest().run(); - } - } - - public static class WideningLongArgumentTest extends VarHandleUnitTest { - private static long v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningLongArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", long.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - vh.set('c'); - vh.set((short) 1); - vh.set((int) 1); - vh.set((long) 1); - try { - vh.set((float) 1.0f); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningLongArgumentTest().run(); - } - } - - public static class WideningFloatArgumentTest extends VarHandleUnitTest { - private static float v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningFloatArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", float.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - vh.set('c'); - vh.set((short) 1); - vh.set((int) 1); - vh.set((long) 1); - vh.set((float) 1.0f); - try { - vh.set((double) 1.0); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningFloatArgumentTest().run(); - } - } - - public static class WideningDoubleArgumentTest extends VarHandleUnitTest { - private static double v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningDoubleArgumentTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", double.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - vh.set((byte) 3); - vh.set('c'); - vh.set((short) 1); - vh.set((int) 1); - vh.set((long) 1); - vh.set((double) 1.0f); - vh.set((double) 1.0); - } - - public static void main(String[] args) { - new WideningDoubleArgumentTest().run(); - } - } - - public static class WideningBooleanReturnValueTest extends VarHandleUnitTest { - private static boolean v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningBooleanReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", boolean.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.set(true); - vh.get(); - boolean z = (boolean) vh.get(); - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - int i = (int) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - long j = (long) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - float f = (float) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - double d = (double) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - } - - public static void main(String[] args) { - new WideningBooleanReturnValueTest().run(); - } - } - - public static class WideningByteReturnValueTest extends VarHandleUnitTest { - private static byte v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningByteReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", byte.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - protected void doTest() { - vh.set((byte) 3); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - - byte b = (byte) vh.get(); - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - short s = (short) vh.get(); - int i = (int) vh.get(); - long j = (long) vh.get(); - float f = (float) vh.get(); - double d = (double) vh.get(); - } - - public static void main(String[] args) { - new WideningByteReturnValueTest().run(); - } - } - - public static class WideningCharacterReturnValueTest extends VarHandleUnitTest { - private static char v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningCharacterReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", char.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningCharacterReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set('c'); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - char c = (char) vh.get(); - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - int i = (int) vh.get(); - long j = (long) vh.get(); - float f = (float) vh.get(); - double d = (double) vh.get(); - } - } - - public static class WideningShortReturnValueTest extends VarHandleUnitTest { - private static short v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningShortReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", short.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningShortReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set((short) 8888); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - short s = (short) vh.get(); - int i = (int) vh.get(); - long j = (long) vh.get(); - float f = (float) vh.get(); - double d = (double) vh.get(); - } - } - - public static class WideningIntegerReturnValueTest extends VarHandleUnitTest { - private static int v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningIntegerReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", int.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningIntegerReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set(0x1234fedc); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - int i = (int) vh.get(); - long j = (long) vh.get(); - float f = (float) vh.get(); - double d = (double) vh.get(); - } - } - - public static class WideningLongReturnValueTest extends VarHandleUnitTest { - private static long v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningLongReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", long.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningLongReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set(0xfedcba987654321l); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - int i = (int) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - long j = (long) vh.get(); - float f = (float) vh.get(); - double d = (double) vh.get(); - } - } - - public static class WideningFloatReturnValueTest extends VarHandleUnitTest { - private static float v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningFloatReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", float.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningFloatReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set(7.77e20f); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - int i = (int) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - long j = (long) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - float f = (float) vh.get(); - double d = (double) vh.get(); - } - } - - public static class WideningDoubleReturnValueTest extends VarHandleUnitTest { - private static double v; - private static final VarHandle vh; - - static { - try { - Class<?> cls = WideningDoubleReturnValueTest.class; - vh = MethodHandles.lookup().findStaticVarHandle(cls, "v", double.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new WideningDoubleReturnValueTest().run(); - } - - @Override - protected void doTest() { - vh.set(Math.E); - vh.get(); - try { - boolean z = (boolean) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - byte b = (byte) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - char c = (char) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - short s = (short) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - int i = (int) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - long j = (long) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - try { - float f = (float) vh.get(); - failUnreachable(); - } catch (WrongMethodTypeException ex) { - } - double d = (double) vh.get(); - } - } - - public static class SubtypeTest extends VarHandleUnitTest { - private static final Widget INITIAL_VALUE = Widget.ONE; - private static final VarHandle vh; - private Widget w = INITIAL_VALUE; - - static { - try { - vh = MethodHandles.lookup().findVarHandle(SubtypeTest.class, "w", Widget.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new SubtypeTest().run(); - } - - // A sub-type of the Widget class - public static class WidgetChild extends Widget { - private int weight; - - public WidgetChild(int requistionNumber, int weight) { - super(requistionNumber); - this.weight = weight; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o instanceof WidgetChild == false) { - return false; - } - WidgetChild wc = (WidgetChild) o; - return (requisitionNumber == wc.requisitionNumber && weight == wc.weight); - } - - public static final WidgetChild ONE = new WidgetChild(1, 100); - public static final WidgetChild TWO = new WidgetChild(2, 2000); - } - - @Override - public void doTest() { - assertEquals(INITIAL_VALUE, vh.getVolatile(this)); - vh.setVolatile(this, null); - Widget rw = (Widget) vh.compareAndExchange(this, null, WidgetChild.ONE); - assertEquals(null, rw); - assertEquals(WidgetChild.ONE, this.w); - WidgetChild rwc = - (WidgetChild) - vh.compareAndExchangeRelease(this, WidgetChild.ONE, WidgetChild.TWO); - assertEquals(WidgetChild.TWO, w); - rwc = (WidgetChild) vh.compareAndExchangeAcquire(this, WidgetChild.TWO, Widget.ONE); - assertEquals(Widget.ONE, w); - assertEquals(false, (boolean) vh.compareAndSet(this, null, null)); - assertEquals(true, vh.compareAndSet(this, Widget.ONE, Widget.TWO)); - assertEquals(Widget.TWO, w); - vh.set(this, null); - assertEquals(null, (Widget) vh.get(this)); - vh.setRelease(this, WidgetChild.ONE); - assertEquals(WidgetChild.ONE, (WidgetChild) vh.getAcquire(this)); - assertEquals(WidgetChild.ONE, w); - vh.setOpaque(this, WidgetChild.TWO); - assertEquals(WidgetChild.TWO, vh.getOpaque(this)); - assertEquals(WidgetChild.TWO, w); - vh.setVolatile(this, null); - assertEquals(null, (Widget) vh.getVolatile(this)); - assertEquals(null, w); - assertEquals(null, (WidgetChild) vh.getAndSet(this, WidgetChild.ONE)); - assertEquals(WidgetChild.ONE, w); - assertEquals(WidgetChild.ONE, (WidgetChild) vh.getAndSetRelease(this, WidgetChild.TWO)); - assertEquals(WidgetChild.TWO, (WidgetChild) vh.getAndSetAcquire(this, WidgetChild.ONE)); - try { - WidgetChild result = (WidgetChild) vh.getAndAdd(this, WidgetChild.ONE); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndAddAcquire(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndAddRelease(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseAnd(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseAndAcquire(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseAndRelease(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseOr(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseOrAcquire(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseOrRelease(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseXor(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseXorAcquire(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - try { - WidgetChild result = (WidgetChild) vh.getAndBitwiseXorRelease(this, 1); - failUnreachable(); - } catch (UnsupportedOperationException e) { - } - } - } - - public static class SupertypeTest extends VarHandleUnitTest { - private Widget w = null; - private static final VarHandle vh; - - static { - try { - vh = MethodHandles.lookup().findVarHandle(SupertypeTest.class, "w", Widget.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new SupertypeTest().run(); - } - - @Override - public void doTest() { - assertEquals(null, (Object) vh.get(this)); - vh.set(this, Widget.ONE); - assertEquals(Widget.ONE, vh.getVolatile(this)); - try { - vh.setVolatile(this, new Object()); - } catch (ClassCastException e) { - } - } - } - - public static class ImplicitBoxingIntegerTest extends VarHandleUnitTest { - private static Integer field; - private static final VarHandle vh; - - static { - try { - vh = - MethodHandles.lookup() - .findStaticVarHandle( - ImplicitBoxingIntegerTest.class, "field", Integer.class); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - new ImplicitBoxingIntegerTest().run(); - } - - @Override - public void doTest() { - try { - vh.set(true); - failUnreachable(); - } catch (WrongMethodTypeException e) { - } - try { - vh.set((byte) 0); - failUnreachable(); - } catch (WrongMethodTypeException e) { - } - try { - vh.set((short) 1); - failUnreachable(); - } catch (WrongMethodTypeException e) { - } - try { - vh.set('A'); - failUnreachable(); - } catch (WrongMethodTypeException e) { - } - vh.set(2); - try { - vh.setRelease(Long.MAX_VALUE); - } catch (WrongMethodTypeException e) { - } - try { - vh.setRelease(Float.MAX_VALUE); - } catch (WrongMethodTypeException e) { - } - try { - vh.setRelease(Double.MAX_VALUE); - } catch (WrongMethodTypeException e) { - } - vh.set(null); - vh.set(Integer.valueOf(Integer.MAX_VALUE)); - } - } - - public static void main(String[] args) { - VoidReturnTypeTest.main(args); - - BoxedNullBooleanThrowsNPETest.main(args); - BoxedNullByteThrowsNPETest.main(args); - BoxedNullCharacterThrowsNPETest.main(args); - BoxedNullShortThrowsNPETest.main(args); - BoxedNullIntegerThrowsNPETest.main(args); - BoxedNullLongThrowsNPETest.main(args); - BoxedNullFloatThrowsNPETest.main(args); - BoxedNullDoubleThrowsNPETest.main(args); - - WideningBooleanArgumentTest.main(args); - WideningByteArgumentTest.main(args); - WideningCharacterArgumentTest.main(args); - WideningShortArgumentTest.main(args); - WideningIntegerArgumentTest.main(args); - WideningLongArgumentTest.main(args); - WideningFloatArgumentTest.main(args); - WideningDoubleArgumentTest.main(args); - - WideningBooleanReturnValueTest.main(args); - WideningByteReturnValueTest.main(args); - WideningCharacterReturnValueTest.main(args); - WideningShortReturnValueTest.main(args); - WideningIntegerReturnValueTest.main(args); - WideningLongReturnValueTest.main(args); - WideningFloatReturnValueTest.main(args); - WideningDoubleReturnValueTest.main(args); - - SubtypeTest.main(args); - SupertypeTest.main(args); - - ImplicitBoxingIntegerTest.main(args); - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleUnitTest.java b/test/712-varhandle-invocations/src/VarHandleUnitTest.java deleted file mode 100644 index 601d470950..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleUnitTest.java +++ /dev/null @@ -1,190 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// Base class for VarHandle unit tests for accessor operations -public abstract class VarHandleUnitTest { - public static VarHandleUnitTestCollector DEFAULT_COLLECTOR = new VarHandleUnitTestCollector(); - - // Error log (lazily initialized on failure). - private StringBuilder lazyErrorLog = null; - - // Tracker of test events (starts, skips, ends) - private final VarHandleUnitTestCollector collector; - - public VarHandleUnitTest(VarHandleUnitTestCollector collector) { - this.collector = collector; - } - - public VarHandleUnitTest() { - this.collector = DEFAULT_COLLECTOR; - } - - // Method that can be overloaded to signify that a test should be - // run or skipped. Returns true if the test should be run and - // false if the test should be skipped. - public boolean checkGuard() { - return true; - } - - // Method that implementations should use to perform a specific test. - protected abstract void doTest() throws Exception; - - public final void assertTrue(boolean value) { - assertEquals(true, value); - } - - public final void assertFalse(boolean value) { - assertEquals(false, value); - } - - public final void assertEquals(boolean expected, boolean actual) { - assertEquals(Boolean.valueOf(expected), Boolean.valueOf(actual)); - } - - public final void assertEquals(byte expected, byte actual) { - assertEquals(Byte.valueOf(expected), Byte.valueOf(actual)); - } - - public final void assertEquals(char expected, char actual) { - assertEquals(Character.valueOf(expected), Character.valueOf(actual)); - } - - public final void assertEquals(short expected, short actual) { - assertEquals(Short.valueOf(expected), Short.valueOf(actual)); - } - - public final void assertEquals(int expected, int actual) { - assertEquals(Integer.valueOf(expected), Integer.valueOf(actual)); - } - - public final void assertEquals(long expected, long actual) { - assertEquals(Long.valueOf(expected), Long.valueOf(actual)); - } - - public final void assertEquals(float expected, float actual) { - assertEquals(Float.valueOf(expected), Float.valueOf(actual)); - } - - public final void assertEquals(double expected, double actual) { - assertEquals(Double.valueOf(expected), Double.valueOf(actual)); - } - - public final void assertEquals(Object expected, Object actual) { - if (expected == null) { - if (actual == null) { - return; - } - } else if (expected.equals(actual)) { - return; - } - failNotEquals("Failed assertion (expected != actual)", expected, actual); - } - - public final void failUnreachable() { - fail("Unreachable code"); - } - - public final void run() { - collector.start(getClass().getSimpleName()); - if (!checkGuard()) { - collector.skip(); - return; - } - - try { - doTest(); - } catch (Exception e) { - fail("Unexpected exception", e); - } finally { - if (lazyErrorLog == null) { - collector.success(); - } else { - collector.fail(lazyErrorLog.toString()); - } - } - } - - private void failNotEquals(String message, Object expected, Object actual) { - errorLog() - .append(message) - .append(": ") - .append(expected) - .append(" != ") - .append(actual) - .append(" in ") - .append(getSourceInfo()) - .append('\n'); - } - - private void fail(String message) { - errorLog().append(message).append(" in ").append(getSourceInfo()).append('\n'); - } - - private void fail(String message, String detail) { - errorLog() - .append(message) - .append(": ") - .append(detail) - .append(" in ") - .append(getSourceInfo()) - .append('\n'); - } - - private void fail(String message, Exception e) { - errorLog() - .append(message) - .append(": ") - .append(e.toString()) - .append(" in ") - .append(getSourceInfo(e)) - .append('\n'); - } - - private String getSourceInfo(Exception e) { - // Unit test has thrown an exception. Stack likely looks like - // runtime frames then unit test frames then - // VarHandleUnitFrames. - StackTraceElement[] stackTraceElements = e.getStackTrace(); - int index = 1; - for (int i = 1; i < stackTraceElements.length; ++i) { - if ("VarHandleUnitTest".equals(stackTraceElements[i].getClassName())) { - return stackTraceElements[i - 1].toString(); - } - } - return "Unknown"; - } - - private String getSourceInfo() { - // Gets source info for a failure such as an assertion. The - // test has called a method on VarHandleUnitTest so the stack - // looks like some frames in VarHandleUnitTest methods and then - // a frame in the test itself. - StackTraceElement[] stackTraceElements = new Exception().getStackTrace(); - for (StackTraceElement stackTraceElement : stackTraceElements) { - if (!"VarHandleUnitTest".equals(stackTraceElement.getClassName())) { - return stackTraceElement.toString(); - } - } - return "Unknown"; - } - - private StringBuilder errorLog() { - if (lazyErrorLog == null) { - lazyErrorLog = new StringBuilder(); - } - return lazyErrorLog; - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleUnitTestCollector.java b/test/712-varhandle-invocations/src/VarHandleUnitTestCollector.java deleted file mode 100644 index bc64c0c8b1..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleUnitTestCollector.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.io.PrintStream; - -// Results collector for VarHandle Unit tests -public final class VarHandleUnitTestCollector { - private final PrintStream out = System.out; - - private int numberOfSuccesses; - private int numberOfSkips; - private int numberOfFailures; - - public void start(String testName) { - out.print(testName); - out.print("..."); - } - - public void skip() { - numberOfSkips += 1; - out.println("SKIP"); - } - - public void success() { - numberOfSuccesses += 1; - out.println("OK"); - } - - public void fail(String errorMessage) { - numberOfFailures += 1; - out.println("FAIL"); - out.print(errorMessage); - } - - public void printSummary() { - out.append(Integer.toString(numberOfSuccesses)) - .append(" successes, ") - .append(Integer.toString(numberOfSkips)) - .append(" skips, ") - .append(Integer.toString(numberOfFailures)) - .append(" failures."); - out.println(); - } - - boolean failuresOccurred() { - return numberOfFailures != 0; - } -} diff --git a/test/712-varhandle-invocations/src/VarHandleUnitTestHelpers.java b/test/712-varhandle-invocations/src/VarHandleUnitTestHelpers.java deleted file mode 100644 index 6f72e9962f..0000000000 --- a/test/712-varhandle-invocations/src/VarHandleUnitTestHelpers.java +++ /dev/null @@ -1,281 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.lang.invoke.MethodHandle; -import java.lang.invoke.MethodHandles; -import java.lang.invoke.MethodType; -import java.lang.invoke.VarHandle; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - -public class VarHandleUnitTestHelpers { - public static boolean isRunningOnAndroid() { - return System.getProperty("java.vm.vendor").contains("Android"); - } - - public static boolean is64Bit() { - // The behaviour of certain accessors depends on the ISA word size. - if (isRunningOnAndroid()) { - try { - Class<?> runtimeClass = Class.forName("dalvik.system.VMRuntime"); - MethodHandle getRuntimeMH = - MethodHandles.lookup() - .findStatic( - runtimeClass, - "getRuntime", - MethodType.methodType(runtimeClass)); - Object runtime = getRuntimeMH.invoke(); - MethodHandle is64BitMH = - MethodHandles.lookup() - .findVirtual( - runtimeClass, - "is64Bit", - MethodType.methodType(boolean.class)); - return (boolean) is64BitMH.invoke(runtime); - } catch (Throwable t) { - throw new RuntimeException(t); - } - } else { - return System.getProperty("sun.arch.data.model").equals("64"); - } - } - - public static boolean getBytesAs_boolean(byte[] array, int index, ByteOrder order) { - return getBytesAs_boolean(ByteBuffer.wrap(array), index, order); - } - - public static byte getBytesAs_byte(byte[] array, int index, ByteOrder order) { - return getBytesAs_byte(ByteBuffer.wrap(array), index, order); - } - - public static char getBytesAs_char(byte[] array, int index, ByteOrder order) { - return getBytesAs_char(ByteBuffer.wrap(array), index, order); - } - - public static short getBytesAs_short(byte[] array, int index, ByteOrder order) { - return getBytesAs_short(ByteBuffer.wrap(array), index, order); - } - - public static int getBytesAs_int(byte[] array, int index, ByteOrder order) { - return getBytesAs_int(ByteBuffer.wrap(array), index, order); - } - - public static long getBytesAs_long(byte[] array, int index, ByteOrder order) { - return getBytesAs_long(ByteBuffer.wrap(array), index, order); - } - - public static float getBytesAs_float(byte[] array, int index, ByteOrder order) { - return getBytesAs_float(ByteBuffer.wrap(array), index, order); - } - - public static double getBytesAs_double(byte[] array, int index, ByteOrder order) { - return getBytesAs_double(ByteBuffer.wrap(array), index, order); - } - - public static boolean getBytesAs_boolean(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).get(index) != 0; - } - - public static byte getBytesAs_byte(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).get(index); - } - - public static char getBytesAs_char(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getChar(index); - } - - public static short getBytesAs_short(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getShort(index); - } - - public static int getBytesAs_int(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getInt(index); - } - - public static long getBytesAs_long(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getLong(index); - } - - public static float getBytesAs_float(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getFloat(index); - } - - public static double getBytesAs_double(ByteBuffer buffer, int index, ByteOrder order) { - return buffer.order(order).getDouble(index); - } - - public static void setBytesAs_boolean(byte[] array, int index, boolean value, ByteOrder order) { - setBytesAs_boolean(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_byte(byte[] array, int index, byte value, ByteOrder order) { - setBytesAs_byte(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_char(byte[] array, int index, char value, ByteOrder order) { - setBytesAs_char(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_short(byte[] array, int index, short value, ByteOrder order) { - setBytesAs_short(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_int(byte[] array, int index, int value, ByteOrder order) { - setBytesAs_int(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_long(byte[] array, int index, long value, ByteOrder order) { - setBytesAs_long(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_float(byte[] array, int index, float value, ByteOrder order) { - setBytesAs_float(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_double(byte[] array, int index, double value, ByteOrder order) { - setBytesAs_double(ByteBuffer.wrap(array), index, value, order); - } - - public static void setBytesAs_boolean( - ByteBuffer buffer, int index, boolean value, ByteOrder order) { - buffer.order(order).put(index, value ? (byte) 1 : (byte) 0); - } - - public static void setBytesAs_byte(ByteBuffer buffer, int index, byte value, ByteOrder order) { - buffer.order(order).put(index, value); - } - - public static void setBytesAs_char(ByteBuffer buffer, int index, char value, ByteOrder order) { - buffer.order(order).putChar(index, value); - } - - public static void setBytesAs_short( - ByteBuffer buffer, int index, short value, ByteOrder order) { - buffer.order(order).putShort(index, value); - } - - public static void setBytesAs_int(ByteBuffer buffer, int index, int value, ByteOrder order) { - buffer.order(order).putInt(index, value); - } - - public static void setBytesAs_long(ByteBuffer buffer, int index, long value, ByteOrder order) { - buffer.order(order).putLong(index, value); - } - - public static void setBytesAs_float( - ByteBuffer buffer, int index, float value, ByteOrder order) { - buffer.order(order).putFloat(index, value); - } - - public static void setBytesAs_double( - ByteBuffer buffer, int index, double value, ByteOrder order) { - buffer.order(order).putDouble(index, value); - } - - // Until ART is running on an OpenJDK9 based runtime, there are no - // calls to help with alignment. OpenJDK9 introduces - // ByteBuffer.alignedSlice() and ByteBuffer.alignmentOffset(). RI - // and ART have different data structure alignments which may make - // porting code interesting. - - public static int alignedOffset_char(ByteBuffer buffer, int start) { - return alignedOffset_short(buffer, start); - } - - public static int alignedOffset_short(ByteBuffer buffer, int start) { - for (int i = 0; i < Short.SIZE; ++i) { - try { - vh_probe_short.getVolatile(buffer, start + i); - return start + i; - } catch (IllegalStateException e) { - // Unaligned access. - } - } - return start; - } - - public static int alignedOffset_int(ByteBuffer buffer, int start) { - for (int i = 0; i < Integer.SIZE; ++i) { - try { - vh_probe_int.getVolatile(buffer, start + i); - return start + i; - } catch (IllegalStateException e) { - // Unaligned access. - } catch (Exception e) { - break; - } - } - return start; - } - - public static int alignedOffset_long(ByteBuffer buffer, int start) { - for (int i = 0; i < Long.SIZE; ++i) { - try { - vh_probe_long.getVolatile(buffer, start + i); - return start + i; - } catch (IllegalStateException e) { - // Unaligned access. - } catch (UnsupportedOperationException e) { - // 64-bit operation is not supported irrespective of alignment. - break; - } - } - return start; - } - - public static int alignedOffset_float(ByteBuffer buffer, int start) { - return alignedOffset_int(buffer, start); - } - - public static int alignedOffset_double(ByteBuffer buffer, int start) { - return alignedOffset_long(buffer, start); - } - - public static int alignedOffset_char(byte[] array, int start) { - return alignedOffset_char(ByteBuffer.wrap(array), start); - } - - public static int alignedOffset_short(byte[] array, int start) { - return alignedOffset_short(ByteBuffer.wrap(array), start); - } - - public static int alignedOffset_int(byte[] array, int start) { - return alignedOffset_int(ByteBuffer.wrap(array), start); - } - - public static int alignedOffset_long(byte[] array, int start) { - return alignedOffset_long(ByteBuffer.wrap(array), start); - } - - public static int alignedOffset_float(byte[] array, int start) { - return alignedOffset_float(ByteBuffer.wrap(array), start); - } - - public static int alignedOffset_double(byte[] array, int start) { - return alignedOffset_double(ByteBuffer.wrap(array), start); - } - - static { - ByteOrder order = ByteOrder.LITTLE_ENDIAN; - vh_probe_short = MethodHandles.byteBufferViewVarHandle(short[].class, order); - vh_probe_int = MethodHandles.byteBufferViewVarHandle(int[].class, order); - vh_probe_long = MethodHandles.byteBufferViewVarHandle(long[].class, order); - } - - private static final VarHandle vh_probe_short; - private static final VarHandle vh_probe_int; - private static final VarHandle vh_probe_long; -} diff --git a/test/712-varhandle-invocations/src/Widget.java b/test/712-varhandle-invocations/src/Widget.java deleted file mode 100644 index 0282ff8d64..0000000000 --- a/test/712-varhandle-invocations/src/Widget.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2018 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// Widget class for reference type accessor tests. -public class Widget { - protected int requisitionNumber; - - public Widget(int requisitionNumber) { - this.requisitionNumber = requisitionNumber; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (!(o instanceof Widget)) { - return false; - } - Widget wo = (Widget) o; - return requisitionNumber == wo.requisitionNumber; - } - - public static final Widget ONE = new Widget(1); - public static final Widget TWO = new Widget(2); -} diff --git a/test/712-varhandle-invocations/util-src/generate_java.py b/test/712-varhandle-invocations/util-src/generate_java.py deleted file mode 100644 index 9520b53844..0000000000 --- a/test/712-varhandle-invocations/util-src/generate_java.py +++ /dev/null @@ -1,876 +0,0 @@ -#!/usr/bin/python3 -# -# Copyright (C) 2018 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -Generate java test files for 712-varhandle-invocations -""" - -from enum import Enum -from pathlib import Path -from random import Random -from string import Template - -import io -import re -import sys - -class JavaType(object): - def __init__(self, name, examples, supports_bitwise=False, supports_numeric=False): - self.name=name - self.examples=examples - self.supports_bitwise=supports_bitwise - self.supports_numeric=supports_numeric - - def is_value_type(self): - return False - - def __repr__(self): - return self.name - - def __str__(self): - return self.name - -class ValueType(JavaType): - def __init__(self, name, boxed_type, examples, ordinal=-1, width=-1, supports_bitwise=True, supports_numeric=True): - JavaType.__init__(self, name, examples, supports_bitwise, supports_numeric) - self.ordinal=ordinal - self.width=width - self.boxed_type=boxed_type - - def boxing_method(self): - return self.boxed_type + ".valueOf" - - def unboxing_method(self): - return self.name + "Value" - - def is_value_type(self): - return True - - def __eq__(self, other): - return self.ordinal == other.ordinal - - def __hash__(self): - return self.ordinal - - def __le__(self, other): - return self.ordinal < other.ordinal - - def __repr__(self): - return self.name - - def __str__(self): - return self.name - -BOOLEAN_TYPE = ValueType("boolean", "Boolean", [ "true", "false" ], ordinal = 0, width = 1, supports_numeric=False) -BYTE_TYPE=ValueType("byte", "Byte", [ "(byte) -128", "(byte) -61", "(byte) 7", "(byte) 127", "(byte) 33" ], ordinal=1, width=1) -SHORT_TYPE=ValueType("short", "Short", [ "(short) -32768", "(short) -384", "(short) 32767", "(short) 0xaa55" ], ordinal=2, width=2) -CHAR_TYPE=ValueType("char", "Character", [ r"'A'", r"'#'", r"'$'", r"'Z'", r"'t'", r"'c'" ], ordinal=3, width=2) -INT_TYPE=ValueType("int", "Integer", [ "-0x01234567", "0x7f6e5d4c", "0x12345678", "0x10215220", "42" ], ordinal=4, width=4) -LONG_TYPE=ValueType("long", "Long", [ "-0x0123456789abcdefl", "0x789abcdef0123456l", "0xfedcba9876543210l" ], ordinal=5, width=8) -FLOAT_TYPE=ValueType("float", "Float", [ "-7.77e23f", "1.234e-17f", "3.40e36f", "-8.888e3f", "4.442e11f" ], ordinal=6, width=4, supports_bitwise=False) -DOUBLE_TYPE=ValueType("double", "Double", [ "-1.0e-200", "1.11e200", "3.141", "1.1111", "6.022e23", "6.626e-34" ], ordinal=7, width=4, supports_bitwise=False) - -VALUE_TYPES = { BOOLEAN_TYPE, BYTE_TYPE, SHORT_TYPE, CHAR_TYPE, INT_TYPE, LONG_TYPE, FLOAT_TYPE, DOUBLE_TYPE } - -WIDENING_CONVERSIONS = { - BOOLEAN_TYPE : set(), - BYTE_TYPE : { SHORT_TYPE, INT_TYPE, LONG_TYPE, FLOAT_TYPE, DOUBLE_TYPE }, - SHORT_TYPE : { INT_TYPE, LONG_TYPE, FLOAT_TYPE, DOUBLE_TYPE }, - CHAR_TYPE : { INT_TYPE, LONG_TYPE, FLOAT_TYPE, DOUBLE_TYPE }, - INT_TYPE : { LONG_TYPE, FLOAT_TYPE, DOUBLE_TYPE }, - LONG_TYPE : { FLOAT_TYPE, DOUBLE_TYPE }, - FLOAT_TYPE : { DOUBLE_TYPE }, - DOUBLE_TYPE : set() -} - -def types_that_widen_to(var_type): - types_that_widen = { var_type } - for src_type in WIDENING_CONVERSIONS: - if var_type in WIDENING_CONVERSIONS[src_type]: - types_that_widen.add(src_type) - return types_that_widen - -class VarHandleKind(object): - ALL_SUPPORTED_TYPES = VALUE_TYPES - VIEW_SUPPORTED_TYPES = list(filter(lambda x : x.width >= 2, ALL_SUPPORTED_TYPES)) - - def __init__(self, name, imports=[], declarations=[], lookup='', coordinates=[], get_value='', may_throw_read_only=False): - self.name = name - self.imports = imports - self.declarations = declarations - self.lookup = lookup - self.coordinates = coordinates - self.get_value_ = get_value - self.may_throw_read_only = may_throw_read_only - - def get_name(self): - return self.name - - def get_coordinates(self): - return self.coordinates - - def get_field_declarations(self, dictionary): - return list(map(lambda d: Template(d).safe_substitute(dictionary), self.declarations)) - - def get_imports(self): - return self.imports - - def get_lookup(self, dictionary): - return Template(self.lookup).safe_substitute(dictionary) - - def get_supported_types(self): - return VarHandleKind.VIEW_SUPPORTED_TYPES if self.is_view() else VarHandleKind.ALL_SUPPORTED_TYPES - - def is_view(self): - return "View" in self.name - - def get_value(self, dictionary): - return Template(self.get_value_).safe_substitute(dictionary) - -FIELD_VAR_HANDLE = VarHandleKind("Field", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle' - ], - [ - "${var_type} field = ${initial_value}" - ], - 'MethodHandles.lookup().findVarHandle(${test_class}.class, "field", ${var_type}.class)', - [ - 'this' - ], - 'field', - may_throw_read_only = False) - -FINAL_FIELD_VAR_HANDLE = VarHandleKind("FinalField", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle' - ], - [ - "${var_type} field = ${initial_value}" - ], - 'MethodHandles.lookup().findVarHandle(${test_class}.class, "field", ${var_type}.class)', - [ - 'this' - ], - 'field', - may_throw_read_only = False) - -STATIC_FIELD_VAR_HANDLE = VarHandleKind("StaticField", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle' - ], - [ - "static ${var_type} field = ${initial_value}" - ], - 'MethodHandles.lookup().findStaticVarHandle(${test_class}.class, "field", ${var_type}.class)', - [], - 'field', - may_throw_read_only = False) - -STATIC_FINAL_FIELD_VAR_HANDLE = VarHandleKind("StaticFinalField", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle' - ], - [ - "static ${var_type} field = ${initial_value}" - ], - 'MethodHandles.lookup().findStaticVarHandle(${test_class}.class, "field", ${var_type}.class)', - [], - 'field', - may_throw_read_only = False) - -ARRAY_ELEMENT_VAR_HANDLE = VarHandleKind("ArrayElement", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle' - ], - [ - "${var_type}[] array = new ${var_type}[11]", - "int index = 3", - "{ array[index] = ${initial_value}; }" - ], - 'MethodHandles.arrayElementVarHandle(${var_type}[].class)', - [ 'array', 'index'], - 'array[index]', - may_throw_read_only = False) - -BYTE_ARRAY_LE_VIEW_VAR_HANDLE = VarHandleKind("ByteArrayViewLE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteOrder' - ], - [ - "byte[] array = new byte[27]", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(array, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(array, index, ${initial_value}, ByteOrder.LITTLE_ENDIAN);" - "}" - ], - 'MethodHandles.byteArrayViewVarHandle(${var_type}[].class, ByteOrder.LITTLE_ENDIAN)', - [ - 'array', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(array, index, ByteOrder.LITTLE_ENDIAN)', - may_throw_read_only = False) - -BYTE_ARRAY_BE_VIEW_VAR_HANDLE = VarHandleKind("ByteArrayViewBE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteOrder' - ], - [ - "byte[] array = new byte[27]", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(array, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(array, index, ${initial_value}, ByteOrder.BIG_ENDIAN);" - "}" - ], - 'MethodHandles.byteArrayViewVarHandle(${var_type}[].class, ByteOrder.BIG_ENDIAN)', - [ - 'array', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(array, index, ByteOrder.BIG_ENDIAN)', - may_throw_read_only = False) - -DIRECT_BYTE_BUFFER_LE_VIEW_VAR_HANDLE = VarHandleKind("DirectByteBufferViewLE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder' - ], - [ - "ByteBuffer bb = ByteBuffer.allocateDirect(31)", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(bb, index, ${initial_value}, ByteOrder.LITTLE_ENDIAN);" - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.LITTLE_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.LITTLE_ENDIAN)', - may_throw_read_only = False) - -DIRECT_BYTE_BUFFER_BE_VIEW_VAR_HANDLE = VarHandleKind("DirectByteBufferViewBE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder' - ], - [ - "ByteBuffer bb = ByteBuffer.allocateDirect(31)", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(bb, index, ${initial_value}, ByteOrder.BIG_ENDIAN);" - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.BIG_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.BIG_ENDIAN)', - may_throw_read_only = False) - -HEAP_BYTE_BUFFER_LE_VIEW_VAR_HANDLE = VarHandleKind("HeapByteBufferViewLE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder' - ], - [ - "byte[] array = new byte[36]", - "int offset = 8", - "ByteBuffer bb = ByteBuffer.wrap(array, offset, array.length - offset)", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(bb, index, ${initial_value}, ByteOrder.LITTLE_ENDIAN);" - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.LITTLE_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.LITTLE_ENDIAN)', - may_throw_read_only = False) - -HEAP_BYTE_BUFFER_BE_VIEW_VAR_HANDLE = VarHandleKind("HeapByteBufferViewBE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder' - ], - [ - "byte[] array = new byte[47]", - "int offset = 8", - "ByteBuffer bb = ByteBuffer.wrap(array, offset, array.length - offset)", - "int index = 8", - "{" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(bb, index, ${initial_value}, ByteOrder.BIG_ENDIAN);" - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.BIG_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.BIG_ENDIAN)', - may_throw_read_only = False) - -HEAP_BYTE_BUFFER_RO_LE_VIEW_VAR_HANDLE = VarHandleKind("HeapByteBufferReadOnlyViewLE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder', - 'java.nio.ReadOnlyBufferException' - ], - [ - "byte[] array = new byte[43]", - "int index = 8", - "ByteBuffer bb", - "{" - " bb = ByteBuffer.wrap(array).asReadOnlyBuffer();" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, index);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(array, index, ${initial_value}, ByteOrder.LITTLE_ENDIAN);" - " bb = bb.asReadOnlyBuffer();" - - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.LITTLE_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.LITTLE_ENDIAN)', - may_throw_read_only = True) - -HEAP_BYTE_BUFFER_RO_BE_VIEW_VAR_HANDLE = VarHandleKind("HeapByteBufferReadOnlyViewBE", - [ - 'java.lang.invoke.MethodHandles', - 'java.lang.invoke.VarHandle', - 'java.nio.ByteBuffer', - 'java.nio.ByteOrder', - 'java.nio.ReadOnlyBufferException' - ], - [ - "byte[] array = new byte[29]", - "int index", - "ByteBuffer bb", - "{" - " bb = ByteBuffer.wrap(array);" - " index = VarHandleUnitTestHelpers.alignedOffset_${var_type}(bb, 8);" - " VarHandleUnitTestHelpers.setBytesAs_${var_type}(array, index, ${initial_value}, ByteOrder.BIG_ENDIAN);" - " bb = bb.asReadOnlyBuffer();" - "}" - ], - 'MethodHandles.byteBufferViewVarHandle(${var_type}[].class, ByteOrder.BIG_ENDIAN)', - [ - 'bb', - 'index' - ], - 'VarHandleUnitTestHelpers.getBytesAs_${var_type}(bb, index, ByteOrder.BIG_ENDIAN)', - may_throw_read_only = True) - -ALL_FIELD_VAR_HANDLE_KINDS = [ - FIELD_VAR_HANDLE, - FINAL_FIELD_VAR_HANDLE, - STATIC_FIELD_VAR_HANDLE, - STATIC_FINAL_FIELD_VAR_HANDLE -] - -ALL_BYTE_VIEW_VAR_HANDLE_KINDS = [ - BYTE_ARRAY_LE_VIEW_VAR_HANDLE, - BYTE_ARRAY_BE_VIEW_VAR_HANDLE, - DIRECT_BYTE_BUFFER_LE_VIEW_VAR_HANDLE, - DIRECT_BYTE_BUFFER_BE_VIEW_VAR_HANDLE, - HEAP_BYTE_BUFFER_LE_VIEW_VAR_HANDLE, - HEAP_BYTE_BUFFER_BE_VIEW_VAR_HANDLE, - HEAP_BYTE_BUFFER_RO_LE_VIEW_VAR_HANDLE, - HEAP_BYTE_BUFFER_RO_BE_VIEW_VAR_HANDLE -] - -ALL_VAR_HANDLE_KINDS = ALL_FIELD_VAR_HANDLE_KINDS + [ ARRAY_ELEMENT_VAR_HANDLE ] + ALL_BYTE_VIEW_VAR_HANDLE_KINDS - -class AccessModeForm(Enum): - GET = 0 - SET = 1 - STRONG_COMPARE_AND_SET = 2 - WEAK_COMPARE_AND_SET = 3 - COMPARE_AND_EXCHANGE = 4 - GET_AND_SET = 5 - GET_AND_UPDATE_BITWISE = 6 - GET_AND_UPDATE_NUMERIC = 7 - -class VarHandleAccessor: - def __init__(self, method_name): - self.method_name = method_name - self.access_mode = self.get_access_mode(method_name) - self.access_mode_form = self.get_access_mode_form(method_name) - - def get_return_type(self, var_type): - if self.access_mode_form == AccessModeForm.SET: - return None - elif (self.access_mode_form == AccessModeForm.STRONG_COMPARE_AND_SET or - self.access_mode_form == AccessModeForm.WEAK_COMPARE_AND_SET): - return BOOLEAN_TYPE - else: - return var_type - - def get_number_of_var_type_arguments(self): - if self.access_mode_form == AccessModeForm.GET: - return 0 - elif (self.access_mode_form == AccessModeForm.SET or - self.access_mode_form == AccessModeForm.GET_AND_SET or - self.access_mode_form == AccessModeForm.GET_AND_UPDATE_BITWISE or - self.access_mode_form == AccessModeForm.GET_AND_UPDATE_NUMERIC): - return 1 - elif (self.access_mode_form == AccessModeForm.STRONG_COMPARE_AND_SET or - self.access_mode_form == AccessModeForm.WEAK_COMPARE_AND_SET or - self.access_mode_form == AccessModeForm.COMPARE_AND_EXCHANGE): - return 2 - else: - raise ValueError(self.access_mode_form) - - def is_read_only(self): - return self.access_mode_form == AccessModeForm.GET - - def get_java_bitwise_operator(self): - if "BitwiseAnd" in self.method_name: - return "&" - elif "BitwiseOr" in self.method_name: - return "|" - elif "BitwiseXor" in self.method_name: - return "^" - raise ValueError(self.method_name) - - def get_java_numeric_operator(self): - if "Add" in self.method_name: - return "+" - raise ValueError(self.method_name) - - @staticmethod - def get_access_mode(accessor_method): - """Converts an access method name to AccessMode value. For example, getAndSet becomes GET_AND_SET""" - return re.sub('([A-Z])', r'_\1', accessor_method).upper() - - @staticmethod - def get_access_mode_form(accessor_method): - prefix_mode_list = [ - ('getAndAdd', AccessModeForm.GET_AND_UPDATE_NUMERIC), - ('getAndBitwise', AccessModeForm.GET_AND_UPDATE_BITWISE), - ('getAndSet', AccessModeForm.GET_AND_SET), - ('get', AccessModeForm.GET), - ('set', AccessModeForm.SET), - ('compareAndSet', AccessModeForm.STRONG_COMPARE_AND_SET), - ('weakCompareAndSet', AccessModeForm.WEAK_COMPARE_AND_SET), - ('compareAndExchange', AccessModeForm.COMPARE_AND_EXCHANGE)] - for prefix, mode in prefix_mode_list: - if accessor_method.startswith(prefix): - return mode - raise ValueError(accessor_method) - -VAR_HANDLE_ACCESSORS = [ - VarHandleAccessor('get'), - VarHandleAccessor('set'), - VarHandleAccessor('getVolatile'), - VarHandleAccessor('setVolatile'), - VarHandleAccessor('getAcquire'), - VarHandleAccessor('setRelease'), - VarHandleAccessor('getOpaque'), - VarHandleAccessor('setOpaque'), - VarHandleAccessor('compareAndSet'), - VarHandleAccessor('compareAndExchange'), - VarHandleAccessor('compareAndExchangeAcquire'), - VarHandleAccessor('compareAndExchangeRelease'), - VarHandleAccessor('weakCompareAndSetPlain'), - VarHandleAccessor('weakCompareAndSet'), - VarHandleAccessor('weakCompareAndSetAcquire'), - VarHandleAccessor('weakCompareAndSetRelease'), - VarHandleAccessor('getAndSet'), - VarHandleAccessor('getAndSetAcquire'), - VarHandleAccessor('getAndSetRelease'), - VarHandleAccessor('getAndAdd'), - VarHandleAccessor('getAndAddAcquire'), - VarHandleAccessor('getAndAddRelease'), - VarHandleAccessor('getAndBitwiseOr'), - VarHandleAccessor('getAndBitwiseOrRelease'), - VarHandleAccessor('getAndBitwiseOrAcquire'), - VarHandleAccessor('getAndBitwiseAnd'), - VarHandleAccessor('getAndBitwiseAndRelease'), - VarHandleAccessor('getAndBitwiseAndAcquire'), - VarHandleAccessor('getAndBitwiseXor'), - VarHandleAccessor('getAndBitwiseXorRelease'), - VarHandleAccessor('getAndBitwiseXorAcquire') -] - -# Pseudo-RNG used for arbitrary decisions -RANDOM = Random(0) - -BANNER = '// This file is generated by util-src/generate_java.py do not directly modify!' - -# List of generated test classes -GENERATED_TEST_CLASSES = [] - -def java_file_for_class(class_name): - return class_name + ".java" - -def capitalize_first(word): - return word[0].upper() + word[1:] - -def indent_code(code): - """Applies rudimentary indentation to code""" - return code - -def build_template_dictionary(test_class, var_handle_kind, accessor, var_type): - initial_value = RANDOM.choice(var_type.examples) - updated_value = RANDOM.choice(list(filter(lambda v : v != initial_value, var_type.examples))) - coordinates = ", ".join(var_handle_kind.get_coordinates()) - if accessor.get_number_of_var_type_arguments() != 0 and coordinates != "": - coordinates += ", " - dictionary = { - 'accessor_method' : accessor.method_name, - 'access_mode' : accessor.access_mode, - 'banner' : BANNER, - 'coordinates' : coordinates, - 'initial_value' : initial_value, - 'test_class' : test_class, - 'updated_value' : updated_value, - 'var_type' : var_type, - } - dictionary['imports'] = ";\n".join(list(map(lambda x: "import " + x, var_handle_kind.get_imports()))) - dictionary['lookup'] = var_handle_kind.get_lookup(dictionary) - dictionary['field_declarations'] = ";\n".join(var_handle_kind.get_field_declarations(dictionary)) - dictionary['read_value'] = var_handle_kind.get_value(dictionary) - return dictionary - -def emit_accessor_test(var_handle_kind, accessor, var_type, output_path): - test_class = var_handle_kind.get_name() + capitalize_first(accessor.method_name) + capitalize_first(var_type.name) - GENERATED_TEST_CLASSES.append(test_class) - src_file_path = output_path / java_file_for_class(test_class) - expansions = build_template_dictionary(test_class, var_handle_kind, accessor, var_type) - # Compute test operation - if accessor.access_mode_form == AccessModeForm.GET: - test_template = Template(""" - ${var_type} value = (${var_type}) vh.${accessor_method}(${coordinates}); - assertEquals(${initial_value}, value);""") - elif accessor.access_mode_form == AccessModeForm.SET: - test_template = Template(""" - vh.${accessor_method}(${coordinates}${updated_value}); - assertEquals(${updated_value}, ${read_value});""") - elif accessor.access_mode_form == AccessModeForm.STRONG_COMPARE_AND_SET: - test_template = Template(""" - assertEquals(${initial_value}, ${read_value}); - // Test an update that should succeed. - boolean applied = (boolean) vh.${accessor_method}(${coordinates}${initial_value}, ${updated_value}); - assertEquals(${updated_value}, ${read_value}); - assertTrue(applied); - // Test an update that should fail. - applied = (boolean) vh.${accessor_method}(${coordinates}${initial_value}, ${initial_value}); - assertFalse(applied); - assertEquals(${updated_value}, ${read_value});""") - elif accessor.access_mode_form == AccessModeForm.WEAK_COMPARE_AND_SET: - test_template = Template(""" - assertEquals(${initial_value}, ${read_value}); - // Test an update that should succeed. - int attempts = 10000; - boolean applied; - do { - applied = (boolean) vh.${accessor_method}(${coordinates}${initial_value}, ${updated_value}); - } while (applied == false && attempts-- > 0); - assertEquals(${updated_value}, ${read_value}); - assertTrue(attempts > 0); - // Test an update that should fail. - applied = (boolean) vh.${accessor_method}(${coordinates}${initial_value}, ${initial_value}); - assertFalse(applied); - assertEquals(${updated_value}, ${read_value});""") - elif accessor.access_mode_form == AccessModeForm.COMPARE_AND_EXCHANGE: - test_template = Template(""" - // This update should succeed. - ${var_type} witness_value = (${var_type}) vh.${accessor_method}(${coordinates}${initial_value}, ${updated_value}); - assertEquals(${initial_value}, witness_value); - assertEquals(${updated_value}, ${read_value}); - // This update should fail. - witness_value = (${var_type}) vh.${accessor_method}(${coordinates}${initial_value}, ${initial_value}); - assertEquals(${updated_value}, witness_value); - assertEquals(${updated_value}, ${read_value});""") - elif accessor.access_mode_form == AccessModeForm.GET_AND_SET: - test_template = Template(""" - ${var_type} old_value = (${var_type}) vh.${accessor_method}(${coordinates}${updated_value}); - assertEquals(${initial_value}, old_value); - assertEquals(${updated_value}, ${read_value});""") - elif accessor.access_mode_form == AccessModeForm.GET_AND_UPDATE_BITWISE: - if var_type.supports_bitwise == True: - expansions['binop'] = accessor.get_java_bitwise_operator() - test_template = Template(""" - ${var_type} old_value = (${var_type}) vh.${accessor_method}(${coordinates}${updated_value}); - assertEquals(${initial_value}, old_value); - assertEquals(${initial_value} ${binop} ${updated_value}, ${read_value});""") - else: - test_template = Template(""" - vh.${accessor_method}(${coordinates}${initial_value}, ${updated_value}); - failUnreachable();""") - elif accessor.access_mode_form == AccessModeForm.GET_AND_UPDATE_NUMERIC: - if var_type.supports_numeric == True: - expansions['binop'] = accessor.get_java_numeric_operator() - test_template = Template(""" - ${var_type} old_value = (${var_type}) vh.${accessor_method}(${coordinates}${updated_value}); - assertEquals(${initial_value}, old_value); - ${var_type} expected_value = (${var_type}) (${initial_value} ${binop} ${updated_value}); - assertEquals(expected_value, ${read_value});""") - else: - test_template = Template(""" - vh.${accessor_method}(${coordinates}${initial_value}, ${updated_value}); - failUnreachable();""") - else: - raise ValueError(accessor.access_mode_form) - - if var_handle_kind.may_throw_read_only and not accessor.is_read_only(): - # ByteBufferViews can be read-only and dynamically raise ReadOnlyBufferException. - expansions['try_statement'] = "try {" - expansions['catch_statement'] = "failUnreachable();\n} catch (ReadOnlyBufferException ex) {}" - else: - expansions['try_statement'] = "" - expansions['catch_statement'] = "" - - expansions['test_body'] = test_template.safe_substitute(expansions) - - s = Template("""${banner} - -${imports}; - -class ${test_class} extends VarHandleUnitTest { - ${field_declarations}; - static final VarHandle vh; - static { - try { - vh = ${lookup}; - } catch (Exception e) { - throw new RuntimeException("Unexpected initialization exception", e); - } - } - - @Override - public void doTest() throws Exception { - if (!vh.isAccessModeSupported(VarHandle.AccessMode.${access_mode})) { - try { - ${test_body} - failUnreachable(); - } catch (UnsupportedOperationException ex) {} - } else { - ${try_statement} - ${test_body} - ${catch_statement} - } - } - - public static void main(String[] args) { - new ${test_class}().run(); - } -} -""").safe_substitute(expansions) - with src_file_path.open("w") as src_file: - print(s, file=src_file) - -def emit_value_type_accessor_tests(output_path): - for var_handle_kind in ALL_VAR_HANDLE_KINDS: - for accessor in VAR_HANDLE_ACCESSORS: - for var_type in var_handle_kind.get_supported_types(): - emit_accessor_test(var_handle_kind, accessor, var_type, output_path) - -def emit_reference_accessor_tests(output_path): - ref_type = JavaType("Widget", [ "Widget.ONE", "Widget.TWO", "null" ]) - for var_handle_kind in ALL_VAR_HANDLE_KINDS: - if var_handle_kind.is_view(): - # Views as reference type arrays are not supported. They - # fail instantiation. This is tested in 710-varhandle-creation. - continue - for accessor in VAR_HANDLE_ACCESSORS: - emit_accessor_test(var_handle_kind, accessor, ref_type, output_path) - -def emit_boxing_value_type_accessor_test(accessor, var_type, output_path): - test_class = "Boxing" + capitalize_first(accessor.method_name) + capitalize_first(var_type.name) - GENERATED_TEST_CLASSES.append(test_class) - src_file_path = output_path / java_file_for_class(test_class) - var_handle_kind = FIELD_VAR_HANDLE - expansions = build_template_dictionary(test_class, var_handle_kind, accessor, var_type) - template = Template(""" -${banner} - -${imports}; -import java.lang.invoke.WrongMethodTypeException; - -public class ${test_class} extends VarHandleUnitTest { - ${field_declarations}; - private static final VarHandle vh; - static { - try { - vh = ${lookup}; - } catch (Exception e) { - throw new RuntimeException("Unexpected initialization exception", e); - } - } - - @Override - public void doTest() throws Exception { - ${body} - } - - public static void main(String[] args) { - new ${test_class}().run(); - } -} -""") - with io.StringIO() as body_text: - compatible_types = types_that_widen_to(var_type) - for value_type in VALUE_TYPES: - print("try {", file=body_text) - return_type = accessor.get_return_type(var_type) - if return_type: - print("{0} result = ({0}) ".format(return_type), end="", file=body_text) - print("vh.{0}(this".format(accessor.method_name), end="", file=body_text) - num_args = accessor.get_number_of_var_type_arguments() - for i in range(0, num_args): - print(", {0}({1})".format(value_type.boxing_method(), value_type.examples[i]), end="", file=body_text) - print(");", file=body_text) - if value_type in compatible_types: - print(" assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.{0}));".format(accessor.access_mode), - file=body_text) - else: - print("failUnreachable();", file=body_text) - print("} catch (WrongMethodTypeException e) {", file=body_text) - print("} catch (UnsupportedOperationException e) {", file=body_text) - print(" assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.{0}));".format(accessor.access_mode), - file=body_text) - print("}", file=body_text) - expansions['body'] = body_text.getvalue(); - with src_file_path.open("w") as src_file: - print(template.safe_substitute(expansions), file=src_file) - -def emit_boxing_return_value_type_test(accessor, var_type, output_path): - test_class = "BoxingReturn" + capitalize_first(accessor.method_name) + capitalize_first(var_type.name) - GENERATED_TEST_CLASSES.append(test_class) - src_file_path = output_path / java_file_for_class(test_class) - var_handle_kind = FIELD_VAR_HANDLE - expansions = build_template_dictionary(test_class, var_handle_kind, accessor, var_type) - template = Template(""" -${banner} - -${imports}; -import java.lang.invoke.WrongMethodTypeException; - -public class ${test_class} extends VarHandleUnitTest { - ${field_declarations}; - private static final VarHandle vh; - static { - try { - vh = ${lookup}; - } catch (Exception e) { - throw new RuntimeException("Unexpected initialization exception", e); - } - } - - @Override - public void doTest() throws Exception { - ${body} - } - - public static void main(String[] args) { - new ${test_class}().run(); - } -} -""") - with io.StringIO() as body_text: - return_type = accessor.get_return_type(var_type) - compatible_types = { return_type } - for value_type in VALUE_TYPES: - print("try {", file=body_text) - print("{0} result = ({0}) ".format(value_type.boxed_type), end="", file=body_text) - print("vh.{0}(this".format(accessor.method_name), end="", file=body_text) - num_args = accessor.get_number_of_var_type_arguments() - for i in range(0, num_args): - print(", {0})".format(var_type.examples[i]), end="", file=body_text) - print(");", file=body_text) - if value_type in compatible_types: - print(" assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.{0}));".format(accessor.access_mode), - file=body_text) - else: - print("failUnreachable();", file=body_text) - print("} catch (WrongMethodTypeException e) {", file=body_text) - print("} catch (UnsupportedOperationException e) {", file=body_text) - print(" assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.{0}));".format(accessor.access_mode), - file=body_text) - print("}", file=body_text) - expansions['body'] = body_text.getvalue(); - with src_file_path.open("w") as src_file: - print(template.safe_substitute(expansions), file=src_file) - -def emit_boxing_value_type_accessor_tests(output_path): - for var_type in VALUE_TYPES: - for accessor in VAR_HANDLE_ACCESSORS: - if accessor.get_number_of_var_type_arguments() > 0: - emit_boxing_value_type_accessor_test(accessor, var_type, output_path) - else: - emit_boxing_return_value_type_test(accessor, var_type, output_path) - -def emit_main(output_path, manual_test_classes): - main_file_path = output_path / "Main.java" - all_test_classes = GENERATED_TEST_CLASSES + manual_test_classes - with main_file_path.open("w") as main_file: - print("// " + BANNER, file=main_file) - print(""" -public class Main { - public static void main(String[] args) { -""", file=main_file) - for cls in all_test_classes: - print(" " + cls + ".main(args);", file=main_file) - print(" VarHandleUnitTest.DEFAULT_COLLECTOR.printSummary();", file=main_file) - print(" System.exit(VarHandleUnitTest.DEFAULT_COLLECTOR.failuresOccurred() ? 1 : 0);", file=main_file) - print(" }\n}", file=main_file) - -def main(argv): - final_java_dir = Path(argv[1]) - if not final_java_dir.exists() or not final_java_dir.is_dir(): - print("{} is not a valid java dir".format(final_java_dir), file=sys.stderr) - sys.exit(1) - emit_value_type_accessor_tests(final_java_dir) - emit_reference_accessor_tests(final_java_dir) - emit_boxing_value_type_accessor_tests(final_java_dir) - emit_main(final_java_dir, argv[2:]) - -if __name__ == '__main__': - main(sys.argv) diff --git a/test/etc/default-build b/test/etc/default-build index 6040f7d910..4dc2393c54 100755 --- a/test/etc/default-build +++ b/test/etc/default-build @@ -124,20 +124,18 @@ JACK_EXPERIMENTAL_ARGS[${DEFAULT_EXPERIMENT}]="-D jack.java.source.version=1.8 - declare -A SMALI_EXPERIMENTAL_ARGS SMALI_EXPERIMENTAL_ARGS["default-methods"]="--api 24" SMALI_EXPERIMENTAL_ARGS["method-handles"]="--api 26" -SMALI_EXPERIMENTAL_ARGS["var-handles"]="--api 26" SMALI_EXPERIMENTAL_ARGS["agents"]="--api 26" declare -A JAVAC_EXPERIMENTAL_ARGS JAVAC_EXPERIMENTAL_ARGS["default-methods"]="-source 1.8 -target 1.8" JAVAC_EXPERIMENTAL_ARGS["lambdas"]="-source 1.8 -target 1.8" JAVAC_EXPERIMENTAL_ARGS["method-handles"]="-source 1.8 -target 1.8" -JAVAC_EXPERIMENTAL_ARGS["var-handles"]="-source 1.8 -target 1.8" +# We need to leave javac at default 1.7 so that dx will continue to work JAVAC_EXPERIMENTAL_ARGS[${DEFAULT_EXPERIMENT}]="-source 1.8 -target 1.8" JAVAC_EXPERIMENTAL_ARGS["agents"]="-source 1.8 -target 1.8" declare -A DX_EXPERIMENTAL_ARGS DX_EXPERIMENTAL_ARGS["method-handles"]="--min-sdk-version=26" -DX_EXPERIMENTAL_ARGS["var-handles"]="--min-sdk-version=26" while true; do if [ "x$1" = "x--dx-option" ]; then @@ -443,7 +441,7 @@ else if [ "${HAS_SRC2}" = "true" ]; then mkdir -p classes - ${JAVAC} ${JAVAC_ARGS} -classpath classes -d classes `find src2 -name '*.java'` + ${JAVAC} ${JAVAC_ARGS} -d classes `find src2 -name '*.java'` fi if [[ "${HAS_SRC}" == "true" || "${HAS_SRC2}" == "true" || "${HAS_SRC_ART}" == "true" ]]; then |