blob: 87031fc28ad31d57782264d622b173cc0673f48f [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 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 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
Mathieu Chartierc645f1d2014-03-06 18:11:53 -080017#include "method_verifier-inl.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070018
Elliott Hughes1f359b02011-07-17 14:27:17 -070019#include <iostream>
20
Andreas Gampe46ee31b2016-12-14 10:11:49 -080021#include "android-base/stringprintf.h"
22
Mathieu Chartierc7853442015-03-27 14:35:38 -070023#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070024#include "art_method-inl.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070025#include "base/enums.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080026#include "base/logging.h"
Ian Rogers637c65b2013-05-31 11:46:00 -070027#include "base/mutex-inl.h"
Vladimir Marko637ee0b2015-09-04 12:47:41 +010028#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080029#include "base/systrace.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010030#include "base/time_utils.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070031#include "class_linker.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000032#include "compiler_callbacks.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070033#include "dex_file-inl.h"
Ian Rogersd0583802013-06-01 10:51:46 -070034#include "dex_instruction-inl.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080035#include "dex_instruction_utils.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070036#include "dex_instruction_visitor.h"
Alex Lighteb7c1442015-08-31 13:17:42 -070037#include "experimental_flags.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070038#include "gc/accounting/card_table-inl.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080039#include "indenter.h"
Ian Rogers84fa0742011-10-25 18:13:30 -070040#include "intern_table.h"
Ian Rogers0571d352011-11-03 19:51:38 -070041#include "leb128.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010042#include "method_resolution_kind.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043#include "mirror/class.h"
44#include "mirror/class-inl.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070045#include "mirror/dex_cache-inl.h"
Orion Hodsoncfa325e2016-10-13 10:25:54 +010046#include "mirror/method_handle_impl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080047#include "mirror/object-inl.h"
48#include "mirror/object_array-inl.h"
Ian Rogers7b078e82014-09-10 14:44:24 -070049#include "reg_type-inl.h"
Ian Rogers39ebcb82013-05-30 16:57:23 -070050#include "register_line-inl.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070051#include "runtime.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070052#include "scoped_thread_state_change-inl.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010053#include "utils.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010054#include "verifier_deps.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070055#include "handle_scope-inl.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070056
57namespace art {
Ian Rogersd81871c2011-10-03 13:57:23 -070058namespace verifier {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070059
Andreas Gampe46ee31b2016-12-14 10:11:49 -080060using android::base::StringPrintf;
61
Mathieu Chartier8e219ae2014-08-19 14:29:46 -070062static constexpr bool kTimeVerifyMethod = !kIsDebugBuild;
Andreas Gampeec6e6c12015-11-05 20:39:56 -080063static constexpr bool kDebugVerify = false;
Anwar Ghuloum75a43f12013-08-13 17:22:14 -070064// TODO: Add a constant to method_verifier to turn on verbose logging?
Ian Rogers2c8a8572011-10-24 17:11:36 -070065
Andreas Gampeebf850c2015-08-14 15:37:35 -070066// On VLOG(verifier), should we dump the whole state when we run into a hard failure?
67static constexpr bool kDumpRegLinesOnHardFailureIfVLOG = true;
68
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -080069// We print a warning blurb about "dx --no-optimize" when we find monitor-locking issues. Make
70// sure we only print this once.
71static bool gPrintedDxMonitorText = false;
72
Mathieu Chartierde40d472015-10-15 17:47:48 -070073PcToRegisterLineTable::PcToRegisterLineTable(ScopedArenaAllocator& arena)
74 : register_lines_(arena.Adapter(kArenaAllocVerifier)) {}
75
Ian Rogers7b3ddd22013-02-21 15:19:52 -080076void PcToRegisterLineTable::Init(RegisterTrackingMode mode, InstructionFlags* flags,
Ian Rogersd81871c2011-10-03 13:57:23 -070077 uint32_t insns_size, uint16_t registers_size,
Ian Rogers776ac1f2012-04-13 23:36:36 -070078 MethodVerifier* verifier) {
Ian Rogersd81871c2011-10-03 13:57:23 -070079 DCHECK_GT(insns_size, 0U);
Mathieu Chartierde40d472015-10-15 17:47:48 -070080 register_lines_.resize(insns_size);
Ian Rogersd81871c2011-10-03 13:57:23 -070081 for (uint32_t i = 0; i < insns_size; i++) {
82 bool interesting = false;
83 switch (mode) {
84 case kTrackRegsAll:
85 interesting = flags[i].IsOpcode();
86 break;
Sameer Abu Asal02c42232013-04-30 12:09:45 -070087 case kTrackCompilerInterestPoints:
Brian Carlstrom02c8cc62013-07-18 15:54:44 -070088 interesting = flags[i].IsCompileTimeInfoPoint() || flags[i].IsBranchTarget();
Ian Rogersd81871c2011-10-03 13:57:23 -070089 break;
90 case kTrackRegsBranches:
91 interesting = flags[i].IsBranchTarget();
92 break;
93 default:
94 break;
95 }
96 if (interesting) {
Mathieu Chartierde40d472015-10-15 17:47:48 -070097 register_lines_[i].reset(RegisterLine::Create(registers_size, verifier));
Ian Rogersd0fbd852013-09-24 18:17:04 -070098 }
99 }
100}
101
Mathieu Chartierde40d472015-10-15 17:47:48 -0700102PcToRegisterLineTable::~PcToRegisterLineTable() {}
Ian Rogersd81871c2011-10-03 13:57:23 -0700103
Andreas Gampe7c038102014-10-27 20:08:46 -0700104// Note: returns true on failure.
105ALWAYS_INLINE static inline bool FailOrAbort(MethodVerifier* verifier, bool condition,
106 const char* error_msg, uint32_t work_insn_idx) {
107 if (kIsDebugBuild) {
Andreas Gampef8f36c22016-11-19 14:51:52 -0800108 // In a debug build, abort if the error condition is wrong. Only warn if
109 // we are already aborting (as this verification is likely run to print
110 // lock information).
111 if (LIKELY(gAborting == 0)) {
112 DCHECK(condition) << error_msg << work_insn_idx;
113 } else {
114 if (!condition) {
115 LOG(ERROR) << error_msg << work_insn_idx;
116 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << error_msg << work_insn_idx;
117 return true;
118 }
119 }
Andreas Gampe7c038102014-10-27 20:08:46 -0700120 } else {
121 // In a non-debug build, just fail the class.
122 if (!condition) {
123 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << error_msg << work_insn_idx;
124 return true;
125 }
126 }
127
128 return false;
129}
130
Stephen Kyle7e541c92014-12-17 17:10:02 +0000131static void SafelyMarkAllRegistersAsConflicts(MethodVerifier* verifier, RegisterLine* reg_line) {
Andreas Gampef10b6e12015-08-12 10:48:12 -0700132 if (verifier->IsInstanceConstructor()) {
Stephen Kyle7e541c92014-12-17 17:10:02 +0000133 // Before we mark all regs as conflicts, check that we don't have an uninitialized this.
134 reg_line->CheckConstructorReturn(verifier);
135 }
136 reg_line->MarkAllRegistersAsConflicts(verifier);
137}
138
Ian Rogers7b078e82014-09-10 14:44:24 -0700139MethodVerifier::FailureKind MethodVerifier::VerifyClass(Thread* self,
140 mirror::Class* klass,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800141 CompilerCallbacks* callbacks,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700142 bool allow_soft_failures,
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700143 HardFailLogMode log_level,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700144 std::string* error) {
jeffhaobdb76512011-09-07 11:43:16 -0700145 if (klass->IsVerified()) {
jeffhaof1e6b7c2012-06-05 18:33:30 -0700146 return kNoFailure;
jeffhaobdb76512011-09-07 11:43:16 -0700147 }
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800148 bool early_failure = false;
149 std::string failure_message;
Mathieu Chartierf8322842014-05-16 10:59:25 -0700150 const DexFile& dex_file = klass->GetDexFile();
151 const DexFile::ClassDef* class_def = klass->GetClassDef();
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800152 mirror::Class* super = klass->GetSuperClass();
Ian Rogers1ff3c982014-08-12 02:30:58 -0700153 std::string temp;
Ian Rogers7b078e82014-09-10 14:44:24 -0700154 if (super == nullptr && strcmp("Ljava/lang/Object;", klass->GetDescriptor(&temp)) != 0) {
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800155 early_failure = true;
156 failure_message = " that has no super class";
Ian Rogers7b078e82014-09-10 14:44:24 -0700157 } else if (super != nullptr && super->IsFinal()) {
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800158 early_failure = true;
David Sehr709b0702016-10-13 09:12:37 -0700159 failure_message = " that attempts to sub-class final class " + super->PrettyDescriptor();
Ian Rogers7b078e82014-09-10 14:44:24 -0700160 } else if (class_def == nullptr) {
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800161 early_failure = true;
162 failure_message = " that isn't present in dex file " + dex_file.GetLocation();
163 }
164 if (early_failure) {
David Sehr709b0702016-10-13 09:12:37 -0700165 *error = "Verifier rejected class " + klass->PrettyDescriptor() + failure_message;
Andreas Gampe53e32d12015-12-09 21:03:23 -0800166 if (callbacks != nullptr) {
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800167 ClassReference ref(&dex_file, klass->GetDexClassDefIndex());
Andreas Gampe53e32d12015-12-09 21:03:23 -0800168 callbacks->ClassRejected(ref);
Jeff Hao2d7e5aa2013-12-13 17:39:59 -0800169 }
jeffhaof1e6b7c2012-06-05 18:33:30 -0700170 return kHardFailure;
jeffhaobdb76512011-09-07 11:43:16 -0700171 }
Ian Rogers7b078e82014-09-10 14:44:24 -0700172 StackHandleScope<2> hs(self);
Mathieu Chartierf8322842014-05-16 10:59:25 -0700173 Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700174 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800175 return VerifyClass(self,
176 &dex_file,
177 dex_cache,
178 class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100179 *class_def,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800180 callbacks,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800181 allow_soft_failures,
Andreas Gampe7fe30232016-03-25 16:58:00 -0700182 log_level,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800183 error);
184}
185
186template <bool kDirect>
187static bool HasNextMethod(ClassDataItemIterator* it) {
188 return kDirect ? it->HasNextDirectMethod() : it->HasNextVirtualMethod();
189}
190
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800191static MethodVerifier::FailureKind FailureKindMax(MethodVerifier::FailureKind fk1,
192 MethodVerifier::FailureKind fk2) {
193 static_assert(MethodVerifier::FailureKind::kNoFailure <
194 MethodVerifier::FailureKind::kSoftFailure
195 && MethodVerifier::FailureKind::kSoftFailure <
196 MethodVerifier::FailureKind::kHardFailure,
197 "Unexpected FailureKind order");
198 return std::max(fk1, fk2);
199}
200
201void MethodVerifier::FailureData::Merge(const MethodVerifier::FailureData& fd) {
202 kind = FailureKindMax(kind, fd.kind);
203 types |= fd.types;
204}
205
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800206template <bool kDirect>
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800207MethodVerifier::FailureData MethodVerifier::VerifyMethods(Thread* self,
208 ClassLinker* linker,
209 const DexFile* dex_file,
David Brazdil15fc7292016-09-02 14:13:18 +0100210 const DexFile::ClassDef& class_def,
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800211 ClassDataItemIterator* it,
212 Handle<mirror::DexCache> dex_cache,
213 Handle<mirror::ClassLoader> class_loader,
214 CompilerCallbacks* callbacks,
215 bool allow_soft_failures,
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700216 HardFailLogMode log_level,
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800217 bool need_precise_constants,
218 std::string* error_string) {
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800219 DCHECK(it != nullptr);
220
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800221 MethodVerifier::FailureData failure_data;
222
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800223 int64_t previous_method_idx = -1;
224 while (HasNextMethod<kDirect>(it)) {
225 self->AllowThreadSuspension();
226 uint32_t method_idx = it->GetMemberIndex();
227 if (method_idx == previous_method_idx) {
228 // smali can create dex files with two encoded_methods sharing the same method_idx
229 // http://code.google.com/p/smali/issues/detail?id=119
230 it->Next();
231 continue;
232 }
233 previous_method_idx = method_idx;
David Brazdil15fc7292016-09-02 14:13:18 +0100234 InvokeType type = it->GetMethodInvokeType(class_def);
Andreas Gampe42ef8ab2015-12-03 17:27:32 -0800235 ArtMethod* method = linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800236 *dex_file, method_idx, dex_cache, class_loader, nullptr, type);
237 if (method == nullptr) {
238 DCHECK(self->IsExceptionPending());
239 // We couldn't resolve the method, but continue regardless.
240 self->ClearException();
241 } else {
242 DCHECK(method->GetDeclaringClassUnchecked() != nullptr) << type;
243 }
244 StackHandleScope<1> hs(self);
245 std::string hard_failure_msg;
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800246 MethodVerifier::FailureData result = VerifyMethod(self,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800247 method_idx,
248 dex_file,
249 dex_cache,
250 class_loader,
251 class_def,
252 it->GetMethodCodeItem(),
253 method,
254 it->GetMethodAccessFlags(),
Andreas Gampe53e32d12015-12-09 21:03:23 -0800255 callbacks,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800256 allow_soft_failures,
Andreas Gampe7fe30232016-03-25 16:58:00 -0700257 log_level,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800258 need_precise_constants,
259 &hard_failure_msg);
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800260 if (result.kind == kHardFailure) {
261 if (failure_data.kind == kHardFailure) {
262 // If we logged an error before, we need a newline.
263 *error_string += "\n";
264 } else {
265 // If we didn't log a hard failure before, print the header of the message.
266 *error_string += "Verifier rejected class ";
David Brazdil15fc7292016-09-02 14:13:18 +0100267 *error_string += PrettyDescriptor(dex_file->GetClassDescriptor(class_def));
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800268 *error_string += ":";
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800269 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800270 *error_string += " ";
271 *error_string += hard_failure_msg;
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800272 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800273 failure_data.Merge(result);
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800274 it->Next();
275 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800276
277 return failure_data;
Shih-wei Liao371814f2011-10-27 16:52:10 -0700278}
279
Ian Rogers7b078e82014-09-10 14:44:24 -0700280MethodVerifier::FailureKind MethodVerifier::VerifyClass(Thread* self,
281 const DexFile* dex_file,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700282 Handle<mirror::DexCache> dex_cache,
283 Handle<mirror::ClassLoader> class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100284 const DexFile::ClassDef& class_def,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800285 CompilerCallbacks* callbacks,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700286 bool allow_soft_failures,
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700287 HardFailLogMode log_level,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700288 std::string* error) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800289 ScopedTrace trace(__FUNCTION__);
Andreas Gampe507cc6f2015-06-19 22:58:47 -0700290
291 // A class must not be abstract and final.
David Brazdil15fc7292016-09-02 14:13:18 +0100292 if ((class_def.access_flags_ & (kAccAbstract | kAccFinal)) == (kAccAbstract | kAccFinal)) {
Andreas Gampe507cc6f2015-06-19 22:58:47 -0700293 *error = "Verifier rejected class ";
David Brazdil15fc7292016-09-02 14:13:18 +0100294 *error += PrettyDescriptor(dex_file->GetClassDescriptor(class_def));
Andreas Gampe507cc6f2015-06-19 22:58:47 -0700295 *error += ": class is abstract and final.";
296 return kHardFailure;
297 }
298
David Brazdil15fc7292016-09-02 14:13:18 +0100299 const uint8_t* class_data = dex_file->GetClassData(class_def);
Ian Rogers7b078e82014-09-10 14:44:24 -0700300 if (class_data == nullptr) {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700301 // empty class, probably a marker interface
jeffhaof1e6b7c2012-06-05 18:33:30 -0700302 return kNoFailure;
Ian Rogersad0b3a32012-04-16 14:50:24 -0700303 }
jeffhaof56197c2012-03-05 18:01:54 -0800304 ClassDataItemIterator it(*dex_file, class_data);
305 while (it.HasNextStaticField() || it.HasNextInstanceField()) {
306 it.Next();
307 }
Ian Rogersad0b3a32012-04-16 14:50:24 -0700308 ClassLinker* linker = Runtime::Current()->GetClassLinker();
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800309 // Direct methods.
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800310 MethodVerifier::FailureData data1 = VerifyMethods<true>(self,
311 linker,
312 dex_file,
313 class_def,
314 &it,
315 dex_cache,
316 class_loader,
317 callbacks,
318 allow_soft_failures,
Andreas Gampe7fe30232016-03-25 16:58:00 -0700319 log_level,
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800320 false /* need precise constants */,
321 error);
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800322 // Virtual methods.
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800323 MethodVerifier::FailureData data2 = VerifyMethods<false>(self,
324 linker,
325 dex_file,
326 class_def,
327 &it,
328 dex_cache,
329 class_loader,
330 callbacks,
331 allow_soft_failures,
Andreas Gampe7fe30232016-03-25 16:58:00 -0700332 log_level,
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800333 false /* need precise constants */,
334 error);
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800335
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800336 data1.Merge(data2);
337
338 if (data1.kind == kNoFailure) {
jeffhaof1e6b7c2012-06-05 18:33:30 -0700339 return kNoFailure;
340 } else {
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800341 if ((data1.types & VERIFY_ERROR_LOCKING) != 0) {
342 // Print a warning about expected slow-down. Use a string temporary to print one contiguous
343 // warning.
344 std::string tmp =
345 StringPrintf("Class %s failed lock verification and will run slower.",
David Brazdil15fc7292016-09-02 14:13:18 +0100346 PrettyDescriptor(dex_file->GetClassDescriptor(class_def)).c_str());
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800347 if (!gPrintedDxMonitorText) {
348 tmp = tmp + "\nCommon causes for lock verification issues are non-optimized dex code\n"
349 "and incorrect proguard optimizations.";
350 gPrintedDxMonitorText = true;
351 }
352 LOG(WARNING) << tmp;
353 }
354 return data1.kind;
jeffhaof1e6b7c2012-06-05 18:33:30 -0700355 }
jeffhaof56197c2012-03-05 18:01:54 -0800356}
357
Andreas Gampea4f5bf62015-05-18 20:50:12 -0700358static bool IsLargeMethod(const DexFile::CodeItem* const code_item) {
Andreas Gampe3c651fc2015-05-21 14:06:46 -0700359 if (code_item == nullptr) {
360 return false;
361 }
362
Andreas Gampea4f5bf62015-05-18 20:50:12 -0700363 uint16_t registers_size = code_item->registers_size_;
364 uint32_t insns_size = code_item->insns_size_in_code_units_;
365
366 return registers_size * insns_size > 4*1024*1024;
367}
368
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800369MethodVerifier::FailureData MethodVerifier::VerifyMethod(Thread* self,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800370 uint32_t method_idx,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800371 const DexFile* dex_file,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700372 Handle<mirror::DexCache> dex_cache,
373 Handle<mirror::ClassLoader> class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100374 const DexFile::ClassDef& class_def,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800375 const DexFile::CodeItem* code_item,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700376 ArtMethod* method,
Jeff Haoee988952013-04-16 14:23:47 -0700377 uint32_t method_access_flags,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800378 CompilerCallbacks* callbacks,
Ian Rogers46960fe2014-05-23 10:43:43 -0700379 bool allow_soft_failures,
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700380 HardFailLogMode log_level,
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800381 bool need_precise_constants,
382 std::string* hard_failure_msg) {
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800383 MethodVerifier::FailureData result;
Mathieu Chartier8e219ae2014-08-19 14:29:46 -0700384 uint64_t start_ns = kTimeVerifyMethod ? NanoTime() : 0;
Ian Rogersc8982582012-09-07 16:53:25 -0700385
Andreas Gampebf9611f2016-03-25 16:58:00 -0700386 MethodVerifier verifier(self,
387 dex_file,
388 dex_cache,
389 class_loader,
390 class_def,
391 code_item,
392 method_idx,
393 method,
394 method_access_flags,
395 true /* can_load_classes */,
396 allow_soft_failures,
397 need_precise_constants,
398 false /* verify to dump */,
399 true /* allow_thread_suspension */);
Ian Rogers46960fe2014-05-23 10:43:43 -0700400 if (verifier.Verify()) {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700401 // Verification completed, however failures may be pending that didn't cause the verification
402 // to hard fail.
Ian Rogers46960fe2014-05-23 10:43:43 -0700403 CHECK(!verifier.have_pending_hard_failure_);
Andreas Gampe53e32d12015-12-09 21:03:23 -0800404
405 if (code_item != nullptr && callbacks != nullptr) {
406 // Let the interested party know that the method was verified.
407 callbacks->MethodVerified(&verifier);
408 }
409
Ian Rogers46960fe2014-05-23 10:43:43 -0700410 if (verifier.failures_.size() != 0) {
Anwar Ghuloum75a43f12013-08-13 17:22:14 -0700411 if (VLOG_IS_ON(verifier)) {
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800412 verifier.DumpFailures(VLOG_STREAM(verifier) << "Soft verification failures in "
David Sehr709b0702016-10-13 09:12:37 -0700413 << dex_file->PrettyMethod(method_idx) << "\n");
Anwar Ghuloum75a43f12013-08-13 17:22:14 -0700414 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800415 result.kind = kSoftFailure;
Nicolas Geoffray250a3782016-04-20 16:27:53 +0100416 if (method != nullptr &&
417 !CanCompilerHandleVerificationFailure(verifier.encountered_failure_types_)) {
Alex Lightfcbafb32017-02-02 15:09:54 -0800418 method->SetDontCompile();
Nicolas Geoffray250a3782016-04-20 16:27:53 +0100419 }
420 }
Andreas Gampe56fdd0e2016-04-28 14:56:54 -0700421 if (method != nullptr) {
422 if (verifier.HasInstructionThatWillThrow()) {
Alex Lightfcbafb32017-02-02 15:09:54 -0800423 method->SetDontCompile();
Calin Juravle857f0582016-12-20 14:36:59 +0000424 if (Runtime::Current()->IsAotCompiler() &&
425 (callbacks != nullptr) && !callbacks->IsBootImage()) {
426 // When compiling apps, make HasInstructionThatWillThrow a soft error to trigger
427 // re-verification at runtime.
428 // The dead code after the throw is not verified and might be invalid. This may cause
429 // the JIT compiler to crash since it assumes that all the code is valid.
430 //
431 // There's a strong assumption that the entire boot image is verified and all its dex
432 // code is valid (even the dead and unverified one). As such this is done only for apps.
433 // (CompilerDriver DCHECKs in VerifyClassVisitor that methods from boot image are
434 // fully verified).
435 result.kind = kSoftFailure;
436 }
Andreas Gampe56fdd0e2016-04-28 14:56:54 -0700437 }
438 if ((verifier.encountered_failure_types_ & VerifyError::VERIFY_ERROR_LOCKING) != 0) {
Mingyao Yang063fc772016-08-02 11:02:54 -0700439 method->AddAccessFlags(kAccMustCountLocks);
Andreas Gampe56fdd0e2016-04-28 14:56:54 -0700440 }
jeffhaof56197c2012-03-05 18:01:54 -0800441 }
442 } else {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700443 // Bad method data.
Ian Rogers46960fe2014-05-23 10:43:43 -0700444 CHECK_NE(verifier.failures_.size(), 0U);
Igor Murashkin4d7b75f2015-07-21 17:03:36 -0700445
446 if (UNLIKELY(verifier.have_pending_experimental_failure_)) {
447 // Failed due to being forced into interpreter. This is ok because
448 // we just want to skip verification.
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800449 result.kind = kSoftFailure;
Igor Murashkin4d7b75f2015-07-21 17:03:36 -0700450 } else {
451 CHECK(verifier.have_pending_hard_failure_);
Andreas Gampe7fe30232016-03-25 16:58:00 -0700452 if (VLOG_IS_ON(verifier)) {
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700453 log_level = std::max(HardFailLogMode::kLogVerbose, log_level);
Andreas Gampe7fe30232016-03-25 16:58:00 -0700454 }
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700455 if (log_level >= HardFailLogMode::kLogVerbose) {
456 LogSeverity severity;
457 switch (log_level) {
458 case HardFailLogMode::kLogVerbose:
459 severity = LogSeverity::VERBOSE;
460 break;
461 case HardFailLogMode::kLogWarning:
462 severity = LogSeverity::WARNING;
463 break;
464 case HardFailLogMode::kLogInternalFatal:
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700465 severity = LogSeverity::FATAL_WITHOUT_ABORT;
Andreas Gampe5fd66d02016-09-12 20:22:19 -0700466 break;
467 default:
468 LOG(FATAL) << "Unsupported log-level " << static_cast<uint32_t>(log_level);
469 UNREACHABLE();
470 }
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700471 verifier.DumpFailures(LOG_STREAM(severity) << "Verification error in "
David Sehr709b0702016-10-13 09:12:37 -0700472 << dex_file->PrettyMethod(method_idx)
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700473 << "\n");
Andreas Gampeec6e6c12015-11-05 20:39:56 -0800474 }
475 if (hard_failure_msg != nullptr) {
476 CHECK(!verifier.failure_messages_.empty());
477 *hard_failure_msg =
478 verifier.failure_messages_[verifier.failure_messages_.size() - 1]->str();
479 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800480 result.kind = kHardFailure;
Andreas Gampe53e32d12015-12-09 21:03:23 -0800481
482 if (callbacks != nullptr) {
483 // Let the interested party know that we failed the class.
David Brazdil15fc7292016-09-02 14:13:18 +0100484 ClassReference ref(dex_file, dex_file->GetIndexForClassDef(class_def));
Andreas Gampe53e32d12015-12-09 21:03:23 -0800485 callbacks->ClassRejected(ref);
486 }
Igor Murashkin4d7b75f2015-07-21 17:03:36 -0700487 }
Andreas Gampe53e32d12015-12-09 21:03:23 -0800488 if (VLOG_IS_ON(verifier)) {
Ian Rogers46960fe2014-05-23 10:43:43 -0700489 std::cout << "\n" << verifier.info_messages_.str();
490 verifier.Dump(std::cout);
jeffhaof56197c2012-03-05 18:01:54 -0800491 }
jeffhaof56197c2012-03-05 18:01:54 -0800492 }
Mathieu Chartier8e219ae2014-08-19 14:29:46 -0700493 if (kTimeVerifyMethod) {
494 uint64_t duration_ns = NanoTime() - start_ns;
495 if (duration_ns > MsToNs(100)) {
David Sehr709b0702016-10-13 09:12:37 -0700496 LOG(WARNING) << "Verification of " << dex_file->PrettyMethod(method_idx)
Andreas Gampea4f5bf62015-05-18 20:50:12 -0700497 << " took " << PrettyDuration(duration_ns)
498 << (IsLargeMethod(code_item) ? " (large method)" : "");
Mathieu Chartier8e219ae2014-08-19 14:29:46 -0700499 }
Ian Rogersc8982582012-09-07 16:53:25 -0700500 }
Andreas Gampe9fcfb8a2016-02-04 20:52:54 -0800501 result.types = verifier.encountered_failure_types_;
Ian Rogersc8982582012-09-07 16:53:25 -0700502 return result;
jeffhaof56197c2012-03-05 18:01:54 -0800503}
504
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100505MethodVerifier* MethodVerifier::VerifyMethodAndDump(Thread* self,
506 VariableIndentationOutputStream* vios,
507 uint32_t dex_method_idx,
508 const DexFile* dex_file,
509 Handle<mirror::DexCache> dex_cache,
510 Handle<mirror::ClassLoader> class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100511 const DexFile::ClassDef& class_def,
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100512 const DexFile::CodeItem* code_item,
513 ArtMethod* method,
514 uint32_t method_access_flags) {
Andreas Gampebf9611f2016-03-25 16:58:00 -0700515 MethodVerifier* verifier = new MethodVerifier(self,
516 dex_file,
517 dex_cache,
518 class_loader,
519 class_def,
520 code_item,
521 dex_method_idx,
522 method,
523 method_access_flags,
524 true /* can_load_classes */,
525 true /* allow_soft_failures */,
526 true /* need_precise_constants */,
527 true /* verify_to_dump */,
528 true /* allow_thread_suspension */);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700529 verifier->Verify();
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100530 verifier->DumpFailures(vios->Stream());
531 vios->Stream() << verifier->info_messages_.str();
Andreas Gampe5cbcde22014-09-16 14:59:49 -0700532 // Only dump and return if no hard failures. Otherwise the verifier may be not fully initialized
533 // and querying any info is dangerous/can abort.
534 if (verifier->have_pending_hard_failure_) {
535 delete verifier;
536 return nullptr;
537 } else {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100538 verifier->Dump(vios);
Andreas Gampe5cbcde22014-09-16 14:59:49 -0700539 return verifier;
540 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800541}
542
Ian Rogers7b078e82014-09-10 14:44:24 -0700543MethodVerifier::MethodVerifier(Thread* self,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800544 const DexFile* dex_file,
545 Handle<mirror::DexCache> dex_cache,
Andreas Gampe5a4b8a22014-09-11 08:30:08 -0700546 Handle<mirror::ClassLoader> class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100547 const DexFile::ClassDef& class_def,
Andreas Gampe53e32d12015-12-09 21:03:23 -0800548 const DexFile::CodeItem* code_item,
549 uint32_t dex_method_idx,
550 ArtMethod* method,
551 uint32_t method_access_flags,
552 bool can_load_classes,
553 bool allow_soft_failures,
554 bool need_precise_constants,
555 bool verify_to_dump,
Mathieu Chartier4306ef82014-12-19 18:41:47 -0800556 bool allow_thread_suspension)
Ian Rogers7b078e82014-09-10 14:44:24 -0700557 : self_(self),
Mathieu Chartierde40d472015-10-15 17:47:48 -0700558 arena_stack_(Runtime::Current()->GetArenaPool()),
559 arena_(&arena_stack_),
560 reg_types_(can_load_classes, arena_),
561 reg_table_(arena_),
Andreas Gamped5ad72f2015-06-26 17:33:47 -0700562 work_insn_idx_(DexFile::kDexNoIndex),
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800563 dex_method_idx_(dex_method_idx),
Ian Rogers637c65b2013-05-31 11:46:00 -0700564 mirror_method_(method),
Ian Rogersad0b3a32012-04-16 14:50:24 -0700565 method_access_flags_(method_access_flags),
Ian Rogersfc0e94b2013-09-23 23:51:32 -0700566 return_type_(nullptr),
jeffhaof56197c2012-03-05 18:01:54 -0800567 dex_file_(dex_file),
568 dex_cache_(dex_cache),
569 class_loader_(class_loader),
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700570 class_def_(class_def),
jeffhaof56197c2012-03-05 18:01:54 -0800571 code_item_(code_item),
Ian Rogers7b078e82014-09-10 14:44:24 -0700572 declaring_class_(nullptr),
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700573 interesting_dex_pc_(-1),
Ian Rogersfc0e94b2013-09-23 23:51:32 -0700574 monitor_enter_dex_pcs_(nullptr),
Ian Rogersad0b3a32012-04-16 14:50:24 -0700575 have_pending_hard_failure_(false),
jeffhaofaf459e2012-08-31 15:32:47 -0700576 have_pending_runtime_throw_failure_(false),
Igor Murashkin4d7b75f2015-07-21 17:03:36 -0700577 have_pending_experimental_failure_(false),
Andreas Gamped12e7822015-06-25 10:26:40 -0700578 have_any_pending_runtime_throw_failure_(false),
jeffhaof56197c2012-03-05 18:01:54 -0800579 new_instance_count_(0),
Elliott Hughes80537bb2013-01-04 16:37:26 -0800580 monitor_enter_count_(0),
Andreas Gampe0760a812015-08-26 17:12:51 -0700581 encountered_failure_types_(0),
Jeff Haoee988952013-04-16 14:23:47 -0700582 can_load_classes_(can_load_classes),
Sebastien Hertz4d4adb12013-07-24 16:14:19 +0200583 allow_soft_failures_(allow_soft_failures),
Ian Rogers46960fe2014-05-23 10:43:43 -0700584 need_precise_constants_(need_precise_constants),
Sebastien Hertz4d4adb12013-07-24 16:14:19 +0200585 has_check_casts_(false),
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700586 has_virtual_or_interface_invokes_(false),
Mathieu Chartier4306ef82014-12-19 18:41:47 -0800587 verify_to_dump_(verify_to_dump),
Andreas Gamped5ad72f2015-06-26 17:33:47 -0700588 allow_thread_suspension_(allow_thread_suspension),
Andreas Gampee6215c02015-08-31 18:54:38 -0700589 is_constructor_(false),
Andreas Gamped5ad72f2015-06-26 17:33:47 -0700590 link_(nullptr) {
Mathieu Chartierd0ad2ee2015-03-31 14:59:59 -0700591 self->PushVerifier(this);
jeffhaof56197c2012-03-05 18:01:54 -0800592}
593
Mathieu Chartier590fee92013-09-13 13:46:47 -0700594MethodVerifier::~MethodVerifier() {
Mathieu Chartierd0ad2ee2015-03-31 14:59:59 -0700595 Thread::Current()->PopVerifier(this);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700596 STLDeleteElements(&failure_messages_);
597}
598
Mathieu Chartiere401d142015-04-22 13:56:20 -0700599void MethodVerifier::FindLocksAtDexPc(ArtMethod* m, uint32_t dex_pc,
Ian Rogers46960fe2014-05-23 10:43:43 -0700600 std::vector<uint32_t>* monitor_enter_dex_pcs) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700601 StackHandleScope<2> hs(Thread::Current());
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700602 Handle<mirror::DexCache> dex_cache(hs.NewHandle(m->GetDexCache()));
603 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(m->GetClassLoader()));
Andreas Gampebf9611f2016-03-25 16:58:00 -0700604 MethodVerifier verifier(hs.Self(),
605 m->GetDexFile(),
606 dex_cache,
607 class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100608 m->GetClassDef(),
Andreas Gampebf9611f2016-03-25 16:58:00 -0700609 m->GetCodeItem(),
610 m->GetDexMethodIndex(),
611 m,
612 m->GetAccessFlags(),
613 false /* can_load_classes */,
614 true /* allow_soft_failures */,
615 false /* need_precise_constants */,
616 false /* verify_to_dump */,
617 false /* allow_thread_suspension */);
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700618 verifier.interesting_dex_pc_ = dex_pc;
Ian Rogers46960fe2014-05-23 10:43:43 -0700619 verifier.monitor_enter_dex_pcs_ = monitor_enter_dex_pcs;
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700620 verifier.FindLocksAtDexPc();
621}
622
Andreas Gampecb3c08f2014-09-18 13:16:38 -0700623static bool HasMonitorEnterInstructions(const DexFile::CodeItem* const code_item) {
624 const Instruction* inst = Instruction::At(code_item->insns_);
625
626 uint32_t insns_size = code_item->insns_size_in_code_units_;
627 for (uint32_t dex_pc = 0; dex_pc < insns_size;) {
628 if (inst->Opcode() == Instruction::MONITOR_ENTER) {
629 return true;
630 }
631
632 dex_pc += inst->SizeInCodeUnits();
633 inst = inst->Next();
634 }
635
636 return false;
637}
638
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700639void MethodVerifier::FindLocksAtDexPc() {
Ian Rogers7b078e82014-09-10 14:44:24 -0700640 CHECK(monitor_enter_dex_pcs_ != nullptr);
641 CHECK(code_item_ != nullptr); // This only makes sense for methods with code.
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700642
Andreas Gampecb3c08f2014-09-18 13:16:38 -0700643 // Quick check whether there are any monitor_enter instructions at all.
644 if (!HasMonitorEnterInstructions(code_item_)) {
645 return;
646 }
647
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700648 // Strictly speaking, we ought to be able to get away with doing a subset of the full method
649 // verification. In practice, the phase we want relies on data structures set up by all the
650 // earlier passes, so we just run the full method verification and bail out early when we've
651 // got what we wanted.
652 Verify();
653}
654
Mathieu Chartiere401d142015-04-22 13:56:20 -0700655ArtField* MethodVerifier::FindAccessedFieldAtDexPc(ArtMethod* m, uint32_t dex_pc) {
656 StackHandleScope<2> hs(Thread::Current());
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700657 Handle<mirror::DexCache> dex_cache(hs.NewHandle(m->GetDexCache()));
658 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(m->GetClassLoader()));
Andreas Gampebf9611f2016-03-25 16:58:00 -0700659 MethodVerifier verifier(hs.Self(),
660 m->GetDexFile(),
661 dex_cache,
662 class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100663 m->GetClassDef(),
Andreas Gampebf9611f2016-03-25 16:58:00 -0700664 m->GetCodeItem(),
665 m->GetDexMethodIndex(),
666 m,
667 m->GetAccessFlags(),
668 true /* can_load_classes */,
669 true /* allow_soft_failures */,
670 false /* need_precise_constants */,
671 false /* verify_to_dump */,
672 true /* allow_thread_suspension */);
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200673 return verifier.FindAccessedFieldAtDexPc(dex_pc);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200674}
675
Mathieu Chartierc7853442015-03-27 14:35:38 -0700676ArtField* MethodVerifier::FindAccessedFieldAtDexPc(uint32_t dex_pc) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700677 CHECK(code_item_ != nullptr); // This only makes sense for methods with code.
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200678
679 // Strictly speaking, we ought to be able to get away with doing a subset of the full method
680 // verification. In practice, the phase we want relies on data structures set up by all the
681 // earlier passes, so we just run the full method verification and bail out early when we've
682 // got what we wanted.
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200683 bool success = Verify();
684 if (!success) {
Ian Rogers9bc54402014-04-17 16:40:01 -0700685 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200686 }
687 RegisterLine* register_line = reg_table_.GetLine(dex_pc);
Ian Rogers7b078e82014-09-10 14:44:24 -0700688 if (register_line == nullptr) {
Ian Rogers9bc54402014-04-17 16:40:01 -0700689 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200690 }
691 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
692 return GetQuickFieldAccess(inst, register_line);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200693}
694
Mathieu Chartiere401d142015-04-22 13:56:20 -0700695ArtMethod* MethodVerifier::FindInvokedMethodAtDexPc(ArtMethod* m, uint32_t dex_pc) {
696 StackHandleScope<2> hs(Thread::Current());
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700697 Handle<mirror::DexCache> dex_cache(hs.NewHandle(m->GetDexCache()));
698 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(m->GetClassLoader()));
Andreas Gampebf9611f2016-03-25 16:58:00 -0700699 MethodVerifier verifier(hs.Self(),
700 m->GetDexFile(),
701 dex_cache,
702 class_loader,
David Brazdil15fc7292016-09-02 14:13:18 +0100703 m->GetClassDef(),
Andreas Gampebf9611f2016-03-25 16:58:00 -0700704 m->GetCodeItem(),
705 m->GetDexMethodIndex(),
706 m,
707 m->GetAccessFlags(),
708 true /* can_load_classes */,
709 true /* allow_soft_failures */,
710 false /* need_precise_constants */,
711 false /* verify_to_dump */,
712 true /* allow_thread_suspension */);
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200713 return verifier.FindInvokedMethodAtDexPc(dex_pc);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200714}
715
Mathieu Chartiere401d142015-04-22 13:56:20 -0700716ArtMethod* MethodVerifier::FindInvokedMethodAtDexPc(uint32_t dex_pc) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700717 CHECK(code_item_ != nullptr); // This only makes sense for methods with code.
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200718
719 // Strictly speaking, we ought to be able to get away with doing a subset of the full method
720 // verification. In practice, the phase we want relies on data structures set up by all the
721 // earlier passes, so we just run the full method verification and bail out early when we've
722 // got what we wanted.
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200723 bool success = Verify();
724 if (!success) {
Ian Rogers7b078e82014-09-10 14:44:24 -0700725 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200726 }
727 RegisterLine* register_line = reg_table_.GetLine(dex_pc);
Ian Rogers7b078e82014-09-10 14:44:24 -0700728 if (register_line == nullptr) {
729 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +0200730 }
731 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
732 const bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
Mathieu Chartier091d2382015-03-06 10:59:06 -0800733 return GetQuickInvokedMethod(inst, register_line, is_range, false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200734}
735
Ian Rogersad0b3a32012-04-16 14:50:24 -0700736bool MethodVerifier::Verify() {
Andreas Gampee6215c02015-08-31 18:54:38 -0700737 // Some older code doesn't correctly mark constructors as such. Test for this case by looking at
738 // the name.
739 const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
740 const char* method_name = dex_file_->StringDataByIdx(method_id.name_idx_);
741 bool instance_constructor_by_name = strcmp("<init>", method_name) == 0;
742 bool static_constructor_by_name = strcmp("<clinit>", method_name) == 0;
743 bool constructor_by_name = instance_constructor_by_name || static_constructor_by_name;
744 // Check that only constructors are tagged, and check for bad code that doesn't tag constructors.
745 if ((method_access_flags_ & kAccConstructor) != 0) {
746 if (!constructor_by_name) {
747 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
748 << "method is marked as constructor, but not named accordingly";
jeffhaobdb76512011-09-07 11:43:16 -0700749 return false;
Andreas Gampee6215c02015-08-31 18:54:38 -0700750 }
751 is_constructor_ = true;
752 } else if (constructor_by_name) {
David Sehr709b0702016-10-13 09:12:37 -0700753 LOG(WARNING) << "Method " << dex_file_->PrettyMethod(dex_method_idx_)
Andreas Gampee6215c02015-08-31 18:54:38 -0700754 << " not marked as constructor.";
755 is_constructor_ = true;
756 }
757 // If it's a constructor, check whether IsStatic() matches the name.
758 // This should have been rejected by the dex file verifier. Only do in debug build.
759 if (kIsDebugBuild) {
760 if (IsConstructor()) {
761 if (IsStatic() ^ static_constructor_by_name) {
762 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
763 << "constructor name doesn't match static flag";
764 return false;
765 }
jeffhaobdb76512011-09-07 11:43:16 -0700766 }
jeffhaobdb76512011-09-07 11:43:16 -0700767 }
Andreas Gampee6215c02015-08-31 18:54:38 -0700768
769 // Methods may only have one of public/protected/private.
770 // This should have been rejected by the dex file verifier. Only do in debug build.
771 if (kIsDebugBuild) {
772 size_t access_mod_count =
773 (((method_access_flags_ & kAccPublic) == 0) ? 0 : 1) +
774 (((method_access_flags_ & kAccProtected) == 0) ? 0 : 1) +
775 (((method_access_flags_ & kAccPrivate) == 0) ? 0 : 1);
776 if (access_mod_count > 1) {
777 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "method has more than one of public/protected/private";
778 return false;
779 }
780 }
781
782 // If there aren't any instructions, make sure that's expected, then exit successfully.
783 if (code_item_ == nullptr) {
Andreas Gampe76ed99d2016-03-28 18:31:29 -0700784 // Only native or abstract methods may not have code.
785 if ((method_access_flags_ & (kAccNative | kAccAbstract)) == 0) {
786 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "zero-length code in concrete non-native method";
787 return false;
788 }
789
Andreas Gampee6215c02015-08-31 18:54:38 -0700790 // This should have been rejected by the dex file verifier. Only do in debug build.
Andreas Gampe76ed99d2016-03-28 18:31:29 -0700791 // Note: the above will also be rejected in the dex file verifier, starting in dex version 37.
Andreas Gampee6215c02015-08-31 18:54:38 -0700792 if (kIsDebugBuild) {
Andreas Gampee6215c02015-08-31 18:54:38 -0700793 if ((method_access_flags_ & kAccAbstract) != 0) {
794 // Abstract methods are not allowed to have the following flags.
795 static constexpr uint32_t kForbidden =
796 kAccPrivate |
797 kAccStatic |
798 kAccFinal |
799 kAccNative |
800 kAccStrict |
801 kAccSynchronized;
802 if ((method_access_flags_ & kForbidden) != 0) {
803 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
804 << "method can't be abstract and private/static/final/native/strict/synchronized";
805 return false;
806 }
807 }
David Brazdil15fc7292016-09-02 14:13:18 +0100808 if ((class_def_.GetJavaAccessFlags() & kAccInterface) != 0) {
Alex Lighteb7c1442015-08-31 13:17:42 -0700809 // Interface methods must be public and abstract (if default methods are disabled).
Neil Fuller9724c632016-01-07 15:42:47 +0000810 uint32_t kRequired = kAccPublic;
Alex Lighteb7c1442015-08-31 13:17:42 -0700811 if ((method_access_flags_ & kRequired) != kRequired) {
Neil Fuller9724c632016-01-07 15:42:47 +0000812 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "interface methods must be public";
Andreas Gampee6215c02015-08-31 18:54:38 -0700813 return false;
814 }
815 // In addition to the above, interface methods must not be protected.
816 static constexpr uint32_t kForbidden = kAccProtected;
817 if ((method_access_flags_ & kForbidden) != 0) {
818 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "interface methods can't be protected";
819 return false;
820 }
821 }
822 // We also don't allow constructors to be abstract or native.
823 if (IsConstructor()) {
824 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "constructors can't be abstract or native";
825 return false;
826 }
827 }
828 return true;
829 }
830
831 // This should have been rejected by the dex file verifier. Only do in debug build.
832 if (kIsDebugBuild) {
833 // When there's code, the method must not be native or abstract.
834 if ((method_access_flags_ & (kAccNative | kAccAbstract)) != 0) {
835 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "non-zero-length code in abstract or native method";
836 return false;
837 }
838
David Brazdil15fc7292016-09-02 14:13:18 +0100839 if ((class_def_.GetJavaAccessFlags() & kAccInterface) != 0) {
Alex Lighteb7c1442015-08-31 13:17:42 -0700840 // Interfaces may always have static initializers for their fields. If we are running with
841 // default methods enabled we also allow other public, static, non-final methods to have code.
842 // Otherwise that is the only type of method allowed.
Alex Light0db36b32015-10-27 14:06:34 -0700843 if (!(IsConstructor() && IsStatic())) {
Neil Fuller9724c632016-01-07 15:42:47 +0000844 if (IsInstanceConstructor()) {
845 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "interfaces may not have non-static constructor";
846 return false;
847 } else if (method_access_flags_ & kAccFinal) {
848 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "interfaces may not have final methods";
849 return false;
Alex Lightb55f1ac2016-04-12 15:50:55 -0700850 } else {
851 uint32_t access_flag_options = kAccPublic;
852 if (dex_file_->GetVersion() >= DexFile::kDefaultMethodsVersion) {
853 access_flag_options |= kAccPrivate;
854 }
855 if (!(method_access_flags_ & access_flag_options)) {
856 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
857 << "interfaces may not have protected or package-private members";
858 return false;
859 }
Alex Lighteb7c1442015-08-31 13:17:42 -0700860 }
Andreas Gampee6215c02015-08-31 18:54:38 -0700861 }
862 }
863
864 // Instance constructors must not be synchronized.
865 if (IsInstanceConstructor()) {
866 static constexpr uint32_t kForbidden = kAccSynchronized;
867 if ((method_access_flags_ & kForbidden) != 0) {
868 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "constructors can't be synchronized";
869 return false;
870 }
871 }
872 }
873
Ian Rogersd81871c2011-10-03 13:57:23 -0700874 // Sanity-check the register counts. ins + locals = registers, so make sure that ins <= registers.
875 if (code_item_->ins_size_ > code_item_->registers_size_) {
jeffhaod5347e02012-03-22 17:25:05 -0700876 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad register counts (ins=" << code_item_->ins_size_
877 << " regs=" << code_item_->registers_size_;
Ian Rogersd81871c2011-10-03 13:57:23 -0700878 return false;
jeffhaobdb76512011-09-07 11:43:16 -0700879 }
Alex Lighteb7c1442015-08-31 13:17:42 -0700880
Ian Rogersd81871c2011-10-03 13:57:23 -0700881 // Allocate and initialize an array to hold instruction data.
Mathieu Chartierde40d472015-10-15 17:47:48 -0700882 insn_flags_.reset(arena_.AllocArray<InstructionFlags>(code_item_->insns_size_in_code_units_));
883 DCHECK(insn_flags_ != nullptr);
884 std::uninitialized_fill_n(insn_flags_.get(),
885 code_item_->insns_size_in_code_units_,
886 InstructionFlags());
Ian Rogersd81871c2011-10-03 13:57:23 -0700887 // Run through the instructions and see if the width checks out.
888 bool result = ComputeWidthsAndCountOps();
889 // Flag instructions guarded by a "try" block and check exception handlers.
890 result = result && ScanTryCatchBlocks();
891 // Perform static instruction verification.
892 result = result && VerifyInstructions();
Ian Rogersad0b3a32012-04-16 14:50:24 -0700893 // Perform code-flow analysis and return.
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000894 result = result && VerifyCodeFlow();
Andreas Gampe53e32d12015-12-09 21:03:23 -0800895
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000896 return result;
jeffhaoba5ebb92011-08-25 17:24:37 -0700897}
898
Ian Rogers776ac1f2012-04-13 23:36:36 -0700899std::ostream& MethodVerifier::Fail(VerifyError error) {
Andreas Gampe0760a812015-08-26 17:12:51 -0700900 // Mark the error type as encountered.
Andreas Gampea727e372015-08-25 09:22:37 -0700901 encountered_failure_types_ |= static_cast<uint32_t>(error);
Andreas Gampe0760a812015-08-26 17:12:51 -0700902
Ian Rogersad0b3a32012-04-16 14:50:24 -0700903 switch (error) {
904 case VERIFY_ERROR_NO_CLASS:
905 case VERIFY_ERROR_NO_FIELD:
906 case VERIFY_ERROR_NO_METHOD:
907 case VERIFY_ERROR_ACCESS_CLASS:
908 case VERIFY_ERROR_ACCESS_FIELD:
909 case VERIFY_ERROR_ACCESS_METHOD:
Ian Rogers08f753d2012-08-24 14:35:25 -0700910 case VERIFY_ERROR_INSTANTIATION:
911 case VERIFY_ERROR_CLASS_CHANGE:
Igor Murashkin158f35c2015-06-10 15:55:30 -0700912 case VERIFY_ERROR_FORCE_INTERPRETER:
Andreas Gampea727e372015-08-25 09:22:37 -0700913 case VERIFY_ERROR_LOCKING:
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800914 if (Runtime::Current()->IsAotCompiler() || !can_load_classes_) {
jeffhaofaf459e2012-08-31 15:32:47 -0700915 // If we're optimistically running verification at compile time, turn NO_xxx, ACCESS_xxx,
916 // class change and instantiation errors into soft verification errors so that we re-verify
917 // at runtime. We may fail to find or to agree on access because of not yet available class
918 // loaders, or class loaders that will differ at runtime. In these cases, we don't want to
919 // affect the soundness of the code being compiled. Instead, the generated code runs "slow
920 // paths" that dynamically perform the verification and cause the behavior to be that akin
921 // to an interpreter.
922 error = VERIFY_ERROR_BAD_CLASS_SOFT;
923 } else {
Jeff Haoa3faaf42013-09-03 19:07:00 -0700924 // If we fail again at runtime, mark that this instruction would throw and force this
925 // method to be executed using the interpreter with checks.
jeffhaofaf459e2012-08-31 15:32:47 -0700926 have_pending_runtime_throw_failure_ = true;
Andreas Gamped7f8d052015-03-12 11:05:47 -0700927
928 // We need to save the work_line if the instruction wasn't throwing before. Otherwise we'll
929 // try to merge garbage.
930 // Note: this assumes that Fail is called before we do any work_line modifications.
Andreas Gamped5ad72f2015-06-26 17:33:47 -0700931 // Note: this can fail before we touch any instruction, for the signature of a method. So
932 // add a check.
933 if (work_insn_idx_ < DexFile::kDexNoIndex) {
934 const uint16_t* insns = code_item_->insns_ + work_insn_idx_;
935 const Instruction* inst = Instruction::At(insns);
936 int opcode_flags = Instruction::FlagsOf(inst->Opcode());
Andreas Gamped7f8d052015-03-12 11:05:47 -0700937
Andreas Gamped5ad72f2015-06-26 17:33:47 -0700938 if ((opcode_flags & Instruction::kThrow) == 0 && CurrentInsnFlags()->IsInTry()) {
939 saved_line_->CopyFromLine(work_line_.get());
940 }
Andreas Gamped7f8d052015-03-12 11:05:47 -0700941 }
jeffhaofaf459e2012-08-31 15:32:47 -0700942 }
Ian Rogersad0b3a32012-04-16 14:50:24 -0700943 break;
Andreas Gampea727e372015-08-25 09:22:37 -0700944
Ian Rogersad0b3a32012-04-16 14:50:24 -0700945 // Indication that verification should be retried at runtime.
946 case VERIFY_ERROR_BAD_CLASS_SOFT:
Jeff Haoee988952013-04-16 14:23:47 -0700947 if (!allow_soft_failures_) {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700948 have_pending_hard_failure_ = true;
949 }
950 break;
Andreas Gampea727e372015-08-25 09:22:37 -0700951
jeffhaod5347e02012-03-22 17:25:05 -0700952 // Hard verification failures at compile time will still fail at runtime, so the class is
953 // marked as rejected to prevent it from being compiled.
Ian Rogersad0b3a32012-04-16 14:50:24 -0700954 case VERIFY_ERROR_BAD_CLASS_HARD: {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700955 have_pending_hard_failure_ = true;
Andreas Gampeebf850c2015-08-14 15:37:35 -0700956 if (VLOG_IS_ON(verifier) && kDumpRegLinesOnHardFailureIfVLOG) {
957 ScopedObjectAccess soa(Thread::Current());
958 std::ostringstream oss;
959 Dump(oss);
960 LOG(ERROR) << oss.str();
961 }
Ian Rogersad0b3a32012-04-16 14:50:24 -0700962 break;
Ian Rogers47a05882012-02-03 12:23:33 -0800963 }
964 }
Ian Rogersad0b3a32012-04-16 14:50:24 -0700965 failures_.push_back(error);
David Sehr709b0702016-10-13 09:12:37 -0700966 std::string location(StringPrintf("%s: [0x%X] ", dex_file_->PrettyMethod(dex_method_idx_).c_str(),
Ian Rogersad0b3a32012-04-16 14:50:24 -0700967 work_insn_idx_));
Elena Sayapina78480ec2014-08-15 15:52:42 +0700968 std::ostringstream* failure_message = new std::ostringstream(location, std::ostringstream::ate);
Ian Rogersad0b3a32012-04-16 14:50:24 -0700969 failure_messages_.push_back(failure_message);
970 return *failure_message;
971}
972
Ian Rogers576ca0c2014-06-06 15:58:22 -0700973std::ostream& MethodVerifier::LogVerifyInfo() {
David Sehr709b0702016-10-13 09:12:37 -0700974 return info_messages_ << "VFY: " << dex_file_->PrettyMethod(dex_method_idx_)
Ian Rogers576ca0c2014-06-06 15:58:22 -0700975 << '[' << reinterpret_cast<void*>(work_insn_idx_) << "] : ";
976}
977
Ian Rogersad0b3a32012-04-16 14:50:24 -0700978void MethodVerifier::PrependToLastFailMessage(std::string prepend) {
979 size_t failure_num = failure_messages_.size();
980 DCHECK_NE(failure_num, 0U);
981 std::ostringstream* last_fail_message = failure_messages_[failure_num - 1];
982 prepend += last_fail_message->str();
Elena Sayapina78480ec2014-08-15 15:52:42 +0700983 failure_messages_[failure_num - 1] = new std::ostringstream(prepend, std::ostringstream::ate);
Ian Rogersad0b3a32012-04-16 14:50:24 -0700984 delete last_fail_message;
985}
986
Vladimir Marko5c657fe2016-11-03 15:12:29 +0000987void MethodVerifier::AppendToLastFailMessage(const std::string& append) {
Ian Rogersad0b3a32012-04-16 14:50:24 -0700988 size_t failure_num = failure_messages_.size();
989 DCHECK_NE(failure_num, 0U);
990 std::ostringstream* last_fail_message = failure_messages_[failure_num - 1];
991 (*last_fail_message) << append;
Ian Rogers47a05882012-02-03 12:23:33 -0800992}
993
Ian Rogers776ac1f2012-04-13 23:36:36 -0700994bool MethodVerifier::ComputeWidthsAndCountOps() {
Ian Rogersd81871c2011-10-03 13:57:23 -0700995 const uint16_t* insns = code_item_->insns_;
996 size_t insns_size = code_item_->insns_size_in_code_units_;
997 const Instruction* inst = Instruction::At(insns);
jeffhaobdb76512011-09-07 11:43:16 -0700998 size_t new_instance_count = 0;
999 size_t monitor_enter_count = 0;
Ian Rogersd81871c2011-10-03 13:57:23 -07001000 size_t dex_pc = 0;
jeffhaobdb76512011-09-07 11:43:16 -07001001
Ian Rogersd81871c2011-10-03 13:57:23 -07001002 while (dex_pc < insns_size) {
jeffhaobdb76512011-09-07 11:43:16 -07001003 Instruction::Code opcode = inst->Opcode();
Ian Rogersa9a82542013-10-04 11:17:26 -07001004 switch (opcode) {
1005 case Instruction::APUT_OBJECT:
1006 case Instruction::CHECK_CAST:
1007 has_check_casts_ = true;
1008 break;
1009 case Instruction::INVOKE_VIRTUAL:
1010 case Instruction::INVOKE_VIRTUAL_RANGE:
1011 case Instruction::INVOKE_INTERFACE:
1012 case Instruction::INVOKE_INTERFACE_RANGE:
1013 has_virtual_or_interface_invokes_ = true;
1014 break;
1015 case Instruction::MONITOR_ENTER:
1016 monitor_enter_count++;
1017 break;
1018 case Instruction::NEW_INSTANCE:
1019 new_instance_count++;
1020 break;
1021 default:
1022 break;
jeffhaobdb76512011-09-07 11:43:16 -07001023 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001024 size_t inst_size = inst->SizeInCodeUnits();
Mathieu Chartierde40d472015-10-15 17:47:48 -07001025 GetInstructionFlags(dex_pc).SetIsOpcode();
Ian Rogersd81871c2011-10-03 13:57:23 -07001026 dex_pc += inst_size;
Ian Rogers7b078e82014-09-10 14:44:24 -07001027 inst = inst->RelativeAt(inst_size);
jeffhaobdb76512011-09-07 11:43:16 -07001028 }
1029
Ian Rogersd81871c2011-10-03 13:57:23 -07001030 if (dex_pc != insns_size) {
jeffhaod5347e02012-03-22 17:25:05 -07001031 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "code did not end where expected ("
1032 << dex_pc << " vs. " << insns_size << ")";
jeffhaobdb76512011-09-07 11:43:16 -07001033 return false;
1034 }
1035
Ian Rogersd81871c2011-10-03 13:57:23 -07001036 new_instance_count_ = new_instance_count;
1037 monitor_enter_count_ = monitor_enter_count;
jeffhaobdb76512011-09-07 11:43:16 -07001038 return true;
1039}
1040
Ian Rogers776ac1f2012-04-13 23:36:36 -07001041bool MethodVerifier::ScanTryCatchBlocks() {
Ian Rogersd81871c2011-10-03 13:57:23 -07001042 uint32_t tries_size = code_item_->tries_size_;
jeffhaobdb76512011-09-07 11:43:16 -07001043 if (tries_size == 0) {
1044 return true;
1045 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001046 uint32_t insns_size = code_item_->insns_size_in_code_units_;
Ian Rogers0571d352011-11-03 19:51:38 -07001047 const DexFile::TryItem* tries = DexFile::GetTryItems(*code_item_, 0);
jeffhaobdb76512011-09-07 11:43:16 -07001048
1049 for (uint32_t idx = 0; idx < tries_size; idx++) {
1050 const DexFile::TryItem* try_item = &tries[idx];
1051 uint32_t start = try_item->start_addr_;
1052 uint32_t end = start + try_item->insn_count_;
jeffhaobdb76512011-09-07 11:43:16 -07001053 if ((start >= end) || (start >= insns_size) || (end > insns_size)) {
jeffhaod5347e02012-03-22 17:25:05 -07001054 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad exception entry: startAddr=" << start
1055 << " endAddr=" << end << " (size=" << insns_size << ")";
jeffhaobdb76512011-09-07 11:43:16 -07001056 return false;
1057 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07001058 if (!GetInstructionFlags(start).IsOpcode()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001059 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1060 << "'try' block starts inside an instruction (" << start << ")";
jeffhaobdb76512011-09-07 11:43:16 -07001061 return false;
1062 }
Ian Rogers7b078e82014-09-10 14:44:24 -07001063 uint32_t dex_pc = start;
1064 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
1065 while (dex_pc < end) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001066 GetInstructionFlags(dex_pc).SetInTry();
Ian Rogers7b078e82014-09-10 14:44:24 -07001067 size_t insn_size = inst->SizeInCodeUnits();
1068 dex_pc += insn_size;
1069 inst = inst->RelativeAt(insn_size);
jeffhaobdb76512011-09-07 11:43:16 -07001070 }
1071 }
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001072 // Iterate over each of the handlers to verify target addresses.
Ian Rogers13735952014-10-08 12:43:28 -07001073 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item_, 0);
jeffhaobdb76512011-09-07 11:43:16 -07001074 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001075 ClassLinker* linker = Runtime::Current()->GetClassLinker();
jeffhaobdb76512011-09-07 11:43:16 -07001076 for (uint32_t idx = 0; idx < handlers_size; idx++) {
Ian Rogers0571d352011-11-03 19:51:38 -07001077 CatchHandlerIterator iterator(handlers_ptr);
1078 for (; iterator.HasNext(); iterator.Next()) {
1079 uint32_t dex_pc= iterator.GetHandlerAddress();
Mathieu Chartierde40d472015-10-15 17:47:48 -07001080 if (!GetInstructionFlags(dex_pc).IsOpcode()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001081 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1082 << "exception handler starts at bad address (" << dex_pc << ")";
jeffhaobdb76512011-09-07 11:43:16 -07001083 return false;
1084 }
Stephen Kyle9bc61992014-09-22 13:53:15 +01001085 if (!CheckNotMoveResult(code_item_->insns_, dex_pc)) {
1086 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1087 << "exception handler begins with move-result* (" << dex_pc << ")";
1088 return false;
1089 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07001090 GetInstructionFlags(dex_pc).SetBranchTarget();
Ian Rogers28ad40d2011-10-27 15:19:26 -07001091 // Ensure exception types are resolved so that they don't need resolution to be delivered,
1092 // unresolved exception types will be ignored by exception delivery
Andreas Gampea5b09a62016-11-17 15:21:22 -08001093 if (iterator.GetHandlerTypeIndex().IsValid()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001094 mirror::Class* exception_type = linker->ResolveType(*dex_file_,
1095 iterator.GetHandlerTypeIndex(),
Mathieu Chartierbf99f772014-08-23 16:37:27 -07001096 dex_cache_, class_loader_);
Ian Rogers7b078e82014-09-10 14:44:24 -07001097 if (exception_type == nullptr) {
1098 DCHECK(self_->IsExceptionPending());
1099 self_->ClearException();
Ian Rogers28ad40d2011-10-27 15:19:26 -07001100 }
1101 }
jeffhaobdb76512011-09-07 11:43:16 -07001102 }
Ian Rogers0571d352011-11-03 19:51:38 -07001103 handlers_ptr = iterator.EndDataPointer();
jeffhaobdb76512011-09-07 11:43:16 -07001104 }
jeffhaobdb76512011-09-07 11:43:16 -07001105 return true;
1106}
1107
Ian Rogers776ac1f2012-04-13 23:36:36 -07001108bool MethodVerifier::VerifyInstructions() {
Ian Rogersd81871c2011-10-03 13:57:23 -07001109 const Instruction* inst = Instruction::At(code_item_->insns_);
jeffhaoba5ebb92011-08-25 17:24:37 -07001110
Ian Rogers0c7abda2012-09-19 13:33:42 -07001111 /* Flag the start of the method as a branch target, and a GC point due to stack overflow errors */
Mathieu Chartierde40d472015-10-15 17:47:48 -07001112 GetInstructionFlags(0).SetBranchTarget();
1113 GetInstructionFlags(0).SetCompileTimeInfoPoint();
Ian Rogersd81871c2011-10-03 13:57:23 -07001114
1115 uint32_t insns_size = code_item_->insns_size_in_code_units_;
Elliott Hughesb25c3f62012-03-26 16:35:06 -07001116 for (uint32_t dex_pc = 0; dex_pc < insns_size;) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001117 if (!VerifyInstruction(inst, dex_pc)) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07001118 DCHECK_NE(failures_.size(), 0U);
Ian Rogersd81871c2011-10-03 13:57:23 -07001119 return false;
1120 }
1121 /* Flag instructions that are garbage collection points */
Sameer Abu Asal02c42232013-04-30 12:09:45 -07001122 // All invoke points are marked as "Throw" points already.
1123 // We are relying on this to also count all the invokes as interesting.
Vladimir Marko8b858e12014-11-27 14:52:37 +00001124 if (inst->IsBranch()) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001125 GetInstructionFlags(dex_pc).SetCompileTimeInfoPoint();
Vladimir Marko8b858e12014-11-27 14:52:37 +00001126 // The compiler also needs safepoints for fall-through to loop heads.
1127 // Such a loop head must be a target of a branch.
1128 int32_t offset = 0;
1129 bool cond, self_ok;
1130 bool target_ok = GetBranchOffset(dex_pc, &offset, &cond, &self_ok);
1131 DCHECK(target_ok);
Mathieu Chartierde40d472015-10-15 17:47:48 -07001132 GetInstructionFlags(dex_pc + offset).SetCompileTimeInfoPoint();
Vladimir Marko8b858e12014-11-27 14:52:37 +00001133 } else if (inst->IsSwitch() || inst->IsThrow()) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001134 GetInstructionFlags(dex_pc).SetCompileTimeInfoPoint();
Ian Rogersb8c78592013-07-25 23:52:52 +00001135 } else if (inst->IsReturn()) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001136 GetInstructionFlags(dex_pc).SetCompileTimeInfoPointAndReturn();
Ian Rogersd81871c2011-10-03 13:57:23 -07001137 }
1138 dex_pc += inst->SizeInCodeUnits();
1139 inst = inst->Next();
1140 }
1141 return true;
1142}
1143
Ian Rogers776ac1f2012-04-13 23:36:36 -07001144bool MethodVerifier::VerifyInstruction(const Instruction* inst, uint32_t code_offset) {
Igor Murashkin4d7b75f2015-07-21 17:03:36 -07001145 if (UNLIKELY(inst->IsExperimental())) {
1146 // Experimental instructions don't yet have verifier support implementation.
1147 // While it is possible to use them by themselves, when we try to use stable instructions
1148 // with a virtual register that was created by an experimental instruction,
1149 // the data flow analysis will fail.
1150 Fail(VERIFY_ERROR_FORCE_INTERPRETER)
1151 << "experimental instruction is not supported by verifier; skipping verification";
1152 have_pending_experimental_failure_ = true;
1153 return false;
1154 }
1155
Ian Rogersd81871c2011-10-03 13:57:23 -07001156 bool result = true;
1157 switch (inst->GetVerifyTypeArgumentA()) {
1158 case Instruction::kVerifyRegA:
Ian Rogers29a26482014-05-02 15:27:29 -07001159 result = result && CheckRegisterIndex(inst->VRegA());
Ian Rogersd81871c2011-10-03 13:57:23 -07001160 break;
1161 case Instruction::kVerifyRegAWide:
Ian Rogers29a26482014-05-02 15:27:29 -07001162 result = result && CheckWideRegisterIndex(inst->VRegA());
Ian Rogersd81871c2011-10-03 13:57:23 -07001163 break;
1164 }
1165 switch (inst->GetVerifyTypeArgumentB()) {
1166 case Instruction::kVerifyRegB:
Ian Rogers29a26482014-05-02 15:27:29 -07001167 result = result && CheckRegisterIndex(inst->VRegB());
Ian Rogersd81871c2011-10-03 13:57:23 -07001168 break;
1169 case Instruction::kVerifyRegBField:
Ian Rogers29a26482014-05-02 15:27:29 -07001170 result = result && CheckFieldIndex(inst->VRegB());
Ian Rogersd81871c2011-10-03 13:57:23 -07001171 break;
1172 case Instruction::kVerifyRegBMethod:
Ian Rogers29a26482014-05-02 15:27:29 -07001173 result = result && CheckMethodIndex(inst->VRegB());
Ian Rogersd81871c2011-10-03 13:57:23 -07001174 break;
1175 case Instruction::kVerifyRegBNewInstance:
Andreas Gampea5b09a62016-11-17 15:21:22 -08001176 result = result && CheckNewInstance(dex::TypeIndex(inst->VRegB()));
Ian Rogersd81871c2011-10-03 13:57:23 -07001177 break;
1178 case Instruction::kVerifyRegBString:
Ian Rogers29a26482014-05-02 15:27:29 -07001179 result = result && CheckStringIndex(inst->VRegB());
Ian Rogersd81871c2011-10-03 13:57:23 -07001180 break;
1181 case Instruction::kVerifyRegBType:
Andreas Gampea5b09a62016-11-17 15:21:22 -08001182 result = result && CheckTypeIndex(dex::TypeIndex(inst->VRegB()));
Ian Rogersd81871c2011-10-03 13:57:23 -07001183 break;
1184 case Instruction::kVerifyRegBWide:
Ian Rogers29a26482014-05-02 15:27:29 -07001185 result = result && CheckWideRegisterIndex(inst->VRegB());
Ian Rogersd81871c2011-10-03 13:57:23 -07001186 break;
1187 }
1188 switch (inst->GetVerifyTypeArgumentC()) {
1189 case Instruction::kVerifyRegC:
Ian Rogers29a26482014-05-02 15:27:29 -07001190 result = result && CheckRegisterIndex(inst->VRegC());
Ian Rogersd81871c2011-10-03 13:57:23 -07001191 break;
1192 case Instruction::kVerifyRegCField:
Ian Rogers29a26482014-05-02 15:27:29 -07001193 result = result && CheckFieldIndex(inst->VRegC());
Ian Rogersd81871c2011-10-03 13:57:23 -07001194 break;
1195 case Instruction::kVerifyRegCNewArray:
Andreas Gampea5b09a62016-11-17 15:21:22 -08001196 result = result && CheckNewArray(dex::TypeIndex(inst->VRegC()));
Ian Rogersd81871c2011-10-03 13:57:23 -07001197 break;
1198 case Instruction::kVerifyRegCType:
Andreas Gampea5b09a62016-11-17 15:21:22 -08001199 result = result && CheckTypeIndex(dex::TypeIndex(inst->VRegC()));
Ian Rogersd81871c2011-10-03 13:57:23 -07001200 break;
1201 case Instruction::kVerifyRegCWide:
Ian Rogers29a26482014-05-02 15:27:29 -07001202 result = result && CheckWideRegisterIndex(inst->VRegC());
Ian Rogersd81871c2011-10-03 13:57:23 -07001203 break;
1204 }
Orion Hodsoncfa325e2016-10-13 10:25:54 +01001205 switch (inst->GetVerifyTypeArgumentH()) {
1206 case Instruction::kVerifyRegHPrototype:
1207 result = result && CheckPrototypeIndex(inst->VRegH());
1208 break;
1209 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001210 switch (inst->GetVerifyExtraFlags()) {
1211 case Instruction::kVerifyArrayData:
1212 result = result && CheckArrayData(code_offset);
1213 break;
1214 case Instruction::kVerifyBranchTarget:
1215 result = result && CheckBranchTarget(code_offset);
1216 break;
1217 case Instruction::kVerifySwitchTargets:
1218 result = result && CheckSwitchTargets(code_offset);
1219 break;
Andreas Gampec3314312014-06-19 18:13:29 -07001220 case Instruction::kVerifyVarArgNonZero:
1221 // Fall-through.
Ian Rogers29a26482014-05-02 15:27:29 -07001222 case Instruction::kVerifyVarArg: {
Taiju Tsuiki29498a22015-04-13 14:21:00 +09001223 // Instructions that can actually return a negative value shouldn't have this flag.
1224 uint32_t v_a = dchecked_integral_cast<uint32_t>(inst->VRegA());
1225 if ((inst->GetVerifyExtraFlags() == Instruction::kVerifyVarArgNonZero && v_a == 0) ||
1226 v_a > Instruction::kMaxVarArgRegs) {
1227 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid arg count (" << v_a << ") in "
Andreas Gampec3314312014-06-19 18:13:29 -07001228 "non-range invoke";
1229 return false;
1230 }
Taiju Tsuiki29498a22015-04-13 14:21:00 +09001231
Ian Rogers29a26482014-05-02 15:27:29 -07001232 uint32_t args[Instruction::kMaxVarArgRegs];
1233 inst->GetVarArgs(args);
Taiju Tsuiki29498a22015-04-13 14:21:00 +09001234 result = result && CheckVarArgRegs(v_a, args);
Ian Rogersd81871c2011-10-03 13:57:23 -07001235 break;
Ian Rogers29a26482014-05-02 15:27:29 -07001236 }
Andreas Gampec3314312014-06-19 18:13:29 -07001237 case Instruction::kVerifyVarArgRangeNonZero:
1238 // Fall-through.
Ian Rogersd81871c2011-10-03 13:57:23 -07001239 case Instruction::kVerifyVarArgRange:
Andreas Gampec3314312014-06-19 18:13:29 -07001240 if (inst->GetVerifyExtraFlags() == Instruction::kVerifyVarArgRangeNonZero &&
1241 inst->VRegA() <= 0) {
1242 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid arg count (" << inst->VRegA() << ") in "
1243 "range invoke";
1244 return false;
1245 }
Ian Rogers29a26482014-05-02 15:27:29 -07001246 result = result && CheckVarArgRangeRegs(inst->VRegA(), inst->VRegC());
Ian Rogersd81871c2011-10-03 13:57:23 -07001247 break;
1248 case Instruction::kVerifyError:
jeffhaod5347e02012-03-22 17:25:05 -07001249 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected opcode " << inst->Name();
Ian Rogersd81871c2011-10-03 13:57:23 -07001250 result = false;
1251 break;
1252 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001253 if (inst->GetVerifyIsRuntimeOnly() && Runtime::Current()->IsAotCompiler() && !verify_to_dump_) {
Ian Rogers5fb22a92014-06-13 10:31:28 -07001254 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "opcode only expected at runtime " << inst->Name();
1255 result = false;
1256 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001257 return result;
1258}
1259
Ian Rogers7b078e82014-09-10 14:44:24 -07001260inline bool MethodVerifier::CheckRegisterIndex(uint32_t idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001261 if (idx >= code_item_->registers_size_) {
jeffhaod5347e02012-03-22 17:25:05 -07001262 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "register index out of range (" << idx << " >= "
1263 << code_item_->registers_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001264 return false;
1265 }
1266 return true;
1267}
1268
Ian Rogers7b078e82014-09-10 14:44:24 -07001269inline bool MethodVerifier::CheckWideRegisterIndex(uint32_t idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001270 if (idx + 1 >= code_item_->registers_size_) {
jeffhaod5347e02012-03-22 17:25:05 -07001271 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "wide register index out of range (" << idx
1272 << "+1 >= " << code_item_->registers_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001273 return false;
1274 }
1275 return true;
1276}
1277
Ian Rogers7b078e82014-09-10 14:44:24 -07001278inline bool MethodVerifier::CheckFieldIndex(uint32_t idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001279 if (idx >= dex_file_->GetHeader().field_ids_size_) {
jeffhaod5347e02012-03-22 17:25:05 -07001280 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad field index " << idx << " (max "
1281 << dex_file_->GetHeader().field_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001282 return false;
1283 }
1284 return true;
1285}
1286
Ian Rogers7b078e82014-09-10 14:44:24 -07001287inline bool MethodVerifier::CheckMethodIndex(uint32_t idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001288 if (idx >= dex_file_->GetHeader().method_ids_size_) {
jeffhaod5347e02012-03-22 17:25:05 -07001289 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad method index " << idx << " (max "
1290 << dex_file_->GetHeader().method_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001291 return false;
1292 }
1293 return true;
1294}
1295
Andreas Gampea5b09a62016-11-17 15:21:22 -08001296inline bool MethodVerifier::CheckNewInstance(dex::TypeIndex idx) {
1297 if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
1298 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
jeffhaod5347e02012-03-22 17:25:05 -07001299 << dex_file_->GetHeader().type_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001300 return false;
1301 }
1302 // We don't need the actual class, just a pointer to the class name.
Ian Rogers0571d352011-11-03 19:51:38 -07001303 const char* descriptor = dex_file_->StringByTypeIdx(idx);
Ian Rogersd81871c2011-10-03 13:57:23 -07001304 if (descriptor[0] != 'L') {
jeffhaod5347e02012-03-22 17:25:05 -07001305 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "can't call new-instance on type '" << descriptor << "'";
Ian Rogersd81871c2011-10-03 13:57:23 -07001306 return false;
Aart Bikdb698f12016-07-25 17:52:22 -07001307 } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
1308 // An unlikely new instance on Class is not allowed. Fall back to interpreter to ensure an
1309 // exception is thrown when this statement is executed (compiled code would not do that).
1310 Fail(VERIFY_ERROR_INSTANTIATION);
Ian Rogersd81871c2011-10-03 13:57:23 -07001311 }
1312 return true;
1313}
1314
Orion Hodsoncfa325e2016-10-13 10:25:54 +01001315inline bool MethodVerifier::CheckPrototypeIndex(uint32_t idx) {
1316 if (idx >= dex_file_->GetHeader().proto_ids_size_) {
1317 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad prototype index " << idx << " (max "
1318 << dex_file_->GetHeader().proto_ids_size_ << ")";
1319 return false;
1320 }
1321 return true;
1322}
1323
Ian Rogers7b078e82014-09-10 14:44:24 -07001324inline bool MethodVerifier::CheckStringIndex(uint32_t idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001325 if (idx >= dex_file_->GetHeader().string_ids_size_) {
jeffhaod5347e02012-03-22 17:25:05 -07001326 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad string index " << idx << " (max "
1327 << dex_file_->GetHeader().string_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001328 return false;
1329 }
1330 return true;
1331}
1332
Andreas Gampea5b09a62016-11-17 15:21:22 -08001333inline bool MethodVerifier::CheckTypeIndex(dex::TypeIndex idx) {
1334 if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
1335 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
jeffhaod5347e02012-03-22 17:25:05 -07001336 << dex_file_->GetHeader().type_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001337 return false;
1338 }
1339 return true;
1340}
1341
Andreas Gampea5b09a62016-11-17 15:21:22 -08001342bool MethodVerifier::CheckNewArray(dex::TypeIndex idx) {
1343 if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
1344 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
jeffhaod5347e02012-03-22 17:25:05 -07001345 << dex_file_->GetHeader().type_ids_size_ << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001346 return false;
1347 }
1348 int bracket_count = 0;
Ian Rogers0571d352011-11-03 19:51:38 -07001349 const char* descriptor = dex_file_->StringByTypeIdx(idx);
Ian Rogersd81871c2011-10-03 13:57:23 -07001350 const char* cp = descriptor;
1351 while (*cp++ == '[') {
1352 bracket_count++;
1353 }
1354 if (bracket_count == 0) {
1355 /* The given class must be an array type. */
Brian Carlstrom93c33962013-07-26 10:37:43 -07001356 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1357 << "can't new-array class '" << descriptor << "' (not an array)";
Ian Rogersd81871c2011-10-03 13:57:23 -07001358 return false;
1359 } else if (bracket_count > 255) {
1360 /* It is illegal to create an array of more than 255 dimensions. */
Brian Carlstrom93c33962013-07-26 10:37:43 -07001361 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1362 << "can't new-array class '" << descriptor << "' (exceeds limit)";
Ian Rogersd81871c2011-10-03 13:57:23 -07001363 return false;
1364 }
1365 return true;
1366}
1367
Ian Rogers776ac1f2012-04-13 23:36:36 -07001368bool MethodVerifier::CheckArrayData(uint32_t cur_offset) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001369 const uint32_t insn_count = code_item_->insns_size_in_code_units_;
1370 const uint16_t* insns = code_item_->insns_ + cur_offset;
1371 const uint16_t* array_data;
1372 int32_t array_data_offset;
1373
1374 DCHECK_LT(cur_offset, insn_count);
1375 /* make sure the start of the array data table is in range */
Andreas Gampe53de99c2015-08-17 13:43:55 -07001376 array_data_offset = insns[1] | (static_cast<int32_t>(insns[2]) << 16);
1377 if (static_cast<int32_t>(cur_offset) + array_data_offset < 0 ||
Ian Rogersd81871c2011-10-03 13:57:23 -07001378 cur_offset + array_data_offset + 2 >= insn_count) {
jeffhaod5347e02012-03-22 17:25:05 -07001379 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid array data start: at " << cur_offset
Brian Carlstrom93c33962013-07-26 10:37:43 -07001380 << ", data offset " << array_data_offset
1381 << ", count " << insn_count;
Ian Rogersd81871c2011-10-03 13:57:23 -07001382 return false;
1383 }
1384 /* offset to array data table is a relative branch-style offset */
1385 array_data = insns + array_data_offset;
Andreas Gampe57c47582015-07-01 22:05:59 -07001386 // Make sure the table is at an even dex pc, that is, 32-bit aligned.
1387 if (!IsAligned<4>(array_data)) {
jeffhaod5347e02012-03-22 17:25:05 -07001388 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unaligned array data table: at " << cur_offset
1389 << ", data offset " << array_data_offset;
Ian Rogersd81871c2011-10-03 13:57:23 -07001390 return false;
1391 }
Andreas Gampe57c47582015-07-01 22:05:59 -07001392 // Make sure the array-data is marked as an opcode. This ensures that it was reached when
1393 // traversing the code item linearly. It is an approximation for a by-spec padding value.
Mathieu Chartierde40d472015-10-15 17:47:48 -07001394 if (!GetInstructionFlags(cur_offset + array_data_offset).IsOpcode()) {
Andreas Gampe57c47582015-07-01 22:05:59 -07001395 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array data table at " << cur_offset
1396 << ", data offset " << array_data_offset
1397 << " not correctly visited, probably bad padding.";
1398 return false;
1399 }
1400
Ian Rogersd81871c2011-10-03 13:57:23 -07001401 uint32_t value_width = array_data[1];
Elliott Hughes398f64b2012-03-26 18:05:48 -07001402 uint32_t value_count = *reinterpret_cast<const uint32_t*>(&array_data[2]);
Ian Rogersd81871c2011-10-03 13:57:23 -07001403 uint32_t table_size = 4 + (value_width * value_count + 1) / 2;
1404 /* make sure the end of the switch is in range */
1405 if (cur_offset + array_data_offset + table_size > insn_count) {
jeffhaod5347e02012-03-22 17:25:05 -07001406 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid array data end: at " << cur_offset
1407 << ", data offset " << array_data_offset << ", end "
1408 << cur_offset + array_data_offset + table_size
1409 << ", count " << insn_count;
Ian Rogersd81871c2011-10-03 13:57:23 -07001410 return false;
1411 }
1412 return true;
1413}
1414
Ian Rogers776ac1f2012-04-13 23:36:36 -07001415bool MethodVerifier::CheckBranchTarget(uint32_t cur_offset) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001416 int32_t offset;
1417 bool isConditional, selfOkay;
1418 if (!GetBranchOffset(cur_offset, &offset, &isConditional, &selfOkay)) {
1419 return false;
1420 }
1421 if (!selfOkay && offset == 0) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001422 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "branch offset of zero not allowed at"
1423 << reinterpret_cast<void*>(cur_offset);
Ian Rogersd81871c2011-10-03 13:57:23 -07001424 return false;
1425 }
Elliott Hughes81ff3182012-03-23 20:35:56 -07001426 // Check for 32-bit overflow. This isn't strictly necessary if we can depend on the runtime
1427 // to have identical "wrap-around" behavior, but it's unwise to depend on that.
Ian Rogersd81871c2011-10-03 13:57:23 -07001428 if (((int64_t) cur_offset + (int64_t) offset) != (int64_t) (cur_offset + offset)) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001429 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "branch target overflow "
1430 << reinterpret_cast<void*>(cur_offset) << " +" << offset;
Ian Rogersd81871c2011-10-03 13:57:23 -07001431 return false;
1432 }
1433 const uint32_t insn_count = code_item_->insns_size_in_code_units_;
1434 int32_t abs_offset = cur_offset + offset;
Brian Carlstrom93c33962013-07-26 10:37:43 -07001435 if (abs_offset < 0 ||
1436 (uint32_t) abs_offset >= insn_count ||
Mathieu Chartierde40d472015-10-15 17:47:48 -07001437 !GetInstructionFlags(abs_offset).IsOpcode()) {
jeffhaod5347e02012-03-22 17:25:05 -07001438 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid branch target " << offset << " (-> "
Elliott Hughes398f64b2012-03-26 18:05:48 -07001439 << reinterpret_cast<void*>(abs_offset) << ") at "
1440 << reinterpret_cast<void*>(cur_offset);
Ian Rogersd81871c2011-10-03 13:57:23 -07001441 return false;
1442 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07001443 GetInstructionFlags(abs_offset).SetBranchTarget();
Ian Rogersd81871c2011-10-03 13:57:23 -07001444 return true;
1445}
1446
Ian Rogers776ac1f2012-04-13 23:36:36 -07001447bool MethodVerifier::GetBranchOffset(uint32_t cur_offset, int32_t* pOffset, bool* pConditional,
Ian Rogersd81871c2011-10-03 13:57:23 -07001448 bool* selfOkay) {
1449 const uint16_t* insns = code_item_->insns_ + cur_offset;
1450 *pConditional = false;
1451 *selfOkay = false;
jeffhaoba5ebb92011-08-25 17:24:37 -07001452 switch (*insns & 0xff) {
1453 case Instruction::GOTO:
1454 *pOffset = ((int16_t) *insns) >> 8;
jeffhaoba5ebb92011-08-25 17:24:37 -07001455 break;
1456 case Instruction::GOTO_32:
1457 *pOffset = insns[1] | (((uint32_t) insns[2]) << 16);
jeffhaoba5ebb92011-08-25 17:24:37 -07001458 *selfOkay = true;
1459 break;
1460 case Instruction::GOTO_16:
1461 *pOffset = (int16_t) insns[1];
jeffhaoba5ebb92011-08-25 17:24:37 -07001462 break;
1463 case Instruction::IF_EQ:
1464 case Instruction::IF_NE:
1465 case Instruction::IF_LT:
1466 case Instruction::IF_GE:
1467 case Instruction::IF_GT:
1468 case Instruction::IF_LE:
1469 case Instruction::IF_EQZ:
1470 case Instruction::IF_NEZ:
1471 case Instruction::IF_LTZ:
1472 case Instruction::IF_GEZ:
1473 case Instruction::IF_GTZ:
1474 case Instruction::IF_LEZ:
1475 *pOffset = (int16_t) insns[1];
1476 *pConditional = true;
jeffhaoba5ebb92011-08-25 17:24:37 -07001477 break;
1478 default:
1479 return false;
jeffhaoba5ebb92011-08-25 17:24:37 -07001480 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001481 return true;
1482}
1483
Ian Rogers776ac1f2012-04-13 23:36:36 -07001484bool MethodVerifier::CheckSwitchTargets(uint32_t cur_offset) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001485 const uint32_t insn_count = code_item_->insns_size_in_code_units_;
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07001486 DCHECK_LT(cur_offset, insn_count);
Ian Rogersd81871c2011-10-03 13:57:23 -07001487 const uint16_t* insns = code_item_->insns_ + cur_offset;
jeffhaoba5ebb92011-08-25 17:24:37 -07001488 /* make sure the start of the switch is in range */
Andreas Gampe53de99c2015-08-17 13:43:55 -07001489 int32_t switch_offset = insns[1] | (static_cast<int32_t>(insns[2]) << 16);
1490 if (static_cast<int32_t>(cur_offset) + switch_offset < 0 ||
1491 cur_offset + switch_offset + 2 > insn_count) {
jeffhaod5347e02012-03-22 17:25:05 -07001492 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch start: at " << cur_offset
Brian Carlstrom93c33962013-07-26 10:37:43 -07001493 << ", switch offset " << switch_offset
1494 << ", count " << insn_count;
jeffhaoba5ebb92011-08-25 17:24:37 -07001495 return false;
1496 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001497 /* offset to switch table is a relative branch-style offset */
Ian Rogersd81871c2011-10-03 13:57:23 -07001498 const uint16_t* switch_insns = insns + switch_offset;
Andreas Gampe57c47582015-07-01 22:05:59 -07001499 // Make sure the table is at an even dex pc, that is, 32-bit aligned.
1500 if (!IsAligned<4>(switch_insns)) {
jeffhaod5347e02012-03-22 17:25:05 -07001501 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unaligned switch table: at " << cur_offset
1502 << ", switch offset " << switch_offset;
jeffhaoba5ebb92011-08-25 17:24:37 -07001503 return false;
1504 }
Andreas Gampe57c47582015-07-01 22:05:59 -07001505 // Make sure the switch data is marked as an opcode. This ensures that it was reached when
1506 // traversing the code item linearly. It is an approximation for a by-spec padding value.
Mathieu Chartierde40d472015-10-15 17:47:48 -07001507 if (!GetInstructionFlags(cur_offset + switch_offset).IsOpcode()) {
Andreas Gampe57c47582015-07-01 22:05:59 -07001508 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "switch table at " << cur_offset
1509 << ", switch offset " << switch_offset
1510 << " not correctly visited, probably bad padding.";
1511 return false;
1512 }
1513
David Brazdil5469d342015-09-25 16:57:53 +01001514 bool is_packed_switch = (*insns & 0xff) == Instruction::PACKED_SWITCH;
1515
Ian Rogersd81871c2011-10-03 13:57:23 -07001516 uint32_t switch_count = switch_insns[1];
David Brazdil5469d342015-09-25 16:57:53 +01001517 int32_t targets_offset;
Ian Rogersd81871c2011-10-03 13:57:23 -07001518 uint16_t expected_signature;
David Brazdil5469d342015-09-25 16:57:53 +01001519 if (is_packed_switch) {
jeffhaoba5ebb92011-08-25 17:24:37 -07001520 /* 0=sig, 1=count, 2/3=firstKey */
1521 targets_offset = 4;
jeffhaoba5ebb92011-08-25 17:24:37 -07001522 expected_signature = Instruction::kPackedSwitchSignature;
1523 } else {
1524 /* 0=sig, 1=count, 2..count*2 = keys */
jeffhaoba5ebb92011-08-25 17:24:37 -07001525 targets_offset = 2 + 2 * switch_count;
1526 expected_signature = Instruction::kSparseSwitchSignature;
1527 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001528 uint32_t table_size = targets_offset + switch_count * 2;
jeffhaoba5ebb92011-08-25 17:24:37 -07001529 if (switch_insns[0] != expected_signature) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001530 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
1531 << StringPrintf("wrong signature for switch table (%x, wanted %x)",
1532 switch_insns[0], expected_signature);
jeffhaoba5ebb92011-08-25 17:24:37 -07001533 return false;
1534 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001535 /* make sure the end of the switch is in range */
1536 if (cur_offset + switch_offset + table_size > (uint32_t) insn_count) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001537 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch end: at " << cur_offset
1538 << ", switch offset " << switch_offset
1539 << ", end " << (cur_offset + switch_offset + table_size)
jeffhaod5347e02012-03-22 17:25:05 -07001540 << ", count " << insn_count;
jeffhaoba5ebb92011-08-25 17:24:37 -07001541 return false;
1542 }
David Brazdil5469d342015-09-25 16:57:53 +01001543
1544 constexpr int32_t keys_offset = 2;
1545 if (switch_count > 1) {
1546 if (is_packed_switch) {
1547 /* for a packed switch, verify that keys do not overflow int32 */
1548 int32_t first_key = switch_insns[keys_offset] | (switch_insns[keys_offset + 1] << 16);
1549 int32_t max_first_key =
1550 std::numeric_limits<int32_t>::max() - (static_cast<int32_t>(switch_count) - 1);
1551 if (first_key > max_first_key) {
1552 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid packed switch: first_key=" << first_key
1553 << ", switch_count=" << switch_count;
jeffhaoba5ebb92011-08-25 17:24:37 -07001554 return false;
1555 }
David Brazdil5469d342015-09-25 16:57:53 +01001556 } else {
1557 /* for a sparse switch, verify the keys are in ascending order */
1558 int32_t last_key = switch_insns[keys_offset] | (switch_insns[keys_offset + 1] << 16);
1559 for (uint32_t targ = 1; targ < switch_count; targ++) {
1560 int32_t key =
1561 static_cast<int32_t>(switch_insns[keys_offset + targ * 2]) |
1562 static_cast<int32_t>(switch_insns[keys_offset + targ * 2 + 1] << 16);
1563 if (key <= last_key) {
1564 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid sparse switch: last key=" << last_key
1565 << ", this=" << key;
1566 return false;
1567 }
1568 last_key = key;
1569 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001570 }
1571 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001572 /* verify each switch target */
Ian Rogersd81871c2011-10-03 13:57:23 -07001573 for (uint32_t targ = 0; targ < switch_count; targ++) {
Andreas Gampe53de99c2015-08-17 13:43:55 -07001574 int32_t offset = static_cast<int32_t>(switch_insns[targets_offset + targ * 2]) |
1575 static_cast<int32_t>(switch_insns[targets_offset + targ * 2 + 1] << 16);
Ian Rogersd81871c2011-10-03 13:57:23 -07001576 int32_t abs_offset = cur_offset + offset;
Brian Carlstrom93c33962013-07-26 10:37:43 -07001577 if (abs_offset < 0 ||
Andreas Gampe53de99c2015-08-17 13:43:55 -07001578 abs_offset >= static_cast<int32_t>(insn_count) ||
Mathieu Chartierde40d472015-10-15 17:47:48 -07001579 !GetInstructionFlags(abs_offset).IsOpcode()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001580 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch target " << offset
1581 << " (-> " << reinterpret_cast<void*>(abs_offset) << ") at "
1582 << reinterpret_cast<void*>(cur_offset)
1583 << "[" << targ << "]";
jeffhaoba5ebb92011-08-25 17:24:37 -07001584 return false;
1585 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07001586 GetInstructionFlags(abs_offset).SetBranchTarget();
Ian Rogersd81871c2011-10-03 13:57:23 -07001587 }
1588 return true;
1589}
1590
Ian Rogers776ac1f2012-04-13 23:36:36 -07001591bool MethodVerifier::CheckVarArgRegs(uint32_t vA, uint32_t arg[]) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001592 uint16_t registers_size = code_item_->registers_size_;
1593 for (uint32_t idx = 0; idx < vA; idx++) {
jeffhao457cc512012-02-02 16:55:13 -08001594 if (arg[idx] >= registers_size) {
jeffhaod5347e02012-03-22 17:25:05 -07001595 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid reg index (" << arg[idx]
1596 << ") in non-range invoke (>= " << registers_size << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001597 return false;
1598 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001599 }
1600
1601 return true;
1602}
1603
Ian Rogers776ac1f2012-04-13 23:36:36 -07001604bool MethodVerifier::CheckVarArgRangeRegs(uint32_t vA, uint32_t vC) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001605 uint16_t registers_size = code_item_->registers_size_;
1606 // vA/vC are unsigned 8-bit/16-bit quantities for /range instructions, so there's no risk of
1607 // integer overflow when adding them here.
1608 if (vA + vC > registers_size) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001609 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid reg index " << vA << "+" << vC
1610 << " in range invoke (> " << registers_size << ")";
jeffhaoba5ebb92011-08-25 17:24:37 -07001611 return false;
1612 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001613 return true;
1614}
1615
Ian Rogers776ac1f2012-04-13 23:36:36 -07001616bool MethodVerifier::VerifyCodeFlow() {
Ian Rogersd81871c2011-10-03 13:57:23 -07001617 uint16_t registers_size = code_item_->registers_size_;
1618 uint32_t insns_size = code_item_->insns_size_in_code_units_;
jeffhaobdb76512011-09-07 11:43:16 -07001619
Ian Rogersd81871c2011-10-03 13:57:23 -07001620 /* Create and initialize table holding register status */
Brian Carlstrom93c33962013-07-26 10:37:43 -07001621 reg_table_.Init(kTrackCompilerInterestPoints,
1622 insn_flags_.get(),
1623 insns_size,
1624 registers_size,
1625 this);
Sameer Abu Asal02c42232013-04-30 12:09:45 -07001626
Ian Rogersd0fbd852013-09-24 18:17:04 -07001627 work_line_.reset(RegisterLine::Create(registers_size, this));
1628 saved_line_.reset(RegisterLine::Create(registers_size, this));
jeffhaobdb76512011-09-07 11:43:16 -07001629
Ian Rogersd81871c2011-10-03 13:57:23 -07001630 /* Initialize register types of method arguments. */
1631 if (!SetTypesFromSignature()) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07001632 DCHECK_NE(failures_.size(), 0U);
1633 std::string prepend("Bad signature in ");
David Sehr709b0702016-10-13 09:12:37 -07001634 prepend += dex_file_->PrettyMethod(dex_method_idx_);
Ian Rogersad0b3a32012-04-16 14:50:24 -07001635 PrependToLastFailMessage(prepend);
Ian Rogersd81871c2011-10-03 13:57:23 -07001636 return false;
1637 }
Andreas Gamped5ad72f2015-06-26 17:33:47 -07001638 // We may have a runtime failure here, clear.
1639 have_pending_runtime_throw_failure_ = false;
1640
Ian Rogersd81871c2011-10-03 13:57:23 -07001641 /* Perform code flow verification. */
1642 if (!CodeFlowVerifyMethod()) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07001643 DCHECK_NE(failures_.size(), 0U);
Ian Rogersd81871c2011-10-03 13:57:23 -07001644 return false;
jeffhaobdb76512011-09-07 11:43:16 -07001645 }
jeffhaobdb76512011-09-07 11:43:16 -07001646 return true;
1647}
1648
Ian Rogersad0b3a32012-04-16 14:50:24 -07001649std::ostream& MethodVerifier::DumpFailures(std::ostream& os) {
1650 DCHECK_EQ(failures_.size(), failure_messages_.size());
Jeff Hao4137f482013-11-22 11:44:57 -08001651 for (size_t i = 0; i < failures_.size(); ++i) {
1652 os << failure_messages_[i]->str() << "\n";
Ian Rogersad0b3a32012-04-16 14:50:24 -07001653 }
1654 return os;
1655}
1656
Ian Rogers776ac1f2012-04-13 23:36:36 -07001657void MethodVerifier::Dump(std::ostream& os) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001658 VariableIndentationOutputStream vios(&os);
1659 Dump(&vios);
1660}
1661
1662void MethodVerifier::Dump(VariableIndentationOutputStream* vios) {
Ian Rogers7b078e82014-09-10 14:44:24 -07001663 if (code_item_ == nullptr) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001664 vios->Stream() << "Native method\n";
Ian Rogersd81871c2011-10-03 13:57:23 -07001665 return;
jeffhaobdb76512011-09-07 11:43:16 -07001666 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001667 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001668 vios->Stream() << "Register Types:\n";
1669 ScopedIndentation indent1(vios);
1670 reg_types_.Dump(vios->Stream());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001671 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001672 vios->Stream() << "Dumping instructions and register lines:\n";
1673 ScopedIndentation indent1(vios);
Ian Rogersd81871c2011-10-03 13:57:23 -07001674 const Instruction* inst = Instruction::At(code_item_->insns_);
1675 for (size_t dex_pc = 0; dex_pc < code_item_->insns_size_in_code_units_;
Andreas Gampeebf850c2015-08-14 15:37:35 -07001676 dex_pc += inst->SizeInCodeUnits(), inst = inst->Next()) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001677 RegisterLine* reg_line = reg_table_.GetLine(dex_pc);
Ian Rogers7b078e82014-09-10 14:44:24 -07001678 if (reg_line != nullptr) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001679 vios->Stream() << reg_line->Dump(this) << "\n";
jeffhaobdb76512011-09-07 11:43:16 -07001680 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001681 vios->Stream()
Mathieu Chartierde40d472015-10-15 17:47:48 -07001682 << StringPrintf("0x%04zx", dex_pc) << ": " << GetInstructionFlags(dex_pc).ToString() << " ";
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001683 const bool kDumpHexOfInstruction = false;
1684 if (kDumpHexOfInstruction) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001685 vios->Stream() << inst->DumpHex(5) << " ";
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001686 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001687 vios->Stream() << inst->DumpString(dex_file_) << "\n";
jeffhaoba5ebb92011-08-25 17:24:37 -07001688 }
jeffhaobdb76512011-09-07 11:43:16 -07001689}
1690
Ian Rogersd81871c2011-10-03 13:57:23 -07001691static bool IsPrimitiveDescriptor(char descriptor) {
1692 switch (descriptor) {
jeffhaobdb76512011-09-07 11:43:16 -07001693 case 'I':
1694 case 'C':
1695 case 'S':
1696 case 'B':
1697 case 'Z':
jeffhaobdb76512011-09-07 11:43:16 -07001698 case 'F':
1699 case 'D':
1700 case 'J':
Ian Rogersd81871c2011-10-03 13:57:23 -07001701 return true;
jeffhaobdb76512011-09-07 11:43:16 -07001702 default:
1703 return false;
1704 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001705}
1706
Ian Rogers776ac1f2012-04-13 23:36:36 -07001707bool MethodVerifier::SetTypesFromSignature() {
Ian Rogersd81871c2011-10-03 13:57:23 -07001708 RegisterLine* reg_line = reg_table_.GetLine(0);
Andreas Gampeef0b1a12015-06-19 20:37:46 -07001709
1710 // Should have been verified earlier.
1711 DCHECK_GE(code_item_->registers_size_, code_item_->ins_size_);
1712
1713 uint32_t arg_start = code_item_->registers_size_ - code_item_->ins_size_;
Ian Rogersd81871c2011-10-03 13:57:23 -07001714 size_t expected_args = code_item_->ins_size_; /* long/double count as two */
jeffhaobdb76512011-09-07 11:43:16 -07001715
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001716 // Include the "this" pointer.
Ian Rogersd81871c2011-10-03 13:57:23 -07001717 size_t cur_arg = 0;
Ian Rogersad0b3a32012-04-16 14:50:24 -07001718 if (!IsStatic()) {
Andreas Gampeef0b1a12015-06-19 20:37:46 -07001719 if (expected_args == 0) {
1720 // Expect at least a receiver.
1721 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected 0 args, but method is not static";
1722 return false;
1723 }
1724
Ian Rogersd81871c2011-10-03 13:57:23 -07001725 // If this is a constructor for a class other than java.lang.Object, mark the first ("this")
1726 // argument as uninitialized. This restricts field access until the superclass constructor is
1727 // called.
Ian Rogersd8f69b02014-09-10 21:43:52 +00001728 const RegType& declaring_class = GetDeclaringClass();
Andreas Gampef10b6e12015-08-12 10:48:12 -07001729 if (IsConstructor()) {
1730 if (declaring_class.IsJavaLangObject()) {
1731 // "this" is implicitly initialized.
1732 reg_line->SetThisInitialized();
Andreas Gampead238ce2015-08-24 21:13:08 -07001733 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, declaring_class);
Andreas Gampef10b6e12015-08-12 10:48:12 -07001734 } else {
Andreas Gampead238ce2015-08-24 21:13:08 -07001735 reg_line->SetRegisterType<LockOp::kClear>(
1736 this,
1737 arg_start + cur_arg,
1738 reg_types_.UninitializedThisArgument(declaring_class));
Andreas Gampef10b6e12015-08-12 10:48:12 -07001739 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001740 } else {
Andreas Gampead238ce2015-08-24 21:13:08 -07001741 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, declaring_class);
jeffhaobdb76512011-09-07 11:43:16 -07001742 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001743 cur_arg++;
jeffhaobdb76512011-09-07 11:43:16 -07001744 }
1745
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001746 const DexFile::ProtoId& proto_id =
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001747 dex_file_->GetMethodPrototype(dex_file_->GetMethodId(dex_method_idx_));
Ian Rogers0571d352011-11-03 19:51:38 -07001748 DexFileParameterIterator iterator(*dex_file_, proto_id);
Ian Rogersd81871c2011-10-03 13:57:23 -07001749
1750 for (; iterator.HasNext(); iterator.Next()) {
1751 const char* descriptor = iterator.GetDescriptor();
Ian Rogers7b078e82014-09-10 14:44:24 -07001752 if (descriptor == nullptr) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001753 LOG(FATAL) << "Null descriptor";
1754 }
1755 if (cur_arg >= expected_args) {
jeffhaod5347e02012-03-22 17:25:05 -07001756 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected " << expected_args
1757 << " args, found more (" << descriptor << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07001758 return false;
1759 }
1760 switch (descriptor[0]) {
1761 case 'L':
1762 case '[':
1763 // We assume that reference arguments are initialized. The only way it could be otherwise
1764 // (assuming the caller was verified) is if the current method is <init>, but in that case
1765 // it's effectively considered initialized the instant we reach here (in the sense that we
1766 // can return without doing anything or call virtual methods).
1767 {
Ian Rogersd8f69b02014-09-10 21:43:52 +00001768 const RegType& reg_type = ResolveClassAndCheckAccess(iterator.GetTypeIdx());
Sebastien Hertz2ed76f92014-04-22 17:11:08 +02001769 if (!reg_type.IsNonZeroReferenceTypes()) {
1770 DCHECK(HasFailures());
1771 return false;
1772 }
Andreas Gampead238ce2015-08-24 21:13:08 -07001773 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_type);
Ian Rogersd81871c2011-10-03 13:57:23 -07001774 }
1775 break;
1776 case 'Z':
Andreas Gampead238ce2015-08-24 21:13:08 -07001777 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Boolean());
Ian Rogersd81871c2011-10-03 13:57:23 -07001778 break;
1779 case 'C':
Andreas Gampead238ce2015-08-24 21:13:08 -07001780 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Char());
Ian Rogersd81871c2011-10-03 13:57:23 -07001781 break;
1782 case 'B':
Andreas Gampead238ce2015-08-24 21:13:08 -07001783 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Byte());
Ian Rogersd81871c2011-10-03 13:57:23 -07001784 break;
1785 case 'I':
Andreas Gampead238ce2015-08-24 21:13:08 -07001786 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Integer());
Ian Rogersd81871c2011-10-03 13:57:23 -07001787 break;
1788 case 'S':
Andreas Gampead238ce2015-08-24 21:13:08 -07001789 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Short());
Ian Rogersd81871c2011-10-03 13:57:23 -07001790 break;
1791 case 'F':
Andreas Gampead238ce2015-08-24 21:13:08 -07001792 reg_line->SetRegisterType<LockOp::kClear>(this, arg_start + cur_arg, reg_types_.Float());
Ian Rogersd81871c2011-10-03 13:57:23 -07001793 break;
1794 case 'J':
1795 case 'D': {
Andreas Gampe77cd4d62014-06-19 17:29:48 -07001796 if (cur_arg + 1 >= expected_args) {
1797 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected " << expected_args
1798 << " args, found more (" << descriptor << ")";
1799 return false;
1800 }
1801
Ian Rogers7b078e82014-09-10 14:44:24 -07001802 const RegType* lo_half;
1803 const RegType* hi_half;
1804 if (descriptor[0] == 'J') {
1805 lo_half = &reg_types_.LongLo();
1806 hi_half = &reg_types_.LongHi();
1807 } else {
1808 lo_half = &reg_types_.DoubleLo();
1809 hi_half = &reg_types_.DoubleHi();
1810 }
1811 reg_line->SetRegisterTypeWide(this, arg_start + cur_arg, *lo_half, *hi_half);
Ian Rogersd81871c2011-10-03 13:57:23 -07001812 cur_arg++;
1813 break;
1814 }
1815 default:
Brian Carlstrom93c33962013-07-26 10:37:43 -07001816 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected signature type char '"
1817 << descriptor << "'";
Ian Rogersd81871c2011-10-03 13:57:23 -07001818 return false;
1819 }
1820 cur_arg++;
1821 }
1822 if (cur_arg != expected_args) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001823 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected " << expected_args
1824 << " arguments, found " << cur_arg;
Ian Rogersd81871c2011-10-03 13:57:23 -07001825 return false;
1826 }
1827 const char* descriptor = dex_file_->GetReturnTypeDescriptor(proto_id);
1828 // Validate return type. We don't do the type lookup; just want to make sure that it has the right
1829 // format. Only major difference from the method argument format is that 'V' is supported.
1830 bool result;
1831 if (IsPrimitiveDescriptor(descriptor[0]) || descriptor[0] == 'V') {
1832 result = descriptor[1] == '\0';
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001833 } else if (descriptor[0] == '[') { // single/multi-dimensional array of object/primitive
Ian Rogersd81871c2011-10-03 13:57:23 -07001834 size_t i = 0;
1835 do {
1836 i++;
1837 } while (descriptor[i] == '['); // process leading [
1838 if (descriptor[i] == 'L') { // object array
1839 do {
1840 i++; // find closing ;
1841 } while (descriptor[i] != ';' && descriptor[i] != '\0');
1842 result = descriptor[i] == ';';
1843 } else { // primitive array
1844 result = IsPrimitiveDescriptor(descriptor[i]) && descriptor[i + 1] == '\0';
1845 }
1846 } else if (descriptor[0] == 'L') {
1847 // could be more thorough here, but shouldn't be required
1848 size_t i = 0;
1849 do {
1850 i++;
1851 } while (descriptor[i] != ';' && descriptor[i] != '\0');
1852 result = descriptor[i] == ';';
1853 } else {
1854 result = false;
1855 }
1856 if (!result) {
jeffhaod5347e02012-03-22 17:25:05 -07001857 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected char in return type descriptor '"
1858 << descriptor << "'";
Ian Rogersd81871c2011-10-03 13:57:23 -07001859 }
1860 return result;
jeffhaobdb76512011-09-07 11:43:16 -07001861}
1862
Ian Rogers776ac1f2012-04-13 23:36:36 -07001863bool MethodVerifier::CodeFlowVerifyMethod() {
Ian Rogersd81871c2011-10-03 13:57:23 -07001864 const uint16_t* insns = code_item_->insns_;
1865 const uint32_t insns_size = code_item_->insns_size_in_code_units_;
jeffhaoba5ebb92011-08-25 17:24:37 -07001866
jeffhaobdb76512011-09-07 11:43:16 -07001867 /* Begin by marking the first instruction as "changed". */
Mathieu Chartierde40d472015-10-15 17:47:48 -07001868 GetInstructionFlags(0).SetChanged();
Ian Rogersd81871c2011-10-03 13:57:23 -07001869 uint32_t start_guess = 0;
jeffhaoba5ebb92011-08-25 17:24:37 -07001870
jeffhaobdb76512011-09-07 11:43:16 -07001871 /* Continue until no instructions are marked "changed". */
1872 while (true) {
Mathieu Chartier4306ef82014-12-19 18:41:47 -08001873 if (allow_thread_suspension_) {
1874 self_->AllowThreadSuspension();
1875 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001876 // Find the first marked one. Use "start_guess" as a way to find one quickly.
1877 uint32_t insn_idx = start_guess;
1878 for (; insn_idx < insns_size; insn_idx++) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001879 if (GetInstructionFlags(insn_idx).IsChanged())
jeffhaobdb76512011-09-07 11:43:16 -07001880 break;
1881 }
jeffhaobdb76512011-09-07 11:43:16 -07001882 if (insn_idx == insns_size) {
1883 if (start_guess != 0) {
1884 /* try again, starting from the top */
1885 start_guess = 0;
1886 continue;
1887 } else {
1888 /* all flags are clear */
1889 break;
1890 }
1891 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001892 // We carry the working set of registers from instruction to instruction. If this address can
1893 // be the target of a branch (or throw) instruction, or if we're skipping around chasing
1894 // "changed" flags, we need to load the set of registers from the table.
1895 // Because we always prefer to continue on to the next instruction, we should never have a
1896 // situation where we have a stray "changed" flag set on an instruction that isn't a branch
1897 // target.
1898 work_insn_idx_ = insn_idx;
Mathieu Chartierde40d472015-10-15 17:47:48 -07001899 if (GetInstructionFlags(insn_idx).IsBranchTarget()) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001900 work_line_->CopyFromLine(reg_table_.GetLine(insn_idx));
Ian Rogersebbdd872014-07-07 23:53:08 -07001901 } else if (kIsDebugBuild) {
jeffhaobdb76512011-09-07 11:43:16 -07001902 /*
1903 * Sanity check: retrieve the stored register line (assuming
1904 * a full table) and make sure it actually matches.
1905 */
Ian Rogersd81871c2011-10-03 13:57:23 -07001906 RegisterLine* register_line = reg_table_.GetLine(insn_idx);
Ian Rogers7b078e82014-09-10 14:44:24 -07001907 if (register_line != nullptr) {
Ian Rogersd81871c2011-10-03 13:57:23 -07001908 if (work_line_->CompareLine(register_line) != 0) {
1909 Dump(std::cout);
1910 std::cout << info_messages_.str();
David Sehr709b0702016-10-13 09:12:37 -07001911 LOG(FATAL) << "work_line diverged in " << dex_file_->PrettyMethod(dex_method_idx_)
Elliott Hughesc073b072012-05-24 19:29:17 -07001912 << "@" << reinterpret_cast<void*>(work_insn_idx_) << "\n"
Ian Rogers7b078e82014-09-10 14:44:24 -07001913 << " work_line=" << work_line_->Dump(this) << "\n"
1914 << " expected=" << register_line->Dump(this);
Ian Rogersd81871c2011-10-03 13:57:23 -07001915 }
jeffhaobdb76512011-09-07 11:43:16 -07001916 }
jeffhaobdb76512011-09-07 11:43:16 -07001917 }
Ian Rogersd81871c2011-10-03 13:57:23 -07001918 if (!CodeFlowVerifyInstruction(&start_guess)) {
David Sehr709b0702016-10-13 09:12:37 -07001919 std::string prepend(dex_file_->PrettyMethod(dex_method_idx_));
Ian Rogersad0b3a32012-04-16 14:50:24 -07001920 prepend += " failed to verify: ";
1921 PrependToLastFailMessage(prepend);
jeffhaoba5ebb92011-08-25 17:24:37 -07001922 return false;
1923 }
jeffhaobdb76512011-09-07 11:43:16 -07001924 /* Clear "changed" and mark as visited. */
Mathieu Chartierde40d472015-10-15 17:47:48 -07001925 GetInstructionFlags(insn_idx).SetVisited();
1926 GetInstructionFlags(insn_idx).ClearChanged();
jeffhaobdb76512011-09-07 11:43:16 -07001927 }
jeffhaoba5ebb92011-08-25 17:24:37 -07001928
Andreas Gampeec6e6c12015-11-05 20:39:56 -08001929 if (kDebugVerify) {
jeffhaobdb76512011-09-07 11:43:16 -07001930 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07001931 * Scan for dead code. There's nothing "evil" about dead code
jeffhaobdb76512011-09-07 11:43:16 -07001932 * (besides the wasted space), but it indicates a flaw somewhere
1933 * down the line, possibly in the verifier.
1934 *
1935 * If we've substituted "always throw" instructions into the stream,
1936 * we are almost certainly going to have some dead code.
1937 */
1938 int dead_start = -1;
Ian Rogersd81871c2011-10-03 13:57:23 -07001939 uint32_t insn_idx = 0;
Ian Rogers7b078e82014-09-10 14:44:24 -07001940 for (; insn_idx < insns_size;
1941 insn_idx += Instruction::At(code_item_->insns_ + insn_idx)->SizeInCodeUnits()) {
jeffhaobdb76512011-09-07 11:43:16 -07001942 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07001943 * Switch-statement data doesn't get "visited" by scanner. It
jeffhaobdb76512011-09-07 11:43:16 -07001944 * may or may not be preceded by a padding NOP (for alignment).
1945 */
1946 if (insns[insn_idx] == Instruction::kPackedSwitchSignature ||
1947 insns[insn_idx] == Instruction::kSparseSwitchSignature ||
1948 insns[insn_idx] == Instruction::kArrayDataSignature ||
Elliott Hughes380aaa72012-07-09 14:33:15 -07001949 (insns[insn_idx] == Instruction::NOP && (insn_idx + 1 < insns_size) &&
jeffhaobdb76512011-09-07 11:43:16 -07001950 (insns[insn_idx + 1] == Instruction::kPackedSwitchSignature ||
1951 insns[insn_idx + 1] == Instruction::kSparseSwitchSignature ||
1952 insns[insn_idx + 1] == Instruction::kArrayDataSignature))) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07001953 GetInstructionFlags(insn_idx).SetVisited();
jeffhaobdb76512011-09-07 11:43:16 -07001954 }
1955
Mathieu Chartierde40d472015-10-15 17:47:48 -07001956 if (!GetInstructionFlags(insn_idx).IsVisited()) {
jeffhaobdb76512011-09-07 11:43:16 -07001957 if (dead_start < 0)
1958 dead_start = insn_idx;
1959 } else if (dead_start >= 0) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001960 LogVerifyInfo() << "dead code " << reinterpret_cast<void*>(dead_start)
1961 << "-" << reinterpret_cast<void*>(insn_idx - 1);
jeffhaobdb76512011-09-07 11:43:16 -07001962 dead_start = -1;
1963 }
1964 }
1965 if (dead_start >= 0) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07001966 LogVerifyInfo() << "dead code " << reinterpret_cast<void*>(dead_start)
1967 << "-" << reinterpret_cast<void*>(insn_idx - 1);
jeffhaoba5ebb92011-08-25 17:24:37 -07001968 }
Ian Rogersc9e463c2013-06-05 16:52:26 -07001969 // To dump the state of the verify after a method, do something like:
David Sehr709b0702016-10-13 09:12:37 -07001970 // if (dex_file_->PrettyMethod(dex_method_idx_) ==
Ian Rogersc9e463c2013-06-05 16:52:26 -07001971 // "boolean java.lang.String.equals(java.lang.Object)") {
1972 // LOG(INFO) << info_messages_.str();
1973 // }
jeffhaoba5ebb92011-08-25 17:24:37 -07001974 }
jeffhaobdb76512011-09-07 11:43:16 -07001975 return true;
1976}
1977
Andreas Gampe68df3202015-06-22 11:35:46 -07001978// Returns the index of the first final instance field of the given class, or kDexNoIndex if there
1979// is no such field.
Andreas Gampea5b09a62016-11-17 15:21:22 -08001980static uint32_t GetFirstFinalInstanceFieldIndex(const DexFile& dex_file, dex::TypeIndex type_idx) {
Andreas Gampe68df3202015-06-22 11:35:46 -07001981 const DexFile::ClassDef* class_def = dex_file.FindClassDef(type_idx);
1982 DCHECK(class_def != nullptr);
1983 const uint8_t* class_data = dex_file.GetClassData(*class_def);
1984 DCHECK(class_data != nullptr);
1985 ClassDataItemIterator it(dex_file, class_data);
1986 // Skip static fields.
1987 while (it.HasNextStaticField()) {
1988 it.Next();
1989 }
1990 while (it.HasNextInstanceField()) {
1991 if ((it.GetFieldAccessFlags() & kAccFinal) != 0) {
1992 return it.GetMemberIndex();
1993 }
1994 it.Next();
1995 }
1996 return DexFile::kDexNoIndex;
1997}
1998
Andreas Gampea727e372015-08-25 09:22:37 -07001999// Setup a register line for the given return instruction.
2000static void AdjustReturnLine(MethodVerifier* verifier,
2001 const Instruction* ret_inst,
2002 RegisterLine* line) {
2003 Instruction::Code opcode = ret_inst->Opcode();
2004
2005 switch (opcode) {
2006 case Instruction::RETURN_VOID:
2007 case Instruction::RETURN_VOID_NO_BARRIER:
2008 SafelyMarkAllRegistersAsConflicts(verifier, line);
2009 break;
2010
2011 case Instruction::RETURN:
2012 case Instruction::RETURN_OBJECT:
2013 line->MarkAllRegistersAsConflictsExcept(verifier, ret_inst->VRegA_11x());
2014 break;
2015
2016 case Instruction::RETURN_WIDE:
2017 line->MarkAllRegistersAsConflictsExceptWide(verifier, ret_inst->VRegA_11x());
2018 break;
2019
2020 default:
2021 LOG(FATAL) << "Unknown return opcode " << opcode;
2022 UNREACHABLE();
2023 }
2024}
2025
Ian Rogers776ac1f2012-04-13 23:36:36 -07002026bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002027 // If we're doing FindLocksAtDexPc, check whether we're at the dex pc we care about.
2028 // We want the state _before_ the instruction, for the case where the dex pc we're
2029 // interested in is itself a monitor-enter instruction (which is a likely place
2030 // for a thread to be suspended).
Ian Rogers7b078e82014-09-10 14:44:24 -07002031 if (monitor_enter_dex_pcs_ != nullptr && work_insn_idx_ == interesting_dex_pc_) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07002032 monitor_enter_dex_pcs_->clear(); // The new work line is more accurate than the previous one.
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002033 for (size_t i = 0; i < work_line_->GetMonitorEnterCount(); ++i) {
2034 monitor_enter_dex_pcs_->push_back(work_line_->GetMonitorEnterDexPc(i));
2035 }
2036 }
2037
jeffhaobdb76512011-09-07 11:43:16 -07002038 /*
2039 * Once we finish decoding the instruction, we need to figure out where
jeffhaod1f0fde2011-09-08 17:25:33 -07002040 * we can go from here. There are three possible ways to transfer
jeffhaobdb76512011-09-07 11:43:16 -07002041 * control to another statement:
2042 *
jeffhaod1f0fde2011-09-08 17:25:33 -07002043 * (1) Continue to the next instruction. Applies to all but
jeffhaobdb76512011-09-07 11:43:16 -07002044 * unconditional branches, method returns, and exception throws.
jeffhaod1f0fde2011-09-08 17:25:33 -07002045 * (2) Branch to one or more possible locations. Applies to branches
jeffhaobdb76512011-09-07 11:43:16 -07002046 * and switch statements.
jeffhaod1f0fde2011-09-08 17:25:33 -07002047 * (3) Exception handlers. Applies to any instruction that can
jeffhaobdb76512011-09-07 11:43:16 -07002048 * throw an exception that is handled by an encompassing "try"
2049 * block.
2050 *
2051 * We can also return, in which case there is no successor instruction
2052 * from this point.
2053 *
Elliott Hughesadb8c672012-03-06 16:49:32 -08002054 * The behavior can be determined from the opcode flags.
jeffhaobdb76512011-09-07 11:43:16 -07002055 */
Ian Rogersd81871c2011-10-03 13:57:23 -07002056 const uint16_t* insns = code_item_->insns_ + work_insn_idx_;
2057 const Instruction* inst = Instruction::At(insns);
Ian Rogersa75a0132012-09-28 11:41:42 -07002058 int opcode_flags = Instruction::FlagsOf(inst->Opcode());
jeffhaobdb76512011-09-07 11:43:16 -07002059
jeffhaobdb76512011-09-07 11:43:16 -07002060 int32_t branch_target = 0;
jeffhaobdb76512011-09-07 11:43:16 -07002061 bool just_set_result = false;
Andreas Gampeec6e6c12015-11-05 20:39:56 -08002062 if (kDebugVerify) {
Ian Rogersd81871c2011-10-03 13:57:23 -07002063 // Generate processing back trace to debug verifier
Elliott Hughesc073b072012-05-24 19:29:17 -07002064 LogVerifyInfo() << "Processing " << inst->DumpString(dex_file_) << "\n"
Ian Rogers7b078e82014-09-10 14:44:24 -07002065 << work_line_->Dump(this) << "\n";
Ian Rogersd81871c2011-10-03 13:57:23 -07002066 }
jeffhaobdb76512011-09-07 11:43:16 -07002067
2068 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07002069 * Make a copy of the previous register state. If the instruction
jeffhaobdb76512011-09-07 11:43:16 -07002070 * can throw an exception, we will copy/merge this into the "catch"
2071 * address rather than work_line, because we don't want the result
2072 * from the "successful" code path (e.g. a check-cast that "improves"
2073 * a type) to be visible to the exception handler.
2074 */
Ian Rogers776ac1f2012-04-13 23:36:36 -07002075 if ((opcode_flags & Instruction::kThrow) != 0 && CurrentInsnFlags()->IsInTry()) {
Ian Rogersd81871c2011-10-03 13:57:23 -07002076 saved_line_->CopyFromLine(work_line_.get());
Ian Rogers1ff3c982014-08-12 02:30:58 -07002077 } else if (kIsDebugBuild) {
Ian Rogersd81871c2011-10-03 13:57:23 -07002078 saved_line_->FillWithGarbage();
jeffhaobdb76512011-09-07 11:43:16 -07002079 }
Andreas Gamped12e7822015-06-25 10:26:40 -07002080 DCHECK(!have_pending_runtime_throw_failure_); // Per-instruction flag, should not be set here.
jeffhaobdb76512011-09-07 11:43:16 -07002081
Dragos Sbirlea980d16b2013-06-04 15:01:40 -07002082
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002083 // We need to ensure the work line is consistent while performing validation. When we spot a
2084 // peephole pattern we compute a new line for either the fallthrough instruction or the
2085 // branch target.
Mathieu Chartier361e04a2016-02-16 14:06:35 -08002086 RegisterLineArenaUniquePtr branch_line;
2087 RegisterLineArenaUniquePtr fallthrough_line;
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002088
Sebastien Hertz5243e912013-05-21 10:55:07 +02002089 switch (inst->Opcode()) {
jeffhaobdb76512011-09-07 11:43:16 -07002090 case Instruction::NOP:
2091 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07002092 * A "pure" NOP has no effect on anything. Data tables start with
jeffhaobdb76512011-09-07 11:43:16 -07002093 * a signature that looks like a NOP; if we see one of these in
2094 * the course of executing code then we have a problem.
2095 */
Sebastien Hertz5243e912013-05-21 10:55:07 +02002096 if (inst->VRegA_10x() != 0) {
jeffhaod5347e02012-03-22 17:25:05 -07002097 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "encountered data table in instruction stream";
jeffhaobdb76512011-09-07 11:43:16 -07002098 }
2099 break;
2100
2101 case Instruction::MOVE:
Ian Rogers7b078e82014-09-10 14:44:24 -07002102 work_line_->CopyRegister1(this, inst->VRegA_12x(), inst->VRegB_12x(), kTypeCategory1nr);
Sebastien Hertz5243e912013-05-21 10:55:07 +02002103 break;
jeffhaobdb76512011-09-07 11:43:16 -07002104 case Instruction::MOVE_FROM16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002105 work_line_->CopyRegister1(this, inst->VRegA_22x(), inst->VRegB_22x(), kTypeCategory1nr);
Sebastien Hertz5243e912013-05-21 10:55:07 +02002106 break;
jeffhaobdb76512011-09-07 11:43:16 -07002107 case Instruction::MOVE_16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002108 work_line_->CopyRegister1(this, inst->VRegA_32x(), inst->VRegB_32x(), kTypeCategory1nr);
jeffhaobdb76512011-09-07 11:43:16 -07002109 break;
2110 case Instruction::MOVE_WIDE:
Ian Rogers7b078e82014-09-10 14:44:24 -07002111 work_line_->CopyRegister2(this, inst->VRegA_12x(), inst->VRegB_12x());
Sebastien Hertz5243e912013-05-21 10:55:07 +02002112 break;
jeffhaobdb76512011-09-07 11:43:16 -07002113 case Instruction::MOVE_WIDE_FROM16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002114 work_line_->CopyRegister2(this, inst->VRegA_22x(), inst->VRegB_22x());
Sebastien Hertz5243e912013-05-21 10:55:07 +02002115 break;
jeffhaobdb76512011-09-07 11:43:16 -07002116 case Instruction::MOVE_WIDE_16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002117 work_line_->CopyRegister2(this, inst->VRegA_32x(), inst->VRegB_32x());
jeffhaobdb76512011-09-07 11:43:16 -07002118 break;
2119 case Instruction::MOVE_OBJECT:
Ian Rogers7b078e82014-09-10 14:44:24 -07002120 work_line_->CopyRegister1(this, inst->VRegA_12x(), inst->VRegB_12x(), kTypeCategoryRef);
Sebastien Hertz5243e912013-05-21 10:55:07 +02002121 break;
jeffhaobdb76512011-09-07 11:43:16 -07002122 case Instruction::MOVE_OBJECT_FROM16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002123 work_line_->CopyRegister1(this, inst->VRegA_22x(), inst->VRegB_22x(), kTypeCategoryRef);
Sebastien Hertz5243e912013-05-21 10:55:07 +02002124 break;
jeffhaobdb76512011-09-07 11:43:16 -07002125 case Instruction::MOVE_OBJECT_16:
Ian Rogers7b078e82014-09-10 14:44:24 -07002126 work_line_->CopyRegister1(this, inst->VRegA_32x(), inst->VRegB_32x(), kTypeCategoryRef);
jeffhaobdb76512011-09-07 11:43:16 -07002127 break;
2128
2129 /*
2130 * The move-result instructions copy data out of a "pseudo-register"
jeffhaod1f0fde2011-09-08 17:25:33 -07002131 * with the results from the last method invocation. In practice we
jeffhaobdb76512011-09-07 11:43:16 -07002132 * might want to hold the result in an actual CPU register, so the
2133 * Dalvik spec requires that these only appear immediately after an
2134 * invoke or filled-new-array.
2135 *
jeffhaod1f0fde2011-09-08 17:25:33 -07002136 * These calls invalidate the "result" register. (This is now
jeffhaobdb76512011-09-07 11:43:16 -07002137 * redundant with the reset done below, but it can make the debug info
2138 * easier to read in some cases.)
2139 */
2140 case Instruction::MOVE_RESULT:
Ian Rogers7b078e82014-09-10 14:44:24 -07002141 work_line_->CopyResultRegister1(this, inst->VRegA_11x(), false);
jeffhaobdb76512011-09-07 11:43:16 -07002142 break;
2143 case Instruction::MOVE_RESULT_WIDE:
Ian Rogers7b078e82014-09-10 14:44:24 -07002144 work_line_->CopyResultRegister2(this, inst->VRegA_11x());
jeffhaobdb76512011-09-07 11:43:16 -07002145 break;
2146 case Instruction::MOVE_RESULT_OBJECT:
Ian Rogers7b078e82014-09-10 14:44:24 -07002147 work_line_->CopyResultRegister1(this, inst->VRegA_11x(), true);
jeffhaobdb76512011-09-07 11:43:16 -07002148 break;
2149
Ian Rogersd81871c2011-10-03 13:57:23 -07002150 case Instruction::MOVE_EXCEPTION: {
Sebastien Hertz270a0e12015-01-16 19:49:09 +01002151 // We do not allow MOVE_EXCEPTION as the first instruction in a method. This is a simple case
2152 // where one entrypoint to the catch block is not actually an exception path.
2153 if (work_insn_idx_ == 0) {
2154 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "move-exception at pc 0x0";
2155 break;
2156 }
jeffhaobdb76512011-09-07 11:43:16 -07002157 /*
jeffhao60f83e32012-02-13 17:16:30 -08002158 * This statement can only appear as the first instruction in an exception handler. We verify
2159 * that as part of extracting the exception type from the catch block list.
jeffhaobdb76512011-09-07 11:43:16 -07002160 */
Ian Rogersd8f69b02014-09-10 21:43:52 +00002161 const RegType& res_type = GetCaughtExceptionType();
Andreas Gampead238ce2015-08-24 21:13:08 -07002162 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_11x(), res_type);
jeffhaobdb76512011-09-07 11:43:16 -07002163 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002164 }
jeffhaobdb76512011-09-07 11:43:16 -07002165 case Instruction::RETURN_VOID:
Andreas Gampef10b6e12015-08-12 10:48:12 -07002166 if (!IsInstanceConstructor() || work_line_->CheckConstructorReturn(this)) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07002167 if (!GetMethodReturnType().IsConflict()) {
jeffhaod5347e02012-03-22 17:25:05 -07002168 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-void not expected";
Ian Rogersd81871c2011-10-03 13:57:23 -07002169 }
jeffhaobdb76512011-09-07 11:43:16 -07002170 }
2171 break;
2172 case Instruction::RETURN:
Andreas Gampef10b6e12015-08-12 10:48:12 -07002173 if (!IsInstanceConstructor() || work_line_->CheckConstructorReturn(this)) {
jeffhaobdb76512011-09-07 11:43:16 -07002174 /* check the method signature */
Ian Rogersd8f69b02014-09-10 21:43:52 +00002175 const RegType& return_type = GetMethodReturnType();
Ian Rogersd81871c2011-10-03 13:57:23 -07002176 if (!return_type.IsCategory1Types()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07002177 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected non-category 1 return type "
2178 << return_type;
Ian Rogersd81871c2011-10-03 13:57:23 -07002179 } else {
2180 // Compilers may generate synthetic functions that write byte values into boolean fields.
2181 // Also, it may use integer values for boolean, byte, short, and character return types.
Sebastien Hertz5243e912013-05-21 10:55:07 +02002182 const uint32_t vregA = inst->VRegA_11x();
Ian Rogers7b078e82014-09-10 14:44:24 -07002183 const RegType& src_type = work_line_->GetRegisterType(this, vregA);
Ian Rogersd81871c2011-10-03 13:57:23 -07002184 bool use_src = ((return_type.IsBoolean() && src_type.IsByte()) ||
2185 ((return_type.IsBoolean() || return_type.IsByte() ||
2186 return_type.IsShort() || return_type.IsChar()) &&
2187 src_type.IsInteger()));
2188 /* check the register contents */
Ian Rogersad0b3a32012-04-16 14:50:24 -07002189 bool success =
Ian Rogers7b078e82014-09-10 14:44:24 -07002190 work_line_->VerifyRegisterType(this, vregA, use_src ? src_type : return_type);
Ian Rogersad0b3a32012-04-16 14:50:24 -07002191 if (!success) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002192 AppendToLastFailMessage(StringPrintf(" return-1nr on invalid register v%d", vregA));
Ian Rogersd81871c2011-10-03 13:57:23 -07002193 }
jeffhaobdb76512011-09-07 11:43:16 -07002194 }
2195 }
2196 break;
2197 case Instruction::RETURN_WIDE:
Andreas Gampef10b6e12015-08-12 10:48:12 -07002198 if (!IsInstanceConstructor() || work_line_->CheckConstructorReturn(this)) {
jeffhaobdb76512011-09-07 11:43:16 -07002199 /* check the method signature */
Ian Rogersd8f69b02014-09-10 21:43:52 +00002200 const RegType& return_type = GetMethodReturnType();
Ian Rogersd81871c2011-10-03 13:57:23 -07002201 if (!return_type.IsCategory2Types()) {
jeffhaod5347e02012-03-22 17:25:05 -07002202 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-wide not expected";
Ian Rogersd81871c2011-10-03 13:57:23 -07002203 } else {
2204 /* check the register contents */
Sebastien Hertz5243e912013-05-21 10:55:07 +02002205 const uint32_t vregA = inst->VRegA_11x();
Ian Rogers7b078e82014-09-10 14:44:24 -07002206 bool success = work_line_->VerifyRegisterType(this, vregA, return_type);
Ian Rogersad0b3a32012-04-16 14:50:24 -07002207 if (!success) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002208 AppendToLastFailMessage(StringPrintf(" return-wide on invalid register v%d", vregA));
Ian Rogersd81871c2011-10-03 13:57:23 -07002209 }
jeffhaobdb76512011-09-07 11:43:16 -07002210 }
2211 }
2212 break;
2213 case Instruction::RETURN_OBJECT:
Andreas Gampef10b6e12015-08-12 10:48:12 -07002214 if (!IsInstanceConstructor() || work_line_->CheckConstructorReturn(this)) {
Ian Rogersd8f69b02014-09-10 21:43:52 +00002215 const RegType& return_type = GetMethodReturnType();
Ian Rogersd81871c2011-10-03 13:57:23 -07002216 if (!return_type.IsReferenceTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07002217 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-object not expected";
Ian Rogersd81871c2011-10-03 13:57:23 -07002218 } else {
2219 /* return_type is the *expected* return type, not register value */
2220 DCHECK(!return_type.IsZero());
2221 DCHECK(!return_type.IsUninitializedReference());
Sebastien Hertz5243e912013-05-21 10:55:07 +02002222 const uint32_t vregA = inst->VRegA_11x();
Ian Rogers7b078e82014-09-10 14:44:24 -07002223 const RegType& reg_type = work_line_->GetRegisterType(this, vregA);
Andreas Gampea32210c2015-06-24 10:26:13 -07002224 // Disallow returning undefined, conflict & uninitialized values and verify that the
2225 // reference in vAA is an instance of the "return_type."
2226 if (reg_type.IsUndefined()) {
2227 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning undefined register";
2228 } else if (reg_type.IsConflict()) {
2229 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning register with conflict";
2230 } else if (reg_type.IsUninitializedTypes()) {
David Brazdil68b5c0b2016-01-19 14:25:29 +00002231 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning uninitialized object '"
Brian Carlstrom93c33962013-07-26 10:37:43 -07002232 << reg_type << "'";
Andreas Gampea4c98f22015-11-06 16:24:49 -08002233 } else if (!reg_type.IsReferenceTypes()) {
2234 // We really do expect a reference here.
2235 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-object returns a non-reference type "
2236 << reg_type;
David Brazdilca3c8c32016-09-06 14:04:48 +01002237 } else if (!return_type.IsAssignableFrom(reg_type, this)) {
Jeff Haoa3faaf42013-09-03 19:07:00 -07002238 if (reg_type.IsUnresolvedTypes() || return_type.IsUnresolvedTypes()) {
2239 Fail(VERIFY_ERROR_NO_CLASS) << " can't resolve returned type '" << return_type
2240 << "' or '" << reg_type << "'";
2241 } else {
Andreas Gampe16f149c2015-03-23 10:10:20 -07002242 bool soft_error = false;
2243 // Check whether arrays are involved. They will show a valid class status, even
2244 // if their components are erroneous.
2245 if (reg_type.IsArrayTypes() && return_type.IsArrayTypes()) {
David Brazdilca3c8c32016-09-06 14:04:48 +01002246 return_type.CanAssignArray(reg_type, reg_types_, class_loader_, this, &soft_error);
Andreas Gampe16f149c2015-03-23 10:10:20 -07002247 if (soft_error) {
2248 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "array with erroneous component type: "
2249 << reg_type << " vs " << return_type;
2250 }
2251 }
2252
2253 if (!soft_error) {
2254 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "returning '" << reg_type
2255 << "', but expected from declaration '" << return_type << "'";
2256 }
Jeff Haoa3faaf42013-09-03 19:07:00 -07002257 }
jeffhaobdb76512011-09-07 11:43:16 -07002258 }
2259 }
2260 }
2261 break;
2262
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002263 /* could be boolean, int, float, or a null reference */
Sebastien Hertz5243e912013-05-21 10:55:07 +02002264 case Instruction::CONST_4: {
2265 int32_t val = static_cast<int32_t>(inst->VRegB_11n() << 28) >> 28;
Andreas Gampead238ce2015-08-24 21:13:08 -07002266 work_line_->SetRegisterType<LockOp::kClear>(
2267 this, inst->VRegA_11n(), DetermineCat1Constant(val, need_precise_constants_));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002268 break;
Sebastien Hertz5243e912013-05-21 10:55:07 +02002269 }
2270 case Instruction::CONST_16: {
2271 int16_t val = static_cast<int16_t>(inst->VRegB_21s());
Andreas Gampead238ce2015-08-24 21:13:08 -07002272 work_line_->SetRegisterType<LockOp::kClear>(
2273 this, inst->VRegA_21s(), DetermineCat1Constant(val, need_precise_constants_));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07002274 break;
Sebastien Hertz5243e912013-05-21 10:55:07 +02002275 }
Sebastien Hertz849600b2013-12-20 10:28:08 +01002276 case Instruction::CONST: {
2277 int32_t val = inst->VRegB_31i();
Andreas Gampead238ce2015-08-24 21:13:08 -07002278 work_line_->SetRegisterType<LockOp::kClear>(
2279 this, inst->VRegA_31i(), DetermineCat1Constant(val, need_precise_constants_));
jeffhaobdb76512011-09-07 11:43:16 -07002280 break;
Sebastien Hertz849600b2013-12-20 10:28:08 +01002281 }
2282 case Instruction::CONST_HIGH16: {
2283 int32_t val = static_cast<int32_t>(inst->VRegB_21h() << 16);
Andreas Gampead238ce2015-08-24 21:13:08 -07002284 work_line_->SetRegisterType<LockOp::kClear>(
2285 this, inst->VRegA_21h(), DetermineCat1Constant(val, need_precise_constants_));
jeffhaobdb76512011-09-07 11:43:16 -07002286 break;
Sebastien Hertz849600b2013-12-20 10:28:08 +01002287 }
jeffhaobdb76512011-09-07 11:43:16 -07002288 /* could be long or double; resolved upon use */
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002289 case Instruction::CONST_WIDE_16: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002290 int64_t val = static_cast<int16_t>(inst->VRegB_21s());
Ian Rogersd8f69b02014-09-10 21:43:52 +00002291 const RegType& lo = reg_types_.FromCat2ConstLo(static_cast<int32_t>(val), true);
2292 const RegType& hi = reg_types_.FromCat2ConstHi(static_cast<int32_t>(val >> 32), true);
Ian Rogers7b078e82014-09-10 14:44:24 -07002293 work_line_->SetRegisterTypeWide(this, inst->VRegA_21s(), lo, hi);
jeffhaobdb76512011-09-07 11:43:16 -07002294 break;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002295 }
2296 case Instruction::CONST_WIDE_32: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002297 int64_t val = static_cast<int32_t>(inst->VRegB_31i());
Ian Rogersd8f69b02014-09-10 21:43:52 +00002298 const RegType& lo = reg_types_.FromCat2ConstLo(static_cast<int32_t>(val), true);
2299 const RegType& hi = reg_types_.FromCat2ConstHi(static_cast<int32_t>(val >> 32), true);
Ian Rogers7b078e82014-09-10 14:44:24 -07002300 work_line_->SetRegisterTypeWide(this, inst->VRegA_31i(), lo, hi);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002301 break;
2302 }
2303 case Instruction::CONST_WIDE: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002304 int64_t val = inst->VRegB_51l();
Ian Rogersd8f69b02014-09-10 21:43:52 +00002305 const RegType& lo = reg_types_.FromCat2ConstLo(static_cast<int32_t>(val), true);
2306 const RegType& hi = reg_types_.FromCat2ConstHi(static_cast<int32_t>(val >> 32), true);
Ian Rogers7b078e82014-09-10 14:44:24 -07002307 work_line_->SetRegisterTypeWide(this, inst->VRegA_51l(), lo, hi);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002308 break;
2309 }
2310 case Instruction::CONST_WIDE_HIGH16: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002311 int64_t val = static_cast<uint64_t>(inst->VRegB_21h()) << 48;
Ian Rogersd8f69b02014-09-10 21:43:52 +00002312 const RegType& lo = reg_types_.FromCat2ConstLo(static_cast<int32_t>(val), true);
2313 const RegType& hi = reg_types_.FromCat2ConstHi(static_cast<int32_t>(val >> 32), true);
Ian Rogers7b078e82014-09-10 14:44:24 -07002314 work_line_->SetRegisterTypeWide(this, inst->VRegA_21h(), lo, hi);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002315 break;
2316 }
jeffhaobdb76512011-09-07 11:43:16 -07002317 case Instruction::CONST_STRING:
Andreas Gampead238ce2015-08-24 21:13:08 -07002318 work_line_->SetRegisterType<LockOp::kClear>(
2319 this, inst->VRegA_21c(), reg_types_.JavaLangString());
Sebastien Hertz5243e912013-05-21 10:55:07 +02002320 break;
jeffhaobdb76512011-09-07 11:43:16 -07002321 case Instruction::CONST_STRING_JUMBO:
Andreas Gampead238ce2015-08-24 21:13:08 -07002322 work_line_->SetRegisterType<LockOp::kClear>(
2323 this, inst->VRegA_31c(), reg_types_.JavaLangString());
jeffhaobdb76512011-09-07 11:43:16 -07002324 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002325 case Instruction::CONST_CLASS: {
Ian Rogers28ad40d2011-10-27 15:19:26 -07002326 // Get type from instruction if unresolved then we need an access check
2327 // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
Andreas Gampea5b09a62016-11-17 15:21:22 -08002328 const RegType& res_type = ResolveClassAndCheckAccess(dex::TypeIndex(inst->VRegB_21c()));
Ian Rogersad0b3a32012-04-16 14:50:24 -07002329 // Register holds class, ie its type is class, on error it will hold Conflict.
Andreas Gampead238ce2015-08-24 21:13:08 -07002330 work_line_->SetRegisterType<LockOp::kClear>(
2331 this, inst->VRegA_21c(), res_type.IsConflict() ? res_type
2332 : reg_types_.JavaLangClass());
jeffhaobdb76512011-09-07 11:43:16 -07002333 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002334 }
jeffhaobdb76512011-09-07 11:43:16 -07002335 case Instruction::MONITOR_ENTER:
Ian Rogers7b078e82014-09-10 14:44:24 -07002336 work_line_->PushMonitor(this, inst->VRegA_11x(), work_insn_idx_);
Andreas Gampec1474102015-08-18 08:57:44 -07002337 // Check whether the previous instruction is a move-object with vAA as a source, creating
2338 // untracked lock aliasing.
Mathieu Chartierde40d472015-10-15 17:47:48 -07002339 if (0 != work_insn_idx_ && !GetInstructionFlags(work_insn_idx_).IsBranchTarget()) {
Andreas Gampec1474102015-08-18 08:57:44 -07002340 uint32_t prev_idx = work_insn_idx_ - 1;
Mathieu Chartierde40d472015-10-15 17:47:48 -07002341 while (0 != prev_idx && !GetInstructionFlags(prev_idx).IsOpcode()) {
Andreas Gampec1474102015-08-18 08:57:44 -07002342 prev_idx--;
2343 }
2344 const Instruction* prev_inst = Instruction::At(code_item_->insns_ + prev_idx);
2345 switch (prev_inst->Opcode()) {
2346 case Instruction::MOVE_OBJECT:
2347 case Instruction::MOVE_OBJECT_16:
2348 case Instruction::MOVE_OBJECT_FROM16:
2349 if (prev_inst->VRegB() == inst->VRegA_11x()) {
2350 // Redo the copy. This won't change the register types, but update the lock status
2351 // for the aliased register.
2352 work_line_->CopyRegister1(this,
2353 prev_inst->VRegA(),
2354 prev_inst->VRegB(),
2355 kTypeCategoryRef);
2356 }
2357 break;
2358
2359 default: // Other instruction types ignored.
2360 break;
2361 }
2362 }
jeffhaobdb76512011-09-07 11:43:16 -07002363 break;
2364 case Instruction::MONITOR_EXIT:
2365 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07002366 * monitor-exit instructions are odd. They can throw exceptions,
jeffhaobdb76512011-09-07 11:43:16 -07002367 * but when they do they act as if they succeeded and the PC is
jeffhaod1f0fde2011-09-08 17:25:33 -07002368 * pointing to the following instruction. (This behavior goes back
jeffhaobdb76512011-09-07 11:43:16 -07002369 * to the need to handle asynchronous exceptions, a now-deprecated
2370 * feature that Dalvik doesn't support.)
2371 *
jeffhaod1f0fde2011-09-08 17:25:33 -07002372 * In practice we don't need to worry about this. The only
jeffhaobdb76512011-09-07 11:43:16 -07002373 * exceptions that can be thrown from monitor-exit are for a
jeffhaod1f0fde2011-09-08 17:25:33 -07002374 * null reference and -exit without a matching -enter. If the
jeffhaobdb76512011-09-07 11:43:16 -07002375 * structured locking checks are working, the former would have
2376 * failed on the -enter instruction, and the latter is impossible.
2377 *
2378 * This is fortunate, because issue 3221411 prevents us from
2379 * chasing the "can throw" path when monitor verification is
jeffhaod1f0fde2011-09-08 17:25:33 -07002380 * enabled. If we can fully verify the locking we can ignore
jeffhaobdb76512011-09-07 11:43:16 -07002381 * some catch blocks (which will show up as "dead" code when
2382 * we skip them here); if we can't, then the code path could be
2383 * "live" so we still need to check it.
2384 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08002385 opcode_flags &= ~Instruction::kThrow;
Ian Rogers7b078e82014-09-10 14:44:24 -07002386 work_line_->PopMonitor(this, inst->VRegA_11x());
jeffhaobdb76512011-09-07 11:43:16 -07002387 break;
Ian Rogers28ad40d2011-10-27 15:19:26 -07002388 case Instruction::CHECK_CAST:
Ian Rogersd81871c2011-10-03 13:57:23 -07002389 case Instruction::INSTANCE_OF: {
Ian Rogers28ad40d2011-10-27 15:19:26 -07002390 /*
2391 * If this instruction succeeds, we will "downcast" register vA to the type in vB. (This
2392 * could be a "upcast" -- not expected, so we don't try to address it.)
2393 *
2394 * If it fails, an exception is thrown, which we deal with later by ignoring the update to
Elliott Hughesadb8c672012-03-06 16:49:32 -08002395 * dec_insn.vA when branching to a handler.
Ian Rogers28ad40d2011-10-27 15:19:26 -07002396 */
Sebastien Hertz5243e912013-05-21 10:55:07 +02002397 const bool is_checkcast = (inst->Opcode() == Instruction::CHECK_CAST);
Andreas Gampea5b09a62016-11-17 15:21:22 -08002398 const dex::TypeIndex type_idx((is_checkcast) ? inst->VRegB_21c() : inst->VRegC_22c());
Ian Rogersd8f69b02014-09-10 21:43:52 +00002399 const RegType& res_type = ResolveClassAndCheckAccess(type_idx);
Ian Rogersad0b3a32012-04-16 14:50:24 -07002400 if (res_type.IsConflict()) {
Andreas Gampe00633eb2014-07-17 16:13:35 -07002401 // If this is a primitive type, fail HARD.
Vladimir Marko8d6768d2017-03-14 10:13:21 +00002402 ObjPtr<mirror::Class> klass =
2403 ClassLinker::LookupResolvedType(type_idx, dex_cache_.Get(), class_loader_.Get());
Andreas Gampe00633eb2014-07-17 16:13:35 -07002404 if (klass != nullptr && klass->IsPrimitive()) {
2405 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "using primitive type "
2406 << dex_file_->StringByTypeIdx(type_idx) << " in instanceof in "
2407 << GetDeclaringClass();
2408 break;
2409 }
2410
Ian Rogersad0b3a32012-04-16 14:50:24 -07002411 DCHECK_NE(failures_.size(), 0U);
2412 if (!is_checkcast) {
Andreas Gampead238ce2015-08-24 21:13:08 -07002413 work_line_->SetRegisterType<LockOp::kClear>(this,
2414 inst->VRegA_22c(),
2415 reg_types_.Boolean());
Ian Rogersad0b3a32012-04-16 14:50:24 -07002416 }
2417 break; // bad class
Ian Rogers9f1ab122011-12-12 08:52:43 -08002418 }
Ian Rogers28ad40d2011-10-27 15:19:26 -07002419 // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
Sebastien Hertz5243e912013-05-21 10:55:07 +02002420 uint32_t orig_type_reg = (is_checkcast) ? inst->VRegA_21c() : inst->VRegB_22c();
Ian Rogers7b078e82014-09-10 14:44:24 -07002421 const RegType& orig_type = work_line_->GetRegisterType(this, orig_type_reg);
Ian Rogers28ad40d2011-10-27 15:19:26 -07002422 if (!res_type.IsNonZeroReferenceTypes()) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002423 if (is_checkcast) {
2424 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "check-cast on unexpected class " << res_type;
2425 } else {
2426 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "instance-of on unexpected class " << res_type;
2427 }
Ian Rogers28ad40d2011-10-27 15:19:26 -07002428 } else if (!orig_type.IsReferenceTypes()) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002429 if (is_checkcast) {
2430 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "check-cast on non-reference in v" << orig_type_reg;
2431 } else {
2432 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "instance-of on non-reference in v" << orig_type_reg;
2433 }
David Brazdil68b5c0b2016-01-19 14:25:29 +00002434 } else if (orig_type.IsUninitializedTypes()) {
2435 if (is_checkcast) {
2436 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "check-cast on uninitialized reference in v"
2437 << orig_type_reg;
2438 } else {
2439 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "instance-of on uninitialized reference in v"
2440 << orig_type_reg;
2441 }
jeffhao2a8a90e2011-09-26 14:25:31 -07002442 } else {
Ian Rogers28ad40d2011-10-27 15:19:26 -07002443 if (is_checkcast) {
Andreas Gampead238ce2015-08-24 21:13:08 -07002444 work_line_->SetRegisterType<LockOp::kKeep>(this, inst->VRegA_21c(), res_type);
Ian Rogersd81871c2011-10-03 13:57:23 -07002445 } else {
Andreas Gampead238ce2015-08-24 21:13:08 -07002446 work_line_->SetRegisterType<LockOp::kClear>(this,
2447 inst->VRegA_22c(),
2448 reg_types_.Boolean());
jeffhaobdb76512011-09-07 11:43:16 -07002449 }
jeffhaobdb76512011-09-07 11:43:16 -07002450 }
jeffhao2a8a90e2011-09-26 14:25:31 -07002451 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002452 }
2453 case Instruction::ARRAY_LENGTH: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002454 const RegType& res_type = work_line_->GetRegisterType(this, inst->VRegB_12x());
Ian Rogers28ad40d2011-10-27 15:19:26 -07002455 if (res_type.IsReferenceTypes()) {
Ian Rogers89310de2012-02-01 13:47:30 -08002456 if (!res_type.IsArrayTypes() && !res_type.IsZero()) { // ie not an array or null
jeffhaod5347e02012-03-22 17:25:05 -07002457 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array-length on non-array " << res_type;
Ian Rogersd81871c2011-10-03 13:57:23 -07002458 } else {
Andreas Gampead238ce2015-08-24 21:13:08 -07002459 work_line_->SetRegisterType<LockOp::kClear>(this,
2460 inst->VRegA_12x(),
2461 reg_types_.Integer());
Ian Rogersd81871c2011-10-03 13:57:23 -07002462 }
Andreas Gampe65c9db82014-07-28 13:14:34 -07002463 } else {
2464 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array-length on non-array " << res_type;
Ian Rogersd81871c2011-10-03 13:57:23 -07002465 }
2466 break;
2467 }
2468 case Instruction::NEW_INSTANCE: {
Andreas Gampea5b09a62016-11-17 15:21:22 -08002469 const RegType& res_type = ResolveClassAndCheckAccess(dex::TypeIndex(inst->VRegB_21c()));
Ian Rogersad0b3a32012-04-16 14:50:24 -07002470 if (res_type.IsConflict()) {
2471 DCHECK_NE(failures_.size(), 0U);
2472 break; // bad class
jeffhao8cd6dda2012-02-22 10:15:34 -08002473 }
Ian Rogers28ad40d2011-10-27 15:19:26 -07002474 // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
2475 // can't create an instance of an interface or abstract class */
2476 if (!res_type.IsInstantiableTypes()) {
2477 Fail(VERIFY_ERROR_INSTANTIATION)
2478 << "new-instance on primitive, interface or abstract class" << res_type;
Ian Rogers08f753d2012-08-24 14:35:25 -07002479 // Soft failure so carry on to set register type.
Ian Rogersd81871c2011-10-03 13:57:23 -07002480 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00002481 const RegType& uninit_type = reg_types_.Uninitialized(res_type, work_insn_idx_);
Ian Rogers08f753d2012-08-24 14:35:25 -07002482 // Any registers holding previous allocations from this address that have not yet been
2483 // initialized must be marked invalid.
Ian Rogers7b078e82014-09-10 14:44:24 -07002484 work_line_->MarkUninitRefsAsInvalid(this, uninit_type);
Ian Rogers08f753d2012-08-24 14:35:25 -07002485 // add the new uninitialized reference to the register state
Andreas Gampead238ce2015-08-24 21:13:08 -07002486 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_21c(), uninit_type);
Ian Rogersd81871c2011-10-03 13:57:23 -07002487 break;
2488 }
Ian Rogers0c4a5062012-02-03 15:18:59 -08002489 case Instruction::NEW_ARRAY:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002490 VerifyNewArray(inst, false, false);
jeffhaobdb76512011-09-07 11:43:16 -07002491 break;
2492 case Instruction::FILLED_NEW_ARRAY:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002493 VerifyNewArray(inst, true, false);
Ian Rogers0c4a5062012-02-03 15:18:59 -08002494 just_set_result = true; // Filled new array sets result register
jeffhaobdb76512011-09-07 11:43:16 -07002495 break;
Ian Rogers0c4a5062012-02-03 15:18:59 -08002496 case Instruction::FILLED_NEW_ARRAY_RANGE:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002497 VerifyNewArray(inst, true, true);
Ian Rogers0c4a5062012-02-03 15:18:59 -08002498 just_set_result = true; // Filled new array range sets result register
2499 break;
jeffhaobdb76512011-09-07 11:43:16 -07002500 case Instruction::CMPL_FLOAT:
2501 case Instruction::CMPG_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07002502 if (!work_line_->VerifyRegisterType(this, inst->VRegB_23x(), reg_types_.Float())) {
jeffhao457cc512012-02-02 16:55:13 -08002503 break;
2504 }
Ian Rogers7b078e82014-09-10 14:44:24 -07002505 if (!work_line_->VerifyRegisterType(this, inst->VRegC_23x(), reg_types_.Float())) {
jeffhao457cc512012-02-02 16:55:13 -08002506 break;
2507 }
Andreas Gampead238ce2015-08-24 21:13:08 -07002508 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_23x(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07002509 break;
2510 case Instruction::CMPL_DOUBLE:
2511 case Instruction::CMPG_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07002512 if (!work_line_->VerifyRegisterTypeWide(this, inst->VRegB_23x(), reg_types_.DoubleLo(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002513 reg_types_.DoubleHi())) {
jeffhao457cc512012-02-02 16:55:13 -08002514 break;
2515 }
Ian Rogers7b078e82014-09-10 14:44:24 -07002516 if (!work_line_->VerifyRegisterTypeWide(this, inst->VRegC_23x(), reg_types_.DoubleLo(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002517 reg_types_.DoubleHi())) {
jeffhao457cc512012-02-02 16:55:13 -08002518 break;
2519 }
Andreas Gampead238ce2015-08-24 21:13:08 -07002520 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_23x(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07002521 break;
2522 case Instruction::CMP_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07002523 if (!work_line_->VerifyRegisterTypeWide(this, inst->VRegB_23x(), reg_types_.LongLo(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002524 reg_types_.LongHi())) {
jeffhao457cc512012-02-02 16:55:13 -08002525 break;
2526 }
Ian Rogers7b078e82014-09-10 14:44:24 -07002527 if (!work_line_->VerifyRegisterTypeWide(this, inst->VRegC_23x(), reg_types_.LongLo(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002528 reg_types_.LongHi())) {
jeffhao457cc512012-02-02 16:55:13 -08002529 break;
2530 }
Andreas Gampead238ce2015-08-24 21:13:08 -07002531 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_23x(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07002532 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002533 case Instruction::THROW: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002534 const RegType& res_type = work_line_->GetRegisterType(this, inst->VRegA_11x());
David Brazdilca3c8c32016-09-06 14:04:48 +01002535 if (!reg_types_.JavaLangThrowable(false).IsAssignableFrom(res_type, this)) {
David Brazdil68b5c0b2016-01-19 14:25:29 +00002536 if (res_type.IsUninitializedTypes()) {
2537 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "thrown exception not initialized";
Pavel Vyssotski980027c2016-02-11 20:28:11 +06002538 } else if (!res_type.IsReferenceTypes()) {
2539 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "thrown value of non-reference type " << res_type;
David Brazdil68b5c0b2016-01-19 14:25:29 +00002540 } else {
2541 Fail(res_type.IsUnresolvedTypes() ? VERIFY_ERROR_NO_CLASS : VERIFY_ERROR_BAD_CLASS_SOFT)
2542 << "thrown class " << res_type << " not instanceof Throwable";
2543 }
jeffhaobdb76512011-09-07 11:43:16 -07002544 }
2545 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002546 }
jeffhaobdb76512011-09-07 11:43:16 -07002547 case Instruction::GOTO:
2548 case Instruction::GOTO_16:
2549 case Instruction::GOTO_32:
2550 /* no effect on or use of registers */
2551 break;
2552
2553 case Instruction::PACKED_SWITCH:
2554 case Instruction::SPARSE_SWITCH:
2555 /* verify that vAA is an integer, or can be converted to one */
Ian Rogers7b078e82014-09-10 14:44:24 -07002556 work_line_->VerifyRegisterType(this, inst->VRegA_31t(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07002557 break;
2558
Ian Rogersd81871c2011-10-03 13:57:23 -07002559 case Instruction::FILL_ARRAY_DATA: {
2560 /* Similar to the verification done for APUT */
Ian Rogers7b078e82014-09-10 14:44:24 -07002561 const RegType& array_type = work_line_->GetRegisterType(this, inst->VRegA_31t());
Ian Rogers89310de2012-02-01 13:47:30 -08002562 /* array_type can be null if the reg type is Zero */
2563 if (!array_type.IsZero()) {
jeffhao457cc512012-02-02 16:55:13 -08002564 if (!array_type.IsArrayTypes()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07002565 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid fill-array-data with array type "
2566 << array_type;
Andreas Gampebb18a032016-03-22 20:34:25 -07002567 } else if (array_type.IsUnresolvedTypes()) {
2568 // If it's an unresolved array type, it must be non-primitive.
2569 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid fill-array-data for array of type "
2570 << array_type;
Ian Rogers89310de2012-02-01 13:47:30 -08002571 } else {
Ian Rogersd8f69b02014-09-10 21:43:52 +00002572 const RegType& component_type = reg_types_.GetComponentType(array_type, GetClassLoader());
Ian Rogersad0b3a32012-04-16 14:50:24 -07002573 DCHECK(!component_type.IsConflict());
jeffhao457cc512012-02-02 16:55:13 -08002574 if (component_type.IsNonZeroReferenceTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07002575 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid fill-array-data with component type "
2576 << component_type;
Ian Rogersd81871c2011-10-03 13:57:23 -07002577 } else {
jeffhao457cc512012-02-02 16:55:13 -08002578 // Now verify if the element width in the table matches the element width declared in
2579 // the array
Andreas Gampe53de99c2015-08-17 13:43:55 -07002580 const uint16_t* array_data =
2581 insns + (insns[1] | (static_cast<int32_t>(insns[2]) << 16));
jeffhao457cc512012-02-02 16:55:13 -08002582 if (array_data[0] != Instruction::kArrayDataSignature) {
jeffhaod5347e02012-03-22 17:25:05 -07002583 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid magic for array-data";
jeffhao457cc512012-02-02 16:55:13 -08002584 } else {
2585 size_t elem_width = Primitive::ComponentSize(component_type.GetPrimitiveType());
2586 // Since we don't compress the data in Dex, expect to see equal width of data stored
2587 // in the table and expected from the array class.
2588 if (array_data[1] != elem_width) {
jeffhaod5347e02012-03-22 17:25:05 -07002589 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array-data size mismatch (" << array_data[1]
2590 << " vs " << elem_width << ")";
jeffhao457cc512012-02-02 16:55:13 -08002591 }
Ian Rogersd81871c2011-10-03 13:57:23 -07002592 }
2593 }
jeffhaobdb76512011-09-07 11:43:16 -07002594 }
2595 }
2596 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002597 }
jeffhaobdb76512011-09-07 11:43:16 -07002598 case Instruction::IF_EQ:
Ian Rogersd81871c2011-10-03 13:57:23 -07002599 case Instruction::IF_NE: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002600 const RegType& reg_type1 = work_line_->GetRegisterType(this, inst->VRegA_22t());
2601 const RegType& reg_type2 = work_line_->GetRegisterType(this, inst->VRegB_22t());
Ian Rogersd81871c2011-10-03 13:57:23 -07002602 bool mismatch = false;
2603 if (reg_type1.IsZero()) { // zero then integral or reference expected
2604 mismatch = !reg_type2.IsReferenceTypes() && !reg_type2.IsIntegralTypes();
2605 } else if (reg_type1.IsReferenceTypes()) { // both references?
2606 mismatch = !reg_type2.IsReferenceTypes();
2607 } else { // both integral?
2608 mismatch = !reg_type1.IsIntegralTypes() || !reg_type2.IsIntegralTypes();
2609 }
2610 if (mismatch) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07002611 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "args to if-eq/if-ne (" << reg_type1 << ","
2612 << reg_type2 << ") must both be references or integral";
jeffhaobdb76512011-09-07 11:43:16 -07002613 }
2614 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002615 }
jeffhaobdb76512011-09-07 11:43:16 -07002616 case Instruction::IF_LT:
2617 case Instruction::IF_GE:
2618 case Instruction::IF_GT:
Ian Rogersd81871c2011-10-03 13:57:23 -07002619 case Instruction::IF_LE: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002620 const RegType& reg_type1 = work_line_->GetRegisterType(this, inst->VRegA_22t());
2621 const RegType& reg_type2 = work_line_->GetRegisterType(this, inst->VRegB_22t());
Ian Rogersd81871c2011-10-03 13:57:23 -07002622 if (!reg_type1.IsIntegralTypes() || !reg_type2.IsIntegralTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07002623 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "args to 'if' (" << reg_type1 << ","
2624 << reg_type2 << ") must be integral";
jeffhaobdb76512011-09-07 11:43:16 -07002625 }
2626 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002627 }
jeffhaobdb76512011-09-07 11:43:16 -07002628 case Instruction::IF_EQZ:
Ian Rogersd81871c2011-10-03 13:57:23 -07002629 case Instruction::IF_NEZ: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002630 const RegType& reg_type = work_line_->GetRegisterType(this, inst->VRegA_21t());
Ian Rogersd81871c2011-10-03 13:57:23 -07002631 if (!reg_type.IsReferenceTypes() && !reg_type.IsIntegralTypes()) {
Brian Carlstrom93c33962013-07-26 10:37:43 -07002632 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "type " << reg_type
2633 << " unexpected as arg to if-eqz/if-nez";
Ian Rogersd81871c2011-10-03 13:57:23 -07002634 }
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002635
2636 // Find previous instruction - its existence is a precondition to peephole optimization.
Ian Rogers9b360392013-06-06 14:45:07 -07002637 uint32_t instance_of_idx = 0;
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002638 if (0 != work_insn_idx_) {
Ian Rogers9b360392013-06-06 14:45:07 -07002639 instance_of_idx = work_insn_idx_ - 1;
Mathieu Chartierde40d472015-10-15 17:47:48 -07002640 while (0 != instance_of_idx && !GetInstructionFlags(instance_of_idx).IsOpcode()) {
Ian Rogers9b360392013-06-06 14:45:07 -07002641 instance_of_idx--;
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002642 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07002643 if (FailOrAbort(this, GetInstructionFlags(instance_of_idx).IsOpcode(),
Andreas Gampe7c038102014-10-27 20:08:46 -07002644 "Unable to get previous instruction of if-eqz/if-nez for work index ",
2645 work_insn_idx_)) {
2646 break;
2647 }
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002648 } else {
2649 break;
2650 }
2651
Ian Rogers9b360392013-06-06 14:45:07 -07002652 const Instruction* instance_of_inst = Instruction::At(code_item_->insns_ + instance_of_idx);
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002653
2654 /* Check for peep-hole pattern of:
2655 * ...;
Ian Rogersfae370a2013-06-05 08:33:27 -07002656 * instance-of vX, vY, T;
2657 * ifXXX vX, label ;
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002658 * ...;
Ian Rogersfae370a2013-06-05 08:33:27 -07002659 * label:
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002660 * ...;
Ian Rogersfae370a2013-06-05 08:33:27 -07002661 * and sharpen the type of vY to be type T.
2662 * Note, this pattern can't be if:
2663 * - if there are other branches to this branch,
2664 * - when vX == vY.
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002665 */
Ian Rogersfae370a2013-06-05 08:33:27 -07002666 if (!CurrentInsnFlags()->IsBranchTarget() &&
Ian Rogers9b360392013-06-06 14:45:07 -07002667 (Instruction::INSTANCE_OF == instance_of_inst->Opcode()) &&
2668 (inst->VRegA_21t() == instance_of_inst->VRegA_22c()) &&
2669 (instance_of_inst->VRegA_22c() != instance_of_inst->VRegB_22c())) {
Ian Rogersebbdd872014-07-07 23:53:08 -07002670 // Check the type of the instance-of is different than that of registers type, as if they
2671 // are the same there is no work to be done here. Check that the conversion is not to or
2672 // from an unresolved type as type information is imprecise. If the instance-of is to an
2673 // interface then ignore the type information as interfaces can only be treated as Objects
2674 // and we don't want to disallow field and other operations on the object. If the value
2675 // being instance-of checked against is known null (zero) then allow the optimization as
2676 // we didn't have type information. If the merge of the instance-of type with the original
2677 // type is assignable to the original then allow optimization. This check is performed to
2678 // ensure that subsequent merges don't lose type information - such as becoming an
2679 // interface from a class that would lose information relevant to field checks.
Ian Rogers7b078e82014-09-10 14:44:24 -07002680 const RegType& orig_type = work_line_->GetRegisterType(this, instance_of_inst->VRegB_22c());
Andreas Gampea5b09a62016-11-17 15:21:22 -08002681 const RegType& cast_type = ResolveClassAndCheckAccess(
2682 dex::TypeIndex(instance_of_inst->VRegC_22c()));
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002683
Ian Rogersebbdd872014-07-07 23:53:08 -07002684 if (!orig_type.Equals(cast_type) &&
2685 !cast_type.IsUnresolvedTypes() && !orig_type.IsUnresolvedTypes() &&
Andreas Gampe00633eb2014-07-17 16:13:35 -07002686 cast_type.HasClass() && // Could be conflict type, make sure it has a class.
Ian Rogersebbdd872014-07-07 23:53:08 -07002687 !cast_type.GetClass()->IsInterface() &&
2688 (orig_type.IsZero() ||
David Brazdilca3c8c32016-09-06 14:04:48 +01002689 orig_type.IsStrictlyAssignableFrom(
2690 cast_type.Merge(orig_type, &reg_types_, this), this))) {
Ian Rogersd0fbd852013-09-24 18:17:04 -07002691 RegisterLine* update_line = RegisterLine::Create(code_item_->registers_size_, this);
Ian Rogersfae370a2013-06-05 08:33:27 -07002692 if (inst->Opcode() == Instruction::IF_EQZ) {
Ian Rogers9b360392013-06-06 14:45:07 -07002693 fallthrough_line.reset(update_line);
Ian Rogersfae370a2013-06-05 08:33:27 -07002694 } else {
Ian Rogers9b360392013-06-06 14:45:07 -07002695 branch_line.reset(update_line);
2696 }
2697 update_line->CopyFromLine(work_line_.get());
Andreas Gampead238ce2015-08-24 21:13:08 -07002698 update_line->SetRegisterType<LockOp::kKeep>(this,
2699 instance_of_inst->VRegB_22c(),
2700 cast_type);
Mathieu Chartierde40d472015-10-15 17:47:48 -07002701 if (!GetInstructionFlags(instance_of_idx).IsBranchTarget() && 0 != instance_of_idx) {
Ian Rogers9b360392013-06-06 14:45:07 -07002702 // See if instance-of was preceded by a move-object operation, common due to the small
2703 // register encoding space of instance-of, and propagate type information to the source
2704 // of the move-object.
2705 uint32_t move_idx = instance_of_idx - 1;
Mathieu Chartierde40d472015-10-15 17:47:48 -07002706 while (0 != move_idx && !GetInstructionFlags(move_idx).IsOpcode()) {
Ian Rogers9b360392013-06-06 14:45:07 -07002707 move_idx--;
2708 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07002709 if (FailOrAbort(this, GetInstructionFlags(move_idx).IsOpcode(),
Andreas Gampe7c038102014-10-27 20:08:46 -07002710 "Unable to get previous instruction of if-eqz/if-nez for work index ",
2711 work_insn_idx_)) {
2712 break;
2713 }
Ian Rogers9b360392013-06-06 14:45:07 -07002714 const Instruction* move_inst = Instruction::At(code_item_->insns_ + move_idx);
2715 switch (move_inst->Opcode()) {
2716 case Instruction::MOVE_OBJECT:
2717 if (move_inst->VRegA_12x() == instance_of_inst->VRegB_22c()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07002718 update_line->SetRegisterType<LockOp::kKeep>(this,
2719 move_inst->VRegB_12x(),
2720 cast_type);
Ian Rogers9b360392013-06-06 14:45:07 -07002721 }
2722 break;
2723 case Instruction::MOVE_OBJECT_FROM16:
2724 if (move_inst->VRegA_22x() == instance_of_inst->VRegB_22c()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07002725 update_line->SetRegisterType<LockOp::kKeep>(this,
2726 move_inst->VRegB_22x(),
2727 cast_type);
Ian Rogers9b360392013-06-06 14:45:07 -07002728 }
2729 break;
2730 case Instruction::MOVE_OBJECT_16:
2731 if (move_inst->VRegA_32x() == instance_of_inst->VRegB_22c()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07002732 update_line->SetRegisterType<LockOp::kKeep>(this,
2733 move_inst->VRegB_32x(),
2734 cast_type);
Ian Rogers9b360392013-06-06 14:45:07 -07002735 }
2736 break;
2737 default:
2738 break;
2739 }
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07002740 }
2741 }
2742 }
2743
jeffhaobdb76512011-09-07 11:43:16 -07002744 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002745 }
jeffhaobdb76512011-09-07 11:43:16 -07002746 case Instruction::IF_LTZ:
2747 case Instruction::IF_GEZ:
2748 case Instruction::IF_GTZ:
Ian Rogersd81871c2011-10-03 13:57:23 -07002749 case Instruction::IF_LEZ: {
Ian Rogers7b078e82014-09-10 14:44:24 -07002750 const RegType& reg_type = work_line_->GetRegisterType(this, inst->VRegA_21t());
Ian Rogersd81871c2011-10-03 13:57:23 -07002751 if (!reg_type.IsIntegralTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07002752 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "type " << reg_type
2753 << " unexpected as arg to if-ltz/if-gez/if-gtz/if-lez";
Ian Rogersd81871c2011-10-03 13:57:23 -07002754 }
jeffhaobdb76512011-09-07 11:43:16 -07002755 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002756 }
jeffhaobdb76512011-09-07 11:43:16 -07002757 case Instruction::AGET_BOOLEAN:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002758 VerifyAGet(inst, reg_types_.Boolean(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002759 break;
jeffhaobdb76512011-09-07 11:43:16 -07002760 case Instruction::AGET_BYTE:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002761 VerifyAGet(inst, reg_types_.Byte(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002762 break;
jeffhaobdb76512011-09-07 11:43:16 -07002763 case Instruction::AGET_CHAR:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002764 VerifyAGet(inst, reg_types_.Char(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002765 break;
jeffhaobdb76512011-09-07 11:43:16 -07002766 case Instruction::AGET_SHORT:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002767 VerifyAGet(inst, reg_types_.Short(), true);
jeffhaobdb76512011-09-07 11:43:16 -07002768 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002769 case Instruction::AGET:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002770 VerifyAGet(inst, reg_types_.Integer(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002771 break;
jeffhaobdb76512011-09-07 11:43:16 -07002772 case Instruction::AGET_WIDE:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002773 VerifyAGet(inst, reg_types_.LongLo(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002774 break;
2775 case Instruction::AGET_OBJECT:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002776 VerifyAGet(inst, reg_types_.JavaLangObject(false), false);
jeffhaobdb76512011-09-07 11:43:16 -07002777 break;
2778
Ian Rogersd81871c2011-10-03 13:57:23 -07002779 case Instruction::APUT_BOOLEAN:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002780 VerifyAPut(inst, reg_types_.Boolean(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002781 break;
2782 case Instruction::APUT_BYTE:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002783 VerifyAPut(inst, reg_types_.Byte(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002784 break;
2785 case Instruction::APUT_CHAR:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002786 VerifyAPut(inst, reg_types_.Char(), true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002787 break;
2788 case Instruction::APUT_SHORT:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002789 VerifyAPut(inst, reg_types_.Short(), true);
jeffhaobdb76512011-09-07 11:43:16 -07002790 break;
2791 case Instruction::APUT:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002792 VerifyAPut(inst, reg_types_.Integer(), true);
jeffhaobdb76512011-09-07 11:43:16 -07002793 break;
2794 case Instruction::APUT_WIDE:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002795 VerifyAPut(inst, reg_types_.LongLo(), true);
jeffhaobdb76512011-09-07 11:43:16 -07002796 break;
2797 case Instruction::APUT_OBJECT:
Sebastien Hertz5243e912013-05-21 10:55:07 +02002798 VerifyAPut(inst, reg_types_.JavaLangObject(false), false);
jeffhaobdb76512011-09-07 11:43:16 -07002799 break;
2800
jeffhaobdb76512011-09-07 11:43:16 -07002801 case Instruction::IGET_BOOLEAN:
Andreas Gampe896df402014-10-20 22:25:29 -07002802 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Boolean(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002803 break;
jeffhaobdb76512011-09-07 11:43:16 -07002804 case Instruction::IGET_BYTE:
Andreas Gampe896df402014-10-20 22:25:29 -07002805 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Byte(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002806 break;
jeffhaobdb76512011-09-07 11:43:16 -07002807 case Instruction::IGET_CHAR:
Andreas Gampe896df402014-10-20 22:25:29 -07002808 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Char(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002809 break;
jeffhaobdb76512011-09-07 11:43:16 -07002810 case Instruction::IGET_SHORT:
Andreas Gampe896df402014-10-20 22:25:29 -07002811 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Short(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002812 break;
2813 case Instruction::IGET:
Andreas Gampe896df402014-10-20 22:25:29 -07002814 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Integer(), true, false);
jeffhaobdb76512011-09-07 11:43:16 -07002815 break;
2816 case Instruction::IGET_WIDE:
Andreas Gampe896df402014-10-20 22:25:29 -07002817 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.LongLo(), true, false);
jeffhaobdb76512011-09-07 11:43:16 -07002818 break;
2819 case Instruction::IGET_OBJECT:
Andreas Gampe896df402014-10-20 22:25:29 -07002820 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.JavaLangObject(false), false,
2821 false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002822 break;
jeffhaobdb76512011-09-07 11:43:16 -07002823
Ian Rogersd81871c2011-10-03 13:57:23 -07002824 case Instruction::IPUT_BOOLEAN:
Andreas Gampe896df402014-10-20 22:25:29 -07002825 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Boolean(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002826 break;
2827 case Instruction::IPUT_BYTE:
Andreas Gampe896df402014-10-20 22:25:29 -07002828 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Byte(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002829 break;
2830 case Instruction::IPUT_CHAR:
Andreas Gampe896df402014-10-20 22:25:29 -07002831 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Char(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002832 break;
2833 case Instruction::IPUT_SHORT:
Andreas Gampe896df402014-10-20 22:25:29 -07002834 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Short(), true, false);
jeffhaobdb76512011-09-07 11:43:16 -07002835 break;
2836 case Instruction::IPUT:
Andreas Gampe896df402014-10-20 22:25:29 -07002837 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Integer(), true, false);
jeffhaobdb76512011-09-07 11:43:16 -07002838 break;
2839 case Instruction::IPUT_WIDE:
Andreas Gampe896df402014-10-20 22:25:29 -07002840 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.LongLo(), true, false);
Ian Rogersd81871c2011-10-03 13:57:23 -07002841 break;
jeffhaobdb76512011-09-07 11:43:16 -07002842 case Instruction::IPUT_OBJECT:
Andreas Gampe896df402014-10-20 22:25:29 -07002843 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.JavaLangObject(false), false,
2844 false);
jeffhaobdb76512011-09-07 11:43:16 -07002845 break;
2846
jeffhaobdb76512011-09-07 11:43:16 -07002847 case Instruction::SGET_BOOLEAN:
Andreas Gampe896df402014-10-20 22:25:29 -07002848 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Boolean(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002849 break;
jeffhaobdb76512011-09-07 11:43:16 -07002850 case Instruction::SGET_BYTE:
Andreas Gampe896df402014-10-20 22:25:29 -07002851 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Byte(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002852 break;
jeffhaobdb76512011-09-07 11:43:16 -07002853 case Instruction::SGET_CHAR:
Andreas Gampe896df402014-10-20 22:25:29 -07002854 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Char(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002855 break;
jeffhaobdb76512011-09-07 11:43:16 -07002856 case Instruction::SGET_SHORT:
Andreas Gampe896df402014-10-20 22:25:29 -07002857 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Short(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002858 break;
2859 case Instruction::SGET:
Andreas Gampe896df402014-10-20 22:25:29 -07002860 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Integer(), true, true);
jeffhaobdb76512011-09-07 11:43:16 -07002861 break;
2862 case Instruction::SGET_WIDE:
Andreas Gampe896df402014-10-20 22:25:29 -07002863 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.LongLo(), true, true);
jeffhaobdb76512011-09-07 11:43:16 -07002864 break;
2865 case Instruction::SGET_OBJECT:
Andreas Gampe896df402014-10-20 22:25:29 -07002866 VerifyISFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.JavaLangObject(false), false,
2867 true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002868 break;
2869
2870 case Instruction::SPUT_BOOLEAN:
Andreas Gampe896df402014-10-20 22:25:29 -07002871 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Boolean(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002872 break;
2873 case Instruction::SPUT_BYTE:
Andreas Gampe896df402014-10-20 22:25:29 -07002874 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Byte(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002875 break;
2876 case Instruction::SPUT_CHAR:
Andreas Gampe896df402014-10-20 22:25:29 -07002877 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Char(), true, true);
Ian Rogersd81871c2011-10-03 13:57:23 -07002878 break;
2879 case Instruction::SPUT_SHORT:
Andreas Gampe896df402014-10-20 22:25:29 -07002880 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Short(), true, true);
jeffhaobdb76512011-09-07 11:43:16 -07002881 break;
2882 case Instruction::SPUT:
Andreas Gampe896df402014-10-20 22:25:29 -07002883 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Integer(), true, true);
jeffhaobdb76512011-09-07 11:43:16 -07002884 break;
2885 case Instruction::SPUT_WIDE:
Andreas Gampe896df402014-10-20 22:25:29 -07002886 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.LongLo(), true, true);
jeffhaobdb76512011-09-07 11:43:16 -07002887 break;
2888 case Instruction::SPUT_OBJECT:
Andreas Gampe896df402014-10-20 22:25:29 -07002889 VerifyISFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.JavaLangObject(false), false,
2890 true);
jeffhaobdb76512011-09-07 11:43:16 -07002891 break;
2892
2893 case Instruction::INVOKE_VIRTUAL:
2894 case Instruction::INVOKE_VIRTUAL_RANGE:
2895 case Instruction::INVOKE_SUPER:
Ian Rogersd81871c2011-10-03 13:57:23 -07002896 case Instruction::INVOKE_SUPER_RANGE: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002897 bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE ||
2898 inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07002899 bool is_super = (inst->Opcode() == Instruction::INVOKE_SUPER ||
2900 inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
Alex Light7268d472016-01-20 15:50:01 -08002901 MethodType type = is_super ? METHOD_SUPER : METHOD_VIRTUAL;
2902 ArtMethod* called_method = VerifyInvocationArgs(inst, type, is_range);
Ian Rogersd8f69b02014-09-10 21:43:52 +00002903 const RegType* return_type = nullptr;
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002904 if (called_method != nullptr) {
Vladimir Marko942fd312017-01-16 20:52:19 +00002905 mirror::Class* return_type_class = called_method->GetReturnType(can_load_classes_);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002906 if (return_type_class != nullptr) {
Andreas Gampef23f33d2015-06-23 14:18:17 -07002907 return_type = &FromClass(called_method->GetReturnTypeDescriptor(),
2908 return_type_class,
2909 return_type_class->CannotBeAssignedFromOtherTypes());
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002910 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07002911 DCHECK(!can_load_classes_ || self_->IsExceptionPending());
2912 self_->ClearException();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002913 }
2914 }
2915 if (return_type == nullptr) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002916 uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
Ian Rogersad0b3a32012-04-16 14:50:24 -07002917 const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
Andreas Gampea5b09a62016-11-17 15:21:22 -08002918 dex::TypeIndex return_type_idx =
2919 dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002920 const char* descriptor = dex_file_->StringByTypeIdx(return_type_idx);
Mathieu Chartierbf99f772014-08-23 16:37:27 -07002921 return_type = &reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
jeffhaobdb76512011-09-07 11:43:16 -07002922 }
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002923 if (!return_type->IsLowHalf()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07002924 work_line_->SetResultRegisterType(this, *return_type);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002925 } else {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07002926 work_line_->SetResultRegisterTypeWide(*return_type, return_type->HighHalf(&reg_types_));
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002927 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07002928 just_set_result = true;
jeffhaobdb76512011-09-07 11:43:16 -07002929 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07002930 }
jeffhaobdb76512011-09-07 11:43:16 -07002931 case Instruction::INVOKE_DIRECT:
Ian Rogersd81871c2011-10-03 13:57:23 -07002932 case Instruction::INVOKE_DIRECT_RANGE: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002933 bool is_range = (inst->Opcode() == Instruction::INVOKE_DIRECT_RANGE);
Alex Light7268d472016-01-20 15:50:01 -08002934 ArtMethod* called_method = VerifyInvocationArgs(inst, METHOD_DIRECT, is_range);
Ian Rogers46685432012-06-03 22:26:43 -07002935 const char* return_type_descriptor;
2936 bool is_constructor;
Ian Rogersd8f69b02014-09-10 21:43:52 +00002937 const RegType* return_type = nullptr;
Ian Rogers7b078e82014-09-10 14:44:24 -07002938 if (called_method == nullptr) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02002939 uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
Ian Rogers46685432012-06-03 22:26:43 -07002940 const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -07002941 is_constructor = strcmp("<init>", dex_file_->StringDataByIdx(method_id.name_idx_)) == 0;
Andreas Gampea5b09a62016-11-17 15:21:22 -08002942 dex::TypeIndex return_type_idx =
2943 dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
Ian Rogers46685432012-06-03 22:26:43 -07002944 return_type_descriptor = dex_file_->StringByTypeIdx(return_type_idx);
2945 } else {
2946 is_constructor = called_method->IsConstructor();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07002947 return_type_descriptor = called_method->GetReturnTypeDescriptor();
Vladimir Marko942fd312017-01-16 20:52:19 +00002948 mirror::Class* return_type_class = called_method->GetReturnType(can_load_classes_);
Ian Rogers1ff3c982014-08-12 02:30:58 -07002949 if (return_type_class != nullptr) {
Andreas Gampef23f33d2015-06-23 14:18:17 -07002950 return_type = &FromClass(return_type_descriptor,
2951 return_type_class,
2952 return_type_class->CannotBeAssignedFromOtherTypes());
Ian Rogers1ff3c982014-08-12 02:30:58 -07002953 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07002954 DCHECK(!can_load_classes_ || self_->IsExceptionPending());
2955 self_->ClearException();
Ian Rogers1ff3c982014-08-12 02:30:58 -07002956 }
Ian Rogers46685432012-06-03 22:26:43 -07002957 }
2958 if (is_constructor) {
jeffhaobdb76512011-09-07 11:43:16 -07002959 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07002960 * Some additional checks when calling a constructor. We know from the invocation arg check
2961 * that the "this" argument is an instance of called_method->klass. Now we further restrict
2962 * that to require that called_method->klass is the same as this->klass or this->super,
2963 * allowing the latter only if the "this" argument is the same as the "this" argument to
2964 * this method (which implies that we're in a constructor ourselves).
jeffhaobdb76512011-09-07 11:43:16 -07002965 */
Orion Hodsoncfa325e2016-10-13 10:25:54 +01002966 const RegType& this_type = work_line_->GetInvocationThis(this, inst);
jeffhaob57e9522012-04-26 18:08:21 -07002967 if (this_type.IsConflict()) // failure.
2968 break;
jeffhaobdb76512011-09-07 11:43:16 -07002969
jeffhaob57e9522012-04-26 18:08:21 -07002970 /* no null refs allowed (?) */
2971 if (this_type.IsZero()) {
2972 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unable to initialize null ref";
2973 break;
jeffhao2a8a90e2011-09-26 14:25:31 -07002974 }
jeffhaob57e9522012-04-26 18:08:21 -07002975
2976 /* must be in same class or in superclass */
Ian Rogersd8f69b02014-09-10 21:43:52 +00002977 // const RegType& this_super_klass = this_type.GetSuperClass(&reg_types_);
Ian Rogers46685432012-06-03 22:26:43 -07002978 // TODO: re-enable constructor type verification
2979 // if (this_super_klass.IsConflict()) {
jeffhaob57e9522012-04-26 18:08:21 -07002980 // Unknown super class, fail so we re-check at runtime.
Ian Rogers46685432012-06-03 22:26:43 -07002981 // Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "super class unknown for '" << this_type << "'";
2982 // break;
2983 // }
jeffhaob57e9522012-04-26 18:08:21 -07002984
2985 /* arg must be an uninitialized reference */
2986 if (!this_type.IsUninitializedTypes()) {
2987 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Expected initialization on uninitialized reference "
2988 << this_type;
2989 break;
2990 }
2991
2992 /*
2993 * Replace the uninitialized reference with an initialized one. We need to do this for all
2994 * registers that have the same object instance in them, not just the "this" register.
2995 */
Nicolas Geoffray98e6ce42016-02-16 18:42:15 +00002996 work_line_->MarkRefsAsInitialized(this, this_type);
Ian Rogersad0b3a32012-04-16 14:50:24 -07002997 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07002998 if (return_type == nullptr) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07002999 return_type = &reg_types_.FromDescriptor(GetClassLoader(), return_type_descriptor, false);
Ian Rogers1ff3c982014-08-12 02:30:58 -07003000 }
3001 if (!return_type->IsLowHalf()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003002 work_line_->SetResultRegisterType(this, *return_type);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003003 } else {
Ian Rogers1ff3c982014-08-12 02:30:58 -07003004 work_line_->SetResultRegisterTypeWide(*return_type, return_type->HighHalf(&reg_types_));
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003005 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07003006 just_set_result = true;
3007 break;
3008 }
3009 case Instruction::INVOKE_STATIC:
3010 case Instruction::INVOKE_STATIC_RANGE: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02003011 bool is_range = (inst->Opcode() == Instruction::INVOKE_STATIC_RANGE);
Alex Light7268d472016-01-20 15:50:01 -08003012 ArtMethod* called_method = VerifyInvocationArgs(inst, METHOD_STATIC, is_range);
Ian Rogers28ad40d2011-10-27 15:19:26 -07003013 const char* descriptor;
Ian Rogers7b078e82014-09-10 14:44:24 -07003014 if (called_method == nullptr) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02003015 uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
Ian Rogers28ad40d2011-10-27 15:19:26 -07003016 const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
Andreas Gampea5b09a62016-11-17 15:21:22 -08003017 dex::TypeIndex return_type_idx =
3018 dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
Mathieu Chartier590fee92013-09-13 13:46:47 -07003019 descriptor = dex_file_->StringByTypeIdx(return_type_idx);
Ian Rogers28ad40d2011-10-27 15:19:26 -07003020 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003021 descriptor = called_method->GetReturnTypeDescriptor();
Ian Rogers28ad40d2011-10-27 15:19:26 -07003022 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00003023 const RegType& return_type = reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003024 if (!return_type.IsLowHalf()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003025 work_line_->SetResultRegisterType(this, return_type);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003026 } else {
3027 work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
3028 }
jeffhaobdb76512011-09-07 11:43:16 -07003029 just_set_result = true;
3030 }
3031 break;
jeffhaobdb76512011-09-07 11:43:16 -07003032 case Instruction::INVOKE_INTERFACE:
Ian Rogersd81871c2011-10-03 13:57:23 -07003033 case Instruction::INVOKE_INTERFACE_RANGE: {
Sebastien Hertz5243e912013-05-21 10:55:07 +02003034 bool is_range = (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
Alex Light7268d472016-01-20 15:50:01 -08003035 ArtMethod* abs_method = VerifyInvocationArgs(inst, METHOD_INTERFACE, is_range);
Ian Rogers7b078e82014-09-10 14:44:24 -07003036 if (abs_method != nullptr) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003037 mirror::Class* called_interface = abs_method->GetDeclaringClass();
Ian Rogersad0b3a32012-04-16 14:50:24 -07003038 if (!called_interface->IsInterface() && !called_interface->IsObjectClass()) {
3039 Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected interface class in invoke-interface '"
David Sehr709b0702016-10-13 09:12:37 -07003040 << abs_method->PrettyMethod() << "'";
Ian Rogersad0b3a32012-04-16 14:50:24 -07003041 break;
Ian Rogers28ad40d2011-10-27 15:19:26 -07003042 }
Ian Rogers0d604842012-04-16 14:50:24 -07003043 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07003044 /* Get the type of the "this" arg, which should either be a sub-interface of called
3045 * interface or Object (see comments in RegType::JoinClass).
3046 */
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003047 const RegType& this_type = work_line_->GetInvocationThis(this, inst);
Ian Rogersad0b3a32012-04-16 14:50:24 -07003048 if (this_type.IsZero()) {
3049 /* null pointer always passes (and always fails at runtime) */
3050 } else {
3051 if (this_type.IsUninitializedTypes()) {
3052 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "interface call on uninitialized object "
3053 << this_type;
3054 break;
3055 }
3056 // In the past we have tried to assert that "called_interface" is assignable
3057 // from "this_type.GetClass()", however, as we do an imprecise Join
3058 // (RegType::JoinClass) we don't have full information on what interfaces are
3059 // implemented by "this_type". For example, two classes may implement the same
3060 // interfaces and have a common parent that doesn't implement the interface. The
3061 // join will set "this_type" to the parent class and a test that this implements
3062 // the interface will incorrectly fail.
3063 }
3064 /*
3065 * We don't have an object instance, so we can't find the concrete method. However, all of
3066 * the type information is in the abstract method, so we're good.
3067 */
3068 const char* descriptor;
Ian Rogers7b078e82014-09-10 14:44:24 -07003069 if (abs_method == nullptr) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02003070 uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
Ian Rogersad0b3a32012-04-16 14:50:24 -07003071 const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
Andreas Gampea5b09a62016-11-17 15:21:22 -08003072 dex::TypeIndex return_type_idx =
3073 dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
Mathieu Chartierde40d472015-10-15 17:47:48 -07003074 descriptor = dex_file_->StringByTypeIdx(return_type_idx);
Ian Rogersad0b3a32012-04-16 14:50:24 -07003075 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003076 descriptor = abs_method->GetReturnTypeDescriptor();
Ian Rogersad0b3a32012-04-16 14:50:24 -07003077 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00003078 const RegType& return_type = reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003079 if (!return_type.IsLowHalf()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003080 work_line_->SetResultRegisterType(this, return_type);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003081 } else {
3082 work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
3083 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07003084 just_set_result = true;
jeffhaobdb76512011-09-07 11:43:16 -07003085 break;
Ian Rogersd81871c2011-10-03 13:57:23 -07003086 }
Narayan Kamath9823e782016-08-03 12:46:58 +01003087 case Instruction::INVOKE_POLYMORPHIC:
3088 case Instruction::INVOKE_POLYMORPHIC_RANGE: {
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003089 bool is_range = (inst->Opcode() == Instruction::INVOKE_POLYMORPHIC_RANGE);
3090 ArtMethod* called_method = VerifyInvocationArgs(inst, METHOD_POLYMORPHIC, is_range);
3091 if (called_method == nullptr) {
3092 // Convert potential soft failures in VerifyInvocationArgs() to hard errors.
3093 if (failure_messages_.size() > 0) {
3094 std::string message = failure_messages_.back()->str();
3095 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << message;
3096 } else {
3097 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invoke-polymorphic verification failure.";
3098 }
3099 break;
3100 }
3101 if (!CheckSignaturePolymorphicMethod(called_method) ||
3102 !CheckSignaturePolymorphicReceiver(inst)) {
3103 break;
3104 }
3105 const uint32_t proto_idx = (is_range) ? inst->VRegH_4rcc() : inst->VRegH_45cc();
Orion Hodsonac141392017-01-13 11:53:47 +00003106 const char* return_descriptor =
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003107 dex_file_->GetReturnTypeDescriptor(dex_file_->GetProtoId(proto_idx));
3108 const RegType& return_type =
Orion Hodsonac141392017-01-13 11:53:47 +00003109 reg_types_.FromDescriptor(GetClassLoader(), return_descriptor, false);
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003110 if (!return_type.IsLowHalf()) {
3111 work_line_->SetResultRegisterType(this, return_type);
3112 } else {
3113 work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
3114 }
Orion Hodsonac141392017-01-13 11:53:47 +00003115 just_set_result = true;
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003116 break;
Narayan Kamath9823e782016-08-03 12:46:58 +01003117 }
Orion Hodsonc069a302017-01-18 09:23:12 +00003118 case Instruction::INVOKE_CUSTOM:
3119 case Instruction::INVOKE_CUSTOM_RANGE: {
3120 // Verify registers based on method_type in the call site.
3121 bool is_range = (inst->Opcode() == Instruction::INVOKE_CUSTOM_RANGE);
3122
3123 // Step 1. Check the call site that produces the method handle for invocation
3124 const uint32_t call_site_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
3125 if (!CheckCallSite(call_site_idx)) {
3126 DCHECK(HasFailures());
3127 break;
3128 }
3129
3130 // Step 2. Check the register arguments correspond to the expected arguments for the
3131 // method handle produced by step 1. The dex file verifier has checked ranges for
3132 // the first three arguments and CheckCallSite has checked the method handle type.
3133 CallSiteArrayValueIterator it(*dex_file_, dex_file_->GetCallSiteId(call_site_idx));
3134 it.Next(); // Skip to name.
3135 it.Next(); // Skip to method type of the method handle
3136 const uint32_t proto_idx = static_cast<uint32_t>(it.GetJavaValue().i);
3137 const DexFile::ProtoId& proto_id = dex_file_->GetProtoId(proto_idx);
3138 DexFileParameterIterator param_it(*dex_file_, proto_id);
3139 // Treat method as static as it has yet to be determined.
3140 VerifyInvocationArgsFromIterator(&param_it, inst, METHOD_STATIC, is_range, nullptr);
3141 const char* return_descriptor = dex_file_->GetReturnTypeDescriptor(proto_id);
3142
3143 // Step 3. Propagate return type information
3144 const RegType& return_type =
3145 reg_types_.FromDescriptor(GetClassLoader(), return_descriptor, false);
3146 if (!return_type.IsLowHalf()) {
3147 work_line_->SetResultRegisterType(this, return_type);
3148 } else {
3149 work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
3150 }
3151 just_set_result = true;
3152 // TODO: Add compiler support for invoke-custom (b/35337872).
3153 Fail(VERIFY_ERROR_FORCE_INTERPRETER);
3154 break;
3155 }
jeffhaobdb76512011-09-07 11:43:16 -07003156 case Instruction::NEG_INT:
3157 case Instruction::NOT_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003158 work_line_->CheckUnaryOp(this, inst, reg_types_.Integer(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003159 break;
3160 case Instruction::NEG_LONG:
3161 case Instruction::NOT_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07003162 work_line_->CheckUnaryOpWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003163 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003164 break;
3165 case Instruction::NEG_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003166 work_line_->CheckUnaryOp(this, inst, reg_types_.Float(), reg_types_.Float());
jeffhaobdb76512011-09-07 11:43:16 -07003167 break;
3168 case Instruction::NEG_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003169 work_line_->CheckUnaryOpWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003170 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003171 break;
3172 case Instruction::INT_TO_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07003173 work_line_->CheckUnaryOpToWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003174 reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003175 break;
3176 case Instruction::INT_TO_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003177 work_line_->CheckUnaryOp(this, inst, reg_types_.Float(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003178 break;
3179 case Instruction::INT_TO_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003180 work_line_->CheckUnaryOpToWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003181 reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003182 break;
3183 case Instruction::LONG_TO_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003184 work_line_->CheckUnaryOpFromWide(this, inst, reg_types_.Integer(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003185 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003186 break;
3187 case Instruction::LONG_TO_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003188 work_line_->CheckUnaryOpFromWide(this, inst, reg_types_.Float(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003189 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003190 break;
3191 case Instruction::LONG_TO_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003192 work_line_->CheckUnaryOpWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003193 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003194 break;
3195 case Instruction::FLOAT_TO_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003196 work_line_->CheckUnaryOp(this, inst, reg_types_.Integer(), reg_types_.Float());
jeffhaobdb76512011-09-07 11:43:16 -07003197 break;
3198 case Instruction::FLOAT_TO_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07003199 work_line_->CheckUnaryOpToWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003200 reg_types_.Float());
jeffhaobdb76512011-09-07 11:43:16 -07003201 break;
3202 case Instruction::FLOAT_TO_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003203 work_line_->CheckUnaryOpToWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003204 reg_types_.Float());
jeffhaobdb76512011-09-07 11:43:16 -07003205 break;
3206 case Instruction::DOUBLE_TO_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003207 work_line_->CheckUnaryOpFromWide(this, inst, reg_types_.Integer(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003208 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003209 break;
3210 case Instruction::DOUBLE_TO_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07003211 work_line_->CheckUnaryOpWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003212 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003213 break;
3214 case Instruction::DOUBLE_TO_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003215 work_line_->CheckUnaryOpFromWide(this, inst, reg_types_.Float(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003216 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003217 break;
3218 case Instruction::INT_TO_BYTE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003219 work_line_->CheckUnaryOp(this, inst, reg_types_.Byte(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003220 break;
3221 case Instruction::INT_TO_CHAR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003222 work_line_->CheckUnaryOp(this, inst, reg_types_.Char(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003223 break;
3224 case Instruction::INT_TO_SHORT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003225 work_line_->CheckUnaryOp(this, inst, reg_types_.Short(), reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003226 break;
3227
3228 case Instruction::ADD_INT:
3229 case Instruction::SUB_INT:
3230 case Instruction::MUL_INT:
3231 case Instruction::REM_INT:
3232 case Instruction::DIV_INT:
3233 case Instruction::SHL_INT:
3234 case Instruction::SHR_INT:
3235 case Instruction::USHR_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003236 work_line_->CheckBinaryOp(this, inst, reg_types_.Integer(), reg_types_.Integer(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003237 reg_types_.Integer(), false);
jeffhaobdb76512011-09-07 11:43:16 -07003238 break;
3239 case Instruction::AND_INT:
3240 case Instruction::OR_INT:
3241 case Instruction::XOR_INT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003242 work_line_->CheckBinaryOp(this, inst, reg_types_.Integer(), reg_types_.Integer(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003243 reg_types_.Integer(), true);
jeffhaobdb76512011-09-07 11:43:16 -07003244 break;
3245 case Instruction::ADD_LONG:
3246 case Instruction::SUB_LONG:
3247 case Instruction::MUL_LONG:
3248 case Instruction::DIV_LONG:
3249 case Instruction::REM_LONG:
3250 case Instruction::AND_LONG:
3251 case Instruction::OR_LONG:
3252 case Instruction::XOR_LONG:
Ian Rogers7b078e82014-09-10 14:44:24 -07003253 work_line_->CheckBinaryOpWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003254 reg_types_.LongLo(), reg_types_.LongHi(),
3255 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003256 break;
3257 case Instruction::SHL_LONG:
3258 case Instruction::SHR_LONG:
3259 case Instruction::USHR_LONG:
Ian Rogersd81871c2011-10-03 13:57:23 -07003260 /* shift distance is Int, making these different from other binary operations */
Ian Rogers7b078e82014-09-10 14:44:24 -07003261 work_line_->CheckBinaryOpWideShift(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003262 reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003263 break;
3264 case Instruction::ADD_FLOAT:
3265 case Instruction::SUB_FLOAT:
3266 case Instruction::MUL_FLOAT:
3267 case Instruction::DIV_FLOAT:
3268 case Instruction::REM_FLOAT:
Ian Rogers7b078e82014-09-10 14:44:24 -07003269 work_line_->CheckBinaryOp(this, inst, reg_types_.Float(), reg_types_.Float(),
3270 reg_types_.Float(), false);
jeffhaobdb76512011-09-07 11:43:16 -07003271 break;
3272 case Instruction::ADD_DOUBLE:
3273 case Instruction::SUB_DOUBLE:
3274 case Instruction::MUL_DOUBLE:
3275 case Instruction::DIV_DOUBLE:
3276 case Instruction::REM_DOUBLE:
Ian Rogers7b078e82014-09-10 14:44:24 -07003277 work_line_->CheckBinaryOpWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003278 reg_types_.DoubleLo(), reg_types_.DoubleHi(),
3279 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003280 break;
3281 case Instruction::ADD_INT_2ADDR:
3282 case Instruction::SUB_INT_2ADDR:
3283 case Instruction::MUL_INT_2ADDR:
3284 case Instruction::REM_INT_2ADDR:
3285 case Instruction::SHL_INT_2ADDR:
3286 case Instruction::SHR_INT_2ADDR:
3287 case Instruction::USHR_INT_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003288 work_line_->CheckBinaryOp2addr(this, inst, reg_types_.Integer(), reg_types_.Integer(),
3289 reg_types_.Integer(), false);
jeffhaobdb76512011-09-07 11:43:16 -07003290 break;
3291 case Instruction::AND_INT_2ADDR:
3292 case Instruction::OR_INT_2ADDR:
3293 case Instruction::XOR_INT_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003294 work_line_->CheckBinaryOp2addr(this, inst, reg_types_.Integer(), reg_types_.Integer(),
3295 reg_types_.Integer(), true);
jeffhaobdb76512011-09-07 11:43:16 -07003296 break;
3297 case Instruction::DIV_INT_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003298 work_line_->CheckBinaryOp2addr(this, inst, reg_types_.Integer(), reg_types_.Integer(),
3299 reg_types_.Integer(), false);
jeffhaobdb76512011-09-07 11:43:16 -07003300 break;
3301 case Instruction::ADD_LONG_2ADDR:
3302 case Instruction::SUB_LONG_2ADDR:
3303 case Instruction::MUL_LONG_2ADDR:
3304 case Instruction::DIV_LONG_2ADDR:
3305 case Instruction::REM_LONG_2ADDR:
3306 case Instruction::AND_LONG_2ADDR:
3307 case Instruction::OR_LONG_2ADDR:
3308 case Instruction::XOR_LONG_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003309 work_line_->CheckBinaryOp2addrWide(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003310 reg_types_.LongLo(), reg_types_.LongHi(),
3311 reg_types_.LongLo(), reg_types_.LongHi());
jeffhaobdb76512011-09-07 11:43:16 -07003312 break;
3313 case Instruction::SHL_LONG_2ADDR:
3314 case Instruction::SHR_LONG_2ADDR:
3315 case Instruction::USHR_LONG_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003316 work_line_->CheckBinaryOp2addrWideShift(this, inst, reg_types_.LongLo(), reg_types_.LongHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003317 reg_types_.Integer());
jeffhaobdb76512011-09-07 11:43:16 -07003318 break;
3319 case Instruction::ADD_FLOAT_2ADDR:
3320 case Instruction::SUB_FLOAT_2ADDR:
3321 case Instruction::MUL_FLOAT_2ADDR:
3322 case Instruction::DIV_FLOAT_2ADDR:
3323 case Instruction::REM_FLOAT_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003324 work_line_->CheckBinaryOp2addr(this, inst, reg_types_.Float(), reg_types_.Float(),
3325 reg_types_.Float(), false);
jeffhaobdb76512011-09-07 11:43:16 -07003326 break;
3327 case Instruction::ADD_DOUBLE_2ADDR:
3328 case Instruction::SUB_DOUBLE_2ADDR:
3329 case Instruction::MUL_DOUBLE_2ADDR:
3330 case Instruction::DIV_DOUBLE_2ADDR:
3331 case Instruction::REM_DOUBLE_2ADDR:
Ian Rogers7b078e82014-09-10 14:44:24 -07003332 work_line_->CheckBinaryOp2addrWide(this, inst, reg_types_.DoubleLo(), reg_types_.DoubleHi(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08003333 reg_types_.DoubleLo(), reg_types_.DoubleHi(),
3334 reg_types_.DoubleLo(), reg_types_.DoubleHi());
jeffhaobdb76512011-09-07 11:43:16 -07003335 break;
3336 case Instruction::ADD_INT_LIT16:
Ian Rogersf72a11d2014-10-30 15:41:08 -07003337 case Instruction::RSUB_INT_LIT16:
jeffhaobdb76512011-09-07 11:43:16 -07003338 case Instruction::MUL_INT_LIT16:
3339 case Instruction::DIV_INT_LIT16:
3340 case Instruction::REM_INT_LIT16:
Ian Rogers7b078e82014-09-10 14:44:24 -07003341 work_line_->CheckLiteralOp(this, inst, reg_types_.Integer(), reg_types_.Integer(), false,
3342 true);
jeffhaobdb76512011-09-07 11:43:16 -07003343 break;
3344 case Instruction::AND_INT_LIT16:
3345 case Instruction::OR_INT_LIT16:
3346 case Instruction::XOR_INT_LIT16:
Ian Rogers7b078e82014-09-10 14:44:24 -07003347 work_line_->CheckLiteralOp(this, inst, reg_types_.Integer(), reg_types_.Integer(), true,
3348 true);
jeffhaobdb76512011-09-07 11:43:16 -07003349 break;
3350 case Instruction::ADD_INT_LIT8:
3351 case Instruction::RSUB_INT_LIT8:
3352 case Instruction::MUL_INT_LIT8:
3353 case Instruction::DIV_INT_LIT8:
3354 case Instruction::REM_INT_LIT8:
3355 case Instruction::SHL_INT_LIT8:
jeffhaobdb76512011-09-07 11:43:16 -07003356 case Instruction::SHR_INT_LIT8:
jeffhaobdb76512011-09-07 11:43:16 -07003357 case Instruction::USHR_INT_LIT8:
Ian Rogers7b078e82014-09-10 14:44:24 -07003358 work_line_->CheckLiteralOp(this, inst, reg_types_.Integer(), reg_types_.Integer(), false,
3359 false);
jeffhaobdb76512011-09-07 11:43:16 -07003360 break;
3361 case Instruction::AND_INT_LIT8:
3362 case Instruction::OR_INT_LIT8:
3363 case Instruction::XOR_INT_LIT8:
Ian Rogers7b078e82014-09-10 14:44:24 -07003364 work_line_->CheckLiteralOp(this, inst, reg_types_.Integer(), reg_types_.Integer(), true,
3365 false);
jeffhaobdb76512011-09-07 11:43:16 -07003366 break;
3367
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003368 // Special instructions.
Mathieu Chartierd7cbf8a2015-03-19 12:43:20 -07003369 case Instruction::RETURN_VOID_NO_BARRIER:
3370 if (IsConstructor() && !IsStatic()) {
3371 auto& declaring_class = GetDeclaringClass();
Andreas Gampe68df3202015-06-22 11:35:46 -07003372 if (declaring_class.IsUnresolvedReference()) {
3373 // We must iterate over the fields, even if we cannot use mirror classes to do so. Do it
3374 // manually over the underlying dex file.
3375 uint32_t first_index = GetFirstFinalInstanceFieldIndex(*dex_file_,
3376 dex_file_->GetMethodId(dex_method_idx_).class_idx_);
3377 if (first_index != DexFile::kDexNoIndex) {
3378 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-void-no-barrier not expected for field "
3379 << first_index;
3380 }
3381 break;
3382 }
Mathieu Chartierd7cbf8a2015-03-19 12:43:20 -07003383 auto* klass = declaring_class.GetClass();
3384 for (uint32_t i = 0, num_fields = klass->NumInstanceFields(); i < num_fields; ++i) {
3385 if (klass->GetInstanceField(i)->IsFinal()) {
Mathieu Chartiere86deef2015-03-19 13:43:37 -07003386 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-void-no-barrier not expected for "
David Sehr709b0702016-10-13 09:12:37 -07003387 << klass->GetInstanceField(i)->PrettyField();
Mathieu Chartierd7cbf8a2015-03-19 12:43:20 -07003388 break;
3389 }
3390 }
Sebastien Hertzcc10e0e2013-06-28 14:24:48 +02003391 }
Andreas Gampeb2917962015-07-31 13:36:10 -07003392 // Handle this like a RETURN_VOID now. Code is duplicated to separate standard from
3393 // quickened opcodes (otherwise this could be a fall-through).
3394 if (!IsConstructor()) {
3395 if (!GetMethodReturnType().IsConflict()) {
3396 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "return-void not expected";
3397 }
3398 }
Sebastien Hertzcc10e0e2013-06-28 14:24:48 +02003399 break;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003400 // Note: the following instructions encode offsets derived from class linking.
Neil Fuller0e844392016-09-08 13:43:31 +01003401 // As such they use Class*/Field*/Executable* as these offsets only have
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003402 // meaning if the class linking and resolution were successful.
3403 case Instruction::IGET_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003404 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Integer(), true);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003405 break;
3406 case Instruction::IGET_WIDE_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003407 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.LongLo(), true);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003408 break;
3409 case Instruction::IGET_OBJECT_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003410 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.JavaLangObject(false), false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003411 break;
Mathieu Chartierffc605c2014-12-10 10:35:44 -08003412 case Instruction::IGET_BOOLEAN_QUICK:
3413 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Boolean(), true);
3414 break;
3415 case Instruction::IGET_BYTE_QUICK:
3416 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Byte(), true);
3417 break;
3418 case Instruction::IGET_CHAR_QUICK:
3419 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Char(), true);
3420 break;
3421 case Instruction::IGET_SHORT_QUICK:
3422 VerifyQuickFieldAccess<FieldAccessType::kAccGet>(inst, reg_types_.Short(), true);
3423 break;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003424 case Instruction::IPUT_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003425 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Integer(), true);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003426 break;
Fred Shih37f05ef2014-07-16 18:38:08 -07003427 case Instruction::IPUT_BOOLEAN_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003428 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Boolean(), true);
Fred Shih37f05ef2014-07-16 18:38:08 -07003429 break;
3430 case Instruction::IPUT_BYTE_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003431 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Byte(), true);
Fred Shih37f05ef2014-07-16 18:38:08 -07003432 break;
3433 case Instruction::IPUT_CHAR_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003434 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Char(), true);
Fred Shih37f05ef2014-07-16 18:38:08 -07003435 break;
3436 case Instruction::IPUT_SHORT_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003437 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.Short(), true);
Fred Shih37f05ef2014-07-16 18:38:08 -07003438 break;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003439 case Instruction::IPUT_WIDE_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003440 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.LongLo(), true);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003441 break;
3442 case Instruction::IPUT_OBJECT_QUICK:
Andreas Gampe896df402014-10-20 22:25:29 -07003443 VerifyQuickFieldAccess<FieldAccessType::kAccPut>(inst, reg_types_.JavaLangObject(false), false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003444 break;
3445 case Instruction::INVOKE_VIRTUAL_QUICK:
3446 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
3447 bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003448 ArtMethod* called_method = VerifyInvokeVirtualQuickArgs(inst, is_range);
Ian Rogers7b078e82014-09-10 14:44:24 -07003449 if (called_method != nullptr) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003450 const char* descriptor = called_method->GetReturnTypeDescriptor();
Ian Rogersd8f69b02014-09-10 21:43:52 +00003451 const RegType& return_type = reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003452 if (!return_type.IsLowHalf()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003453 work_line_->SetResultRegisterType(this, return_type);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003454 } else {
3455 work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
3456 }
3457 just_set_result = true;
3458 }
3459 break;
3460 }
3461
Ian Rogersd81871c2011-10-03 13:57:23 -07003462 /* These should never appear during verification. */
Mathieu Chartierffc605c2014-12-10 10:35:44 -08003463 case Instruction::UNUSED_3E ... Instruction::UNUSED_43:
Narayan Kamath8ec3bd22016-08-03 12:46:23 +01003464 case Instruction::UNUSED_F3 ... Instruction::UNUSED_F9:
Orion Hodsonc069a302017-01-18 09:23:12 +00003465 case Instruction::UNUSED_FE ... Instruction::UNUSED_FF:
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02003466 case Instruction::UNUSED_79:
3467 case Instruction::UNUSED_7A:
jeffhaod5347e02012-03-22 17:25:05 -07003468 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Unexpected opcode " << inst->DumpString(dex_file_);
jeffhaobdb76512011-09-07 11:43:16 -07003469 break;
3470
3471 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07003472 * DO NOT add a "default" clause here. Without it the compiler will
jeffhaobdb76512011-09-07 11:43:16 -07003473 * complain if an instruction is missing (which is desirable).
3474 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08003475 } // end - switch (dec_insn.opcode)
jeffhaobdb76512011-09-07 11:43:16 -07003476
Ian Rogersad0b3a32012-04-16 14:50:24 -07003477 if (have_pending_hard_failure_) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08003478 if (Runtime::Current()->IsAotCompiler()) {
3479 /* When AOT compiling, check that the last failure is a hard failure */
Andreas Gampeb588f4c2015-05-26 13:35:39 -07003480 if (failures_[failures_.size() - 1] != VERIFY_ERROR_BAD_CLASS_HARD) {
3481 LOG(ERROR) << "Pending failures:";
3482 for (auto& error : failures_) {
3483 LOG(ERROR) << error;
3484 }
3485 for (auto& error_msg : failure_messages_) {
3486 LOG(ERROR) << error_msg->str();
3487 }
3488 LOG(FATAL) << "Pending hard failure, but last failure not hard.";
3489 }
Ian Rogerse1758fe2012-04-19 11:31:15 -07003490 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07003491 /* immediate failure, reject class */
3492 info_messages_ << "Rejecting opcode " << inst->DumpString(dex_file_);
3493 return false;
jeffhaofaf459e2012-08-31 15:32:47 -07003494 } else if (have_pending_runtime_throw_failure_) {
Jeff Haoa3faaf42013-09-03 19:07:00 -07003495 /* checking interpreter will throw, mark following code as unreachable */
jeffhaofaf459e2012-08-31 15:32:47 -07003496 opcode_flags = Instruction::kThrow;
Andreas Gampea727e372015-08-25 09:22:37 -07003497 // Note: the flag must be reset as it is only global to decouple Fail and is semantically per
3498 // instruction. However, RETURN checking may throw LOCKING errors, so we clear at the
3499 // very end.
jeffhaobdb76512011-09-07 11:43:16 -07003500 }
jeffhaobdb76512011-09-07 11:43:16 -07003501 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07003502 * If we didn't just set the result register, clear it out. This ensures that you can only use
3503 * "move-result" immediately after the result is set. (We could check this statically, but it's
3504 * not expensive and it makes our debugging output cleaner.)
jeffhaobdb76512011-09-07 11:43:16 -07003505 */
3506 if (!just_set_result) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003507 work_line_->SetResultTypeToUnknown(this);
jeffhaobdb76512011-09-07 11:43:16 -07003508 }
3509
jeffhaobdb76512011-09-07 11:43:16 -07003510 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07003511 * Handle "branch". Tag the branch target.
jeffhaobdb76512011-09-07 11:43:16 -07003512 *
3513 * NOTE: instructions like Instruction::EQZ provide information about the
jeffhaod1f0fde2011-09-08 17:25:33 -07003514 * state of the register when the branch is taken or not taken. For example,
jeffhaobdb76512011-09-07 11:43:16 -07003515 * somebody could get a reference field, check it for zero, and if the
3516 * branch is taken immediately store that register in a boolean field
jeffhaod1f0fde2011-09-08 17:25:33 -07003517 * since the value is known to be zero. We do not currently account for
jeffhaobdb76512011-09-07 11:43:16 -07003518 * that, and will reject the code.
3519 *
3520 * TODO: avoid re-fetching the branch target
3521 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08003522 if ((opcode_flags & Instruction::kBranch) != 0) {
jeffhaobdb76512011-09-07 11:43:16 -07003523 bool isConditional, selfOkay;
Ian Rogersd81871c2011-10-03 13:57:23 -07003524 if (!GetBranchOffset(work_insn_idx_, &branch_target, &isConditional, &selfOkay)) {
jeffhaobdb76512011-09-07 11:43:16 -07003525 /* should never happen after static verification */
jeffhaod5347e02012-03-22 17:25:05 -07003526 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad branch";
jeffhaobdb76512011-09-07 11:43:16 -07003527 return false;
3528 }
Elliott Hughesadb8c672012-03-06 16:49:32 -08003529 DCHECK_EQ(isConditional, (opcode_flags & Instruction::kContinue) != 0);
Stephen Kyle9bc61992014-09-22 13:53:15 +01003530 if (!CheckNotMoveExceptionOrMoveResult(code_item_->insns_, work_insn_idx_ + branch_target)) {
jeffhaobdb76512011-09-07 11:43:16 -07003531 return false;
Ian Rogersd81871c2011-10-03 13:57:23 -07003532 }
jeffhaobdb76512011-09-07 11:43:16 -07003533 /* update branch target, set "changed" if appropriate */
Mathieu Chartierde40d472015-10-15 17:47:48 -07003534 if (nullptr != branch_line) {
Ian Rogersebbdd872014-07-07 23:53:08 -07003535 if (!UpdateRegisters(work_insn_idx_ + branch_target, branch_line.get(), false)) {
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07003536 return false;
3537 }
3538 } else {
Ian Rogersebbdd872014-07-07 23:53:08 -07003539 if (!UpdateRegisters(work_insn_idx_ + branch_target, work_line_.get(), false)) {
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07003540 return false;
3541 }
Ian Rogersd81871c2011-10-03 13:57:23 -07003542 }
jeffhaobdb76512011-09-07 11:43:16 -07003543 }
3544
3545 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07003546 * Handle "switch". Tag all possible branch targets.
jeffhaobdb76512011-09-07 11:43:16 -07003547 *
3548 * We've already verified that the table is structurally sound, so we
3549 * just need to walk through and tag the targets.
3550 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08003551 if ((opcode_flags & Instruction::kSwitch) != 0) {
Andreas Gampe53de99c2015-08-17 13:43:55 -07003552 int offset_to_switch = insns[1] | (static_cast<int32_t>(insns[2]) << 16);
jeffhaobdb76512011-09-07 11:43:16 -07003553 const uint16_t* switch_insns = insns + offset_to_switch;
3554 int switch_count = switch_insns[1];
3555 int offset_to_targets, targ;
3556
3557 if ((*insns & 0xff) == Instruction::PACKED_SWITCH) {
3558 /* 0 = sig, 1 = count, 2/3 = first key */
3559 offset_to_targets = 4;
3560 } else {
3561 /* 0 = sig, 1 = count, 2..count * 2 = keys */
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -07003562 DCHECK((*insns & 0xff) == Instruction::SPARSE_SWITCH);
jeffhaobdb76512011-09-07 11:43:16 -07003563 offset_to_targets = 2 + 2 * switch_count;
3564 }
3565
3566 /* verify each switch target */
3567 for (targ = 0; targ < switch_count; targ++) {
3568 int offset;
3569 uint32_t abs_offset;
3570
3571 /* offsets are 32-bit, and only partly endian-swapped */
3572 offset = switch_insns[offset_to_targets + targ * 2] |
Andreas Gampe53de99c2015-08-17 13:43:55 -07003573 (static_cast<int32_t>(switch_insns[offset_to_targets + targ * 2 + 1]) << 16);
Ian Rogersd81871c2011-10-03 13:57:23 -07003574 abs_offset = work_insn_idx_ + offset;
3575 DCHECK_LT(abs_offset, code_item_->insns_size_in_code_units_);
Stephen Kyle9bc61992014-09-22 13:53:15 +01003576 if (!CheckNotMoveExceptionOrMoveResult(code_item_->insns_, abs_offset)) {
jeffhaobdb76512011-09-07 11:43:16 -07003577 return false;
Ian Rogersd81871c2011-10-03 13:57:23 -07003578 }
Ian Rogersebbdd872014-07-07 23:53:08 -07003579 if (!UpdateRegisters(abs_offset, work_line_.get(), false)) {
jeffhaobdb76512011-09-07 11:43:16 -07003580 return false;
Ian Rogersebbdd872014-07-07 23:53:08 -07003581 }
jeffhaobdb76512011-09-07 11:43:16 -07003582 }
3583 }
3584
3585 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07003586 * Handle instructions that can throw and that are sitting in a "try" block. (If they're not in a
3587 * "try" block when they throw, control transfers out of the method.)
jeffhaobdb76512011-09-07 11:43:16 -07003588 */
Mathieu Chartierde40d472015-10-15 17:47:48 -07003589 if ((opcode_flags & Instruction::kThrow) != 0 && GetInstructionFlags(work_insn_idx_).IsInTry()) {
Andreas Gampef91baf12014-07-18 15:41:00 -07003590 bool has_catch_all_handler = false;
Ian Rogers0571d352011-11-03 19:51:38 -07003591 CatchHandlerIterator iterator(*code_item_, work_insn_idx_);
jeffhaobdb76512011-09-07 11:43:16 -07003592
Andreas Gampef91baf12014-07-18 15:41:00 -07003593 // Need the linker to try and resolve the handled class to check if it's Throwable.
3594 ClassLinker* linker = Runtime::Current()->GetClassLinker();
3595
Ian Rogers0571d352011-11-03 19:51:38 -07003596 for (; iterator.HasNext(); iterator.Next()) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08003597 dex::TypeIndex handler_type_idx = iterator.GetHandlerTypeIndex();
3598 if (!handler_type_idx.IsValid()) {
Andreas Gampef91baf12014-07-18 15:41:00 -07003599 has_catch_all_handler = true;
3600 } else {
3601 // It is also a catch-all if it is java.lang.Throwable.
Mathieu Chartierbf99f772014-08-23 16:37:27 -07003602 mirror::Class* klass = linker->ResolveType(*dex_file_, handler_type_idx, dex_cache_,
3603 class_loader_);
Andreas Gampef91baf12014-07-18 15:41:00 -07003604 if (klass != nullptr) {
3605 if (klass == mirror::Throwable::GetJavaLangThrowable()) {
3606 has_catch_all_handler = true;
3607 }
3608 } else {
3609 // Clear exception.
Ian Rogers7b078e82014-09-10 14:44:24 -07003610 DCHECK(self_->IsExceptionPending());
3611 self_->ClearException();
Andreas Gampef91baf12014-07-18 15:41:00 -07003612 }
Ian Rogersd81871c2011-10-03 13:57:23 -07003613 }
jeffhaobdb76512011-09-07 11:43:16 -07003614 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07003615 * Merge registers into the "catch" block. We want to use the "savedRegs" rather than
3616 * "work_regs", because at runtime the exception will be thrown before the instruction
3617 * modifies any registers.
jeffhaobdb76512011-09-07 11:43:16 -07003618 */
Ian Rogersebbdd872014-07-07 23:53:08 -07003619 if (!UpdateRegisters(iterator.GetHandlerAddress(), saved_line_.get(), false)) {
jeffhaobdb76512011-09-07 11:43:16 -07003620 return false;
Ian Rogersd81871c2011-10-03 13:57:23 -07003621 }
jeffhaobdb76512011-09-07 11:43:16 -07003622 }
3623
3624 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07003625 * If the monitor stack depth is nonzero, there must be a "catch all" handler for this
3626 * instruction. This does apply to monitor-exit because of async exception handling.
jeffhaobdb76512011-09-07 11:43:16 -07003627 */
Andreas Gampef91baf12014-07-18 15:41:00 -07003628 if (work_line_->MonitorStackDepth() > 0 && !has_catch_all_handler) {
jeffhaobdb76512011-09-07 11:43:16 -07003629 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07003630 * The state in work_line reflects the post-execution state. If the current instruction is a
3631 * monitor-enter and the monitor stack was empty, we don't need a catch-all (if it throws,
jeffhaobdb76512011-09-07 11:43:16 -07003632 * it will do so before grabbing the lock).
3633 */
Sebastien Hertz5243e912013-05-21 10:55:07 +02003634 if (inst->Opcode() != Instruction::MONITOR_ENTER || work_line_->MonitorStackDepth() != 1) {
jeffhaod5347e02012-03-22 17:25:05 -07003635 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
Ian Rogersd81871c2011-10-03 13:57:23 -07003636 << "expected to be within a catch-all for an instruction where a monitor is held";
jeffhaobdb76512011-09-07 11:43:16 -07003637 return false;
3638 }
3639 }
3640 }
3641
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07003642 /* Handle "continue". Tag the next consecutive instruction.
3643 * Note: Keep the code handling "continue" case below the "branch" and "switch" cases,
3644 * because it changes work_line_ when performing peephole optimization
3645 * and this change should not be used in those cases.
3646 */
Ian Rogers6d376ae2013-07-23 15:12:40 -07003647 if ((opcode_flags & Instruction::kContinue) != 0) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003648 DCHECK_EQ(Instruction::At(code_item_->insns_ + work_insn_idx_), inst);
3649 uint32_t next_insn_idx = work_insn_idx_ + inst->SizeInCodeUnits();
Ian Rogers6d376ae2013-07-23 15:12:40 -07003650 if (next_insn_idx >= code_item_->insns_size_in_code_units_) {
3651 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Execution can walk off end of code area";
3652 return false;
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07003653 }
Ian Rogers6d376ae2013-07-23 15:12:40 -07003654 // The only way to get to a move-exception instruction is to get thrown there. Make sure the
3655 // next instruction isn't one.
3656 if (!CheckNotMoveException(code_item_->insns_, next_insn_idx)) {
3657 return false;
3658 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07003659 if (nullptr != fallthrough_line) {
Ian Rogers6d376ae2013-07-23 15:12:40 -07003660 // Make workline consistent with fallthrough computed from peephole optimization.
3661 work_line_->CopyFromLine(fallthrough_line.get());
3662 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07003663 if (GetInstructionFlags(next_insn_idx).IsReturn()) {
Ian Rogersb8c78592013-07-25 23:52:52 +00003664 // For returns we only care about the operand to the return, all other registers are dead.
3665 const Instruction* ret_inst = Instruction::At(code_item_->insns_ + next_insn_idx);
Andreas Gampea727e372015-08-25 09:22:37 -07003666 AdjustReturnLine(this, ret_inst, work_line_.get());
Ian Rogersb8c78592013-07-25 23:52:52 +00003667 }
Ian Rogers6d376ae2013-07-23 15:12:40 -07003668 RegisterLine* next_line = reg_table_.GetLine(next_insn_idx);
Ian Rogers7b078e82014-09-10 14:44:24 -07003669 if (next_line != nullptr) {
Ian Rogersebbdd872014-07-07 23:53:08 -07003670 // Merge registers into what we have for the next instruction, and set the "changed" flag if
3671 // needed. If the merge changes the state of the registers then the work line will be
3672 // updated.
3673 if (!UpdateRegisters(next_insn_idx, work_line_.get(), true)) {
Ian Rogers6d376ae2013-07-23 15:12:40 -07003674 return false;
3675 }
3676 } else {
3677 /*
3678 * We're not recording register data for the next instruction, so we don't know what the
3679 * prior state was. We have to assume that something has changed and re-evaluate it.
3680 */
Mathieu Chartierde40d472015-10-15 17:47:48 -07003681 GetInstructionFlags(next_insn_idx).SetChanged();
Ian Rogers6d376ae2013-07-23 15:12:40 -07003682 }
3683 }
Dragos Sbirlea2b87ddf2013-05-28 14:14:12 -07003684
jeffhaod1f0fde2011-09-08 17:25:33 -07003685 /* If we're returning from the method, make sure monitor stack is empty. */
Elliott Hughesadb8c672012-03-06 16:49:32 -08003686 if ((opcode_flags & Instruction::kReturn) != 0) {
Andreas Gampea727e372015-08-25 09:22:37 -07003687 work_line_->VerifyMonitorStackEmpty(this);
jeffhaobdb76512011-09-07 11:43:16 -07003688 }
3689
3690 /*
jeffhaod1f0fde2011-09-08 17:25:33 -07003691 * Update start_guess. Advance to the next instruction of that's
3692 * possible, otherwise use the branch target if one was found. If
jeffhaobdb76512011-09-07 11:43:16 -07003693 * neither of those exists we're in a return or throw; leave start_guess
3694 * alone and let the caller sort it out.
3695 */
Elliott Hughesadb8c672012-03-06 16:49:32 -08003696 if ((opcode_flags & Instruction::kContinue) != 0) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003697 DCHECK_EQ(Instruction::At(code_item_->insns_ + work_insn_idx_), inst);
3698 *start_guess = work_insn_idx_ + inst->SizeInCodeUnits();
Elliott Hughesadb8c672012-03-06 16:49:32 -08003699 } else if ((opcode_flags & Instruction::kBranch) != 0) {
jeffhaobdb76512011-09-07 11:43:16 -07003700 /* we're still okay if branch_target is zero */
Ian Rogersd81871c2011-10-03 13:57:23 -07003701 *start_guess = work_insn_idx_ + branch_target;
jeffhaobdb76512011-09-07 11:43:16 -07003702 }
3703
Ian Rogersd81871c2011-10-03 13:57:23 -07003704 DCHECK_LT(*start_guess, code_item_->insns_size_in_code_units_);
Mathieu Chartierde40d472015-10-15 17:47:48 -07003705 DCHECK(GetInstructionFlags(*start_guess).IsOpcode());
jeffhaobdb76512011-09-07 11:43:16 -07003706
Andreas Gampea727e372015-08-25 09:22:37 -07003707 if (have_pending_runtime_throw_failure_) {
3708 have_any_pending_runtime_throw_failure_ = true;
3709 // Reset the pending_runtime_throw flag now.
3710 have_pending_runtime_throw_failure_ = false;
3711 }
3712
jeffhaobdb76512011-09-07 11:43:16 -07003713 return true;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003714} // NOLINT(readability/fn_size)
jeffhaobdb76512011-09-07 11:43:16 -07003715
Mathieu Chartierde40d472015-10-15 17:47:48 -07003716void MethodVerifier::UninstantiableError(const char* descriptor) {
3717 Fail(VerifyError::VERIFY_ERROR_NO_CLASS) << "Could not create precise reference for "
3718 << "non-instantiable klass " << descriptor;
3719}
3720
3721inline bool MethodVerifier::IsInstantiableOrPrimitive(mirror::Class* klass) {
3722 return klass->IsInstantiable() || klass->IsPrimitive();
3723}
3724
Andreas Gampea5b09a62016-11-17 15:21:22 -08003725const RegType& MethodVerifier::ResolveClassAndCheckAccess(dex::TypeIndex class_idx) {
Vladimir Marko8d6768d2017-03-14 10:13:21 +00003726 mirror::Class* klass = can_load_classes_
3727 ? Runtime::Current()->GetClassLinker()->ResolveType(
3728 *dex_file_, class_idx, dex_cache_, class_loader_)
3729 : ClassLinker::LookupResolvedType(class_idx, dex_cache_.Get(), class_loader_.Get()).Ptr();
3730 if (can_load_classes_ && klass == nullptr) {
3731 DCHECK(self_->IsExceptionPending());
3732 self_->ClearException();
3733 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07003734 const RegType* result = nullptr;
Vladimir Marko8d6768d2017-03-14 10:13:21 +00003735 if (klass != nullptr && !klass->IsErroneous()) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07003736 bool precise = klass->CannotBeAssignedFromOtherTypes();
3737 if (precise && !IsInstantiableOrPrimitive(klass)) {
3738 const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
3739 UninstantiableError(descriptor);
3740 precise = false;
3741 }
3742 result = reg_types_.FindClass(klass, precise);
3743 if (result == nullptr) {
3744 const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
3745 result = reg_types_.InsertClass(descriptor, klass, precise);
3746 }
3747 } else {
3748 const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
3749 result = &reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogersad0b3a32012-04-16 14:50:24 -07003750 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07003751 DCHECK(result != nullptr);
3752 if (result->IsConflict()) {
3753 const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
3754 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "accessing broken descriptor '" << descriptor
3755 << "' in " << GetDeclaringClass();
3756 return *result;
3757 }
David Brazdilca3c8c32016-09-06 14:04:48 +01003758
3759 // Record result of class resolution attempt.
3760 VerifierDeps::MaybeRecordClassResolution(*dex_file_, class_idx, klass);
3761
Ian Rogersad0b3a32012-04-16 14:50:24 -07003762 // Check if access is allowed. Unresolved types use xxxWithAccessCheck to
Jeff Haob24b4a72013-07-31 13:47:31 -07003763 // check at runtime if access is allowed and so pass here. If result is
3764 // primitive, skip the access check.
Mathieu Chartierde40d472015-10-15 17:47:48 -07003765 if (result->IsNonZeroReferenceTypes() && !result->IsUnresolvedTypes()) {
3766 const RegType& referrer = GetDeclaringClass();
3767 if (!referrer.IsUnresolvedTypes() && !referrer.CanAccess(*result)) {
3768 Fail(VERIFY_ERROR_ACCESS_CLASS) << "illegal class access: '"
3769 << referrer << "' -> '" << result << "'";
3770 }
Ian Rogers28ad40d2011-10-27 15:19:26 -07003771 }
Mathieu Chartierde40d472015-10-15 17:47:48 -07003772 return *result;
Ian Rogersd81871c2011-10-03 13:57:23 -07003773}
3774
Ian Rogersd8f69b02014-09-10 21:43:52 +00003775const RegType& MethodVerifier::GetCaughtExceptionType() {
Ian Rogers7b078e82014-09-10 14:44:24 -07003776 const RegType* common_super = nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07003777 if (code_item_->tries_size_ != 0) {
Ian Rogers13735952014-10-08 12:43:28 -07003778 const uint8_t* handlers_ptr = DexFile::GetCatchHandlerData(*code_item_, 0);
Ian Rogersd81871c2011-10-03 13:57:23 -07003779 uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
3780 for (uint32_t i = 0; i < handlers_size; i++) {
Ian Rogers0571d352011-11-03 19:51:38 -07003781 CatchHandlerIterator iterator(handlers_ptr);
3782 for (; iterator.HasNext(); iterator.Next()) {
3783 if (iterator.GetHandlerAddress() == (uint32_t) work_insn_idx_) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08003784 if (!iterator.GetHandlerTypeIndex().IsValid()) {
Ian Rogersb4903572012-10-11 11:52:56 -07003785 common_super = &reg_types_.JavaLangThrowable(false);
Ian Rogersd81871c2011-10-03 13:57:23 -07003786 } else {
Ian Rogersd8f69b02014-09-10 21:43:52 +00003787 const RegType& exception = ResolveClassAndCheckAccess(iterator.GetHandlerTypeIndex());
David Brazdilca3c8c32016-09-06 14:04:48 +01003788 if (!reg_types_.JavaLangThrowable(false).IsAssignableFrom(exception, this)) {
David Brazdil68b5c0b2016-01-19 14:25:29 +00003789 DCHECK(!exception.IsUninitializedTypes()); // Comes from dex, shouldn't be uninit.
Jeff Haoc26a56c2013-11-04 12:00:47 -08003790 if (exception.IsUnresolvedTypes()) {
3791 // We don't know enough about the type. Fail here and let runtime handle it.
3792 Fail(VERIFY_ERROR_NO_CLASS) << "unresolved exception class " << exception;
3793 return exception;
3794 } else {
3795 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "unexpected non-exception class " << exception;
3796 return reg_types_.Conflict();
3797 }
Jeff Haob878f212014-04-24 16:25:36 -07003798 } else if (common_super == nullptr) {
3799 common_super = &exception;
Ian Rogers28ad40d2011-10-27 15:19:26 -07003800 } else if (common_super->Equals(exception)) {
Ian Rogersc4762272012-02-01 15:55:55 -08003801 // odd case, but nothing to do
Ian Rogersd81871c2011-10-03 13:57:23 -07003802 } else {
David Brazdilca3c8c32016-09-06 14:04:48 +01003803 common_super = &common_super->Merge(exception, &reg_types_, this);
Andreas Gampe7c038102014-10-27 20:08:46 -07003804 if (FailOrAbort(this,
David Brazdilca3c8c32016-09-06 14:04:48 +01003805 reg_types_.JavaLangThrowable(false).IsAssignableFrom(
3806 *common_super, this),
Andreas Gampe7c038102014-10-27 20:08:46 -07003807 "java.lang.Throwable is not assignable-from common_super at ",
3808 work_insn_idx_)) {
3809 break;
3810 }
Ian Rogersd81871c2011-10-03 13:57:23 -07003811 }
3812 }
3813 }
3814 }
Ian Rogers0571d352011-11-03 19:51:38 -07003815 handlers_ptr = iterator.EndDataPointer();
Ian Rogersd81871c2011-10-03 13:57:23 -07003816 }
3817 }
Ian Rogers7b078e82014-09-10 14:44:24 -07003818 if (common_super == nullptr) {
Ian Rogersd81871c2011-10-03 13:57:23 -07003819 /* no catch blocks, or no catches with classes we can find */
jeffhaod5347e02012-03-22 17:25:05 -07003820 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "unable to find exception handler";
Ian Rogersad0b3a32012-04-16 14:50:24 -07003821 return reg_types_.Conflict();
Ian Rogersd81871c2011-10-03 13:57:23 -07003822 }
Ian Rogers28ad40d2011-10-27 15:19:26 -07003823 return *common_super;
Ian Rogersd81871c2011-10-03 13:57:23 -07003824}
3825
David Brazdilca3c8c32016-09-06 14:04:48 +01003826inline static MethodResolutionKind GetMethodResolutionKind(
3827 MethodType method_type, bool is_interface) {
3828 if (method_type == METHOD_DIRECT || method_type == METHOD_STATIC) {
3829 return kDirectMethodResolution;
3830 } else if (method_type == METHOD_INTERFACE) {
3831 return kInterfaceMethodResolution;
3832 } else if (method_type == METHOD_SUPER && is_interface) {
3833 return kInterfaceMethodResolution;
3834 } else {
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003835 DCHECK(method_type == METHOD_VIRTUAL || method_type == METHOD_SUPER
3836 || method_type == METHOD_POLYMORPHIC);
David Brazdilca3c8c32016-09-06 14:04:48 +01003837 return kVirtualMethodResolution;
3838 }
3839}
3840
Mathieu Chartiere401d142015-04-22 13:56:20 -07003841ArtMethod* MethodVerifier::ResolveMethodAndCheckAccess(
Alex Light7268d472016-01-20 15:50:01 -08003842 uint32_t dex_method_idx, MethodType method_type) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07003843 const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx);
Ian Rogersd8f69b02014-09-10 21:43:52 +00003844 const RegType& klass_type = ResolveClassAndCheckAccess(method_id.class_idx_);
Ian Rogersad0b3a32012-04-16 14:50:24 -07003845 if (klass_type.IsConflict()) {
3846 std::string append(" in attempt to access method ");
3847 append += dex_file_->GetMethodName(method_id);
3848 AppendToLastFailMessage(append);
Ian Rogers7b078e82014-09-10 14:44:24 -07003849 return nullptr;
Ian Rogers90040192011-12-16 08:54:29 -08003850 }
jeffhao8cd6dda2012-02-22 10:15:34 -08003851 if (klass_type.IsUnresolvedTypes()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07003852 return nullptr; // Can't resolve Class so no more to do here
Ian Rogers90040192011-12-16 08:54:29 -08003853 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003854 mirror::Class* klass = klass_type.GetClass();
Ian Rogersd8f69b02014-09-10 21:43:52 +00003855 const RegType& referrer = GetDeclaringClass();
Mathieu Chartiere401d142015-04-22 13:56:20 -07003856 auto* cl = Runtime::Current()->GetClassLinker();
3857 auto pointer_size = cl->GetImagePointerSize();
David Brazdilca3c8c32016-09-06 14:04:48 +01003858 MethodResolutionKind res_kind = GetMethodResolutionKind(method_type, klass->IsInterface());
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003859
Mathieu Chartiere401d142015-04-22 13:56:20 -07003860 ArtMethod* res_method = dex_cache_->GetResolvedMethod(dex_method_idx, pointer_size);
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003861 bool stash_method = false;
Ian Rogers7b078e82014-09-10 14:44:24 -07003862 if (res_method == nullptr) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07003863 const char* name = dex_file_->GetMethodName(method_id);
Ian Rogersd91d6d62013-09-25 20:26:14 -07003864 const Signature signature = dex_file_->GetMethodSignature(method_id);
jeffhao8cd6dda2012-02-22 10:15:34 -08003865
David Brazdilca3c8c32016-09-06 14:04:48 +01003866 if (res_kind == kDirectMethodResolution) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003867 res_method = klass->FindDirectMethod(name, signature, pointer_size);
David Brazdilca3c8c32016-09-06 14:04:48 +01003868 } else if (res_kind == kVirtualMethodResolution) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003869 res_method = klass->FindVirtualMethod(name, signature, pointer_size);
David Brazdilca3c8c32016-09-06 14:04:48 +01003870 } else {
3871 DCHECK_EQ(res_kind, kInterfaceMethodResolution);
3872 res_method = klass->FindInterfaceMethod(name, signature, pointer_size);
Ian Rogersd81871c2011-10-03 13:57:23 -07003873 }
David Brazdilca3c8c32016-09-06 14:04:48 +01003874
Ian Rogers7b078e82014-09-10 14:44:24 -07003875 if (res_method != nullptr) {
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003876 stash_method = true;
Ian Rogersd81871c2011-10-03 13:57:23 -07003877 } else {
jeffhao8cd6dda2012-02-22 10:15:34 -08003878 // If a virtual or interface method wasn't found with the expected type, look in
3879 // the direct methods. This can happen when the wrong invoke type is used or when
3880 // a class has changed, and will be flagged as an error in later checks.
David Brazdilca3c8c32016-09-06 14:04:48 +01003881 // Note that in this case, we do not put the resolved method in the Dex cache
3882 // because it was not discovered using the expected type of method resolution.
3883 if (res_kind != kDirectMethodResolution) {
3884 // Record result of the initial resolution attempt.
3885 VerifierDeps::MaybeRecordMethodResolution(*dex_file_, dex_method_idx, res_kind, nullptr);
3886 // Change resolution type to 'direct' and try to resolve again.
3887 res_kind = kDirectMethodResolution;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003888 res_method = klass->FindDirectMethod(name, signature, pointer_size);
jeffhao8cd6dda2012-02-22 10:15:34 -08003889 }
Ian Rogersd81871c2011-10-03 13:57:23 -07003890 }
3891 }
David Brazdilca3c8c32016-09-06 14:04:48 +01003892
3893 // Record result of method resolution attempt.
3894 VerifierDeps::MaybeRecordMethodResolution(*dex_file_, dex_method_idx, res_kind, res_method);
3895
3896 if (res_method == nullptr) {
3897 Fail(VERIFY_ERROR_NO_METHOD) << "couldn't find method "
David Sehr709b0702016-10-13 09:12:37 -07003898 << klass->PrettyDescriptor() << "."
David Brazdilca3c8c32016-09-06 14:04:48 +01003899 << dex_file_->GetMethodName(method_id) << " "
3900 << dex_file_->GetMethodSignature(method_id);
3901 return nullptr;
3902 }
3903
Ian Rogersd81871c2011-10-03 13:57:23 -07003904 // Make sure calls to constructors are "direct". There are additional restrictions but we don't
3905 // enforce them here.
3906 if (res_method->IsConstructor() && method_type != METHOD_DIRECT) {
jeffhaod5347e02012-03-22 17:25:05 -07003907 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "rejecting non-direct call to constructor "
David Sehr709b0702016-10-13 09:12:37 -07003908 << res_method->PrettyMethod();
Ian Rogers7b078e82014-09-10 14:44:24 -07003909 return nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07003910 }
jeffhao8cd6dda2012-02-22 10:15:34 -08003911 // Disallow any calls to class initializers.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003912 if (res_method->IsClassInitializer()) {
jeffhaod5347e02012-03-22 17:25:05 -07003913 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "rejecting call to class initializer "
David Sehr709b0702016-10-13 09:12:37 -07003914 << res_method->PrettyMethod();
Ian Rogers7b078e82014-09-10 14:44:24 -07003915 return nullptr;
jeffhao8cd6dda2012-02-22 10:15:34 -08003916 }
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003917
3918 // Check that interface methods are static or match interface classes.
3919 // We only allow statics if we don't have default methods enabled.
3920 //
3921 // Note: this check must be after the initializer check, as those are required to fail a class,
3922 // while this check implies an IncompatibleClassChangeError.
3923 if (klass->IsInterface()) {
Alex Lightb55f1ac2016-04-12 15:50:55 -07003924 // methods called on interfaces should be invoke-interface, invoke-super, invoke-direct (if
3925 // dex file version is 37 or greater), or invoke-static.
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003926 if (method_type != METHOD_INTERFACE &&
Neil Fuller9724c632016-01-07 15:42:47 +00003927 method_type != METHOD_STATIC &&
Alex Lightb55f1ac2016-04-12 15:50:55 -07003928 ((dex_file_->GetVersion() < DexFile::kDefaultMethodsVersion) ||
3929 method_type != METHOD_DIRECT) &&
Neil Fuller9724c632016-01-07 15:42:47 +00003930 method_type != METHOD_SUPER) {
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003931 Fail(VERIFY_ERROR_CLASS_CHANGE)
David Sehr709b0702016-10-13 09:12:37 -07003932 << "non-interface method " << dex_file_->PrettyMethod(dex_method_idx)
3933 << " is in an interface class " << klass->PrettyClass();
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003934 return nullptr;
3935 }
3936 } else {
3937 if (method_type == METHOD_INTERFACE) {
3938 Fail(VERIFY_ERROR_CLASS_CHANGE)
David Sehr709b0702016-10-13 09:12:37 -07003939 << "interface method " << dex_file_->PrettyMethod(dex_method_idx)
3940 << " is in a non-interface class " << klass->PrettyClass();
Andreas Gampe42ef8ab2015-12-03 17:27:32 -08003941 return nullptr;
3942 }
3943 }
3944
3945 // Only stash after the above passed. Otherwise the method wasn't guaranteed to be correct.
3946 if (stash_method) {
3947 dex_cache_->SetResolvedMethod(dex_method_idx, res_method, pointer_size);
3948 }
3949
jeffhao8cd6dda2012-02-22 10:15:34 -08003950 // Check if access is allowed.
Ian Rogersad0b3a32012-04-16 14:50:24 -07003951 if (!referrer.CanAccessMember(res_method->GetDeclaringClass(), res_method->GetAccessFlags())) {
David Sehr709b0702016-10-13 09:12:37 -07003952 Fail(VERIFY_ERROR_ACCESS_METHOD) << "illegal method access (call "
3953 << res_method->PrettyMethod()
Ian Rogersad0b3a32012-04-16 14:50:24 -07003954 << " from " << referrer << ")";
jeffhaob57e9522012-04-26 18:08:21 -07003955 return res_method;
jeffhao8cd6dda2012-02-22 10:15:34 -08003956 }
jeffhaode0d9c92012-02-27 13:58:13 -08003957 // Check that invoke-virtual and invoke-super are not used on private methods of the same class.
Alex Light7268d472016-01-20 15:50:01 -08003958 if (res_method->IsPrivate() && (method_type == METHOD_VIRTUAL || method_type == METHOD_SUPER)) {
jeffhaod5347e02012-03-22 17:25:05 -07003959 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invoke-super/virtual can't be used on private method "
David Sehr709b0702016-10-13 09:12:37 -07003960 << res_method->PrettyMethod();
Ian Rogers7b078e82014-09-10 14:44:24 -07003961 return nullptr;
jeffhaode0d9c92012-02-27 13:58:13 -08003962 }
Ian Rogersd81871c2011-10-03 13:57:23 -07003963 // See if the method type implied by the invoke instruction matches the access flags for the
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003964 // target method. The flags for METHOD_POLYMORPHIC are based on there being precisely two
3965 // signature polymorphic methods supported by the run-time which are native methods with variable
3966 // arguments.
Brian Carlstrombe6fa5e2014-12-09 20:15:42 -08003967 if ((method_type == METHOD_DIRECT && (!res_method->IsDirect() || res_method->IsStatic())) ||
Ian Rogersd81871c2011-10-03 13:57:23 -07003968 (method_type == METHOD_STATIC && !res_method->IsStatic()) ||
Alex Light7268d472016-01-20 15:50:01 -08003969 ((method_type == METHOD_SUPER ||
3970 method_type == METHOD_VIRTUAL ||
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003971 method_type == METHOD_INTERFACE) && res_method->IsDirect()) ||
3972 ((method_type == METHOD_POLYMORPHIC) &&
3973 (!res_method->IsNative() || !res_method->IsVarargs()))) {
Ian Rogers2fc14272012-08-30 10:56:57 -07003974 Fail(VERIFY_ERROR_CLASS_CHANGE) << "invoke type (" << method_type << ") does not match method "
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003975 "type of " << res_method->PrettyMethod();
Ian Rogers7b078e82014-09-10 14:44:24 -07003976 return nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07003977 }
jeffhao8cd6dda2012-02-22 10:15:34 -08003978 return res_method;
3979}
3980
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003981template <class T>
Mathieu Chartiere401d142015-04-22 13:56:20 -07003982ArtMethod* MethodVerifier::VerifyInvocationArgsFromIterator(
3983 T* it, const Instruction* inst, MethodType method_type, bool is_range, ArtMethod* res_method) {
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003984 // We use vAA as our expected arg count, rather than res_method->insSize, because we need to
3985 // match the call to the signature. Also, we might be calling through an abstract method
3986 // definition (which doesn't have register count values).
Orion Hodsoncfa325e2016-10-13 10:25:54 +01003987 const size_t expected_args = inst->VRegA();
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003988 /* caught by static verifier */
3989 DCHECK(is_range || expected_args <= 5);
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003990
Orion Hodson7f7a0742016-12-08 14:15:25 +00003991 // TODO(oth): Enable this path for invoke-polymorphic when b/33099829 is resolved.
3992 if (method_type != METHOD_POLYMORPHIC) {
3993 if (expected_args > code_item_->outs_size_) {
3994 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid argument count (" << expected_args
3995 << ") exceeds outsSize (" << code_item_->outs_size_ << ")";
3996 return nullptr;
3997 }
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003998 }
Andreas Gampe95c0bf82014-06-16 14:06:52 -07003999
4000 /*
4001 * Check the "this" argument, which must be an instance of the class that declared the method.
4002 * For an interface class, we don't do the full interface merge (see JoinClass), so we can't do a
4003 * rigorous check here (which is okay since we have to do it at runtime).
4004 */
4005 if (method_type != METHOD_STATIC) {
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004006 const RegType& actual_arg_type = work_line_->GetInvocationThis(this, inst);
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004007 if (actual_arg_type.IsConflict()) { // GetInvocationThis failed.
4008 CHECK(have_pending_hard_failure_);
4009 return nullptr;
4010 }
David Brazdil68b5c0b2016-01-19 14:25:29 +00004011 bool is_init = false;
4012 if (actual_arg_type.IsUninitializedTypes()) {
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004013 if (res_method) {
4014 if (!res_method->IsConstructor()) {
4015 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "'this' arg must be initialized";
4016 return nullptr;
4017 }
4018 } else {
4019 // Check whether the name of the called method is "<init>"
4020 const uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
Jeff Hao0d087272014-08-04 14:47:17 -07004021 if (strcmp(dex_file_->GetMethodName(dex_file_->GetMethodId(method_idx)), "<init>") != 0) {
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004022 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "'this' arg must be initialized";
4023 return nullptr;
4024 }
4025 }
David Brazdil68b5c0b2016-01-19 14:25:29 +00004026 is_init = true;
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004027 }
David Brazdil68b5c0b2016-01-19 14:25:29 +00004028 const RegType& adjusted_type = is_init
4029 ? GetRegTypeCache()->FromUninitialized(actual_arg_type)
4030 : actual_arg_type;
4031 if (method_type != METHOD_INTERFACE && !adjusted_type.IsZero()) {
Ian Rogersd8f69b02014-09-10 21:43:52 +00004032 const RegType* res_method_class;
Andreas Gamped9e23012015-06-04 22:19:58 -07004033 // Miranda methods have the declaring interface as their declaring class, not the abstract
4034 // class. It would be wrong to use this for the type check (interface type checks are
4035 // postponed to runtime).
4036 if (res_method != nullptr && !res_method->IsMiranda()) {
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004037 mirror::Class* klass = res_method->GetDeclaringClass();
Ian Rogers1ff3c982014-08-12 02:30:58 -07004038 std::string temp;
Andreas Gampef23f33d2015-06-23 14:18:17 -07004039 res_method_class = &FromClass(klass->GetDescriptor(&temp), klass,
4040 klass->CannotBeAssignedFromOtherTypes());
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004041 } else {
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004042 const uint32_t method_idx = inst->VRegB();
Andreas Gampea5b09a62016-11-17 15:21:22 -08004043 const dex::TypeIndex class_idx = dex_file_->GetMethodId(method_idx).class_idx_;
Mathieu Chartierde40d472015-10-15 17:47:48 -07004044 res_method_class = &reg_types_.FromDescriptor(
4045 GetClassLoader(),
4046 dex_file_->StringByTypeIdx(class_idx),
4047 false);
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004048 }
David Brazdilca3c8c32016-09-06 14:04:48 +01004049 if (!res_method_class->IsAssignableFrom(adjusted_type, this)) {
David Brazdil68b5c0b2016-01-19 14:25:29 +00004050 Fail(adjusted_type.IsUnresolvedTypes()
4051 ? VERIFY_ERROR_NO_CLASS
4052 : VERIFY_ERROR_BAD_CLASS_SOFT)
4053 << "'this' argument '" << actual_arg_type << "' not instance of '"
4054 << *res_method_class << "'";
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004055 // Continue on soft failures. We need to find possible hard failures to avoid problems in
4056 // the compiler.
4057 if (have_pending_hard_failure_) {
4058 return nullptr;
4059 }
4060 }
4061 }
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004062 }
4063
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004064 uint32_t arg[5];
4065 if (!is_range) {
4066 inst->GetVarArgs(arg);
4067 }
4068 uint32_t sig_registers = (method_type == METHOD_STATIC) ? 0 : 1;
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004069 for ( ; it->HasNext(); it->Next()) {
4070 if (sig_registers >= expected_args) {
4071 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation, expected " << inst->VRegA() <<
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004072 " argument registers, method signature has " << sig_registers + 1 << " or more";
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004073 return nullptr;
4074 }
4075
4076 const char* param_descriptor = it->GetDescriptor();
4077
4078 if (param_descriptor == nullptr) {
4079 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation because of missing signature "
4080 "component";
4081 return nullptr;
4082 }
4083
Ian Rogersd8f69b02014-09-10 21:43:52 +00004084 const RegType& reg_type = reg_types_.FromDescriptor(GetClassLoader(), param_descriptor, false);
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004085 uint32_t get_reg = is_range ? inst->VRegC() + static_cast<uint32_t>(sig_registers) :
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004086 arg[sig_registers];
4087 if (reg_type.IsIntegralTypes()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004088 const RegType& src_type = work_line_->GetRegisterType(this, get_reg);
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004089 if (!src_type.IsIntegralTypes()) {
4090 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "register v" << get_reg << " has type " << src_type
4091 << " but expected " << reg_type;
Andreas Gampeb588f4c2015-05-26 13:35:39 -07004092 return nullptr;
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004093 }
Andreas Gampeda9badb2015-06-05 20:22:12 -07004094 } else {
4095 if (!work_line_->VerifyRegisterType(this, get_reg, reg_type)) {
4096 // Continue on soft failures. We need to find possible hard failures to avoid problems in
4097 // the compiler.
4098 if (have_pending_hard_failure_) {
4099 return nullptr;
4100 }
4101 } else if (reg_type.IsLongOrDoubleTypes()) {
4102 // Check that registers are consecutive (for non-range invokes). Invokes are the only
4103 // instructions not specifying register pairs by the first component, but require them
4104 // nonetheless. Only check when there's an actual register in the parameters. If there's
4105 // none, this will fail below.
4106 if (!is_range && sig_registers + 1 < expected_args) {
4107 uint32_t second_reg = arg[sig_registers + 1];
4108 if (second_reg != get_reg + 1) {
4109 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation, long or double parameter "
4110 "at index " << sig_registers << " is not a pair: " << get_reg << " + "
4111 << second_reg << ".";
4112 return nullptr;
4113 }
4114 }
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004115 }
4116 }
4117 sig_registers += reg_type.IsLongOrDoubleTypes() ? 2 : 1;
4118 }
4119 if (expected_args != sig_registers) {
4120 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation, expected " << expected_args <<
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004121 " argument registers, method signature has " << sig_registers;
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004122 return nullptr;
4123 }
4124 return res_method;
4125}
4126
4127void MethodVerifier::VerifyInvocationArgsUnresolvedMethod(const Instruction* inst,
4128 MethodType method_type,
4129 bool is_range) {
4130 // As the method may not have been resolved, make this static check against what we expect.
4131 // The main reason for this code block is to fail hard when we find an illegal use, e.g.,
4132 // wrong number of arguments or wrong primitive types, even if the method could not be resolved.
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004133 const uint32_t method_idx = inst->VRegB();
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004134 DexFileParameterIterator it(*dex_file_,
4135 dex_file_->GetProtoId(dex_file_->GetMethodId(method_idx).proto_idx_));
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004136 VerifyInvocationArgsFromIterator(&it, inst, method_type, is_range, nullptr);
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004137}
4138
Orion Hodsonc069a302017-01-18 09:23:12 +00004139bool MethodVerifier::CheckCallSite(uint32_t call_site_idx) {
Orion Hodson3a842f52017-04-21 15:24:10 +01004140 if (call_site_idx >= dex_file_->NumCallSiteIds()) {
4141 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Bad call site id #" << call_site_idx
4142 << " >= " << dex_file_->NumCallSiteIds();
4143 return false;
4144 }
4145
Orion Hodsonc069a302017-01-18 09:23:12 +00004146 CallSiteArrayValueIterator it(*dex_file_, dex_file_->GetCallSiteId(call_site_idx));
4147 // Check essential arguments are provided. The dex file verifier has verified indicies of the
4148 // main values (method handle, name, method_type).
4149 if (it.Size() < 3) {
4150 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4151 << " has too few arguments: "
4152 << it.Size() << "< 3";
4153 return false;
4154 }
4155
Orion Hodson3a842f52017-04-21 15:24:10 +01004156 // Get and check the first argument: the method handle (index range
4157 // checked by the dex file verifier).
Orion Hodsonc069a302017-01-18 09:23:12 +00004158 uint32_t method_handle_idx = static_cast<uint32_t>(it.GetJavaValue().i);
4159 it.Next();
Orion Hodson3a842f52017-04-21 15:24:10 +01004160
Orion Hodsonc069a302017-01-18 09:23:12 +00004161 const DexFile::MethodHandleItem& mh = dex_file_->GetMethodHandle(method_handle_idx);
4162 if (mh.method_handle_type_ != static_cast<uint16_t>(DexFile::MethodHandleType::kInvokeStatic)) {
4163 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4164 << " argument 0 method handle type is not InvokeStatic";
4165 return false;
4166 }
4167
4168 // Skip the second argument, the name to resolve, as checked by the
4169 // dex file verifier.
4170 it.Next();
4171
4172 // Skip the third argument, the method type expected, as checked by
4173 // the dex file verifier.
4174 it.Next();
4175
4176 // Check the bootstrap method handle and remaining arguments.
4177 const DexFile::MethodId& method_id = dex_file_->GetMethodId(mh.field_or_method_idx_);
4178 uint32_t length;
4179 const char* shorty = dex_file_->GetMethodShorty(method_id, &length);
4180
4181 if (it.Size() < length - 1) {
4182 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4183 << " too few arguments for bootstrap method: "
4184 << it.Size() << " < " << (length - 1);
4185 return false;
4186 }
4187
4188 // Check the return type and first 3 arguments are references
4189 // (CallSite, Lookup, String, MethodType). If they are not of the
4190 // expected types (or subtypes), it will trigger a
4191 // WrongMethodTypeException during execution.
4192 if (shorty[0] != 'L') {
4193 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4194 << " bootstrap return type is not a reference";
4195 return false;
4196 }
4197
4198 for (uint32_t i = 1; i < 4; ++i) {
4199 if (shorty[i] != 'L') {
4200 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4201 << " bootstrap method argument " << (i - 1)
4202 << " is not a reference";
4203 return false;
4204 }
4205 }
4206
4207 // Check the optional arguments.
4208 for (uint32_t i = 4; i < length; ++i, it.Next()) {
4209 bool match = false;
4210 switch (it.GetValueType()) {
4211 case EncodedArrayValueIterator::ValueType::kBoolean:
4212 case EncodedArrayValueIterator::ValueType::kByte:
4213 case EncodedArrayValueIterator::ValueType::kShort:
4214 case EncodedArrayValueIterator::ValueType::kChar:
4215 case EncodedArrayValueIterator::ValueType::kInt:
4216 // These all fit within one register and encoders do not seem
4217 // too exacting on the encoding type they use (ie using
4218 // integer for all of these).
4219 match = (strchr("ZBCSI", shorty[i]) != nullptr);
4220 break;
4221 case EncodedArrayValueIterator::ValueType::kLong:
4222 match = ('J' == shorty[i]);
4223 break;
4224 case EncodedArrayValueIterator::ValueType::kFloat:
4225 match = ('F' == shorty[i]);
4226 break;
4227 case EncodedArrayValueIterator::ValueType::kDouble:
4228 match = ('D' == shorty[i]);
4229 break;
4230 case EncodedArrayValueIterator::ValueType::kMethodType:
4231 case EncodedArrayValueIterator::ValueType::kMethodHandle:
4232 case EncodedArrayValueIterator::ValueType::kString:
4233 case EncodedArrayValueIterator::ValueType::kType:
4234 case EncodedArrayValueIterator::ValueType::kNull:
4235 match = ('L' == shorty[i]);
4236 break;
4237 case EncodedArrayValueIterator::ValueType::kField:
4238 case EncodedArrayValueIterator::ValueType::kMethod:
4239 case EncodedArrayValueIterator::ValueType::kEnum:
4240 case EncodedArrayValueIterator::ValueType::kArray:
4241 case EncodedArrayValueIterator::ValueType::kAnnotation:
4242 // Unreachable based on current EncodedArrayValueIterator::Next().
4243 UNREACHABLE();
4244 }
4245
4246 if (!match) {
4247 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
4248 << " bootstrap method argument " << (i - 1)
4249 << " expected " << shorty[i]
4250 << " got value type: " << it.GetValueType();
4251 return false;
4252 }
4253 }
4254 return true;
4255}
4256
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004257class MethodParamListDescriptorIterator {
4258 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -07004259 explicit MethodParamListDescriptorIterator(ArtMethod* res_method) :
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004260 res_method_(res_method), pos_(0), params_(res_method->GetParameterTypeList()),
4261 params_size_(params_ == nullptr ? 0 : params_->Size()) {
4262 }
4263
4264 bool HasNext() {
4265 return pos_ < params_size_;
4266 }
4267
4268 void Next() {
4269 ++pos_;
4270 }
4271
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004272 const char* GetDescriptor() REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004273 return res_method_->GetTypeDescriptorFromTypeIdx(params_->GetTypeItem(pos_).type_idx_);
4274 }
4275
4276 private:
Mathieu Chartiere401d142015-04-22 13:56:20 -07004277 ArtMethod* res_method_;
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004278 size_t pos_;
4279 const DexFile::TypeList* params_;
4280 const size_t params_size_;
4281};
4282
Mathieu Chartiere401d142015-04-22 13:56:20 -07004283ArtMethod* MethodVerifier::VerifyInvocationArgs(
Alex Light7268d472016-01-20 15:50:01 -08004284 const Instruction* inst, MethodType method_type, bool is_range) {
jeffhao8cd6dda2012-02-22 10:15:34 -08004285 // Resolve the method. This could be an abstract or concrete method depending on what sort of call
4286 // we're making.
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004287 const uint32_t method_idx = inst->VRegB();
Alex Light7268d472016-01-20 15:50:01 -08004288 ArtMethod* res_method = ResolveMethodAndCheckAccess(method_idx, method_type);
Ian Rogers7b078e82014-09-10 14:44:24 -07004289 if (res_method == nullptr) { // error or class is unresolved
Andreas Gampe95c0bf82014-06-16 14:06:52 -07004290 // Check what we can statically.
4291 if (!have_pending_hard_failure_) {
4292 VerifyInvocationArgsUnresolvedMethod(inst, method_type, is_range);
4293 }
4294 return nullptr;
jeffhao8cd6dda2012-02-22 10:15:34 -08004295 }
4296
Ian Rogersd81871c2011-10-03 13:57:23 -07004297 // If we're using invoke-super(method), make sure that the executing method's class' superclass
Alex Light705ad492015-09-21 11:36:30 -07004298 // has a vtable entry for the target method. Or the target is on a interface.
Alex Light7268d472016-01-20 15:50:01 -08004299 if (method_type == METHOD_SUPER) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08004300 dex::TypeIndex class_idx = dex_file_->GetMethodId(method_idx).class_idx_;
David Brazdilca3c8c32016-09-06 14:04:48 +01004301 const RegType& reference_type = reg_types_.FromDescriptor(
4302 GetClassLoader(),
4303 dex_file_->StringByTypeIdx(class_idx),
4304 false);
4305 if (reference_type.IsUnresolvedTypes()) {
Alex Lightfedd91d2016-01-07 14:49:16 -08004306 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "Unable to find referenced class from invoke-super";
4307 return nullptr;
4308 }
David Brazdilca3c8c32016-09-06 14:04:48 +01004309 if (reference_type.GetClass()->IsInterface()) {
Alex Lightfedd91d2016-01-07 14:49:16 -08004310 // TODO Can we verify anything else.
David Brazdil15fc7292016-09-02 14:13:18 +01004311 if (class_idx == class_def_.class_idx_) {
Alex Lightfedd91d2016-01-07 14:49:16 -08004312 Fail(VERIFY_ERROR_CLASS_CHANGE) << "Cannot invoke-super on self as interface";
Alex Light55ea94d2016-03-15 09:50:26 -07004313 return nullptr;
Alex Lightfedd91d2016-01-07 14:49:16 -08004314 }
4315 // TODO Revisit whether we want to allow invoke-super on direct interfaces only like the JLS
4316 // does.
Alex Light55ea94d2016-03-15 09:50:26 -07004317 if (!GetDeclaringClass().HasClass()) {
4318 Fail(VERIFY_ERROR_NO_CLASS) << "Unable to resolve the full class of 'this' used in an"
4319 << "interface invoke-super";
4320 return nullptr;
David Brazdilca3c8c32016-09-06 14:04:48 +01004321 } else if (!reference_type.IsStrictlyAssignableFrom(GetDeclaringClass(), this)) {
Alex Lightfedd91d2016-01-07 14:49:16 -08004322 Fail(VERIFY_ERROR_CLASS_CHANGE)
David Sehr709b0702016-10-13 09:12:37 -07004323 << "invoke-super in " << mirror::Class::PrettyClass(GetDeclaringClass().GetClass())
4324 << " in method "
4325 << dex_file_->PrettyMethod(dex_method_idx_) << " to method "
4326 << dex_file_->PrettyMethod(method_idx) << " references "
4327 << "non-super-interface type " << mirror::Class::PrettyClass(reference_type.GetClass());
Alex Lightfedd91d2016-01-07 14:49:16 -08004328 return nullptr;
Alex Light705ad492015-09-21 11:36:30 -07004329 }
4330 } else {
4331 const RegType& super = GetDeclaringClass().GetSuperClass(&reg_types_);
4332 if (super.IsUnresolvedTypes()) {
4333 Fail(VERIFY_ERROR_NO_METHOD) << "unknown super class in invoke-super from "
David Sehr709b0702016-10-13 09:12:37 -07004334 << dex_file_->PrettyMethod(dex_method_idx_)
4335 << " to super " << res_method->PrettyMethod();
Alex Light705ad492015-09-21 11:36:30 -07004336 return nullptr;
4337 }
David Brazdilca3c8c32016-09-06 14:04:48 +01004338 if (!reference_type.IsStrictlyAssignableFrom(GetDeclaringClass(), this) ||
Aart Bikf663e342016-04-04 17:28:59 -07004339 (res_method->GetMethodIndex() >= super.GetClass()->GetVTableLength())) {
Alex Light705ad492015-09-21 11:36:30 -07004340 Fail(VERIFY_ERROR_NO_METHOD) << "invalid invoke-super from "
David Sehr709b0702016-10-13 09:12:37 -07004341 << dex_file_->PrettyMethod(dex_method_idx_)
Alex Light705ad492015-09-21 11:36:30 -07004342 << " to super " << super
4343 << "." << res_method->GetName()
4344 << res_method->GetSignature();
4345 return nullptr;
4346 }
Ian Rogersd81871c2011-10-03 13:57:23 -07004347 }
4348 }
Ian Rogers7b0c5b42012-02-16 15:29:07 -08004349
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004350 if (method_type == METHOD_POLYMORPHIC) {
4351 // Process the signature of the calling site that is invoking the method handle.
4352 DexFileParameterIterator it(*dex_file_, dex_file_->GetProtoId(inst->VRegH()));
4353 return VerifyInvocationArgsFromIterator(&it, inst, method_type, is_range, res_method);
4354 } else {
4355 // Process the target method's signature.
4356 MethodParamListDescriptorIterator it(res_method);
4357 return VerifyInvocationArgsFromIterator(&it, inst, method_type, is_range, res_method);
4358 }
4359}
4360
4361bool MethodVerifier::CheckSignaturePolymorphicMethod(ArtMethod* method) {
4362 mirror::Class* klass = method->GetDeclaringClass();
4363 if (klass != mirror::MethodHandle::StaticClass()) {
4364 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4365 << "Signature polymorphic method must be declared in java.lang.invoke.MethodClass";
4366 return false;
4367 }
4368
4369 const char* method_name = method->GetName();
4370 if (strcmp(method_name, "invoke") != 0 && strcmp(method_name, "invokeExact") != 0) {
4371 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4372 << "Signature polymorphic method name invalid: " << method_name;
4373 return false;
4374 }
4375
4376 const DexFile::TypeList* types = method->GetParameterTypeList();
4377 if (types->Size() != 1) {
4378 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4379 << "Signature polymorphic method has too many arguments " << types->Size() << " != 1";
4380 return false;
4381 }
4382
4383 const dex::TypeIndex argument_type_index = types->GetTypeItem(0).type_idx_;
4384 const char* argument_descriptor = method->GetTypeDescriptorFromTypeIdx(argument_type_index);
4385 if (strcmp(argument_descriptor, "[Ljava/lang/Object;") != 0) {
4386 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4387 << "Signature polymorphic method has unexpected argument type: " << argument_descriptor;
4388 return false;
4389 }
4390
4391 const char* return_descriptor = method->GetReturnTypeDescriptor();
4392 if (strcmp(return_descriptor, "Ljava/lang/Object;") != 0) {
4393 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4394 << "Signature polymorphic method has unexpected return type: " << return_descriptor;
4395 return false;
4396 }
4397
4398 return true;
4399}
4400
4401bool MethodVerifier::CheckSignaturePolymorphicReceiver(const Instruction* inst) {
4402 const RegType& this_type = work_line_->GetInvocationThis(this, inst);
4403 if (this_type.IsZero()) {
4404 /* null pointer always passes (and always fails at run time) */
4405 return true;
4406 } else if (!this_type.IsNonZeroReferenceTypes()) {
4407 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4408 << "invoke-polymorphic receiver is not a reference: "
4409 << this_type;
4410 return false;
4411 } else if (this_type.IsUninitializedReference()) {
4412 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4413 << "invoke-polymorphic receiver is uninitialized: "
4414 << this_type;
4415 return false;
4416 } else if (!this_type.HasClass()) {
4417 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4418 << "invoke-polymorphic receiver has no class: "
4419 << this_type;
4420 return false;
4421 } else if (!this_type.GetClass()->IsSubClass(mirror::MethodHandle::StaticClass())) {
4422 Fail(VERIFY_ERROR_BAD_CLASS_HARD)
4423 << "invoke-polymorphic receiver is not a subclass of MethodHandle: "
4424 << this_type;
4425 return false;
4426 }
4427 return true;
Ian Rogersd81871c2011-10-03 13:57:23 -07004428}
4429
Mathieu Chartiere401d142015-04-22 13:56:20 -07004430ArtMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction* inst, RegisterLine* reg_line,
4431 bool is_range, bool allow_failure) {
Mathieu Chartier091d2382015-03-06 10:59:06 -08004432 if (is_range) {
4433 DCHECK_EQ(inst->Opcode(), Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
4434 } else {
4435 DCHECK_EQ(inst->Opcode(), Instruction::INVOKE_VIRTUAL_QUICK);
4436 }
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004437 const RegType& actual_arg_type = reg_line->GetInvocationThis(this, inst, allow_failure);
Ian Rogers9bc54402014-04-17 16:40:01 -07004438 if (!actual_arg_type.HasClass()) {
4439 VLOG(verifier) << "Failed to get mirror::Class* from '" << actual_arg_type << "'";
Andreas Gampe63981562014-04-17 12:28:43 -07004440 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004441 }
Ian Rogersa4cf1df2014-05-07 19:47:17 -07004442 mirror::Class* klass = actual_arg_type.GetClass();
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004443 mirror::Class* dispatch_class;
Ian Rogersa4cf1df2014-05-07 19:47:17 -07004444 if (klass->IsInterface()) {
4445 // Derive Object.class from Class.class.getSuperclass().
4446 mirror::Class* object_klass = klass->GetClass()->GetSuperClass();
Andreas Gampe7c038102014-10-27 20:08:46 -07004447 if (FailOrAbort(this, object_klass->IsObjectClass(),
Mathieu Chartier091d2382015-03-06 10:59:06 -08004448 "Failed to find Object class in quickened invoke receiver", work_insn_idx_)) {
Andreas Gampe7c038102014-10-27 20:08:46 -07004449 return nullptr;
4450 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004451 dispatch_class = object_klass;
Ian Rogersa4cf1df2014-05-07 19:47:17 -07004452 } else {
Mingyao Yang2cdbad72014-07-16 10:44:41 -07004453 dispatch_class = klass;
Ian Rogersa4cf1df2014-05-07 19:47:17 -07004454 }
Mathieu Chartier091d2382015-03-06 10:59:06 -08004455 if (!dispatch_class->HasVTable()) {
4456 FailOrAbort(this, allow_failure, "Receiver class has no vtable for quickened invoke at ",
4457 work_insn_idx_);
Andreas Gampe7c038102014-10-27 20:08:46 -07004458 return nullptr;
4459 }
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004460 uint16_t vtable_index = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
Mathieu Chartiere401d142015-04-22 13:56:20 -07004461 auto* cl = Runtime::Current()->GetClassLinker();
4462 auto pointer_size = cl->GetImagePointerSize();
Mathieu Chartier091d2382015-03-06 10:59:06 -08004463 if (static_cast<int32_t>(vtable_index) >= dispatch_class->GetVTableLength()) {
4464 FailOrAbort(this, allow_failure,
4465 "Receiver class has not enough vtable slots for quickened invoke at ",
4466 work_insn_idx_);
Andreas Gampe7c038102014-10-27 20:08:46 -07004467 return nullptr;
4468 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07004469 ArtMethod* res_method = dispatch_class->GetVTableEntry(vtable_index, pointer_size);
Mathieu Chartier091d2382015-03-06 10:59:06 -08004470 if (self_->IsExceptionPending()) {
4471 FailOrAbort(this, allow_failure, "Unexpected exception pending for quickened invoke at ",
4472 work_insn_idx_);
Andreas Gampe7c038102014-10-27 20:08:46 -07004473 return nullptr;
4474 }
Sebastien Hertzc15853b2013-06-25 17:36:27 +02004475 return res_method;
4476}
4477
Mathieu Chartiere401d142015-04-22 13:56:20 -07004478ArtMethod* MethodVerifier::VerifyInvokeVirtualQuickArgs(const Instruction* inst, bool is_range) {
Andreas Gampe76bd8802014-12-10 16:43:58 -08004479 DCHECK(Runtime::Current()->IsStarted() || verify_to_dump_)
David Sehr709b0702016-10-13 09:12:37 -07004480 << dex_file_->PrettyMethod(dex_method_idx_, true) << "@" << work_insn_idx_;
Andreas Gampe76bd8802014-12-10 16:43:58 -08004481
Mathieu Chartiere401d142015-04-22 13:56:20 -07004482 ArtMethod* res_method = GetQuickInvokedMethod(inst, work_line_.get(), is_range, false);
Ian Rogers7b078e82014-09-10 14:44:24 -07004483 if (res_method == nullptr) {
Sebastien Hertzc15853b2013-06-25 17:36:27 +02004484 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer method from " << inst->Name();
Ian Rogers7b078e82014-09-10 14:44:24 -07004485 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004486 }
Andreas Gampe7c038102014-10-27 20:08:46 -07004487 if (FailOrAbort(this, !res_method->IsDirect(), "Quick-invoked method is direct at ",
4488 work_insn_idx_)) {
4489 return nullptr;
4490 }
4491 if (FailOrAbort(this, !res_method->IsStatic(), "Quick-invoked method is static at ",
4492 work_insn_idx_)) {
4493 return nullptr;
4494 }
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004495
4496 // We use vAA as our expected arg count, rather than res_method->insSize, because we need to
4497 // match the call to the signature. Also, we might be calling through an abstract method
4498 // definition (which doesn't have register count values).
Orion Hodsoncfa325e2016-10-13 10:25:54 +01004499 const RegType& actual_arg_type = work_line_->GetInvocationThis(this, inst);
Sebastien Hertzc15853b2013-06-25 17:36:27 +02004500 if (actual_arg_type.IsConflict()) { // GetInvocationThis failed.
Ian Rogers7b078e82014-09-10 14:44:24 -07004501 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +02004502 }
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004503 const size_t expected_args = (is_range) ? inst->VRegA_3rc() : inst->VRegA_35c();
4504 /* caught by static verifier */
4505 DCHECK(is_range || expected_args <= 5);
4506 if (expected_args > code_item_->outs_size_) {
4507 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid argument count (" << expected_args
4508 << ") exceeds outsSize (" << code_item_->outs_size_ << ")";
Ian Rogers7b078e82014-09-10 14:44:24 -07004509 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004510 }
4511
4512 /*
4513 * Check the "this" argument, which must be an instance of the class that declared the method.
4514 * For an interface class, we don't do the full interface merge (see JoinClass), so we can't do a
4515 * rigorous check here (which is okay since we have to do it at runtime).
4516 */
David Brazdil68b5c0b2016-01-19 14:25:29 +00004517 // Note: given an uninitialized type, this should always fail. Constructors aren't virtual.
4518 if (actual_arg_type.IsUninitializedTypes() && !res_method->IsConstructor()) {
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004519 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "'this' arg must be initialized";
Ian Rogers7b078e82014-09-10 14:44:24 -07004520 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004521 }
4522 if (!actual_arg_type.IsZero()) {
4523 mirror::Class* klass = res_method->GetDeclaringClass();
Ian Rogers1ff3c982014-08-12 02:30:58 -07004524 std::string temp;
Ian Rogersd8f69b02014-09-10 21:43:52 +00004525 const RegType& res_method_class =
Andreas Gampef23f33d2015-06-23 14:18:17 -07004526 FromClass(klass->GetDescriptor(&temp), klass, klass->CannotBeAssignedFromOtherTypes());
David Brazdilca3c8c32016-09-06 14:04:48 +01004527 if (!res_method_class.IsAssignableFrom(actual_arg_type, this)) {
David Brazdil68b5c0b2016-01-19 14:25:29 +00004528 Fail(actual_arg_type.IsUninitializedTypes() // Just overcautious - should have never
4529 ? VERIFY_ERROR_BAD_CLASS_HARD // quickened this.
4530 : actual_arg_type.IsUnresolvedTypes()
4531 ? VERIFY_ERROR_NO_CLASS
4532 : VERIFY_ERROR_BAD_CLASS_SOFT) << "'this' argument '" << actual_arg_type
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004533 << "' not instance of '" << res_method_class << "'";
Ian Rogers7b078e82014-09-10 14:44:24 -07004534 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004535 }
4536 }
4537 /*
4538 * Process the target method's signature. This signature may or may not
4539 * have been verified, so we can't assume it's properly formed.
4540 */
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004541 const DexFile::TypeList* params = res_method->GetParameterTypeList();
Ian Rogers7b078e82014-09-10 14:44:24 -07004542 size_t params_size = params == nullptr ? 0 : params->Size();
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004543 uint32_t arg[5];
4544 if (!is_range) {
Ian Rogers29a26482014-05-02 15:27:29 -07004545 inst->GetVarArgs(arg);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004546 }
4547 size_t actual_args = 1;
4548 for (size_t param_index = 0; param_index < params_size; param_index++) {
4549 if (actual_args >= expected_args) {
David Sehr709b0702016-10-13 09:12:37 -07004550 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invalid call to '"
4551 << res_method->PrettyMethod()
Brian Carlstrom93c33962013-07-26 10:37:43 -07004552 << "'. Expected " << expected_args
4553 << " arguments, processing argument " << actual_args
4554 << " (where longs/doubles count twice).";
Ian Rogers7b078e82014-09-10 14:44:24 -07004555 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004556 }
4557 const char* descriptor =
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004558 res_method->GetTypeDescriptorFromTypeIdx(params->GetTypeItem(param_index).type_idx_);
Ian Rogers7b078e82014-09-10 14:44:24 -07004559 if (descriptor == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07004560 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation of "
4561 << res_method->PrettyMethod()
Sebastien Hertzc15853b2013-06-25 17:36:27 +02004562 << " missing signature component";
Ian Rogers7b078e82014-09-10 14:44:24 -07004563 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004564 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00004565 const RegType& reg_type = reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004566 uint32_t get_reg = is_range ? inst->VRegC_3rc() + actual_args : arg[actual_args];
Ian Rogers7b078e82014-09-10 14:44:24 -07004567 if (!work_line_->VerifyRegisterType(this, get_reg, reg_type)) {
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004568 return res_method;
4569 }
4570 actual_args = reg_type.IsLongOrDoubleTypes() ? actual_args + 2 : actual_args + 1;
4571 }
4572 if (actual_args != expected_args) {
David Sehr709b0702016-10-13 09:12:37 -07004573 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Rejecting invocation of "
4574 << res_method->PrettyMethod() << " expected "
4575 << expected_args << " arguments, found " << actual_args;
Ian Rogers7b078e82014-09-10 14:44:24 -07004576 return nullptr;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02004577 } else {
4578 return res_method;
4579 }
4580}
4581
Ian Rogers62342ec2013-06-11 10:26:37 -07004582void MethodVerifier::VerifyNewArray(const Instruction* inst, bool is_filled, bool is_range) {
Andreas Gampea5b09a62016-11-17 15:21:22 -08004583 dex::TypeIndex type_idx;
Sebastien Hertz5243e912013-05-21 10:55:07 +02004584 if (!is_filled) {
4585 DCHECK_EQ(inst->Opcode(), Instruction::NEW_ARRAY);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004586 type_idx = dex::TypeIndex(inst->VRegC_22c());
Sebastien Hertz5243e912013-05-21 10:55:07 +02004587 } else if (!is_range) {
4588 DCHECK_EQ(inst->Opcode(), Instruction::FILLED_NEW_ARRAY);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004589 type_idx = dex::TypeIndex(inst->VRegB_35c());
Sebastien Hertz5243e912013-05-21 10:55:07 +02004590 } else {
4591 DCHECK_EQ(inst->Opcode(), Instruction::FILLED_NEW_ARRAY_RANGE);
Andreas Gampea5b09a62016-11-17 15:21:22 -08004592 type_idx = dex::TypeIndex(inst->VRegB_3rc());
Sebastien Hertz5243e912013-05-21 10:55:07 +02004593 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00004594 const RegType& res_type = ResolveClassAndCheckAccess(type_idx);
Ian Rogersad0b3a32012-04-16 14:50:24 -07004595 if (res_type.IsConflict()) { // bad class
4596 DCHECK_NE(failures_.size(), 0U);
Ian Rogers0c4a5062012-02-03 15:18:59 -08004597 } else {
4598 // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
4599 if (!res_type.IsArrayTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07004600 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "new-array on non-array class " << res_type;
Ian Rogers0c4a5062012-02-03 15:18:59 -08004601 } else if (!is_filled) {
4602 /* make sure "size" register is valid type */
Ian Rogers7b078e82014-09-10 14:44:24 -07004603 work_line_->VerifyRegisterType(this, inst->VRegB_22c(), reg_types_.Integer());
Ian Rogers0c4a5062012-02-03 15:18:59 -08004604 /* set register type to array class */
Ian Rogersd8f69b02014-09-10 21:43:52 +00004605 const RegType& precise_type = reg_types_.FromUninitialized(res_type);
Andreas Gampead238ce2015-08-24 21:13:08 -07004606 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_22c(), precise_type);
Ian Rogers0c4a5062012-02-03 15:18:59 -08004607 } else {
Andreas Gampebb18a032016-03-22 20:34:25 -07004608 DCHECK(!res_type.IsUnresolvedMergedReference());
Ian Rogers0c4a5062012-02-03 15:18:59 -08004609 // Verify each register. If "arg_count" is bad, VerifyRegisterType() will run off the end of
4610 // the list and fail. It's legal, if silly, for arg_count to be zero.
Ian Rogersd8f69b02014-09-10 21:43:52 +00004611 const RegType& expected_type = reg_types_.GetComponentType(res_type, GetClassLoader());
Sebastien Hertz5243e912013-05-21 10:55:07 +02004612 uint32_t arg_count = (is_range) ? inst->VRegA_3rc() : inst->VRegA_35c();
4613 uint32_t arg[5];
4614 if (!is_range) {
Ian Rogers29a26482014-05-02 15:27:29 -07004615 inst->GetVarArgs(arg);
Sebastien Hertz5243e912013-05-21 10:55:07 +02004616 }
Ian Rogers0c4a5062012-02-03 15:18:59 -08004617 for (size_t ui = 0; ui < arg_count; ui++) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02004618 uint32_t get_reg = is_range ? inst->VRegC_3rc() + ui : arg[ui];
Ian Rogers7b078e82014-09-10 14:44:24 -07004619 if (!work_line_->VerifyRegisterType(this, get_reg, expected_type)) {
4620 work_line_->SetResultRegisterType(this, reg_types_.Conflict());
Ian Rogers0c4a5062012-02-03 15:18:59 -08004621 return;
4622 }
4623 }
4624 // filled-array result goes into "result" register
Ian Rogersd8f69b02014-09-10 21:43:52 +00004625 const RegType& precise_type = reg_types_.FromUninitialized(res_type);
Ian Rogers7b078e82014-09-10 14:44:24 -07004626 work_line_->SetResultRegisterType(this, precise_type);
Ian Rogers0c4a5062012-02-03 15:18:59 -08004627 }
4628 }
4629}
4630
Sebastien Hertz5243e912013-05-21 10:55:07 +02004631void MethodVerifier::VerifyAGet(const Instruction* inst,
Ian Rogersd8f69b02014-09-10 21:43:52 +00004632 const RegType& insn_type, bool is_primitive) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004633 const RegType& index_type = work_line_->GetRegisterType(this, inst->VRegC_23x());
Ian Rogersd81871c2011-10-03 13:57:23 -07004634 if (!index_type.IsArrayIndexTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07004635 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Invalid reg type for array index (" << index_type << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07004636 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07004637 const RegType& array_type = work_line_->GetRegisterType(this, inst->VRegB_23x());
Ian Rogers89310de2012-02-01 13:47:30 -08004638 if (array_type.IsZero()) {
Nicolas Geoffray4824c272015-06-24 15:53:03 +01004639 have_pending_runtime_throw_failure_ = true;
Ian Rogers89310de2012-02-01 13:47:30 -08004640 // Null array class; this code path will fail at runtime. Infer a merge-able type from the
4641 // instruction type. TODO: have a proper notion of bottom here.
4642 if (!is_primitive || insn_type.IsCategory1Types()) {
4643 // Reference or category 1
Andreas Gampead238ce2015-08-24 21:13:08 -07004644 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_23x(), reg_types_.Zero());
Ian Rogersd81871c2011-10-03 13:57:23 -07004645 } else {
Ian Rogers89310de2012-02-01 13:47:30 -08004646 // Category 2
Ian Rogers7b078e82014-09-10 14:44:24 -07004647 work_line_->SetRegisterTypeWide(this, inst->VRegA_23x(),
4648 reg_types_.FromCat2ConstLo(0, false),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08004649 reg_types_.FromCat2ConstHi(0, false));
Ian Rogers89310de2012-02-01 13:47:30 -08004650 }
jeffhaofc3144e2012-02-01 17:21:15 -08004651 } else if (!array_type.IsArrayTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07004652 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "not array type " << array_type << " with aget";
Andreas Gampe8d8fc482016-03-25 16:24:20 -07004653 } else if (array_type.IsUnresolvedMergedReference()) {
Andreas Gampebb18a032016-03-22 20:34:25 -07004654 // Unresolved array types must be reference array types.
4655 if (is_primitive) {
4656 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "reference array type " << array_type
4657 << " source for category 1 aget";
4658 } else {
4659 Fail(VERIFY_ERROR_NO_CLASS) << "cannot verify aget for " << array_type
4660 << " because of missing class";
Andreas Gampe8d8fc482016-03-25 16:24:20 -07004661 // Approximate with java.lang.Object[].
4662 work_line_->SetRegisterType<LockOp::kClear>(this,
4663 inst->VRegA_23x(),
4664 reg_types_.JavaLangObject(false));
Andreas Gampebb18a032016-03-22 20:34:25 -07004665 }
Ian Rogers89310de2012-02-01 13:47:30 -08004666 } else {
4667 /* verify the class */
Ian Rogersd8f69b02014-09-10 21:43:52 +00004668 const RegType& component_type = reg_types_.GetComponentType(array_type, GetClassLoader());
jeffhaofc3144e2012-02-01 17:21:15 -08004669 if (!component_type.IsReferenceTypes() && !is_primitive) {
jeffhaod5347e02012-03-22 17:25:05 -07004670 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "primitive array type " << array_type
Ian Rogers89310de2012-02-01 13:47:30 -08004671 << " source for aget-object";
4672 } else if (component_type.IsNonZeroReferenceTypes() && is_primitive) {
jeffhaod5347e02012-03-22 17:25:05 -07004673 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "reference array type " << array_type
Ian Rogers89310de2012-02-01 13:47:30 -08004674 << " source for category 1 aget";
4675 } else if (is_primitive && !insn_type.Equals(component_type) &&
4676 !((insn_type.IsInteger() && component_type.IsFloat()) ||
Ian Rogers2bcb4a42012-11-08 10:39:18 -08004677 (insn_type.IsLong() && component_type.IsDouble()))) {
4678 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array type " << array_type
4679 << " incompatible with aget of type " << insn_type;
Ian Rogers89310de2012-02-01 13:47:30 -08004680 } else {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08004681 // Use knowledge of the field type which is stronger than the type inferred from the
4682 // instruction, which can't differentiate object types and ints from floats, longs from
4683 // doubles.
4684 if (!component_type.IsLowHalf()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07004685 work_line_->SetRegisterType<LockOp::kClear>(this, inst->VRegA_23x(), component_type);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08004686 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07004687 work_line_->SetRegisterTypeWide(this, inst->VRegA_23x(), component_type,
Ian Rogers2bcb4a42012-11-08 10:39:18 -08004688 component_type.HighHalf(&reg_types_));
4689 }
Ian Rogersd81871c2011-10-03 13:57:23 -07004690 }
4691 }
4692 }
4693}
4694
Ian Rogersd8f69b02014-09-10 21:43:52 +00004695void MethodVerifier::VerifyPrimitivePut(const RegType& target_type, const RegType& insn_type,
Jeff Haofe1f7c82013-08-01 14:50:24 -07004696 const uint32_t vregA) {
4697 // Primitive assignability rules are weaker than regular assignability rules.
4698 bool instruction_compatible;
4699 bool value_compatible;
Ian Rogers7b078e82014-09-10 14:44:24 -07004700 const RegType& value_type = work_line_->GetRegisterType(this, vregA);
Jeff Haofe1f7c82013-08-01 14:50:24 -07004701 if (target_type.IsIntegralTypes()) {
Jeff Haoa4647482013-08-06 15:35:47 -07004702 instruction_compatible = target_type.Equals(insn_type);
Jeff Haofe1f7c82013-08-01 14:50:24 -07004703 value_compatible = value_type.IsIntegralTypes();
4704 } else if (target_type.IsFloat()) {
4705 instruction_compatible = insn_type.IsInteger(); // no put-float, so expect put-int
4706 value_compatible = value_type.IsFloatTypes();
4707 } else if (target_type.IsLong()) {
4708 instruction_compatible = insn_type.IsLong();
Andreas Gampe376fa682014-09-07 13:06:12 -07004709 // Additional register check: this is not checked statically (as part of VerifyInstructions),
4710 // as target_type depends on the resolved type of the field.
4711 if (instruction_compatible && work_line_->NumRegs() > vregA + 1) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004712 const RegType& value_type_hi = work_line_->GetRegisterType(this, vregA + 1);
Andreas Gampe376fa682014-09-07 13:06:12 -07004713 value_compatible = value_type.IsLongTypes() && value_type.CheckWidePair(value_type_hi);
4714 } else {
4715 value_compatible = false;
4716 }
Jeff Haofe1f7c82013-08-01 14:50:24 -07004717 } else if (target_type.IsDouble()) {
4718 instruction_compatible = insn_type.IsLong(); // no put-double, so expect put-long
Andreas Gampe376fa682014-09-07 13:06:12 -07004719 // Additional register check: this is not checked statically (as part of VerifyInstructions),
4720 // as target_type depends on the resolved type of the field.
4721 if (instruction_compatible && work_line_->NumRegs() > vregA + 1) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004722 const RegType& value_type_hi = work_line_->GetRegisterType(this, vregA + 1);
Andreas Gampe376fa682014-09-07 13:06:12 -07004723 value_compatible = value_type.IsDoubleTypes() && value_type.CheckWidePair(value_type_hi);
4724 } else {
4725 value_compatible = false;
4726 }
Jeff Haofe1f7c82013-08-01 14:50:24 -07004727 } else {
4728 instruction_compatible = false; // reference with primitive store
4729 value_compatible = false; // unused
4730 }
4731 if (!instruction_compatible) {
4732 // This is a global failure rather than a class change failure as the instructions and
4733 // the descriptors for the type should have been consistent within the same file at
4734 // compile time.
4735 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "put insn has type '" << insn_type
4736 << "' but expected type '" << target_type << "'";
4737 return;
4738 }
4739 if (!value_compatible) {
4740 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected value in v" << vregA
4741 << " of type " << value_type << " but expected " << target_type << " for put";
4742 return;
4743 }
4744}
4745
Sebastien Hertz5243e912013-05-21 10:55:07 +02004746void MethodVerifier::VerifyAPut(const Instruction* inst,
Ian Rogersd8f69b02014-09-10 21:43:52 +00004747 const RegType& insn_type, bool is_primitive) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004748 const RegType& index_type = work_line_->GetRegisterType(this, inst->VRegC_23x());
Ian Rogersd81871c2011-10-03 13:57:23 -07004749 if (!index_type.IsArrayIndexTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07004750 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Invalid reg type for array index (" << index_type << ")";
Ian Rogersd81871c2011-10-03 13:57:23 -07004751 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07004752 const RegType& array_type = work_line_->GetRegisterType(this, inst->VRegB_23x());
Ian Rogers89310de2012-02-01 13:47:30 -08004753 if (array_type.IsZero()) {
Nicolas Geoffray66389fb2015-06-19 10:35:42 +01004754 // Null array type; this code path will fail at runtime.
4755 // Still check that the given value matches the instruction's type.
Andreas Gampe4bf4c782015-08-14 14:07:43 -07004756 // Note: this is, as usual, complicated by the fact the the instruction isn't fully typed
4757 // and fits multiple register types.
4758 const RegType* modified_reg_type = &insn_type;
4759 if ((modified_reg_type == &reg_types_.Integer()) ||
4760 (modified_reg_type == &reg_types_.LongLo())) {
4761 // May be integer or float | long or double. Overwrite insn_type accordingly.
4762 const RegType& value_type = work_line_->GetRegisterType(this, inst->VRegA_23x());
4763 if (modified_reg_type == &reg_types_.Integer()) {
4764 if (&value_type == &reg_types_.Float()) {
4765 modified_reg_type = &value_type;
4766 }
4767 } else {
4768 if (&value_type == &reg_types_.DoubleLo()) {
4769 modified_reg_type = &value_type;
4770 }
4771 }
4772 }
4773 work_line_->VerifyRegisterType(this, inst->VRegA_23x(), *modified_reg_type);
jeffhaofc3144e2012-02-01 17:21:15 -08004774 } else if (!array_type.IsArrayTypes()) {
jeffhaod5347e02012-03-22 17:25:05 -07004775 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "not array type " << array_type << " with aput";
Andreas Gampe8d8fc482016-03-25 16:24:20 -07004776 } else if (array_type.IsUnresolvedMergedReference()) {
Andreas Gampebb18a032016-03-22 20:34:25 -07004777 // Unresolved array types must be reference array types.
4778 if (is_primitive) {
4779 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "put insn has type '" << insn_type
4780 << "' but unresolved type '" << array_type << "'";
4781 } else {
4782 Fail(VERIFY_ERROR_NO_CLASS) << "cannot verify aput for " << array_type
4783 << " because of missing class";
4784 }
Ian Rogers89310de2012-02-01 13:47:30 -08004785 } else {
Ian Rogersd8f69b02014-09-10 21:43:52 +00004786 const RegType& component_type = reg_types_.GetComponentType(array_type, GetClassLoader());
Jeff Haofe1f7c82013-08-01 14:50:24 -07004787 const uint32_t vregA = inst->VRegA_23x();
Jeff Haob24b4a72013-07-31 13:47:31 -07004788 if (is_primitive) {
Jeff Haofe1f7c82013-08-01 14:50:24 -07004789 VerifyPrimitivePut(component_type, insn_type, vregA);
Ian Rogersd81871c2011-10-03 13:57:23 -07004790 } else {
Jeff Haob24b4a72013-07-31 13:47:31 -07004791 if (!component_type.IsReferenceTypes()) {
4792 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "primitive array type " << array_type
4793 << " source for aput-object";
4794 } else {
4795 // The instruction agrees with the type of array, confirm the value to be stored does too
4796 // Note: we use the instruction type (rather than the component type) for aput-object as
4797 // incompatible classes will be caught at runtime as an array store exception
Ian Rogers7b078e82014-09-10 14:44:24 -07004798 work_line_->VerifyRegisterType(this, vregA, insn_type);
Jeff Haob24b4a72013-07-31 13:47:31 -07004799 }
Ian Rogersd81871c2011-10-03 13:57:23 -07004800 }
4801 }
4802 }
4803}
4804
Mathieu Chartierc7853442015-03-27 14:35:38 -07004805ArtField* MethodVerifier::GetStaticField(int field_idx) {
Ian Rogers90040192011-12-16 08:54:29 -08004806 const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
4807 // Check access to class
Ian Rogersd8f69b02014-09-10 21:43:52 +00004808 const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004809 if (klass_type.IsConflict()) { // bad class
Ian Rogersad0b3a32012-04-16 14:50:24 -07004810 AppendToLastFailMessage(StringPrintf(" in attempt to access static field %d (%s) in %s",
4811 field_idx, dex_file_->GetFieldName(field_id),
4812 dex_file_->GetFieldDeclaringClassDescriptor(field_id)));
Ian Rogers7b078e82014-09-10 14:44:24 -07004813 return nullptr;
Ian Rogers90040192011-12-16 08:54:29 -08004814 }
Elliott Hughesb25c3f62012-03-26 16:35:06 -07004815 if (klass_type.IsUnresolvedTypes()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004816 return nullptr; // Can't resolve Class so no more to do here, will do checking at runtime.
Ian Rogers90040192011-12-16 08:54:29 -08004817 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07004818 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
David Brazdilca3c8c32016-09-06 14:04:48 +01004819 ArtField* field = class_linker->ResolveFieldJLS(*dex_file_, field_idx, dex_cache_, class_loader_);
4820
4821 // Record result of the field resolution attempt.
4822 VerifierDeps::MaybeRecordFieldResolution(*dex_file_, field_idx, field);
4823
Ian Rogers7b078e82014-09-10 14:44:24 -07004824 if (field == nullptr) {
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07004825 VLOG(verifier) << "Unable to resolve static field " << field_idx << " ("
Ian Rogersf4028cc2011-11-02 14:56:39 -07004826 << dex_file_->GetFieldName(field_id) << ") in "
4827 << dex_file_->GetFieldDeclaringClassDescriptor(field_id);
Ian Rogers7b078e82014-09-10 14:44:24 -07004828 DCHECK(self_->IsExceptionPending());
4829 self_->ClearException();
4830 return nullptr;
Ian Rogersad0b3a32012-04-16 14:50:24 -07004831 } else if (!GetDeclaringClass().CanAccessMember(field->GetDeclaringClass(),
4832 field->GetAccessFlags())) {
David Sehr709b0702016-10-13 09:12:37 -07004833 Fail(VERIFY_ERROR_ACCESS_FIELD) << "cannot access static field " << field->PrettyField()
Ian Rogersad0b3a32012-04-16 14:50:24 -07004834 << " from " << GetDeclaringClass();
Ian Rogers7b078e82014-09-10 14:44:24 -07004835 return nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07004836 } else if (!field->IsStatic()) {
David Sehr709b0702016-10-13 09:12:37 -07004837 Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected field " << field->PrettyField() << " to be static";
Ian Rogers7b078e82014-09-10 14:44:24 -07004838 return nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07004839 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07004840 return field;
Ian Rogersd81871c2011-10-03 13:57:23 -07004841}
4842
Mathieu Chartierc7853442015-03-27 14:35:38 -07004843ArtField* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
Ian Rogers90040192011-12-16 08:54:29 -08004844 const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
Aart Bik31883642016-06-06 15:02:44 -07004845 // Check access to class.
Ian Rogersd8f69b02014-09-10 21:43:52 +00004846 const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
Ian Rogersad0b3a32012-04-16 14:50:24 -07004847 if (klass_type.IsConflict()) {
4848 AppendToLastFailMessage(StringPrintf(" in attempt to access instance field %d (%s) in %s",
4849 field_idx, dex_file_->GetFieldName(field_id),
4850 dex_file_->GetFieldDeclaringClassDescriptor(field_id)));
Ian Rogers7b078e82014-09-10 14:44:24 -07004851 return nullptr;
Ian Rogers90040192011-12-16 08:54:29 -08004852 }
jeffhao8cd6dda2012-02-22 10:15:34 -08004853 if (klass_type.IsUnresolvedTypes()) {
Ian Rogers7b078e82014-09-10 14:44:24 -07004854 return nullptr; // Can't resolve Class so no more to do here
Ian Rogers90040192011-12-16 08:54:29 -08004855 }
Mathieu Chartier590fee92013-09-13 13:46:47 -07004856 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
David Brazdilca3c8c32016-09-06 14:04:48 +01004857 ArtField* field = class_linker->ResolveFieldJLS(*dex_file_, field_idx, dex_cache_, class_loader_);
4858
4859 // Record result of the field resolution attempt.
4860 VerifierDeps::MaybeRecordFieldResolution(*dex_file_, field_idx, field);
4861
Ian Rogers7b078e82014-09-10 14:44:24 -07004862 if (field == nullptr) {
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07004863 VLOG(verifier) << "Unable to resolve instance field " << field_idx << " ("
Ian Rogersf4028cc2011-11-02 14:56:39 -07004864 << dex_file_->GetFieldName(field_id) << ") in "
4865 << dex_file_->GetFieldDeclaringClassDescriptor(field_id);
Ian Rogers7b078e82014-09-10 14:44:24 -07004866 DCHECK(self_->IsExceptionPending());
4867 self_->ClearException();
4868 return nullptr;
Ian Rogersd81871c2011-10-03 13:57:23 -07004869 } else if (obj_type.IsZero()) {
Aart Bik31883642016-06-06 15:02:44 -07004870 // Cannot infer and check type, however, access will cause null pointer exception.
4871 // Fall through into a few last soft failure checks below.
Stephen Kyle695c5982014-08-22 15:03:07 +01004872 } else if (!obj_type.IsReferenceTypes()) {
Aart Bik31883642016-06-06 15:02:44 -07004873 // Trying to read a field from something that isn't a reference.
Stephen Kyle695c5982014-08-22 15:03:07 +01004874 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "instance field access on object that has "
4875 << "non-reference type " << obj_type;
Ian Rogers7b078e82014-09-10 14:44:24 -07004876 return nullptr;
Ian Rogerse1758fe2012-04-19 11:31:15 -07004877 } else {
David Brazdil0d638bb2016-07-27 15:29:25 +01004878 std::string temp;
Mathieu Chartier3398c782016-09-30 10:27:43 -07004879 ObjPtr<mirror::Class> klass = field->GetDeclaringClass();
Ian Rogersd8f69b02014-09-10 21:43:52 +00004880 const RegType& field_klass =
Mathieu Chartier3398c782016-09-30 10:27:43 -07004881 FromClass(klass->GetDescriptor(&temp),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07004882 klass.Ptr(),
Mathieu Chartier3398c782016-09-30 10:27:43 -07004883 klass->CannotBeAssignedFromOtherTypes());
David Brazdil68b5c0b2016-01-19 14:25:29 +00004884 if (obj_type.IsUninitializedTypes()) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07004885 // Field accesses through uninitialized references are only allowable for constructors where
David Brazdil68b5c0b2016-01-19 14:25:29 +00004886 // the field is declared in this class.
4887 // Note: this IsConstructor check is technically redundant, as UninitializedThis should only
4888 // appear in constructors.
4889 if (!obj_type.IsUninitializedThisReference() ||
4890 !IsConstructor() ||
4891 !field_klass.Equals(GetDeclaringClass())) {
David Sehr709b0702016-10-13 09:12:37 -07004892 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "cannot access instance field " << field->PrettyField()
David Brazdil68b5c0b2016-01-19 14:25:29 +00004893 << " of a not fully initialized object within the context"
David Sehr709b0702016-10-13 09:12:37 -07004894 << " of " << dex_file_->PrettyMethod(dex_method_idx_);
David Brazdil68b5c0b2016-01-19 14:25:29 +00004895 return nullptr;
4896 }
David Brazdilca3c8c32016-09-06 14:04:48 +01004897 } else if (!field_klass.IsAssignableFrom(obj_type, this)) {
Ian Rogersad0b3a32012-04-16 14:50:24 -07004898 // Trying to access C1.field1 using reference of type C2, which is neither C1 or a sub-class
4899 // of C1. For resolution to occur the declared class of the field must be compatible with
4900 // obj_type, we've discovered this wasn't so, so report the field didn't exist.
Andreas Gampe66596242016-04-14 10:55:04 -07004901 VerifyError type;
4902 bool is_aot = Runtime::Current()->IsAotCompiler();
4903 if (is_aot && (field_klass.IsUnresolvedTypes() || obj_type.IsUnresolvedTypes())) {
4904 // Compiler & unresolved types involved, retry at runtime.
4905 type = VerifyError::VERIFY_ERROR_NO_CLASS;
4906 } else {
Andreas Gampe8f4ade02016-04-15 10:09:16 -07004907 // Classes known (resolved; and thus assignability check is precise), or we are at runtime
4908 // and still missing classes. This is a hard failure.
Andreas Gampe66596242016-04-14 10:55:04 -07004909 type = VerifyError::VERIFY_ERROR_BAD_CLASS_HARD;
4910 }
David Sehr709b0702016-10-13 09:12:37 -07004911 Fail(type) << "cannot access instance field " << field->PrettyField()
Andreas Gampe66596242016-04-14 10:55:04 -07004912 << " from object of type " << obj_type;
Ian Rogers7b078e82014-09-10 14:44:24 -07004913 return nullptr;
Ian Rogersad0b3a32012-04-16 14:50:24 -07004914 }
Ian Rogersd81871c2011-10-03 13:57:23 -07004915 }
Aart Bik31883642016-06-06 15:02:44 -07004916
4917 // Few last soft failure checks.
4918 if (!GetDeclaringClass().CanAccessMember(field->GetDeclaringClass(),
4919 field->GetAccessFlags())) {
David Sehr709b0702016-10-13 09:12:37 -07004920 Fail(VERIFY_ERROR_ACCESS_FIELD) << "cannot access instance field " << field->PrettyField()
Aart Bik31883642016-06-06 15:02:44 -07004921 << " from " << GetDeclaringClass();
4922 return nullptr;
4923 } else if (field->IsStatic()) {
David Sehr709b0702016-10-13 09:12:37 -07004924 Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected field " << field->PrettyField()
Aart Bik31883642016-06-06 15:02:44 -07004925 << " to not be static";
4926 return nullptr;
4927 }
4928
4929 return field;
Ian Rogersd81871c2011-10-03 13:57:23 -07004930}
4931
Andreas Gampe896df402014-10-20 22:25:29 -07004932template <MethodVerifier::FieldAccessType kAccType>
4933void MethodVerifier::VerifyISFieldAccess(const Instruction* inst, const RegType& insn_type,
4934 bool is_primitive, bool is_static) {
Sebastien Hertz5243e912013-05-21 10:55:07 +02004935 uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
Mathieu Chartierc7853442015-03-27 14:35:38 -07004936 ArtField* field;
Ian Rogersb94a27b2011-10-26 00:33:41 -07004937 if (is_static) {
Ian Rogersf4028cc2011-11-02 14:56:39 -07004938 field = GetStaticField(field_idx);
Ian Rogersb94a27b2011-10-26 00:33:41 -07004939 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07004940 const RegType& object_type = work_line_->GetRegisterType(this, inst->VRegB_22c());
David Brazdil68b5c0b2016-01-19 14:25:29 +00004941
4942 // One is not allowed to access fields on uninitialized references, except to write to
4943 // fields in the constructor (before calling another constructor).
4944 // GetInstanceField does an assignability check which will fail for uninitialized types.
4945 // We thus modify the type if the uninitialized reference is a "this" reference (this also
4946 // checks at the same time that we're verifying a constructor).
4947 bool should_adjust = (kAccType == FieldAccessType::kAccPut) &&
4948 object_type.IsUninitializedThisReference();
4949 const RegType& adjusted_type = should_adjust
4950 ? GetRegTypeCache()->FromUninitialized(object_type)
4951 : object_type;
4952 field = GetInstanceField(adjusted_type, field_idx);
Andreas Gampe896df402014-10-20 22:25:29 -07004953 if (UNLIKELY(have_pending_hard_failure_)) {
4954 return;
4955 }
Alex Light4a2c8fc2016-02-12 11:01:54 -08004956 if (should_adjust) {
4957 if (field == nullptr) {
4958 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "Might be accessing a superclass instance field prior "
4959 << "to the superclass being initialized in "
David Sehr709b0702016-10-13 09:12:37 -07004960 << dex_file_->PrettyMethod(dex_method_idx_);
Alex Light4a2c8fc2016-02-12 11:01:54 -08004961 } else if (field->GetDeclaringClass() != GetDeclaringClass().GetClass()) {
4962 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "cannot access superclass instance field "
David Sehr709b0702016-10-13 09:12:37 -07004963 << field->PrettyField() << " of a not fully initialized "
Alex Light4a2c8fc2016-02-12 11:01:54 -08004964 << "object within the context of "
David Sehr709b0702016-10-13 09:12:37 -07004965 << dex_file_->PrettyMethod(dex_method_idx_);
Alex Light4a2c8fc2016-02-12 11:01:54 -08004966 return;
4967 }
4968 }
Ian Rogersb94a27b2011-10-26 00:33:41 -07004969 }
Ian Rogersd8f69b02014-09-10 21:43:52 +00004970 const RegType* field_type = nullptr;
Ian Rogers7b078e82014-09-10 14:44:24 -07004971 if (field != nullptr) {
Andreas Gampe896df402014-10-20 22:25:29 -07004972 if (kAccType == FieldAccessType::kAccPut) {
4973 if (field->IsFinal() && field->GetDeclaringClass() != GetDeclaringClass().GetClass()) {
David Sehr709b0702016-10-13 09:12:37 -07004974 Fail(VERIFY_ERROR_ACCESS_FIELD) << "cannot modify final field " << field->PrettyField()
Andreas Gampe896df402014-10-20 22:25:29 -07004975 << " from other class " << GetDeclaringClass();
Aart Bikc2bc2652016-05-23 14:58:49 -07004976 // Keep hunting for possible hard fails.
Andreas Gampe896df402014-10-20 22:25:29 -07004977 }
4978 }
4979
Mathieu Chartier3398c782016-09-30 10:27:43 -07004980 ObjPtr<mirror::Class> field_type_class =
Mathieu Chartierc7853442015-03-27 14:35:38 -07004981 can_load_classes_ ? field->GetType<true>() : field->GetType<false>();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004982 if (field_type_class != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07004983 field_type = &FromClass(field->GetTypeDescriptor(),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07004984 field_type_class.Ptr(),
Andreas Gampef23f33d2015-06-23 14:18:17 -07004985 field_type_class->CannotBeAssignedFromOtherTypes());
Mathieu Chartiereae2fb22014-01-14 14:31:25 -08004986 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07004987 DCHECK(!can_load_classes_ || self_->IsExceptionPending());
4988 self_->ClearException();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004989 }
Ian Rogers0d604842012-04-16 14:50:24 -07004990 }
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004991 if (field_type == nullptr) {
4992 const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
4993 const char* descriptor = dex_file_->GetFieldTypeDescriptor(field_id);
Mathieu Chartierbf99f772014-08-23 16:37:27 -07004994 field_type = &reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07004995 }
Sebastien Hertz757b3042014-03-28 14:34:28 +01004996 DCHECK(field_type != nullptr);
Sebastien Hertz5243e912013-05-21 10:55:07 +02004997 const uint32_t vregA = (is_static) ? inst->VRegA_21c() : inst->VRegA_22c();
Andreas Gampe896df402014-10-20 22:25:29 -07004998 static_assert(kAccType == FieldAccessType::kAccPut || kAccType == FieldAccessType::kAccGet,
4999 "Unexpected third access type");
5000 if (kAccType == FieldAccessType::kAccPut) {
5001 // sput or iput.
5002 if (is_primitive) {
5003 VerifyPrimitivePut(*field_type, insn_type, vregA);
Ian Rogersad0b3a32012-04-16 14:50:24 -07005004 } else {
David Brazdilca3c8c32016-09-06 14:04:48 +01005005 if (!insn_type.IsAssignableFrom(*field_type, this)) {
Vladimir Marko414000e2015-06-23 17:45:21 +01005006 // If the field type is not a reference, this is a global failure rather than
5007 // a class change failure as the instructions and the descriptors for the type
5008 // should have been consistent within the same file at compile time.
5009 VerifyError error = field_type->IsReferenceTypes() ? VERIFY_ERROR_BAD_CLASS_SOFT
5010 : VERIFY_ERROR_BAD_CLASS_HARD;
David Sehr709b0702016-10-13 09:12:37 -07005011 Fail(error) << "expected field " << ArtField::PrettyField(field)
Vladimir Marko414000e2015-06-23 17:45:21 +01005012 << " to be compatible with type '" << insn_type
5013 << "' but found type '" << *field_type
5014 << "' in put-object";
Andreas Gampe896df402014-10-20 22:25:29 -07005015 return;
5016 }
5017 work_line_->VerifyRegisterType(this, vregA, *field_type);
Ian Rogersad0b3a32012-04-16 14:50:24 -07005018 }
Andreas Gampe896df402014-10-20 22:25:29 -07005019 } else if (kAccType == FieldAccessType::kAccGet) {
5020 // sget or iget.
5021 if (is_primitive) {
5022 if (field_type->Equals(insn_type) ||
5023 (field_type->IsFloat() && insn_type.IsInteger()) ||
5024 (field_type->IsDouble() && insn_type.IsLong())) {
5025 // expected that read is of the correct primitive type or that int reads are reading
5026 // floats or long reads are reading doubles
5027 } else {
5028 // This is a global failure rather than a class change failure as the instructions and
5029 // the descriptors for the type should have been consistent within the same file at
5030 // compile time
David Sehr709b0702016-10-13 09:12:37 -07005031 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected field " << ArtField::PrettyField(field)
Andreas Gampe896df402014-10-20 22:25:29 -07005032 << " to be of type '" << insn_type
5033 << "' but found type '" << *field_type << "' in get";
5034 return;
5035 }
Mathieu Chartiereae2fb22014-01-14 14:31:25 -08005036 } else {
David Brazdilca3c8c32016-09-06 14:04:48 +01005037 if (!insn_type.IsAssignableFrom(*field_type, this)) {
Vladimir Marko414000e2015-06-23 17:45:21 +01005038 // If the field type is not a reference, this is a global failure rather than
5039 // a class change failure as the instructions and the descriptors for the type
5040 // should have been consistent within the same file at compile time.
5041 VerifyError error = field_type->IsReferenceTypes() ? VERIFY_ERROR_BAD_CLASS_SOFT
5042 : VERIFY_ERROR_BAD_CLASS_HARD;
David Sehr709b0702016-10-13 09:12:37 -07005043 Fail(error) << "expected field " << ArtField::PrettyField(field)
Vladimir Marko414000e2015-06-23 17:45:21 +01005044 << " to be compatible with type '" << insn_type
5045 << "' but found type '" << *field_type
5046 << "' in get-object";
Andreas Gampe890da292015-07-06 17:20:18 -07005047 if (error != VERIFY_ERROR_BAD_CLASS_HARD) {
Andreas Gampead238ce2015-08-24 21:13:08 -07005048 work_line_->SetRegisterType<LockOp::kClear>(this, vregA, reg_types_.Conflict());
Andreas Gampe890da292015-07-06 17:20:18 -07005049 }
Andreas Gampe896df402014-10-20 22:25:29 -07005050 return;
5051 }
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005052 }
Andreas Gampe896df402014-10-20 22:25:29 -07005053 if (!field_type->IsLowHalf()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07005054 work_line_->SetRegisterType<LockOp::kClear>(this, vregA, *field_type);
Andreas Gampe896df402014-10-20 22:25:29 -07005055 } else {
5056 work_line_->SetRegisterTypeWide(this, vregA, *field_type, field_type->HighHalf(&reg_types_));
5057 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07005058 } else {
Andreas Gampe896df402014-10-20 22:25:29 -07005059 LOG(FATAL) << "Unexpected case.";
Ian Rogersd81871c2011-10-03 13:57:23 -07005060 }
5061}
5062
Mathieu Chartierc7853442015-03-27 14:35:38 -07005063ArtField* MethodVerifier::GetQuickFieldAccess(const Instruction* inst,
Ian Rogers98379392014-02-24 16:53:16 -08005064 RegisterLine* reg_line) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08005065 DCHECK(IsInstructionIGetQuickOrIPutQuick(inst->Opcode())) << inst->Opcode();
Ian Rogers7b078e82014-09-10 14:44:24 -07005066 const RegType& object_type = reg_line->GetRegisterType(this, inst->VRegB_22c());
Ian Rogers9bc54402014-04-17 16:40:01 -07005067 if (!object_type.HasClass()) {
5068 VLOG(verifier) << "Failed to get mirror::Class* from '" << object_type << "'";
5069 return nullptr;
Sebastien Hertzc15853b2013-06-25 17:36:27 +02005070 }
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005071 uint32_t field_offset = static_cast<uint32_t>(inst->VRegC_22c());
Mathieu Chartierc7853442015-03-27 14:35:38 -07005072 ArtField* const f = ArtField::FindInstanceFieldWithOffset(object_type.GetClass(), field_offset);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08005073 DCHECK_EQ(f->GetOffset().Uint32Value(), field_offset);
Sebastien Hertz479fc1e2014-04-04 17:51:34 +02005074 if (f == nullptr) {
5075 VLOG(verifier) << "Failed to find instance field at offset '" << field_offset
David Sehr709b0702016-10-13 09:12:37 -07005076 << "' from '" << mirror::Class::PrettyDescriptor(object_type.GetClass()) << "'";
Sebastien Hertz479fc1e2014-04-04 17:51:34 +02005077 }
5078 return f;
Sebastien Hertzc15853b2013-06-25 17:36:27 +02005079}
5080
Andreas Gampe896df402014-10-20 22:25:29 -07005081template <MethodVerifier::FieldAccessType kAccType>
5082void MethodVerifier::VerifyQuickFieldAccess(const Instruction* inst, const RegType& insn_type,
5083 bool is_primitive) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07005084 DCHECK(Runtime::Current()->IsStarted() || verify_to_dump_);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005085
Mathieu Chartierc7853442015-03-27 14:35:38 -07005086 ArtField* field = GetQuickFieldAccess(inst, work_line_.get());
Ian Rogers7b078e82014-09-10 14:44:24 -07005087 if (field == nullptr) {
Sebastien Hertzc15853b2013-06-25 17:36:27 +02005088 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer field from " << inst->Name();
5089 return;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005090 }
Andreas Gampe896df402014-10-20 22:25:29 -07005091
5092 // For an IPUT_QUICK, we now test for final flag of the field.
5093 if (kAccType == FieldAccessType::kAccPut) {
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005094 if (field->IsFinal() && field->GetDeclaringClass() != GetDeclaringClass().GetClass()) {
David Sehr709b0702016-10-13 09:12:37 -07005095 Fail(VERIFY_ERROR_ACCESS_FIELD) << "cannot modify final field " << field->PrettyField()
Sebastien Hertzc15853b2013-06-25 17:36:27 +02005096 << " from other class " << GetDeclaringClass();
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005097 return;
5098 }
5099 }
Andreas Gampe896df402014-10-20 22:25:29 -07005100
5101 // Get the field type.
5102 const RegType* field_type;
5103 {
Mathieu Chartier3398c782016-09-30 10:27:43 -07005104 ObjPtr<mirror::Class> field_type_class = can_load_classes_ ? field->GetType<true>() :
Mathieu Chartierc7853442015-03-27 14:35:38 -07005105 field->GetType<false>();
Andreas Gampe896df402014-10-20 22:25:29 -07005106
5107 if (field_type_class != nullptr) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07005108 field_type = &FromClass(field->GetTypeDescriptor(),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07005109 field_type_class.Ptr(),
Andreas Gampef23f33d2015-06-23 14:18:17 -07005110 field_type_class->CannotBeAssignedFromOtherTypes());
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005111 } else {
Andreas Gampe896df402014-10-20 22:25:29 -07005112 Thread* self = Thread::Current();
5113 DCHECK(!can_load_classes_ || self->IsExceptionPending());
5114 self->ClearException();
5115 field_type = &reg_types_.FromDescriptor(field->GetDeclaringClass()->GetClassLoader(),
Mathieu Chartierde40d472015-10-15 17:47:48 -07005116 field->GetTypeDescriptor(),
5117 false);
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005118 }
Andreas Gampe896df402014-10-20 22:25:29 -07005119 if (field_type == nullptr) {
5120 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer field type from " << inst->Name();
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005121 return;
5122 }
Andreas Gampe896df402014-10-20 22:25:29 -07005123 }
5124
5125 const uint32_t vregA = inst->VRegA_22c();
5126 static_assert(kAccType == FieldAccessType::kAccPut || kAccType == FieldAccessType::kAccGet,
5127 "Unexpected third access type");
5128 if (kAccType == FieldAccessType::kAccPut) {
5129 if (is_primitive) {
5130 // Primitive field assignability rules are weaker than regular assignability rules
5131 bool instruction_compatible;
5132 bool value_compatible;
5133 const RegType& value_type = work_line_->GetRegisterType(this, vregA);
5134 if (field_type->IsIntegralTypes()) {
5135 instruction_compatible = insn_type.IsIntegralTypes();
5136 value_compatible = value_type.IsIntegralTypes();
5137 } else if (field_type->IsFloat()) {
5138 instruction_compatible = insn_type.IsInteger(); // no [is]put-float, so expect [is]put-int
5139 value_compatible = value_type.IsFloatTypes();
5140 } else if (field_type->IsLong()) {
5141 instruction_compatible = insn_type.IsLong();
5142 value_compatible = value_type.IsLongTypes();
5143 } else if (field_type->IsDouble()) {
5144 instruction_compatible = insn_type.IsLong(); // no [is]put-double, so expect [is]put-long
5145 value_compatible = value_type.IsDoubleTypes();
5146 } else {
5147 instruction_compatible = false; // reference field with primitive store
5148 value_compatible = false; // unused
5149 }
5150 if (!instruction_compatible) {
5151 // This is a global failure rather than a class change failure as the instructions and
5152 // the descriptors for the type should have been consistent within the same file at
5153 // compile time
David Sehr709b0702016-10-13 09:12:37 -07005154 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected field " << ArtField::PrettyField(field)
Andreas Gampe896df402014-10-20 22:25:29 -07005155 << " to be of type '" << insn_type
5156 << "' but found type '" << *field_type
5157 << "' in put";
5158 return;
5159 }
5160 if (!value_compatible) {
5161 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected value in v" << vregA
5162 << " of type " << value_type
5163 << " but expected " << *field_type
David Sehr709b0702016-10-13 09:12:37 -07005164 << " for store to " << ArtField::PrettyField(field) << " in put";
Andreas Gampe896df402014-10-20 22:25:29 -07005165 return;
5166 }
5167 } else {
David Brazdilca3c8c32016-09-06 14:04:48 +01005168 if (!insn_type.IsAssignableFrom(*field_type, this)) {
David Sehr709b0702016-10-13 09:12:37 -07005169 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "expected field " << ArtField::PrettyField(field)
Andreas Gampe896df402014-10-20 22:25:29 -07005170 << " to be compatible with type '" << insn_type
5171 << "' but found type '" << *field_type
5172 << "' in put-object";
5173 return;
5174 }
5175 work_line_->VerifyRegisterType(this, vregA, *field_type);
5176 }
5177 } else if (kAccType == FieldAccessType::kAccGet) {
5178 if (is_primitive) {
5179 if (field_type->Equals(insn_type) ||
5180 (field_type->IsFloat() && insn_type.IsIntegralTypes()) ||
5181 (field_type->IsDouble() && insn_type.IsLongTypes())) {
5182 // expected that read is of the correct primitive type or that int reads are reading
5183 // floats or long reads are reading doubles
5184 } else {
5185 // This is a global failure rather than a class change failure as the instructions and
5186 // the descriptors for the type should have been consistent within the same file at
5187 // compile time
David Sehr709b0702016-10-13 09:12:37 -07005188 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "expected field " << ArtField::PrettyField(field)
Andreas Gampe896df402014-10-20 22:25:29 -07005189 << " to be of type '" << insn_type
5190 << "' but found type '" << *field_type << "' in Get";
5191 return;
5192 }
5193 } else {
David Brazdilca3c8c32016-09-06 14:04:48 +01005194 if (!insn_type.IsAssignableFrom(*field_type, this)) {
David Sehr709b0702016-10-13 09:12:37 -07005195 Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "expected field " << ArtField::PrettyField(field)
Andreas Gampe896df402014-10-20 22:25:29 -07005196 << " to be compatible with type '" << insn_type
5197 << "' but found type '" << *field_type
5198 << "' in get-object";
Andreas Gampead238ce2015-08-24 21:13:08 -07005199 work_line_->SetRegisterType<LockOp::kClear>(this, vregA, reg_types_.Conflict());
Andreas Gampe896df402014-10-20 22:25:29 -07005200 return;
5201 }
5202 }
5203 if (!field_type->IsLowHalf()) {
Andreas Gampead238ce2015-08-24 21:13:08 -07005204 work_line_->SetRegisterType<LockOp::kClear>(this, vregA, *field_type);
Andreas Gampe896df402014-10-20 22:25:29 -07005205 } else {
5206 work_line_->SetRegisterTypeWide(this, vregA, *field_type, field_type->HighHalf(&reg_types_));
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005207 }
5208 } else {
Andreas Gampe896df402014-10-20 22:25:29 -07005209 LOG(FATAL) << "Unexpected case.";
Sebastien Hertz2d6ba512013-05-17 11:31:37 +02005210 }
5211}
5212
Ian Rogers776ac1f2012-04-13 23:36:36 -07005213bool MethodVerifier::CheckNotMoveException(const uint16_t* insns, int insn_idx) {
Ian Rogersd81871c2011-10-03 13:57:23 -07005214 if ((insns[insn_idx] & 0xff) == Instruction::MOVE_EXCEPTION) {
jeffhaod5347e02012-03-22 17:25:05 -07005215 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid use of move-exception";
Ian Rogersd81871c2011-10-03 13:57:23 -07005216 return false;
5217 }
5218 return true;
5219}
5220
Stephen Kyle9bc61992014-09-22 13:53:15 +01005221bool MethodVerifier::CheckNotMoveResult(const uint16_t* insns, int insn_idx) {
5222 if (((insns[insn_idx] & 0xff) >= Instruction::MOVE_RESULT) &&
5223 ((insns[insn_idx] & 0xff) <= Instruction::MOVE_RESULT_OBJECT)) {
5224 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid use of move-result*";
5225 return false;
5226 }
5227 return true;
5228}
5229
5230bool MethodVerifier::CheckNotMoveExceptionOrMoveResult(const uint16_t* insns, int insn_idx) {
5231 return (CheckNotMoveException(insns, insn_idx) && CheckNotMoveResult(insns, insn_idx));
5232}
5233
Ian Rogersebbdd872014-07-07 23:53:08 -07005234bool MethodVerifier::UpdateRegisters(uint32_t next_insn, RegisterLine* merge_line,
5235 bool update_merge_line) {
Ian Rogersd81871c2011-10-03 13:57:23 -07005236 bool changed = true;
5237 RegisterLine* target_line = reg_table_.GetLine(next_insn);
Mathieu Chartierde40d472015-10-15 17:47:48 -07005238 if (!GetInstructionFlags(next_insn).IsVisitedOrChanged()) {
jeffhaobdb76512011-09-07 11:43:16 -07005239 /*
Ian Rogersd81871c2011-10-03 13:57:23 -07005240 * We haven't processed this instruction before, and we haven't touched the registers here, so
5241 * there's nothing to "merge". Copy the registers over and mark it as changed. (This is the
5242 * only way a register can transition out of "unknown", so this is not just an optimization.)
jeffhaobdb76512011-09-07 11:43:16 -07005243 */
Andreas Gampea727e372015-08-25 09:22:37 -07005244 target_line->CopyFromLine(merge_line);
Mathieu Chartierde40d472015-10-15 17:47:48 -07005245 if (GetInstructionFlags(next_insn).IsReturn()) {
Jeff Haob24b4a72013-07-31 13:47:31 -07005246 // Verify that the monitor stack is empty on return.
Andreas Gampea727e372015-08-25 09:22:37 -07005247 merge_line->VerifyMonitorStackEmpty(this);
5248
Ian Rogersb8c78592013-07-25 23:52:52 +00005249 // For returns we only care about the operand to the return, all other registers are dead.
5250 // Initialize them as conflicts so they don't add to GC and deoptimization information.
5251 const Instruction* ret_inst = Instruction::At(code_item_->insns_ + next_insn);
Andreas Gampea727e372015-08-25 09:22:37 -07005252 AdjustReturnLine(this, ret_inst, target_line);
Aart Bik31883642016-06-06 15:02:44 -07005253 // Directly bail if a hard failure was found.
Aart Bikb0526322016-06-01 14:06:00 -07005254 if (have_pending_hard_failure_) {
5255 return false;
5256 }
Ian Rogersb8c78592013-07-25 23:52:52 +00005257 }
jeffhaobdb76512011-09-07 11:43:16 -07005258 } else {
Mathieu Chartier361e04a2016-02-16 14:06:35 -08005259 RegisterLineArenaUniquePtr copy;
Andreas Gampeec6e6c12015-11-05 20:39:56 -08005260 if (kDebugVerify) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07005261 copy.reset(RegisterLine::Create(target_line->NumRegs(), this));
Ian Rogers7b0c5b42012-02-16 15:29:07 -08005262 copy->CopyFromLine(target_line);
5263 }
Ian Rogers7b078e82014-09-10 14:44:24 -07005264 changed = target_line->MergeRegisters(this, merge_line);
Ian Rogersad0b3a32012-04-16 14:50:24 -07005265 if (have_pending_hard_failure_) {
Ian Rogersd81871c2011-10-03 13:57:23 -07005266 return false;
jeffhaobdb76512011-09-07 11:43:16 -07005267 }
Andreas Gampeec6e6c12015-11-05 20:39:56 -08005268 if (kDebugVerify && changed) {
Elliott Hughes398f64b2012-03-26 18:05:48 -07005269 LogVerifyInfo() << "Merging at [" << reinterpret_cast<void*>(work_insn_idx_) << "]"
Elliott Hughesc073b072012-05-24 19:29:17 -07005270 << " to [" << reinterpret_cast<void*>(next_insn) << "]: " << "\n"
Ian Rogers7b078e82014-09-10 14:44:24 -07005271 << copy->Dump(this) << " MERGE\n"
5272 << merge_line->Dump(this) << " ==\n"
5273 << target_line->Dump(this) << "\n";
jeffhaobdb76512011-09-07 11:43:16 -07005274 }
Ian Rogersebbdd872014-07-07 23:53:08 -07005275 if (update_merge_line && changed) {
5276 merge_line->CopyFromLine(target_line);
5277 }
jeffhaobdb76512011-09-07 11:43:16 -07005278 }
Ian Rogersd81871c2011-10-03 13:57:23 -07005279 if (changed) {
Mathieu Chartierde40d472015-10-15 17:47:48 -07005280 GetInstructionFlags(next_insn).SetChanged();
jeffhaobdb76512011-09-07 11:43:16 -07005281 }
5282 return true;
5283}
5284
Ian Rogers7b3ddd22013-02-21 15:19:52 -08005285InstructionFlags* MethodVerifier::CurrentInsnFlags() {
Mathieu Chartierde40d472015-10-15 17:47:48 -07005286 return &GetInstructionFlags(work_insn_idx_);
Ian Rogers776ac1f2012-04-13 23:36:36 -07005287}
5288
Ian Rogersd8f69b02014-09-10 21:43:52 +00005289const RegType& MethodVerifier::GetMethodReturnType() {
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005290 if (return_type_ == nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07005291 if (mirror_method_ != nullptr) {
Vladimir Marko942fd312017-01-16 20:52:19 +00005292 mirror::Class* return_type_class = mirror_method_->GetReturnType(can_load_classes_);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005293 if (return_type_class != nullptr) {
Andreas Gampef23f33d2015-06-23 14:18:17 -07005294 return_type_ = &FromClass(mirror_method_->GetReturnTypeDescriptor(),
5295 return_type_class,
5296 return_type_class->CannotBeAssignedFromOtherTypes());
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005297 } else {
Ian Rogers7b078e82014-09-10 14:44:24 -07005298 DCHECK(!can_load_classes_ || self_->IsExceptionPending());
5299 self_->ClearException();
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005300 }
5301 }
5302 if (return_type_ == nullptr) {
5303 const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
5304 const DexFile::ProtoId& proto_id = dex_file_->GetMethodPrototype(method_id);
Andreas Gampea5b09a62016-11-17 15:21:22 -08005305 dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005306 const char* descriptor = dex_file_->GetTypeDescriptor(dex_file_->GetTypeId(return_type_idx));
Mathieu Chartierbf99f772014-08-23 16:37:27 -07005307 return_type_ = &reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogersfc0e94b2013-09-23 23:51:32 -07005308 }
5309 }
5310 return *return_type_;
Ian Rogersad0b3a32012-04-16 14:50:24 -07005311}
5312
Ian Rogersd8f69b02014-09-10 21:43:52 +00005313const RegType& MethodVerifier::GetDeclaringClass() {
Ian Rogers7b078e82014-09-10 14:44:24 -07005314 if (declaring_class_ == nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005315 const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
Brian Carlstrom93c33962013-07-26 10:37:43 -07005316 const char* descriptor
5317 = dex_file_->GetTypeDescriptor(dex_file_->GetTypeId(method_id.class_idx_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07005318 if (mirror_method_ != nullptr) {
Ian Rogers637c65b2013-05-31 11:46:00 -07005319 mirror::Class* klass = mirror_method_->GetDeclaringClass();
Mathieu Chartierde40d472015-10-15 17:47:48 -07005320 declaring_class_ = &FromClass(descriptor, klass, klass->CannotBeAssignedFromOtherTypes());
Ian Rogers637c65b2013-05-31 11:46:00 -07005321 } else {
Mathieu Chartierbf99f772014-08-23 16:37:27 -07005322 declaring_class_ = &reg_types_.FromDescriptor(GetClassLoader(), descriptor, false);
Ian Rogers637c65b2013-05-31 11:46:00 -07005323 }
Ian Rogersad0b3a32012-04-16 14:50:24 -07005324 }
Ian Rogers637c65b2013-05-31 11:46:00 -07005325 return *declaring_class_;
Ian Rogersad0b3a32012-04-16 14:50:24 -07005326}
5327
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005328std::vector<int32_t> MethodVerifier::DescribeVRegs(uint32_t dex_pc) {
5329 RegisterLine* line = reg_table_.GetLine(dex_pc);
Sebastien Hertzaa0c00c2014-03-14 17:58:54 +01005330 DCHECK(line != nullptr) << "No register line at DEX pc " << StringPrintf("0x%x", dex_pc);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005331 std::vector<int32_t> result;
5332 for (size_t i = 0; i < line->NumRegs(); ++i) {
Ian Rogers7b078e82014-09-10 14:44:24 -07005333 const RegType& type = line->GetRegisterType(this, i);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005334 if (type.IsConstant()) {
5335 result.push_back(type.IsPreciseConstant() ? kConstant : kImpreciseConstant);
Ian Rogers7b078e82014-09-10 14:44:24 -07005336 const ConstantType* const_val = down_cast<const ConstantType*>(&type);
5337 result.push_back(const_val->ConstantValue());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005338 } else if (type.IsConstantLo()) {
5339 result.push_back(type.IsPreciseConstantLo() ? kConstant : kImpreciseConstant);
Ian Rogers7b078e82014-09-10 14:44:24 -07005340 const ConstantType* const_val = down_cast<const ConstantType*>(&type);
5341 result.push_back(const_val->ConstantValueLo());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005342 } else if (type.IsConstantHi()) {
5343 result.push_back(type.IsPreciseConstantHi() ? kConstant : kImpreciseConstant);
Ian Rogers7b078e82014-09-10 14:44:24 -07005344 const ConstantType* const_val = down_cast<const ConstantType*>(&type);
5345 result.push_back(const_val->ConstantValueHi());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005346 } else if (type.IsIntegralTypes()) {
5347 result.push_back(kIntVReg);
5348 result.push_back(0);
5349 } else if (type.IsFloat()) {
5350 result.push_back(kFloatVReg);
5351 result.push_back(0);
5352 } else if (type.IsLong()) {
5353 result.push_back(kLongLoVReg);
5354 result.push_back(0);
5355 result.push_back(kLongHiVReg);
5356 result.push_back(0);
5357 ++i;
5358 } else if (type.IsDouble()) {
5359 result.push_back(kDoubleLoVReg);
5360 result.push_back(0);
5361 result.push_back(kDoubleHiVReg);
5362 result.push_back(0);
5363 ++i;
5364 } else if (type.IsUndefined() || type.IsConflict() || type.IsHighHalf()) {
5365 result.push_back(kUndefined);
5366 result.push_back(0);
5367 } else {
Ian Rogers7b3ddd22013-02-21 15:19:52 -08005368 CHECK(type.IsNonZeroReferenceTypes());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08005369 result.push_back(kReferenceVReg);
5370 result.push_back(0);
5371 }
5372 }
5373 return result;
5374}
5375
Ian Rogersd8f69b02014-09-10 21:43:52 +00005376const RegType& MethodVerifier::DetermineCat1Constant(int32_t value, bool precise) {
Sebastien Hertz849600b2013-12-20 10:28:08 +01005377 if (precise) {
5378 // Precise constant type.
5379 return reg_types_.FromCat1Const(value, true);
5380 } else {
5381 // Imprecise constant type.
5382 if (value < -32768) {
5383 return reg_types_.IntConstant();
5384 } else if (value < -128) {
5385 return reg_types_.ShortConstant();
5386 } else if (value < 0) {
5387 return reg_types_.ByteConstant();
5388 } else if (value == 0) {
5389 return reg_types_.Zero();
5390 } else if (value == 1) {
5391 return reg_types_.One();
5392 } else if (value < 128) {
5393 return reg_types_.PosByteConstant();
5394 } else if (value < 32768) {
5395 return reg_types_.PosShortConstant();
5396 } else if (value < 65536) {
5397 return reg_types_.CharConstant();
5398 } else {
5399 return reg_types_.IntConstant();
5400 }
5401 }
5402}
5403
Elliott Hughes0a1038b2012-06-14 16:24:17 -07005404void MethodVerifier::Init() {
Sameer Abu Asal51a5fb72013-02-19 14:25:01 -08005405 art::verifier::RegTypeCache::Init();
Brian Carlstrome7d856b2012-01-11 18:10:55 -08005406}
5407
Elliott Hughes0a1038b2012-06-14 16:24:17 -07005408void MethodVerifier::Shutdown() {
Sameer Abu Asal51a5fb72013-02-19 14:25:01 -08005409 verifier::RegTypeCache::ShutDown();
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08005410}
jeffhaod1224c72012-02-29 13:43:08 -08005411
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07005412void MethodVerifier::VisitStaticRoots(RootVisitor* visitor) {
5413 RegTypeCache::VisitStaticRoots(visitor);
Mathieu Chartier7c438b12014-09-12 17:01:24 -07005414}
5415
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07005416void MethodVerifier::VisitRoots(RootVisitor* visitor, const RootInfo& root_info) {
5417 reg_types_.VisitRoots(visitor, root_info);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08005418}
5419
Andreas Gampef23f33d2015-06-23 14:18:17 -07005420const RegType& MethodVerifier::FromClass(const char* descriptor,
5421 mirror::Class* klass,
5422 bool precise) {
5423 DCHECK(klass != nullptr);
5424 if (precise && !klass->IsInstantiable() && !klass->IsPrimitive()) {
5425 Fail(VerifyError::VERIFY_ERROR_NO_CLASS) << "Could not create precise reference for "
5426 << "non-instantiable klass " << descriptor;
5427 precise = false;
5428 }
5429 return reg_types_.FromClass(descriptor, klass, precise);
5430}
5431
Ian Rogersd81871c2011-10-03 13:57:23 -07005432} // namespace verifier
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07005433} // namespace art