blob: f94923e0650a17eced49ad7594989d64179088c0 [file] [log] [blame]
Sebastien Hertzd45a1f52014-01-09 14:56:54 +01001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Sebastien Hertzfd3077e2014-04-23 10:32:43 +020017#include "quick_exception_handler.h"
18
Ian Rogerse63db272014-07-15 15:36:11 -070019#include "arch/context.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070020#include "art_method-inl.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070021#include "base/enums.h"
Andreas Gampee2abbc62017-09-15 11:59:26 -070022#include "dex_file_types.h"
Ian Rogers5cf98192014-05-29 21:31:50 -070023#include "dex_instruction.h"
Sebastien Hertzfd3077e2014-04-23 10:32:43 +020024#include "entrypoints/entrypoint_utils.h"
Andreas Gampe639bdd12015-06-03 11:22:45 -070025#include "entrypoints/quick/quick_entrypoints_enum.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070026#include "entrypoints/runtime_asm_entrypoints.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070027#include "handle_scope-inl.h"
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +000028#include "jit/jit.h"
29#include "jit/jit_code_cache.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070030#include "mirror/class-inl.h"
31#include "mirror/class_loader.h"
32#include "mirror/throwable.h"
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +010033#include "oat_quick_method_header.h"
Vladimir Marko3a21e382016-09-02 12:38:38 +010034#include "stack.h"
Nicolas Geoffray6bc43742015-10-12 18:11:10 +010035#include "stack_map.h"
Sebastien Hertzd45a1f52014-01-09 14:56:54 +010036
37namespace art {
38
Ian Rogers5cf98192014-05-29 21:31:50 -070039static constexpr bool kDebugExceptionDelivery = false;
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -070040static constexpr size_t kInvalidFrameDepth = 0xffffffff;
Ian Rogers5cf98192014-05-29 21:31:50 -070041
Sebastien Hertzfd3077e2014-04-23 10:32:43 +020042QuickExceptionHandler::QuickExceptionHandler(Thread* self, bool is_deoptimization)
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +010043 : self_(self),
44 context_(self->GetLongJumpContext()),
45 is_deoptimization_(is_deoptimization),
46 method_tracing_active_(is_deoptimization ||
47 Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()),
48 handler_quick_frame_(nullptr),
49 handler_quick_frame_pc_(0),
50 handler_method_header_(nullptr),
51 handler_quick_arg0_(0),
52 handler_method_(nullptr),
53 handler_dex_pc_(0),
54 clear_exception_(false),
Mingyao Yangf711f2c2016-05-23 12:29:39 -070055 handler_frame_depth_(kInvalidFrameDepth),
56 full_fragment_done_(false) {}
Sebastien Hertzd45a1f52014-01-09 14:56:54 +010057
Sebastien Hertz520633b2015-09-08 17:03:36 +020058// Finds catch handler.
Ian Rogers5cf98192014-05-29 21:31:50 -070059class CatchBlockStackVisitor FINAL : public StackVisitor {
60 public:
61 CatchBlockStackVisitor(Thread* self, Context* context, Handle<mirror::Throwable>* exception,
62 QuickExceptionHandler* exception_handler)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -070063 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +010064 : StackVisitor(self, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +010065 exception_(exception),
Ian Rogers5cf98192014-05-29 21:31:50 -070066 exception_handler_(exception_handler) {
67 }
68
Andreas Gampebdf7f1c2016-08-30 16:38:47 -070069 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -070070 ArtMethod* method = GetMethod();
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -070071 exception_handler_->SetHandlerFrameDepth(GetFrameDepth());
Ian Rogers5cf98192014-05-29 21:31:50 -070072 if (method == nullptr) {
73 // This is the upcall, we remember the frame and last pc so that we may long jump to them.
74 exception_handler_->SetHandlerQuickFramePc(GetCurrentQuickFramePc());
75 exception_handler_->SetHandlerQuickFrame(GetCurrentQuickFrame());
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +010076 exception_handler_->SetHandlerMethodHeader(GetCurrentOatQuickMethodHeader());
Ian Rogers5cf98192014-05-29 21:31:50 -070077 uint32_t next_dex_pc;
Mathieu Chartiere401d142015-04-22 13:56:20 -070078 ArtMethod* next_art_method;
Ian Rogers5cf98192014-05-29 21:31:50 -070079 bool has_next = GetNextMethodAndDexPc(&next_art_method, &next_dex_pc);
80 // Report the method that did the down call as the handler.
81 exception_handler_->SetHandlerDexPc(next_dex_pc);
82 exception_handler_->SetHandlerMethod(next_art_method);
83 if (!has_next) {
84 // No next method? Check exception handler is set up for the unhandled exception handler
85 // case.
86 DCHECK_EQ(0U, exception_handler_->GetHandlerDexPc());
87 DCHECK(nullptr == exception_handler_->GetHandlerMethod());
88 }
89 return false; // End stack walk.
90 }
91 if (method->IsRuntimeMethod()) {
92 // Ignore callee save method.
93 DCHECK(method->IsCalleeSaveMethod());
94 return true;
95 }
Mathieu Chartiere401d142015-04-22 13:56:20 -070096 return HandleTryItems(method);
Ian Rogers5cf98192014-05-29 21:31:50 -070097 }
98
99 private:
Mathieu Chartiere401d142015-04-22 13:56:20 -0700100 bool HandleTryItems(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700101 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampee2abbc62017-09-15 11:59:26 -0700102 uint32_t dex_pc = dex::kDexNoIndex;
Ian Rogers5cf98192014-05-29 21:31:50 -0700103 if (!method->IsNative()) {
104 dex_pc = GetDexPc();
105 }
Andreas Gampee2abbc62017-09-15 11:59:26 -0700106 if (dex_pc != dex::kDexNoIndex) {
Ian Rogers5cf98192014-05-29 21:31:50 -0700107 bool clear_exception = false;
Sebastien Hertz26f72862015-09-15 09:52:07 +0200108 StackHandleScope<1> hs(GetThread());
Ian Rogers5cf98192014-05-29 21:31:50 -0700109 Handle<mirror::Class> to_find(hs.NewHandle((*exception_)->GetClass()));
Mathieu Chartiere401d142015-04-22 13:56:20 -0700110 uint32_t found_dex_pc = method->FindCatchBlock(to_find, dex_pc, &clear_exception);
Ian Rogers5cf98192014-05-29 21:31:50 -0700111 exception_handler_->SetClearException(clear_exception);
Andreas Gampee2abbc62017-09-15 11:59:26 -0700112 if (found_dex_pc != dex::kDexNoIndex) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700113 exception_handler_->SetHandlerMethod(method);
Ian Rogers5cf98192014-05-29 21:31:50 -0700114 exception_handler_->SetHandlerDexPc(found_dex_pc);
David Brazdil72f7b882015-09-15 17:00:52 +0100115 exception_handler_->SetHandlerQuickFramePc(
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100116 GetCurrentOatQuickMethodHeader()->ToNativeQuickPc(
117 method, found_dex_pc, /* is_catch_handler */ true));
Ian Rogers5cf98192014-05-29 21:31:50 -0700118 exception_handler_->SetHandlerQuickFrame(GetCurrentQuickFrame());
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100119 exception_handler_->SetHandlerMethodHeader(GetCurrentOatQuickMethodHeader());
Ian Rogers5cf98192014-05-29 21:31:50 -0700120 return false; // End stack walk.
Mingyao Yang99170c62015-07-06 11:10:37 -0700121 } else if (UNLIKELY(GetThread()->HasDebuggerShadowFrames())) {
122 // We are going to unwind this frame. Did we prepare a shadow frame for debugging?
123 size_t frame_id = GetFrameId();
124 ShadowFrame* frame = GetThread()->FindDebuggerShadowFrame(frame_id);
125 if (frame != nullptr) {
126 // We will not execute this shadow frame so we can safely deallocate it.
127 GetThread()->RemoveDebuggerShadowFrameMapping(frame_id);
128 ShadowFrame::DeleteDeoptimizedFrame(frame);
129 }
Ian Rogers5cf98192014-05-29 21:31:50 -0700130 }
131 }
132 return true; // Continue stack walk.
133 }
134
Ian Rogers5cf98192014-05-29 21:31:50 -0700135 // The exception we're looking for the catch block of.
136 Handle<mirror::Throwable>* exception_;
137 // The quick exception handler we're visiting for.
138 QuickExceptionHandler* const exception_handler_;
139
140 DISALLOW_COPY_AND_ASSIGN(CatchBlockStackVisitor);
141};
142
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800143void QuickExceptionHandler::FindCatch(ObjPtr<mirror::Throwable> exception) {
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200144 DCHECK(!is_deoptimization_);
Ian Rogers5cf98192014-05-29 21:31:50 -0700145 if (kDebugExceptionDelivery) {
146 mirror::String* msg = exception->GetDetailMessage();
147 std::string str_msg(msg != nullptr ? msg->ToModifiedUtf8() : "");
David Sehr709b0702016-10-13 09:12:37 -0700148 self_->DumpStack(LOG_STREAM(INFO) << "Delivering exception: " << exception->PrettyTypeOf()
Ian Rogers5cf98192014-05-29 21:31:50 -0700149 << ": " << str_msg << "\n");
150 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700151 StackHandleScope<1> hs(self_);
152 Handle<mirror::Throwable> exception_ref(hs.NewHandle(exception));
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200153
Sebastien Hertz520633b2015-09-08 17:03:36 +0200154 // Walk the stack to find catch handler.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700155 CatchBlockStackVisitor visitor(self_, context_, &exception_ref, this);
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100156 visitor.WalkStack(true);
157
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200158 if (kDebugExceptionDelivery) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700159 if (*handler_quick_frame_ == nullptr) {
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100160 LOG(INFO) << "Handler is upcall";
Ian Rogers5cf98192014-05-29 21:31:50 -0700161 }
162 if (handler_method_ != nullptr) {
David Sehr9323e6e2016-09-13 08:58:35 -0700163 const DexFile* dex_file = handler_method_->GetDeclaringClass()->GetDexCache()->GetDexFile();
164 int line_number = annotations::GetLineNumFromPC(dex_file, handler_method_, handler_dex_pc_);
David Sehr709b0702016-10-13 09:12:37 -0700165 LOG(INFO) << "Handler: " << handler_method_->PrettyMethod() << " (line: "
166 << line_number << ")";
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100167 }
168 }
Roland Levillainb77b6982017-06-08 18:03:48 +0100169 // Exception was cleared as part of delivery.
170 DCHECK(!self_->IsExceptionPending());
171 if (!clear_exception_) {
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100172 // Put exception back in root set with clear throw location.
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000173 self_->SetException(exception_ref.Get());
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100174 }
David Brazdil77a48ae2015-09-15 12:34:04 +0000175 // If the handler is in optimized code, we need to set the catch environment.
176 if (*handler_quick_frame_ != nullptr &&
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100177 handler_method_header_ != nullptr &&
178 handler_method_header_->IsOptimized()) {
David Brazdil77a48ae2015-09-15 12:34:04 +0000179 SetCatchEnvironmentForOptimizedHandler(&visitor);
180 }
181}
182
183static VRegKind ToVRegKind(DexRegisterLocation::Kind kind) {
184 // Slightly hacky since we cannot map DexRegisterLocationKind and VRegKind
185 // one to one. However, StackVisitor::GetVRegFromOptimizedCode only needs to
186 // distinguish between core/FPU registers and low/high bits on 64-bit.
187 switch (kind) {
188 case DexRegisterLocation::Kind::kConstant:
189 case DexRegisterLocation::Kind::kInStack:
190 // VRegKind is ignored.
191 return VRegKind::kUndefined;
192
193 case DexRegisterLocation::Kind::kInRegister:
194 // Selects core register. For 64-bit registers, selects low 32 bits.
195 return VRegKind::kLongLoVReg;
196
197 case DexRegisterLocation::Kind::kInRegisterHigh:
198 // Selects core register. For 64-bit registers, selects high 32 bits.
199 return VRegKind::kLongHiVReg;
200
201 case DexRegisterLocation::Kind::kInFpuRegister:
202 // Selects FPU register. For 64-bit registers, selects low 32 bits.
203 return VRegKind::kDoubleLoVReg;
204
205 case DexRegisterLocation::Kind::kInFpuRegisterHigh:
206 // Selects FPU register. For 64-bit registers, selects high 32 bits.
207 return VRegKind::kDoubleHiVReg;
208
209 default:
David Srbecky7dc11782016-02-25 13:23:56 +0000210 LOG(FATAL) << "Unexpected vreg location " << kind;
David Brazdil77a48ae2015-09-15 12:34:04 +0000211 UNREACHABLE();
212 }
213}
214
215void QuickExceptionHandler::SetCatchEnvironmentForOptimizedHandler(StackVisitor* stack_visitor) {
216 DCHECK(!is_deoptimization_);
217 DCHECK(*handler_quick_frame_ != nullptr) << "Method should not be called on upcall exceptions";
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100218 DCHECK(handler_method_ != nullptr && handler_method_header_->IsOptimized());
David Brazdil77a48ae2015-09-15 12:34:04 +0000219
220 if (kDebugExceptionDelivery) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700221 self_->DumpStack(LOG_STREAM(INFO) << "Setting catch phis: ");
David Brazdil77a48ae2015-09-15 12:34:04 +0000222 }
223
224 const size_t number_of_vregs = handler_method_->GetCodeItem()->registers_size_;
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +0100225 CodeInfo code_info = handler_method_header_->GetOptimizedCodeInfo();
David Srbecky09ed0982016-02-12 21:58:43 +0000226 CodeInfoEncoding encoding = code_info.ExtractEncoding();
David Brazdil77a48ae2015-09-15 12:34:04 +0000227
Nicolas Geoffray012fc4e2016-01-08 15:58:19 +0000228 // Find stack map of the catch block.
229 StackMap catch_stack_map = code_info.GetCatchStackMapForDexPc(GetHandlerDexPc(), encoding);
230 DCHECK(catch_stack_map.IsValid());
231 DexRegisterMap catch_vreg_map =
232 code_info.GetDexRegisterMapOf(catch_stack_map, encoding, number_of_vregs);
233 if (!catch_vreg_map.IsValid()) {
234 return;
235 }
236
David Brazdil77a48ae2015-09-15 12:34:04 +0000237 // Find stack map of the throwing instruction.
238 StackMap throw_stack_map =
239 code_info.GetStackMapForNativePcOffset(stack_visitor->GetNativePcOffset(), encoding);
240 DCHECK(throw_stack_map.IsValid());
241 DexRegisterMap throw_vreg_map =
242 code_info.GetDexRegisterMapOf(throw_stack_map, encoding, number_of_vregs);
Nicolas Geoffray012fc4e2016-01-08 15:58:19 +0000243 DCHECK(throw_vreg_map.IsValid());
David Brazdil77a48ae2015-09-15 12:34:04 +0000244
245 // Copy values between them.
246 for (uint16_t vreg = 0; vreg < number_of_vregs; ++vreg) {
247 DexRegisterLocation::Kind catch_location =
248 catch_vreg_map.GetLocationKind(vreg, number_of_vregs, code_info, encoding);
249 if (catch_location == DexRegisterLocation::Kind::kNone) {
250 continue;
251 }
252 DCHECK(catch_location == DexRegisterLocation::Kind::kInStack);
253
254 // Get vreg value from its current location.
255 uint32_t vreg_value;
256 VRegKind vreg_kind = ToVRegKind(throw_vreg_map.GetLocationKind(vreg,
257 number_of_vregs,
258 code_info,
259 encoding));
260 bool get_vreg_success = stack_visitor->GetVReg(stack_visitor->GetMethod(),
261 vreg,
262 vreg_kind,
263 &vreg_value);
264 CHECK(get_vreg_success) << "VReg " << vreg << " was optimized out ("
David Sehr709b0702016-10-13 09:12:37 -0700265 << "method=" << ArtMethod::PrettyMethod(stack_visitor->GetMethod())
266 << ", dex_pc=" << stack_visitor->GetDexPc() << ", "
David Brazdil77a48ae2015-09-15 12:34:04 +0000267 << "native_pc_offset=" << stack_visitor->GetNativePcOffset() << ")";
268
269 // Copy value to the catch phi's stack slot.
270 int32_t slot_offset = catch_vreg_map.GetStackOffsetInBytes(vreg,
271 number_of_vregs,
272 code_info,
273 encoding);
274 ArtMethod** frame_top = stack_visitor->GetCurrentQuickFrame();
275 uint8_t* slot_address = reinterpret_cast<uint8_t*>(frame_top) + slot_offset;
276 uint32_t* slot_ptr = reinterpret_cast<uint32_t*>(slot_address);
277 *slot_ptr = vreg_value;
278 }
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200279}
280
Ian Rogers5cf98192014-05-29 21:31:50 -0700281// Prepares deoptimization.
282class DeoptimizeStackVisitor FINAL : public StackVisitor {
283 public:
Andreas Gampe639bdd12015-06-03 11:22:45 -0700284 DeoptimizeStackVisitor(Thread* self,
285 Context* context,
286 QuickExceptionHandler* exception_handler,
287 bool single_frame)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700288 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +0100289 : StackVisitor(self, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +0100290 exception_handler_(exception_handler),
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700291 prev_shadow_frame_(nullptr),
Andreas Gampe639bdd12015-06-03 11:22:45 -0700292 stacked_shadow_frame_pushed_(false),
293 single_frame_deopt_(single_frame),
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100294 single_frame_done_(false),
Nicolas Geoffrayb52de242016-02-19 12:43:12 +0000295 single_frame_deopt_method_(nullptr),
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700296 single_frame_deopt_quick_method_header_(nullptr),
297 callee_method_(nullptr) {
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100298 }
299
300 ArtMethod* GetSingleFrameDeoptMethod() const {
301 return single_frame_deopt_method_;
Ian Rogers5cf98192014-05-29 21:31:50 -0700302 }
303
Nicolas Geoffrayb52de242016-02-19 12:43:12 +0000304 const OatQuickMethodHeader* GetSingleFrameDeoptQuickMethodHeader() const {
305 return single_frame_deopt_quick_method_header_;
306 }
307
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700308 void FinishStackWalk() REQUIRES_SHARED(Locks::mutator_lock_) {
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700309 // This is the upcall, or the next full frame in single-frame deopt, or the
310 // code isn't deoptimizeable. We remember the frame and last pc so that we
311 // may long jump to them.
312 exception_handler_->SetHandlerQuickFramePc(GetCurrentQuickFramePc());
313 exception_handler_->SetHandlerQuickFrame(GetCurrentQuickFrame());
314 exception_handler_->SetHandlerMethodHeader(GetCurrentOatQuickMethodHeader());
315 if (!stacked_shadow_frame_pushed_) {
316 // In case there is no deoptimized shadow frame for this upcall, we still
317 // need to push a nullptr to the stack since there is always a matching pop after
318 // the long jump.
319 GetThread()->PushStackedShadowFrame(nullptr,
320 StackedShadowFrameType::kDeoptimizationShadowFrame);
321 stacked_shadow_frame_pushed_ = true;
322 }
323 if (GetMethod() == nullptr) {
324 exception_handler_->SetFullFragmentDone(true);
325 } else {
David Sehr709b0702016-10-13 09:12:37 -0700326 CHECK(callee_method_ != nullptr) << GetMethod()->PrettyMethod(false);
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700327 exception_handler_->SetHandlerQuickArg0(reinterpret_cast<uintptr_t>(callee_method_));
328 }
329 }
330
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700331 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -0700332 exception_handler_->SetHandlerFrameDepth(GetFrameDepth());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700333 ArtMethod* method = GetMethod();
Andreas Gampe639bdd12015-06-03 11:22:45 -0700334 if (method == nullptr || single_frame_done_) {
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700335 FinishStackWalk();
Ian Rogers5cf98192014-05-29 21:31:50 -0700336 return false; // End stack walk.
337 } else if (method->IsRuntimeMethod()) {
338 // Ignore callee save method.
339 DCHECK(method->IsCalleeSaveMethod());
340 return true;
Sebastien Hertz520633b2015-09-08 17:03:36 +0200341 } else if (method->IsNative()) {
342 // If we return from JNI with a pending exception and want to deoptimize, we need to skip
343 // the native method.
344 // The top method is a runtime method, the native method comes next.
345 CHECK_EQ(GetFrameDepth(), 1U);
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700346 callee_method_ = method;
Sebastien Hertz520633b2015-09-08 17:03:36 +0200347 return true;
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700348 } else if (!single_frame_deopt_ &&
Nicolas Geoffray433b79a2017-01-30 20:54:45 +0000349 !Runtime::Current()->IsAsyncDeoptimizeable(GetCurrentQuickFramePc())) {
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700350 // We hit some code that's not deoptimizeable. However, Single-frame deoptimization triggered
351 // from compiled code is always allowed since HDeoptimize always saves the full environment.
Nicolas Geoffray433b79a2017-01-30 20:54:45 +0000352 LOG(WARNING) << "Got request to deoptimize un-deoptimizable method "
353 << method->PrettyMethod();
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700354 FinishStackWalk();
355 return false; // End stack walk.
Ian Rogers5cf98192014-05-29 21:31:50 -0700356 } else {
Nicolas Geoffray33856502015-10-20 15:52:58 +0100357 // Check if a shadow frame already exists for debugger's set-local-value purpose.
358 const size_t frame_id = GetFrameId();
359 ShadowFrame* new_frame = GetThread()->FindDebuggerShadowFrame(frame_id);
360 const bool* updated_vregs;
361 const size_t num_regs = method->GetCodeItem()->registers_size_;
362 if (new_frame == nullptr) {
363 new_frame = ShadowFrame::CreateDeoptimizedFrame(num_regs, nullptr, method, GetDexPc());
364 updated_vregs = nullptr;
365 } else {
366 updated_vregs = GetThread()->GetUpdatedVRegFlags(frame_id);
367 DCHECK(updated_vregs != nullptr);
368 }
Andreas Gampebf9611f2016-03-25 16:58:00 -0700369 HandleOptimizingDeoptimization(method, new_frame, updated_vregs);
Nicolas Geoffray33856502015-10-20 15:52:58 +0100370 if (updated_vregs != nullptr) {
371 // Calling Thread::RemoveDebuggerShadowFrameMapping will also delete the updated_vregs
372 // array so this must come after we processed the frame.
373 GetThread()->RemoveDebuggerShadowFrameMapping(frame_id);
374 DCHECK(GetThread()->FindDebuggerShadowFrame(frame_id) == nullptr);
375 }
376 if (prev_shadow_frame_ != nullptr) {
377 prev_shadow_frame_->SetLink(new_frame);
378 } else {
379 // Will be popped after the long jump after DeoptimizeStack(),
380 // right before interpreter::EnterInterpreterFromDeoptimize().
381 stacked_shadow_frame_pushed_ = true;
382 GetThread()->PushStackedShadowFrame(
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700383 new_frame, StackedShadowFrameType::kDeoptimizationShadowFrame);
Nicolas Geoffray33856502015-10-20 15:52:58 +0100384 }
385 prev_shadow_frame_ = new_frame;
386
Andreas Gampe639bdd12015-06-03 11:22:45 -0700387 if (single_frame_deopt_ && !IsInInlinedFrame()) {
388 // Single-frame deopt ends at the first non-inlined frame and needs to store that method.
Andreas Gampe639bdd12015-06-03 11:22:45 -0700389 single_frame_done_ = true;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100390 single_frame_deopt_method_ = method;
Nicolas Geoffrayb52de242016-02-19 12:43:12 +0000391 single_frame_deopt_quick_method_header_ = GetCurrentOatQuickMethodHeader();
Andreas Gampe639bdd12015-06-03 11:22:45 -0700392 }
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700393 callee_method_ = method;
Andreas Gampe639bdd12015-06-03 11:22:45 -0700394 return true;
Ian Rogers5cf98192014-05-29 21:31:50 -0700395 }
396 }
397
398 private:
Nicolas Geoffray33856502015-10-20 15:52:58 +0100399 void HandleOptimizingDeoptimization(ArtMethod* m,
400 ShadowFrame* new_frame,
401 const bool* updated_vregs)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700402 REQUIRES_SHARED(Locks::mutator_lock_) {
Nicolas Geoffray33856502015-10-20 15:52:58 +0100403 const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
404 CodeInfo code_info = method_header->GetOptimizedCodeInfo();
405 uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
David Srbecky09ed0982016-02-12 21:58:43 +0000406 CodeInfoEncoding encoding = code_info.ExtractEncoding();
Nicolas Geoffray33856502015-10-20 15:52:58 +0100407 StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
408 const size_t number_of_vregs = m->GetCodeItem()->registers_size_;
Mathieu Chartier1a20b682017-01-31 14:25:16 -0800409 uint32_t register_mask = code_info.GetRegisterMaskOf(encoding, stack_map);
David Srbecky45aa5982016-03-18 02:15:09 +0000410 BitMemoryRegion stack_mask = code_info.GetStackMaskOf(encoding, stack_map);
David Brazdilefc3f022015-10-28 12:19:06 -0500411 DexRegisterMap vreg_map = IsInInlinedFrame()
412 ? code_info.GetDexRegisterMapAtDepth(GetCurrentInliningDepth() - 1,
413 code_info.GetInlineInfoOf(stack_map, encoding),
414 encoding,
415 number_of_vregs)
416 : code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_vregs);
Nicolas Geoffray33856502015-10-20 15:52:58 +0100417
Nicolas Geoffray012fc4e2016-01-08 15:58:19 +0000418 if (!vreg_map.IsValid()) {
419 return;
420 }
421
Nicolas Geoffray33856502015-10-20 15:52:58 +0100422 for (uint16_t vreg = 0; vreg < number_of_vregs; ++vreg) {
423 if (updated_vregs != nullptr && updated_vregs[vreg]) {
424 // Keep the value set by debugger.
425 continue;
426 }
427
428 DexRegisterLocation::Kind location =
429 vreg_map.GetLocationKind(vreg, number_of_vregs, code_info, encoding);
430 static constexpr uint32_t kDeadValue = 0xEBADDE09;
431 uint32_t value = kDeadValue;
432 bool is_reference = false;
433
434 switch (location) {
435 case DexRegisterLocation::Kind::kInStack: {
436 const int32_t offset = vreg_map.GetStackOffsetInBytes(vreg,
437 number_of_vregs,
438 code_info,
439 encoding);
440 const uint8_t* addr = reinterpret_cast<const uint8_t*>(GetCurrentQuickFrame()) + offset;
441 value = *reinterpret_cast<const uint32_t*>(addr);
442 uint32_t bit = (offset >> 2);
Mathieu Chartier575d3e62017-02-06 11:00:40 -0800443 if (bit < encoding.stack_mask.encoding.BitSize() && stack_mask.LoadBit(bit)) {
Nicolas Geoffray33856502015-10-20 15:52:58 +0100444 is_reference = true;
445 }
446 break;
447 }
448 case DexRegisterLocation::Kind::kInRegister:
449 case DexRegisterLocation::Kind::kInRegisterHigh:
450 case DexRegisterLocation::Kind::kInFpuRegister:
451 case DexRegisterLocation::Kind::kInFpuRegisterHigh: {
452 uint32_t reg = vreg_map.GetMachineRegister(vreg, number_of_vregs, code_info, encoding);
453 bool result = GetRegisterIfAccessible(reg, ToVRegKind(location), &value);
454 CHECK(result);
455 if (location == DexRegisterLocation::Kind::kInRegister) {
456 if (((1u << reg) & register_mask) != 0) {
457 is_reference = true;
458 }
459 }
460 break;
461 }
462 case DexRegisterLocation::Kind::kConstant: {
463 value = vreg_map.GetConstant(vreg, number_of_vregs, code_info, encoding);
464 if (value == 0) {
465 // Make it a reference for extra safety.
466 is_reference = true;
467 }
468 break;
469 }
470 case DexRegisterLocation::Kind::kNone: {
471 break;
472 }
473 default: {
474 LOG(FATAL)
David Srbecky7dc11782016-02-25 13:23:56 +0000475 << "Unexpected location kind "
476 << vreg_map.GetLocationInternalKind(vreg,
477 number_of_vregs,
478 code_info,
479 encoding);
Nicolas Geoffray33856502015-10-20 15:52:58 +0100480 UNREACHABLE();
481 }
482 }
483 if (is_reference) {
484 new_frame->SetVRegReference(vreg, reinterpret_cast<mirror::Object*>(value));
485 } else {
486 new_frame->SetVReg(vreg, value);
487 }
488 }
489 }
490
Sebastien Hertzc901dd72014-07-16 11:56:07 +0200491 static VRegKind GetVRegKind(uint16_t reg, const std::vector<int32_t>& kinds) {
492 return static_cast<VRegKind>(kinds.at(reg * 2));
493 }
494
Ian Rogers5cf98192014-05-29 21:31:50 -0700495 QuickExceptionHandler* const exception_handler_;
496 ShadowFrame* prev_shadow_frame_;
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700497 bool stacked_shadow_frame_pushed_;
Andreas Gampe639bdd12015-06-03 11:22:45 -0700498 const bool single_frame_deopt_;
499 bool single_frame_done_;
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100500 ArtMethod* single_frame_deopt_method_;
Nicolas Geoffrayb52de242016-02-19 12:43:12 +0000501 const OatQuickMethodHeader* single_frame_deopt_quick_method_header_;
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700502 ArtMethod* callee_method_;
Ian Rogers5cf98192014-05-29 21:31:50 -0700503
504 DISALLOW_COPY_AND_ASSIGN(DeoptimizeStackVisitor);
505};
506
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700507void QuickExceptionHandler::PrepareForLongJumpToInvokeStubOrInterpreterBridge() {
508 if (full_fragment_done_) {
509 // Restore deoptimization exception. When returning from the invoke stub,
510 // ArtMethod::Invoke() will see the special exception to know deoptimization
511 // is needed.
512 self_->SetException(Thread::GetDeoptimizationException());
513 } else {
514 // PC needs to be of the quick-to-interpreter bridge.
515 int32_t offset;
Andreas Gampe542451c2016-07-26 09:02:02 -0700516 offset = GetThreadOffset<kRuntimePointerSize>(kQuickQuickToInterpreterBridge).Int32Value();
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700517 handler_quick_frame_pc_ = *reinterpret_cast<uintptr_t*>(
518 reinterpret_cast<uint8_t*>(self_) + offset);
519 }
520}
521
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200522void QuickExceptionHandler::DeoptimizeStack() {
523 DCHECK(is_deoptimization_);
Ian Rogers5cf98192014-05-29 21:31:50 -0700524 if (kDebugExceptionDelivery) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700525 self_->DumpStack(LOG_STREAM(INFO) << "Deoptimizing: ");
Ian Rogers5cf98192014-05-29 21:31:50 -0700526 }
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200527
Andreas Gampe639bdd12015-06-03 11:22:45 -0700528 DeoptimizeStackVisitor visitor(self_, context_, this, false);
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200529 visitor.WalkStack(true);
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700530 PrepareForLongJumpToInvokeStubOrInterpreterBridge();
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100531}
532
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +0100533void QuickExceptionHandler::DeoptimizeSingleFrame(DeoptimizationKind kind) {
Andreas Gampe639bdd12015-06-03 11:22:45 -0700534 DCHECK(is_deoptimization_);
535
Andreas Gampe639bdd12015-06-03 11:22:45 -0700536 DeoptimizeStackVisitor visitor(self_, context_, this, true);
537 visitor.WalkStack(true);
538
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +0000539 // Compiled code made an explicit deoptimization.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100540 ArtMethod* deopt_method = visitor.GetSingleFrameDeoptMethod();
541 DCHECK(deopt_method != nullptr);
Nicolas Geoffray646d6382017-08-09 10:50:00 +0100542 if (VLOG_IS_ON(deopt) || kDebugExceptionDelivery) {
543 LOG(INFO) << "Single-frame deopting: "
544 << deopt_method->PrettyMethod()
545 << " due to "
546 << GetDeoptimizationKindName(kind);
547 DumpFramesWithType(self_, /* details */ true);
548 }
Calin Juravleffc87072016-04-20 14:22:09 +0100549 if (Runtime::Current()->UseJitCompilation()) {
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +0000550 Runtime::Current()->GetJit()->GetCodeCache()->InvalidateCompiledCodeFor(
Nicolas Geoffrayb52de242016-02-19 12:43:12 +0000551 deopt_method, visitor.GetSingleFrameDeoptQuickMethodHeader());
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +0000552 } else {
553 // Transfer the code to interpreter.
554 Runtime::Current()->GetInstrumentation()->UpdateMethodsCode(
555 deopt_method, GetQuickToInterpreterBridge());
556 }
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100557
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700558 PrepareForLongJumpToInvokeStubOrInterpreterBridge();
Andreas Gampe639bdd12015-06-03 11:22:45 -0700559}
560
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700561void QuickExceptionHandler::DeoptimizePartialFragmentFixup(uintptr_t return_pc) {
562 // At this point, the instrumentation stack has been updated. We need to install
563 // the real return pc on stack, in case instrumentation stub is stored there,
564 // so that the interpreter bridge code can return to the right place.
565 if (return_pc != 0) {
566 uintptr_t* pc_addr = reinterpret_cast<uintptr_t*>(handler_quick_frame_);
567 CHECK(pc_addr != nullptr);
568 pc_addr--;
569 *reinterpret_cast<uintptr_t*>(pc_addr) = return_pc;
570 }
Andreas Gampe639bdd12015-06-03 11:22:45 -0700571
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700572 // Architecture-dependent work. This is to get the LR right for x86 and x86-64.
Andreas Gampe639bdd12015-06-03 11:22:45 -0700573 if (kRuntimeISA == InstructionSet::kX86 || kRuntimeISA == InstructionSet::kX86_64) {
574 // On x86, the return address is on the stack, so just reuse it. Otherwise we would have to
575 // change how longjump works.
576 handler_quick_frame_ = reinterpret_cast<ArtMethod**>(
577 reinterpret_cast<uintptr_t>(handler_quick_frame_) - sizeof(void*));
578 }
579}
580
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100581// Unwinds all instrumentation stack frame prior to catch handler or upcall.
582class InstrumentationStackVisitor : public StackVisitor {
583 public:
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700584 InstrumentationStackVisitor(Thread* self, size_t frame_depth)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700585 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +0100586 : StackVisitor(self, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
Ian Rogerscf7f1912014-10-22 22:06:39 -0700587 frame_depth_(frame_depth),
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100588 instrumentation_frames_to_pop_(0) {
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -0700589 CHECK_NE(frame_depth_, kInvalidFrameDepth);
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100590 }
591
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700592 bool VisitFrame() REQUIRES_SHARED(Locks::mutator_lock_) {
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -0700593 size_t current_frame_depth = GetFrameDepth();
594 if (current_frame_depth < frame_depth_) {
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100595 CHECK(GetMethod() != nullptr);
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700596 if (UNLIKELY(reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()) == GetReturnPc())) {
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +0100597 if (!IsInInlinedFrame()) {
598 // We do not count inlined frames, because we do not instrument them. The reason we
599 // include them in the stack walking is the check against `frame_depth_`, which is
600 // given to us by a visitor that visits inlined frames.
601 ++instrumentation_frames_to_pop_;
602 }
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100603 }
604 return true;
605 } else {
606 // We reached the frame of the catch handler or the upcall.
607 return false;
608 }
609 }
610
611 size_t GetInstrumentationFramesToPop() const {
612 return instrumentation_frames_to_pop_;
613 }
614
615 private:
Hiroshi Yamauchi649278c2014-08-13 11:12:22 -0700616 const size_t frame_depth_;
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100617 size_t instrumentation_frames_to_pop_;
618
619 DISALLOW_COPY_AND_ASSIGN(InstrumentationStackVisitor);
620};
621
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700622uintptr_t QuickExceptionHandler::UpdateInstrumentationStack() {
623 uintptr_t return_pc = 0;
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100624 if (method_tracing_active_) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700625 InstrumentationStackVisitor visitor(self_, handler_frame_depth_);
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100626 visitor.WalkStack(true);
627
628 size_t instrumentation_frames_to_pop = visitor.GetInstrumentationFramesToPop();
629 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
630 for (size_t i = 0; i < instrumentation_frames_to_pop; ++i) {
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700631 return_pc = instrumentation->PopMethodForUnwind(self_, is_deoptimization_);
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100632 }
633 }
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700634 return return_pc;
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100635}
636
Andreas Gampe639bdd12015-06-03 11:22:45 -0700637void QuickExceptionHandler::DoLongJump(bool smash_caller_saves) {
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100638 // Place context back on thread so it will be available when we continue.
639 self_->ReleaseLongJumpContext(context_);
640 context_->SetSP(reinterpret_cast<uintptr_t>(handler_quick_frame_));
641 CHECK_NE(handler_quick_frame_pc_, 0u);
642 context_->SetPC(handler_quick_frame_pc_);
Andreas Gampe639bdd12015-06-03 11:22:45 -0700643 context_->SetArg0(handler_quick_arg0_);
644 if (smash_caller_saves) {
645 context_->SmashCallerSaves();
646 }
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100647 context_->DoLongJump();
Andreas Gampe794ad762015-02-23 08:12:24 -0800648 UNREACHABLE();
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100649}
650
Andreas Gampe639bdd12015-06-03 11:22:45 -0700651// Prints out methods with their type of frame.
652class DumpFramesWithTypeStackVisitor FINAL : public StackVisitor {
653 public:
Chih-Hung Hsieh471118e2016-04-29 14:27:41 -0700654 explicit DumpFramesWithTypeStackVisitor(Thread* self, bool show_details = false)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700655 REQUIRES_SHARED(Locks::mutator_lock_)
Andreas Gampe639bdd12015-06-03 11:22:45 -0700656 : StackVisitor(self, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
657 show_details_(show_details) {}
658
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700659 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe639bdd12015-06-03 11:22:45 -0700660 ArtMethod* method = GetMethod();
661 if (show_details_) {
662 LOG(INFO) << "|> pc = " << std::hex << GetCurrentQuickFramePc();
663 LOG(INFO) << "|> addr = " << std::hex << reinterpret_cast<uintptr_t>(GetCurrentQuickFrame());
664 if (GetCurrentQuickFrame() != nullptr && method != nullptr) {
665 LOG(INFO) << "|> ret = " << std::hex << GetReturnPc();
666 }
667 }
668 if (method == nullptr) {
669 // Transition, do go on, we want to unwind over bridges, all the way.
670 if (show_details_) {
671 LOG(INFO) << "N <transition>";
672 }
673 return true;
674 } else if (method->IsRuntimeMethod()) {
675 if (show_details_) {
David Sehr709b0702016-10-13 09:12:37 -0700676 LOG(INFO) << "R " << method->PrettyMethod(true);
Andreas Gampe639bdd12015-06-03 11:22:45 -0700677 }
678 return true;
679 } else {
680 bool is_shadow = GetCurrentShadowFrame() != nullptr;
681 LOG(INFO) << (is_shadow ? "S" : "Q")
682 << ((!is_shadow && IsInInlinedFrame()) ? "i" : " ")
683 << " "
David Sehr709b0702016-10-13 09:12:37 -0700684 << method->PrettyMethod(true);
Andreas Gampe639bdd12015-06-03 11:22:45 -0700685 return true; // Go on.
686 }
687 }
688
689 private:
690 bool show_details_;
691
692 DISALLOW_COPY_AND_ASSIGN(DumpFramesWithTypeStackVisitor);
693};
694
695void QuickExceptionHandler::DumpFramesWithType(Thread* self, bool details) {
696 DumpFramesWithTypeStackVisitor visitor(self, details);
697 visitor.WalkStack(true);
698}
699
Sebastien Hertzd45a1f52014-01-09 14:56:54 +0100700} // namespace art