Address review comments from change 000e1885701c8f.
Style fixes, and better OOM handling.
bug: 30550796
Test: make test-art-host
Change-Id: I2ab58e25bd08daace6609ba45d860994a354280f
diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc
index 4fc92a3..1a99100 100644
--- a/runtime/interpreter/interpreter_common.cc
+++ b/runtime/interpreter/interpreter_common.cc
@@ -653,53 +653,51 @@
//
template <bool is_range, bool do_assignability_check>
- REQUIRES_SHARED(Locks::mutator_lock_)
-static inline bool DoCallCommon(ArtMethod* called_method,
- Thread* self,
- ShadowFrame& shadow_frame,
- JValue* result,
- uint16_t number_of_inputs,
- uint32_t (&arg)[Instruction::kMaxVarArgRegs],
- uint32_t vregC) ALWAYS_INLINE;
-
-template <bool is_range> REQUIRES_SHARED(Locks::mutator_lock_)
-static inline bool DoCallPolymorphic(ArtMethod* called_method,
- Handle<mirror::MethodType> callsite_type,
- Handle<mirror::MethodType> target_type,
- Thread* self,
- ShadowFrame& shadow_frame,
- JValue* result,
- uint32_t (&arg)[Instruction::kMaxVarArgRegs],
- uint32_t vregC,
- const MethodHandleKind handle_kind) ALWAYS_INLINE;
-
-template <bool is_range> REQUIRES_SHARED(Locks::mutator_lock_)
-static inline bool DoCallTransform(ArtMethod* called_method,
- Handle<mirror::MethodType> callsite_type,
- Handle<mirror::MethodType> callee_type,
- Thread* self,
- ShadowFrame& shadow_frame,
- Handle<mirror::MethodHandleImpl> receiver,
- JValue* result,
- uint32_t (&arg)[Instruction::kMaxVarArgRegs],
- uint32_t vregC) ALWAYS_INLINE;
-
-REQUIRES_SHARED(Locks::mutator_lock_)
-inline void PerformCall(Thread* self,
- const DexFile::CodeItem* code_item,
- ArtMethod* caller_method,
- const size_t first_dest_reg,
- ShadowFrame* callee_frame,
- JValue* result) ALWAYS_INLINE;
+static ALWAYS_INLINE bool DoCallCommon(ArtMethod* called_method,
+ Thread* self,
+ ShadowFrame& shadow_frame,
+ JValue* result,
+ uint16_t number_of_inputs,
+ uint32_t (&arg)[Instruction::kMaxVarArgRegs],
+ uint32_t vregC) REQUIRES_SHARED(Locks::mutator_lock_);
template <bool is_range>
-REQUIRES_SHARED(Locks::mutator_lock_)
-inline void CopyRegisters(ShadowFrame& caller_frame,
- ShadowFrame* callee_frame,
- const uint32_t (&arg)[Instruction::kMaxVarArgRegs],
- const size_t first_src_reg,
- const size_t first_dest_reg,
- const size_t num_regs) ALWAYS_INLINE;
+static ALWAYS_INLINE bool DoCallPolymorphic(ArtMethod* called_method,
+ Handle<mirror::MethodType> callsite_type,
+ Handle<mirror::MethodType> target_type,
+ Thread* self,
+ ShadowFrame& shadow_frame,
+ JValue* result,
+ uint32_t (&arg)[Instruction::kMaxVarArgRegs],
+ uint32_t vregC,
+ const MethodHandleKind handle_kind)
+ REQUIRES_SHARED(Locks::mutator_lock_);
+
+template <bool is_range>
+static ALWAYS_INLINE bool DoCallTransform(ArtMethod* called_method,
+ Handle<mirror::MethodType> callsite_type,
+ Handle<mirror::MethodType> callee_type,
+ Thread* self,
+ ShadowFrame& shadow_frame,
+ Handle<mirror::MethodHandleImpl> receiver,
+ JValue* result,
+ uint32_t (&arg)[Instruction::kMaxVarArgRegs],
+ uint32_t vregC) REQUIRES_SHARED(Locks::mutator_lock_);
+
+ALWAYS_INLINE void PerformCall(Thread* self,
+ const DexFile::CodeItem* code_item,
+ ArtMethod* caller_method,
+ const size_t first_dest_reg,
+ ShadowFrame* callee_frame,
+ JValue* result) REQUIRES_SHARED(Locks::mutator_lock_);
+
+template <bool is_range>
+ALWAYS_INLINE void CopyRegisters(ShadowFrame& caller_frame,
+ ShadowFrame* callee_frame,
+ const uint32_t (&arg)[Instruction::kMaxVarArgRegs],
+ const size_t first_src_reg,
+ const size_t first_dest_reg,
+ const size_t num_regs) REQUIRES_SHARED(Locks::mutator_lock_);
// END DECLARATIONS.
diff --git a/runtime/method_handles-inl.h b/runtime/method_handles-inl.h
index ff5d2a1..b279a37 100644
--- a/runtime/method_handles-inl.h
+++ b/runtime/method_handles-inl.h
@@ -64,7 +64,6 @@
}
}
-REQUIRES_SHARED(Locks::mutator_lock_)
inline bool ConvertJValue(Handle<mirror::Class> from,
Handle<mirror::Class> to,
const JValue& from_value,
@@ -103,15 +102,21 @@
// First perform a primitive conversion to the unboxed equivalent of the target,
// if necessary. This should be for the rarer cases like (int->Long) etc.
if (UNLIKELY(from_type != type)) {
- if (!ConvertPrimitiveValue(false, from_type, type, from_value, to_value)) {
- return false;
- }
+ if (!ConvertPrimitiveValue(false, from_type, type, from_value, to_value)) {
+ return false;
+ }
} else {
*to_value = from_value;
}
- // Then perform the actual boxing, and then set the reference.
+ // Then perform the actual boxing, and then set the reference. Note that
+ // BoxPrimitive can return null if an OOM occurs.
ObjPtr<mirror::Object> boxed = BoxPrimitive(type, from_value);
+ if (boxed.Ptr() == nullptr) {
+ DCHECK(Thread::Current()->IsExceptionPending());
+ return false;
+ }
+
to_value->SetL(boxed.Ptr());
return true;
} else {
@@ -156,8 +161,6 @@
} else {
setter->Set(getter->Get());
}
-
- continue;
} else {
JValue from_value;
JValue to_value;
diff --git a/runtime/method_handles.h b/runtime/method_handles.h
index 0d3f9f1..06509bf 100644
--- a/runtime/method_handles.h
+++ b/runtime/method_handles.h
@@ -58,11 +58,10 @@
// Performs a single argument conversion from type |from| to a distinct
// type |to|. Returns true on success, false otherwise.
-REQUIRES_SHARED(Locks::mutator_lock_)
-inline bool ConvertJValue(Handle<mirror::Class> from,
+ALWAYS_INLINE bool ConvertJValue(Handle<mirror::Class> from,
Handle<mirror::Class> to,
const JValue& from_value,
- JValue* to_value) ALWAYS_INLINE;
+ JValue* to_value) REQUIRES_SHARED(Locks::mutator_lock_);
// Perform argument conversions between |callsite_type| (the type of the
// incoming arguments) and |callee_type| (the type of the method being
@@ -109,17 +108,16 @@
// up too much space, we can make G / S abstract base classes that are
// overridden by concrete classes.
template <typename G, typename S>
-REQUIRES_SHARED(Locks::mutator_lock_)
bool PerformConversions(Thread* self,
Handle<mirror::ObjectArray<mirror::Class>> from_types,
Handle<mirror::ObjectArray<mirror::Class>> to_types,
G* getter,
S* setter,
- int32_t num_conversions);
+ int32_t num_conversions) REQUIRES_SHARED(Locks::mutator_lock_);
// A convenience wrapper around |PerformConversions|, for the case where
// the setter and getter are both ShadowFrame based.
-template <bool is_range> REQUIRES_SHARED(Locks::mutator_lock_)
+template <bool is_range>
bool ConvertAndCopyArgumentsFromCallerFrame(Thread* self,
Handle<mirror::MethodType> callsite_type,
Handle<mirror::MethodType> callee_type,
@@ -127,7 +125,8 @@
uint32_t first_src_reg,
uint32_t first_dest_reg,
const uint32_t (&arg)[Instruction::kMaxVarArgRegs],
- ShadowFrame* callee_frame);
+ ShadowFrame* callee_frame)
+ REQUIRES_SHARED(Locks::mutator_lock_);
// A convenience class that allows for iteration through a list of
// input argument registers |arg| for non-range invokes or a list of
diff --git a/runtime/mirror/emulated_stack_frame.cc b/runtime/mirror/emulated_stack_frame.cc
index 4ba71ea..861d416 100644
--- a/runtime/mirror/emulated_stack_frame.cc
+++ b/runtime/mirror/emulated_stack_frame.cc
@@ -173,13 +173,22 @@
Handle<mirror::ObjectArray<mirror::Object>> references(hs.NewHandle(
mirror::ObjectArray<mirror::Object>::Alloc(self, array_class, refs_size)));
+ if (references.Get() == nullptr) {
+ DCHECK(self->IsExceptionPending());
+ return nullptr;
+ }
+
Handle<ByteArray> stack_frame(hs.NewHandle(ByteArray::Alloc(self, frame_size)));
+ if (stack_frame.Get() == nullptr) {
+ DCHECK(self->IsExceptionPending());
+ return nullptr;
+ }
// Step 4 : Perform argument conversions (if required).
ShadowFrameGetter<is_range> getter(first_src_reg, arg, caller_frame);
EmulatedStackFrameAccessor setter(references, stack_frame, stack_frame->GetLength());
if (!PerformConversions<ShadowFrameGetter<is_range>, EmulatedStackFrameAccessor>(
- self, from_types, to_types, &getter, &setter, num_method_params)) {
+ self, from_types, to_types, &getter, &setter, num_method_params)) {
return nullptr;
}