Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 1 | /* |
| 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 | */ |
| 16 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 17 | #include "art_method.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 18 | |
Andreas Gampe | 479b1de | 2016-07-19 18:27:17 -0700 | [diff] [blame] | 19 | #include <cstddef> |
| 20 | |
Ian Rogers | e63db27 | 2014-07-15 15:36:11 -0700 | [diff] [blame] | 21 | #include "arch/context.h" |
Ian Rogers | 62f0512 | 2014-03-21 11:21:29 -0700 | [diff] [blame] | 22 | #include "art_field-inl.h" |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 23 | #include "art_method-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 24 | #include "base/stringpiece.h" |
Hiroshi Yamauchi | 0037082 | 2015-08-18 14:47:25 -0700 | [diff] [blame] | 25 | #include "class_linker-inl.h" |
Andreas Gampe | 2a5c468 | 2015-08-14 08:22:54 -0700 | [diff] [blame] | 26 | #include "debugger.h" |
Ian Rogers | 4f6ad8a | 2013-03-18 15:27:28 -0700 | [diff] [blame] | 27 | #include "dex_file-inl.h" |
Ian Rogers | c449aa8 | 2013-07-29 14:35:46 -0700 | [diff] [blame] | 28 | #include "dex_instruction.h" |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 29 | #include "entrypoints/runtime_asm_entrypoints.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 30 | #include "gc/accounting/card_table-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 31 | #include "interpreter/interpreter.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 32 | #include "jit/jit.h" |
| 33 | #include "jit/jit_code_cache.h" |
Nicolas Geoffray | 5550ca8 | 2015-08-21 18:38:30 +0100 | [diff] [blame] | 34 | #include "jit/profiling_info.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 35 | #include "jni_internal.h" |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 36 | #include "mirror/abstract_method.h" |
| 37 | #include "mirror/class-inl.h" |
| 38 | #include "mirror/object_array-inl.h" |
| 39 | #include "mirror/object-inl.h" |
| 40 | #include "mirror/string.h" |
Nicolas Geoffray | 9523a3e | 2015-07-17 11:51:28 +0000 | [diff] [blame] | 41 | #include "oat_file-inl.h" |
Ian Rogers | 62f0512 | 2014-03-21 11:21:29 -0700 | [diff] [blame] | 42 | #include "scoped_thread_state_change.h" |
Ian Rogers | 62f0512 | 2014-03-21 11:21:29 -0700 | [diff] [blame] | 43 | #include "well_known_classes.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 44 | |
| 45 | namespace art { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 46 | |
Ian Rogers | 0177e53 | 2014-02-11 16:30:46 -0800 | [diff] [blame] | 47 | extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, |
| 48 | const char*); |
Ian Rogers | 936b37f | 2014-02-14 00:52:24 -0800 | [diff] [blame] | 49 | extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, |
| 50 | const char*); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 51 | |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 52 | ArtMethod* ArtMethod::FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa, |
| 53 | jobject jlr_method) { |
Mathieu Chartier | fc58af4 | 2015-04-16 18:00:39 -0700 | [diff] [blame] | 54 | auto* abstract_method = soa.Decode<mirror::AbstractMethod*>(jlr_method); |
| 55 | DCHECK(abstract_method != nullptr); |
| 56 | return abstract_method->GetArtMethod(); |
Ian Rogers | 62f0512 | 2014-03-21 11:21:29 -0700 | [diff] [blame] | 57 | } |
| 58 | |
Ian Rogers | 6b14d55 | 2014-10-28 21:50:58 -0700 | [diff] [blame] | 59 | mirror::String* ArtMethod::GetNameAsString(Thread* self) { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 60 | CHECK(!IsProxyMethod()); |
Ian Rogers | 6b14d55 | 2014-10-28 21:50:58 -0700 | [diff] [blame] | 61 | StackHandleScope<1> hs(self); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 62 | Handle<mirror::DexCache> dex_cache(hs.NewHandle(GetDexCache())); |
| 63 | auto* dex_file = dex_cache->GetDexFile(); |
| 64 | uint32_t dex_method_idx = GetDexMethodIndex(); |
| 65 | const DexFile::MethodId& method_id = dex_file->GetMethodId(dex_method_idx); |
Ian Rogers | 6b14d55 | 2014-10-28 21:50:58 -0700 | [diff] [blame] | 66 | return Runtime::Current()->GetClassLinker()->ResolveString(*dex_file, method_id.name_idx_, |
| 67 | dex_cache); |
| 68 | } |
| 69 | |
Alex Light | 9139e00 | 2015-10-09 15:59:48 -0700 | [diff] [blame] | 70 | void ArtMethod::ThrowInvocationTimeError() { |
| 71 | DCHECK(!IsInvokable()); |
| 72 | // NOTE: IsDefaultConflicting must be first since the actual method might or might not be abstract |
| 73 | // due to the way we select it. |
| 74 | if (IsDefaultConflicting()) { |
| 75 | ThrowIncompatibleClassChangeErrorForMethodConflict(this); |
| 76 | } else { |
| 77 | DCHECK(IsAbstract()); |
| 78 | ThrowAbstractMethodError(this); |
| 79 | } |
| 80 | } |
| 81 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 82 | InvokeType ArtMethod::GetInvokeType() { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 83 | // TODO: kSuper? |
Nicolas Geoffray | 3aaf964 | 2016-06-07 14:14:37 +0000 | [diff] [blame] | 84 | if (IsStatic()) { |
Nicolas Geoffray | 12abcbd | 2016-06-06 15:51:58 +0000 | [diff] [blame] | 85 | return kStatic; |
Nicolas Geoffray | 3aaf964 | 2016-06-07 14:14:37 +0000 | [diff] [blame] | 86 | } else if (GetDeclaringClass()->IsInterface()) { |
| 87 | return kInterface; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 88 | } else if (IsDirect()) { |
| 89 | return kDirect; |
| 90 | } else { |
| 91 | return kVirtual; |
| 92 | } |
| 93 | } |
| 94 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 95 | size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) { |
Ian Rogers | 6b604a1 | 2014-09-25 15:35:37 -0700 | [diff] [blame] | 96 | CHECK_LE(1U, shorty.length()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 97 | uint32_t num_registers = 0; |
Ian Rogers | 6b604a1 | 2014-09-25 15:35:37 -0700 | [diff] [blame] | 98 | for (size_t i = 1; i < shorty.length(); ++i) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 99 | char ch = shorty[i]; |
| 100 | if (ch == 'D' || ch == 'J') { |
| 101 | num_registers += 2; |
| 102 | } else { |
| 103 | num_registers += 1; |
| 104 | } |
| 105 | } |
| 106 | return num_registers; |
| 107 | } |
| 108 | |
Alex Light | 6c8467f | 2015-11-20 15:03:26 -0800 | [diff] [blame] | 109 | bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) { |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 110 | ScopedAssertNoThreadSuspension ants(Thread::Current(), "HasSameNameAndSignature"); |
Alex Light | 6c8467f | 2015-11-20 15:03:26 -0800 | [diff] [blame] | 111 | const DexFile* dex_file = GetDexFile(); |
| 112 | const DexFile::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex()); |
| 113 | if (GetDexCache() == other->GetDexCache()) { |
| 114 | const DexFile::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex()); |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 115 | return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_; |
| 116 | } |
Alex Light | 6c8467f | 2015-11-20 15:03:26 -0800 | [diff] [blame] | 117 | const DexFile* dex_file2 = other->GetDexFile(); |
| 118 | const DexFile::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex()); |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 119 | if (!DexFileStringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) { |
| 120 | return false; // Name mismatch. |
| 121 | } |
| 122 | return dex_file->GetMethodSignature(mid) == dex_file2->GetMethodSignature(mid2); |
| 123 | } |
| 124 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 125 | ArtMethod* ArtMethod::FindOverriddenMethod(PointerSize pointer_size) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 126 | if (IsStatic()) { |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 127 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 128 | } |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 129 | mirror::Class* declaring_class = GetDeclaringClass(); |
| 130 | mirror::Class* super_class = declaring_class->GetSuperClass(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 131 | uint16_t method_index = GetMethodIndex(); |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 132 | ArtMethod* result = nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 133 | // Did this method override a super class method? If so load the result from the super class' |
| 134 | // vtable |
Mingyao Yang | 2cdbad7 | 2014-07-16 10:44:41 -0700 | [diff] [blame] | 135 | if (super_class->HasVTable() && method_index < super_class->GetVTableLength()) { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 136 | result = super_class->GetVTableEntry(method_index, pointer_size); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 137 | } else { |
| 138 | // Method didn't override superclass method so search interfaces |
| 139 | if (IsProxyMethod()) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 140 | result = mirror::DexCache::GetElementPtrSize(GetDexCacheResolvedMethods(pointer_size), |
| 141 | GetDexMethodIndex(), |
| 142 | pointer_size); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 143 | CHECK_EQ(result, |
| 144 | Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this)); |
| 145 | } else { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 146 | mirror::IfTable* iftable = GetDeclaringClass()->GetIfTable(); |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 147 | for (size_t i = 0; i < iftable->Count() && result == nullptr; i++) { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 148 | mirror::Class* interface = iftable->GetInterface(i); |
Alex Light | 51a64d5 | 2015-12-17 13:55:59 -0800 | [diff] [blame] | 149 | for (ArtMethod& interface_method : interface->GetVirtualMethods(pointer_size)) { |
| 150 | if (HasSameNameAndSignature(interface_method.GetInterfaceMethodIfProxy(pointer_size))) { |
| 151 | result = &interface_method; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 152 | break; |
| 153 | } |
| 154 | } |
| 155 | } |
| 156 | } |
| 157 | } |
Alex Light | 6c8467f | 2015-11-20 15:03:26 -0800 | [diff] [blame] | 158 | DCHECK(result == nullptr || |
Alex Light | 51a64d5 | 2015-12-17 13:55:59 -0800 | [diff] [blame] | 159 | GetInterfaceMethodIfProxy(pointer_size)->HasSameNameAndSignature( |
| 160 | result->GetInterfaceMethodIfProxy(pointer_size))); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 161 | return result; |
| 162 | } |
| 163 | |
Ian Rogers | e0a02da | 2014-12-02 14:10:53 -0800 | [diff] [blame] | 164 | uint32_t ArtMethod::FindDexMethodIndexInOtherDexFile(const DexFile& other_dexfile, |
| 165 | uint32_t name_and_signature_idx) { |
| 166 | const DexFile* dexfile = GetDexFile(); |
| 167 | const uint32_t dex_method_idx = GetDexMethodIndex(); |
| 168 | const DexFile::MethodId& mid = dexfile->GetMethodId(dex_method_idx); |
| 169 | const DexFile::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx); |
| 170 | DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid)); |
| 171 | DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid)); |
| 172 | if (dexfile == &other_dexfile) { |
| 173 | return dex_method_idx; |
| 174 | } |
| 175 | const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_); |
Mathieu Chartier | 9507fa2 | 2015-10-29 15:08:57 -0700 | [diff] [blame] | 176 | const DexFile::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor); |
| 177 | if (other_type_id != nullptr) { |
| 178 | const DexFile::MethodId* other_mid = other_dexfile.FindMethodId( |
| 179 | *other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_), |
| 180 | other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_)); |
| 181 | if (other_mid != nullptr) { |
| 182 | return other_dexfile.GetIndexForMethodId(*other_mid); |
Ian Rogers | e0a02da | 2014-12-02 14:10:53 -0800 | [diff] [blame] | 183 | } |
| 184 | } |
| 185 | return DexFile::kDexNoIndex; |
| 186 | } |
| 187 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 188 | uint32_t ArtMethod::FindCatchBlock(Handle<mirror::Class> exception_type, |
Mathieu Chartier | bfd9a43 | 2014-05-21 17:43:44 -0700 | [diff] [blame] | 189 | uint32_t dex_pc, bool* has_no_move_exception) { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 190 | const DexFile::CodeItem* code_item = GetCodeItem(); |
Jeff Hao | aa96191 | 2014-04-22 13:54:32 -0700 | [diff] [blame] | 191 | // Set aside the exception while we resolve its type. |
| 192 | Thread* self = Thread::Current(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 193 | StackHandleScope<1> hs(self); |
Nicolas Geoffray | 14691c5 | 2015-03-05 10:40:17 +0000 | [diff] [blame] | 194 | Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException())); |
Jeff Hao | aa96191 | 2014-04-22 13:54:32 -0700 | [diff] [blame] | 195 | self->ClearException(); |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 196 | // Default to handler not found. |
| 197 | uint32_t found_dex_pc = DexFile::kDexNoIndex; |
| 198 | // Iterate over the catch handlers associated with dex_pc. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 199 | PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 200 | for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) { |
| 201 | uint16_t iter_type_idx = it.GetHandlerTypeIndex(); |
| 202 | // Catch all case |
| 203 | if (iter_type_idx == DexFile::kDexNoIndex16) { |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 204 | found_dex_pc = it.GetHandlerAddress(); |
| 205 | break; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 206 | } |
| 207 | // Does this catch exception type apply? |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 208 | mirror::Class* iter_exception_type = GetClassFromTypeIndex(iter_type_idx, |
| 209 | true /* resolve */, |
| 210 | pointer_size); |
Ian Rogers | 822266b | 2014-05-29 16:55:06 -0700 | [diff] [blame] | 211 | if (UNLIKELY(iter_exception_type == nullptr)) { |
| 212 | // Now have a NoClassDefFoundError as exception. Ignore in case the exception class was |
| 213 | // removed by a pro-guard like tool. |
Andreas Gampe | 72b3e43 | 2014-05-13 21:42:05 -0700 | [diff] [blame] | 214 | // Note: this is not RI behavior. RI would have failed when loading the class. |
Ian Rogers | 822266b | 2014-05-29 16:55:06 -0700 | [diff] [blame] | 215 | self->ClearException(); |
| 216 | // Delete any long jump context as this routine is called during a stack walk which will |
| 217 | // release its in use context at the end. |
| 218 | delete self->GetLongJumpContext(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 219 | LOG(WARNING) << "Unresolved exception class when finding catch block: " |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 220 | << DescriptorToDot(GetTypeDescriptorFromTypeIdx(iter_type_idx)); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 221 | } else if (iter_exception_type->IsAssignableFrom(exception_type.Get())) { |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 222 | found_dex_pc = it.GetHandlerAddress(); |
| 223 | break; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 224 | } |
| 225 | } |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 226 | if (found_dex_pc != DexFile::kDexNoIndex) { |
| 227 | const Instruction* first_catch_instr = |
Jeff Hao | aa96191 | 2014-04-22 13:54:32 -0700 | [diff] [blame] | 228 | Instruction::At(&code_item->insns_[found_dex_pc]); |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 229 | *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION); |
| 230 | } |
Jeff Hao | aa96191 | 2014-04-22 13:54:32 -0700 | [diff] [blame] | 231 | // Put the exception back. |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 232 | if (exception.Get() != nullptr) { |
Nicolas Geoffray | 14691c5 | 2015-03-05 10:40:17 +0000 | [diff] [blame] | 233 | self->SetException(exception.Get()); |
Jeff Hao | aa96191 | 2014-04-22 13:54:32 -0700 | [diff] [blame] | 234 | } |
Ian Rogers | 9e8f45e | 2013-07-31 10:58:53 -0700 | [diff] [blame] | 235 | return found_dex_pc; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 236 | } |
| 237 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 238 | void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, |
Ian Rogers | 0177e53 | 2014-02-11 16:30:46 -0800 | [diff] [blame] | 239 | const char* shorty) { |
Dave Allison | 648d711 | 2014-07-25 16:15:27 -0700 | [diff] [blame] | 240 | if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) { |
| 241 | ThrowStackOverflowError(self); |
| 242 | return; |
| 243 | } |
| 244 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 245 | if (kIsDebugBuild) { |
| 246 | self->AssertThreadSuspensionIsAllowable(); |
| 247 | CHECK_EQ(kRunnable, self->GetState()); |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 248 | CHECK_STREQ(GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetShorty(), shorty); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | // Push a transition back into managed code onto the linked list in thread. |
| 252 | ManagedStack fragment; |
| 253 | self->PushManagedStackFragment(&fragment); |
| 254 | |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 255 | Runtime* runtime = Runtime::Current(); |
Jeff Hao | 74180ca | 2013-03-27 15:29:11 -0700 | [diff] [blame] | 256 | // Call the invoke stub, passing everything as arguments. |
Daniel Mihalyi | eb07669 | 2014-08-22 17:33:31 +0200 | [diff] [blame] | 257 | // If the runtime is not yet started or it is required by the debugger, then perform the |
Aart Bik | 0122320 | 2016-05-05 15:10:42 -0700 | [diff] [blame] | 258 | // Invocation by the interpreter, explicitly forcing interpretation over JIT to prevent |
| 259 | // cycling around the various JIT/Interpreter methods that handle method invocation. |
Daniel Mihalyi | eb07669 | 2014-08-22 17:33:31 +0200 | [diff] [blame] | 260 | if (UNLIKELY(!runtime->IsStarted() || Dbg::IsForcedInterpreterNeededForCalling(self, this))) { |
Ian Rogers | 5d27faf | 2014-05-02 17:17:18 -0700 | [diff] [blame] | 261 | if (IsStatic()) { |
Aart Bik | 0122320 | 2016-05-05 15:10:42 -0700 | [diff] [blame] | 262 | art::interpreter::EnterInterpreterFromInvoke( |
| 263 | self, this, nullptr, args, result, /*stay_in_interpreter*/ true); |
Ian Rogers | 5d27faf | 2014-05-02 17:17:18 -0700 | [diff] [blame] | 264 | } else { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 265 | mirror::Object* receiver = |
| 266 | reinterpret_cast<StackReference<mirror::Object>*>(&args[0])->AsMirrorPtr(); |
Aart Bik | 0122320 | 2016-05-05 15:10:42 -0700 | [diff] [blame] | 267 | art::interpreter::EnterInterpreterFromInvoke( |
| 268 | self, this, receiver, args + 1, result, /*stay_in_interpreter*/ true); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 269 | } |
| 270 | } else { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 271 | DCHECK_EQ(runtime->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 272 | |
| 273 | constexpr bool kLogInvocationStartAndReturn = false; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 274 | bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr; |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 275 | if (LIKELY(have_quick_code)) { |
Jeff Hao | 790ad90 | 2013-05-22 15:02:08 -0700 | [diff] [blame] | 276 | if (kLogInvocationStartAndReturn) { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 277 | LOG(INFO) << StringPrintf( |
| 278 | "Invoking '%s' quick code=%p static=%d", PrettyMethod(this).c_str(), |
| 279 | GetEntryPointFromQuickCompiledCode(), static_cast<int>(IsStatic() ? 1 : 0)); |
Jeff Hao | 790ad90 | 2013-05-22 15:02:08 -0700 | [diff] [blame] | 280 | } |
Hiroshi Yamauchi | 9bdec88 | 2014-08-15 17:11:12 -0700 | [diff] [blame] | 281 | |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 282 | // Ensure that we won't be accidentally calling quick compiled code when -Xint. |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 283 | if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) { |
Calin Juravle | ffc8707 | 2016-04-20 14:22:09 +0100 | [diff] [blame] | 284 | CHECK(!runtime->UseJitCompilation()); |
Nicolas Geoffray | 6bc4374 | 2015-10-12 18:11:10 +0100 | [diff] [blame] | 285 | const void* oat_quick_code = runtime->GetClassLinker()->GetOatMethodQuickCodeFor(this); |
| 286 | CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode()) |
Hiroshi Yamauchi | 9bdec88 | 2014-08-15 17:11:12 -0700 | [diff] [blame] | 287 | << "Don't call compiled code when -Xint " << PrettyMethod(this); |
| 288 | } |
| 289 | |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 290 | if (!IsStatic()) { |
Ian Rogers | 0177e53 | 2014-02-11 16:30:46 -0800 | [diff] [blame] | 291 | (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 292 | } else { |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 293 | (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 294 | } |
Nicolas Geoffray | 14691c5 | 2015-03-05 10:40:17 +0000 | [diff] [blame] | 295 | if (UNLIKELY(self->GetException() == Thread::GetDeoptimizationException())) { |
Sebastien Hertz | fd3077e | 2014-04-23 10:32:43 +0200 | [diff] [blame] | 296 | // Unusual case where we were running generated code and an |
Jeff Hao | 790ad90 | 2013-05-22 15:02:08 -0700 | [diff] [blame] | 297 | // exception was thrown to force the activations to be removed from the |
| 298 | // stack. Continue execution in the interpreter. |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 299 | self->DeoptimizeWithDeoptimizationException(result); |
Jeff Hao | 790ad90 | 2013-05-22 15:02:08 -0700 | [diff] [blame] | 300 | } |
| 301 | if (kLogInvocationStartAndReturn) { |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 302 | LOG(INFO) << StringPrintf("Returned '%s' quick code=%p", PrettyMethod(this).c_str(), |
| 303 | GetEntryPointFromQuickCompiledCode()); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 304 | } |
| 305 | } else { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 306 | LOG(INFO) << "Not invoking '" << PrettyMethod(this) << "' code=null"; |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 307 | if (result != nullptr) { |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 308 | result->SetJ(0); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 309 | } |
| 310 | } |
| 311 | } |
| 312 | |
| 313 | // Pop transition. |
| 314 | self->PopManagedStackFragment(fragment); |
| 315 | } |
| 316 | |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 317 | void ArtMethod::RegisterNative(const void* native_method, bool is_fast) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 318 | CHECK(IsNative()) << PrettyMethod(this); |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 319 | CHECK(!IsFastNative()) << PrettyMethod(this); |
Ian Rogers | f224751 | 2014-12-02 16:17:08 -0800 | [diff] [blame] | 320 | CHECK(native_method != nullptr) << PrettyMethod(this); |
Ian Rogers | 987560f | 2014-04-22 11:42:59 -0700 | [diff] [blame] | 321 | if (is_fast) { |
| 322 | SetAccessFlags(GetAccessFlags() | kAccFastNative); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 323 | } |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 324 | SetEntryPointFromJni(native_method); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 325 | } |
| 326 | |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 327 | void ArtMethod::UnregisterNative() { |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 328 | CHECK(IsNative() && !IsFastNative()) << PrettyMethod(this); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 329 | // restore stub to lookup native pointer via dlsym |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 330 | RegisterNative(GetJniDlsymLookupStub(), false); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 331 | } |
| 332 | |
Alex Light | 9139e00 | 2015-10-09 15:59:48 -0700 | [diff] [blame] | 333 | bool ArtMethod::IsOverridableByDefaultMethod() { |
| 334 | return GetDeclaringClass()->IsInterface(); |
| 335 | } |
| 336 | |
Igor Murashkin | 9d4b6da | 2016-07-29 09:51:58 -0700 | [diff] [blame^] | 337 | bool ArtMethod::IsAnnotatedWithFastNative() { |
| 338 | Thread* self = Thread::Current(); |
| 339 | ScopedObjectAccess soa(self); |
| 340 | StackHandleScope<1> shs(self); |
| 341 | |
| 342 | const DexFile& dex_file = GetDeclaringClass()->GetDexFile(); |
| 343 | |
| 344 | mirror::Class* fast_native_annotation = |
| 345 | soa.Decode<mirror::Class*>(WellKnownClasses::dalvik_annotation_optimization_FastNative); |
| 346 | Handle<mirror::Class> fast_native_handle(shs.NewHandle(fast_native_annotation)); |
| 347 | |
| 348 | // Note: Resolves any method annotations' classes as a side-effect. |
| 349 | // -- This seems allowed by the spec since it says we can preload any classes |
| 350 | // referenced by another classes's constant pool table. |
| 351 | return dex_file.IsMethodAnnotationPresent(this, fast_native_handle, DexFile::kDexVisibilityBuild); |
| 352 | } |
| 353 | |
Mathieu Chartier | fc58af4 | 2015-04-16 18:00:39 -0700 | [diff] [blame] | 354 | bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) { |
| 355 | auto* dex_cache = GetDexCache(); |
| 356 | auto* dex_file = dex_cache->GetDexFile(); |
| 357 | const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex()); |
| 358 | const auto& proto_id = dex_file->GetMethodPrototype(method_id); |
| 359 | const DexFile::TypeList* proto_params = dex_file->GetProtoParameters(proto_id); |
| 360 | auto count = proto_params != nullptr ? proto_params->Size() : 0u; |
| 361 | auto param_len = params.Get() != nullptr ? params->GetLength() : 0u; |
| 362 | if (param_len != count) { |
| 363 | return false; |
| 364 | } |
| 365 | auto* cl = Runtime::Current()->GetClassLinker(); |
| 366 | for (size_t i = 0; i < count; ++i) { |
| 367 | auto type_idx = proto_params->GetTypeItem(i).type_idx_; |
| 368 | auto* type = cl->ResolveType(type_idx, this); |
| 369 | if (type == nullptr) { |
| 370 | Thread::Current()->AssertPendingException(); |
| 371 | return false; |
| 372 | } |
| 373 | if (type != params->GetWithoutChecks(i)) { |
| 374 | return false; |
| 375 | } |
| 376 | } |
| 377 | return true; |
| 378 | } |
| 379 | |
Nicolas Geoffray | 6bc4374 | 2015-10-12 18:11:10 +0100 | [diff] [blame] | 380 | const uint8_t* ArtMethod::GetQuickenedInfo() { |
| 381 | bool found = false; |
| 382 | OatFile::OatMethod oat_method = |
| 383 | Runtime::Current()->GetClassLinker()->FindOatMethodFor(this, &found); |
| 384 | if (!found || (oat_method.GetQuickCode() != nullptr)) { |
| 385 | return nullptr; |
| 386 | } |
| 387 | return oat_method.GetVmapTable(); |
| 388 | } |
| 389 | |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 390 | const OatQuickMethodHeader* ArtMethod::GetOatQuickMethodHeader(uintptr_t pc) { |
Nicolas Geoffray | 5a23d2e | 2015-11-03 18:58:57 +0000 | [diff] [blame] | 391 | // Our callers should make sure they don't pass the instrumentation exit pc, |
| 392 | // as this method does not look at the side instrumentation stack. |
| 393 | DCHECK_NE(pc, reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc())); |
| 394 | |
Nicolas Geoffray | 22cf3d3 | 2015-11-02 11:57:11 +0000 | [diff] [blame] | 395 | if (IsRuntimeMethod()) { |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 396 | return nullptr; |
| 397 | } |
| 398 | |
| 399 | Runtime* runtime = Runtime::Current(); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 400 | const void* existing_entry_point = GetEntryPointFromQuickCompiledCode(); |
Nicolas Geoffray | de16654 | 2016-03-07 15:44:08 +0000 | [diff] [blame] | 401 | CHECK(existing_entry_point != nullptr) << PrettyMethod(this) << "@" << this; |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 402 | ClassLinker* class_linker = runtime->GetClassLinker(); |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 403 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 404 | if (class_linker->IsQuickGenericJniStub(existing_entry_point)) { |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 405 | // The generic JNI does not have any method header. |
| 406 | return nullptr; |
| 407 | } |
| 408 | |
Nicolas Geoffray | 22cf3d3 | 2015-11-02 11:57:11 +0000 | [diff] [blame] | 409 | if (existing_entry_point == GetQuickProxyInvokeHandler()) { |
| 410 | DCHECK(IsProxyMethod() && !IsConstructor()); |
| 411 | // The proxy entry point does not have any method header. |
| 412 | return nullptr; |
| 413 | } |
| 414 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 415 | // Check whether the current entry point contains this pc. |
| 416 | if (!class_linker->IsQuickResolutionStub(existing_entry_point) && |
| 417 | !class_linker->IsQuickToInterpreterBridge(existing_entry_point)) { |
| 418 | OatQuickMethodHeader* method_header = |
| 419 | OatQuickMethodHeader::FromEntryPoint(existing_entry_point); |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 420 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 421 | if (method_header->Contains(pc)) { |
| 422 | return method_header; |
| 423 | } |
| 424 | } |
| 425 | |
| 426 | // Check whether the pc is in the JIT code cache. |
| 427 | jit::Jit* jit = Runtime::Current()->GetJit(); |
| 428 | if (jit != nullptr) { |
| 429 | jit::JitCodeCache* code_cache = jit->GetCodeCache(); |
| 430 | OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this); |
| 431 | if (method_header != nullptr) { |
| 432 | DCHECK(method_header->Contains(pc)); |
| 433 | return method_header; |
| 434 | } else { |
Nicolas Geoffray | 2a524bd | 2016-03-01 12:18:47 +0000 | [diff] [blame] | 435 | DCHECK(!code_cache->ContainsPc(reinterpret_cast<const void*>(pc))) |
| 436 | << PrettyMethod(this) |
| 437 | << ", pc=" << std::hex << pc |
| 438 | << ", entry_point=" << std::hex << reinterpret_cast<uintptr_t>(existing_entry_point) |
| 439 | << ", copy=" << std::boolalpha << IsCopied() |
| 440 | << ", proxy=" << std::boolalpha << IsProxyMethod(); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 441 | } |
| 442 | } |
| 443 | |
| 444 | // The code has to be in an oat file. |
| 445 | bool found; |
| 446 | OatFile::OatMethod oat_method = class_linker->FindOatMethodFor(this, &found); |
| 447 | if (!found) { |
Nicolas Geoffray | 49e4396 | 2015-10-28 16:16:16 +0000 | [diff] [blame] | 448 | if (class_linker->IsQuickResolutionStub(existing_entry_point)) { |
| 449 | // We are running the generic jni stub, but the entry point of the method has not |
| 450 | // been updated yet. |
Nicolas Geoffray | 703c282 | 2015-10-30 12:23:16 +0000 | [diff] [blame] | 451 | DCHECK_EQ(pc, 0u) << "Should be a downcall"; |
| 452 | DCHECK(IsNative()); |
| 453 | return nullptr; |
| 454 | } |
| 455 | if (existing_entry_point == GetQuickInstrumentationEntryPoint()) { |
| 456 | // We are running the generic jni stub, but the method is being instrumented. |
| 457 | DCHECK_EQ(pc, 0u) << "Should be a downcall"; |
Nicolas Geoffray | 49e4396 | 2015-10-28 16:16:16 +0000 | [diff] [blame] | 458 | DCHECK(IsNative()); |
| 459 | return nullptr; |
| 460 | } |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 461 | // Only for unit tests. |
| 462 | // TODO(ngeoffray): Update these tests to pass the right pc? |
| 463 | return OatQuickMethodHeader::FromEntryPoint(existing_entry_point); |
| 464 | } |
| 465 | const void* oat_entry_point = oat_method.GetQuickCode(); |
| 466 | if (oat_entry_point == nullptr || class_linker->IsQuickGenericJniStub(oat_entry_point)) { |
Nicolas Geoffray | 5a23d2e | 2015-11-03 18:58:57 +0000 | [diff] [blame] | 467 | DCHECK(IsNative()) << PrettyMethod(this); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 468 | return nullptr; |
| 469 | } |
| 470 | |
| 471 | OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromEntryPoint(oat_entry_point); |
| 472 | if (pc == 0) { |
| 473 | // This is a downcall, it can only happen for a native method. |
| 474 | DCHECK(IsNative()); |
| 475 | return method_header; |
| 476 | } |
| 477 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 478 | DCHECK(method_header->Contains(pc)) |
| 479 | << PrettyMethod(this) |
| 480 | << std::hex << pc << " " << oat_entry_point |
| 481 | << " " << (uintptr_t)(method_header->code_ + method_header->code_size_); |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 482 | return method_header; |
| 483 | } |
| 484 | |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 485 | bool ArtMethod::HasAnyCompiledCode() { |
| 486 | // Check whether the JIT has compiled it. |
| 487 | jit::Jit* jit = Runtime::Current()->GetJit(); |
| 488 | if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) { |
| 489 | return true; |
| 490 | } |
| 491 | |
| 492 | // Check whether we have AOT code. |
| 493 | return Runtime::Current()->GetClassLinker()->GetOatMethodQuickCodeFor(this) != nullptr; |
| 494 | } |
Nicolas Geoffray | 22cf3d3 | 2015-11-02 11:57:11 +0000 | [diff] [blame] | 495 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 496 | void ArtMethod::CopyFrom(ArtMethod* src, PointerSize image_pointer_size) { |
Nicolas Geoffray | 22cf3d3 | 2015-11-02 11:57:11 +0000 | [diff] [blame] | 497 | memcpy(reinterpret_cast<void*>(this), reinterpret_cast<const void*>(src), |
| 498 | Size(image_pointer_size)); |
| 499 | declaring_class_ = GcRoot<mirror::Class>(const_cast<ArtMethod*>(src)->GetDeclaringClass()); |
| 500 | |
| 501 | // If the entry point of the method we are copying from is from JIT code, we just |
| 502 | // put the entry point of the new method to interpreter. We could set the entry point |
| 503 | // to the JIT code, but this would require taking the JIT code cache lock to notify |
| 504 | // it, which we do not want at this level. |
| 505 | Runtime* runtime = Runtime::Current(); |
Calin Juravle | ffc8707 | 2016-04-20 14:22:09 +0100 | [diff] [blame] | 506 | if (runtime->UseJitCompilation()) { |
Nicolas Geoffray | 22cf3d3 | 2015-11-02 11:57:11 +0000 | [diff] [blame] | 507 | if (runtime->GetJit()->GetCodeCache()->ContainsPc(GetEntryPointFromQuickCompiledCode())) { |
| 508 | SetEntryPointFromQuickCompiledCodePtrSize(GetQuickToInterpreterBridge(), image_pointer_size); |
| 509 | } |
| 510 | } |
| 511 | // Clear the profiling info for the same reasons as the JIT code. |
| 512 | if (!src->IsNative()) { |
| 513 | SetProfilingInfoPtrSize(nullptr, image_pointer_size); |
| 514 | } |
| 515 | // Clear hotness to let the JIT properly decide when to compile this method. |
| 516 | hotness_count_ = 0; |
| 517 | } |
| 518 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 519 | bool ArtMethod::IsImagePointerSize(PointerSize pointer_size) { |
Andreas Gampe | 479b1de | 2016-07-19 18:27:17 -0700 | [diff] [blame] | 520 | // Hijack this function to get access to PtrSizedFieldsOffset. |
| 521 | // |
| 522 | // Ensure that PrtSizedFieldsOffset is correct. We rely here on usually having both 32-bit and |
| 523 | // 64-bit builds. |
| 524 | static_assert(std::is_standard_layout<ArtMethod>::value, "ArtMethod is not standard layout."); |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 525 | static_assert( |
| 526 | (sizeof(void*) != 4) || |
| 527 | (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k32)), |
| 528 | "Unexpected 32-bit class layout."); |
| 529 | static_assert( |
| 530 | (sizeof(void*) != 8) || |
| 531 | (offsetof(ArtMethod, ptr_sized_fields_) == PtrSizedFieldsOffset(PointerSize::k64)), |
| 532 | "Unexpected 64-bit class layout."); |
Andreas Gampe | 479b1de | 2016-07-19 18:27:17 -0700 | [diff] [blame] | 533 | |
Andreas Gampe | 75f0885 | 2016-07-19 08:06:07 -0700 | [diff] [blame] | 534 | Runtime* runtime = Runtime::Current(); |
| 535 | if (runtime == nullptr) { |
| 536 | return true; |
| 537 | } |
| 538 | return runtime->GetClassLinker()->GetImagePointerSize() == pointer_size; |
| 539 | } |
| 540 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 541 | } // namespace art |